blob: 564185cc75d465254911dc3b04487bc3166da335 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Brian Carlstrome24fa612011-09-29 00:53:55 -070016
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_OAT_FILE_H_
18#define ART_RUNTIME_OAT_FILE_H_
Brian Carlstrome24fa612011-09-29 00:53:55 -070019
Vladimir Marko3f5838d2014-08-07 18:07:18 +010020#include <list>
Brian Carlstrom700c8d32012-11-05 10:42:02 -080021#include <string>
Brian Carlstrome24fa612011-09-29 00:53:55 -070022#include <vector>
23
Vladimir Marko3f5838d2014-08-07 18:07:18 +010024#include "base/mutex.h"
Vladimir Marko539690a2014-06-05 18:36:42 +010025#include "base/stringpiece.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080026#include "dex_file.h"
27#include "invoke_type.h"
28#include "mem_map.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070029#include "mirror/class.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080030#include "oat.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080031#include "os.h"
Brian Carlstrome24fa612011-09-29 00:53:55 -070032
33namespace art {
34
Brian Carlstromba150c32013-08-27 17:31:03 -070035class BitVector;
Brian Carlstrom700c8d32012-11-05 10:42:02 -080036class ElfFile;
37class MemMap;
38class OatMethodOffsets;
Ian Rogers33e95662013-05-20 20:29:14 -070039class OatHeader;
Brian Carlstrom700c8d32012-11-05 10:42:02 -080040
Brian Carlstrome24fa612011-09-29 00:53:55 -070041class OatFile {
42 public:
Alex Light84d76052014-08-22 17:49:35 -070043 // Opens an oat file contained within the given elf file. This is always opened as
44 // non-executable at the moment.
45 static OatFile* OpenWithElfFile(ElfFile* elf_file, const std::string& location,
46 std::string* error_msg);
Brian Carlstrome24fa612011-09-29 00:53:55 -070047 // Open an oat file. Returns NULL on failure. Requested base can
48 // optionally be used to request where the file should be loaded.
49 static OatFile* Open(const std::string& filename,
Brian Carlstroma004aa92012-02-08 18:05:09 -080050 const std::string& location,
Ian Rogers13735952014-10-08 12:43:28 -070051 uint8_t* requested_base,
Igor Murashkin46774762014-10-22 11:37:02 -070052 uint8_t* oat_file_begin,
Ian Rogers8d31bbd2013-10-13 10:44:14 -070053 bool executable,
54 std::string* error_msg);
Brian Carlstrome24fa612011-09-29 00:53:55 -070055
Brian Carlstrom700c8d32012-11-05 10:42:02 -080056 // Open an oat file from an already opened File.
Brian Carlstrom265091e2013-01-30 14:08:26 -080057 // Does not use dlopen underneath so cannot be used for runtime use
58 // where relocations may be required. Currently used from
59 // ImageWriter which wants to open a writable version from an existing
60 // file descriptor for patching.
Ian Rogers8d31bbd2013-10-13 10:44:14 -070061 static OatFile* OpenWritable(File* file, const std::string& location, std::string* error_msg);
Alex Lighta59dd802014-07-02 16:28:08 -070062 // Opens an oat file from an already opened File. Maps it PROT_READ, MAP_PRIVATE.
63 static OatFile* OpenReadable(File* file, const std::string& location, std::string* error_msg);
Brian Carlstrom700c8d32012-11-05 10:42:02 -080064
Brian Carlstrome24fa612011-09-29 00:53:55 -070065 ~OatFile();
66
Alex Light9dcc4572014-08-14 14:16:26 -070067 bool IsExecutable() const {
68 return is_executable_;
69 }
70
Andreas Gampe7ba64962014-10-23 11:37:40 -070071 bool IsPic() const;
72
Alex Light53cb16b2014-06-12 11:26:29 -070073 ElfFile* GetElfFile() const {
74 CHECK_NE(reinterpret_cast<uintptr_t>(elf_file_.get()), reinterpret_cast<uintptr_t>(nullptr))
75 << "Cannot get an elf file from " << GetLocation();
76 return elf_file_.get();
77 }
78
Brian Carlstrome24fa612011-09-29 00:53:55 -070079 const std::string& GetLocation() const {
80 return location_;
81 }
82
83 const OatHeader& GetOatHeader() const;
84
85 class OatDexFile;
86
Brian Carlstrom3320cf42011-10-04 14:58:28 -070087 class OatMethod {
88 public:
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070089 void LinkMethod(mirror::ArtMethod* method) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstromae826982011-11-09 01:33:42 -080090
91 uint32_t GetCodeOffset() const {
92 return code_offset_;
93 }
Brian Carlstromae826982011-11-09 01:33:42 -080094
Ian Rogersef7d42f2014-01-06 12:55:46 -080095 const void* GetQuickCode() const {
Elliott Hughes956af0f2014-12-11 14:34:28 -080096 return GetOatPointer<const void*>(code_offset_);
Ian Rogersef7d42f2014-01-06 12:55:46 -080097 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -070098
99 // Returns size of quick code.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800100 uint32_t GetQuickCodeSize() const;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700101 uint32_t GetQuickCodeSizeOffset() const;
102
103 // Returns OatQuickMethodHeader for debugging. Most callers should
104 // use more specific methods such as GetQuickCodeSize.
105 const OatQuickMethodHeader* GetOatQuickMethodHeader() const;
106 uint32_t GetOatQuickMethodHeaderOffset() const;
Logan Chien0c717dd2012-03-28 18:31:07 +0800107
Vladimir Marko7624d252014-05-02 14:40:15 +0100108 size_t GetFrameSizeInBytes() const;
109 uint32_t GetCoreSpillMask() const;
110 uint32_t GetFpSpillMask() const;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700111
Vladimir Marko8a630572014-04-09 18:45:35 +0100112 const uint8_t* GetMappingTable() const;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700113 uint32_t GetMappingTableOffset() const;
114 uint32_t GetMappingTableOffsetOffset() const;
115
Vladimir Marko8a630572014-04-09 18:45:35 +0100116 const uint8_t* GetVmapTable() const;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700117 uint32_t GetVmapTableOffset() const;
118 uint32_t GetVmapTableOffsetOffset() const;
Vladimir Marko8a630572014-04-09 18:45:35 +0100119
Mathieu Chartier957ca1c2014-11-21 16:51:29 -0800120 const uint8_t* GetGcMap() const;
121 uint32_t GetGcMapOffset() const;
122 uint32_t GetGcMapOffsetOffset() const;
123
Brian Carlstromae826982011-11-09 01:33:42 -0800124 // Create an OatMethod with offsets relative to the given base address
Mathieu Chartier957ca1c2014-11-21 16:51:29 -0800125 OatMethod(const uint8_t* base, const uint32_t code_offset)
126 : begin_(base), code_offset_(code_offset) {
Ian Rogers97b52f82014-08-14 11:34:07 -0700127 }
128 ~OatMethod() {}
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700129
Ian Rogers97b52f82014-08-14 11:34:07 -0700130 // A representation of an invalid OatMethod, used when an OatMethod or OatClass can't be found.
131 // See ClassLinker::FindOatMethodFor.
132 static const OatMethod Invalid() {
Mathieu Chartier957ca1c2014-11-21 16:51:29 -0800133 return OatMethod(nullptr, -1);
Ian Rogers97b52f82014-08-14 11:34:07 -0700134 }
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100135
Brian Carlstromae826982011-11-09 01:33:42 -0800136 private:
137 template<class T>
138 T GetOatPointer(uint32_t offset) const {
139 if (offset == 0) {
140 return NULL;
141 }
Ian Rogers30fab402012-01-23 15:43:46 -0800142 return reinterpret_cast<T>(begin_ + offset);
Brian Carlstromae826982011-11-09 01:33:42 -0800143 }
144
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800145 const uint8_t* begin_;
146 uint32_t code_offset_;
Brian Carlstromae826982011-11-09 01:33:42 -0800147
148 friend class OatClass;
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700149 };
150
Brian Carlstrome24fa612011-09-29 00:53:55 -0700151 class OatClass {
152 public:
Brian Carlstromba150c32013-08-27 17:31:03 -0700153 mirror::Class::Status GetStatus() const {
154 return status_;
155 }
156
157 OatClassType GetType() const {
158 return type_;
159 }
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800160
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700161 // Get the OatMethod entry based on its index into the class
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700162 // defintion. Direct methods come first, followed by virtual
163 // methods. Note that runtime created methods such as miranda
Brian Carlstrome24fa612011-09-29 00:53:55 -0700164 // methods are not included.
Brian Carlstromaded5f72011-10-07 17:15:04 -0700165 const OatMethod GetOatMethod(uint32_t method_index) const;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700166
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700167 // Return a pointer to the OatMethodOffsets for the requested
168 // method_index, or nullptr if none is present. Note that most
169 // callers should use GetOatMethod.
170 const OatMethodOffsets* GetOatMethodOffsets(uint32_t method_index) const;
171
172 // Return the offset from the start of the OatFile to the
173 // OatMethodOffsets for the requested method_index, or 0 if none
174 // is present. Note that most callers should use GetOatMethod.
175 uint32_t GetOatMethodOffsetsOffset(uint32_t method_index) const;
176
Ian Rogers97b52f82014-08-14 11:34:07 -0700177 // A representation of an invalid OatClass, used when an OatClass can't be found.
178 // See ClassLinker::FindOatClass.
179 static OatClass Invalid() {
180 return OatClass(nullptr, mirror::Class::kStatusError, kOatClassNoneCompiled, 0, nullptr,
181 nullptr);
182 }
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100183
Brian Carlstrome24fa612011-09-29 00:53:55 -0700184 private:
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800185 OatClass(const OatFile* oat_file,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800186 mirror::Class::Status status,
Brian Carlstromba150c32013-08-27 17:31:03 -0700187 OatClassType type,
188 uint32_t bitmap_size,
189 const uint32_t* bitmap_pointer,
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800190 const OatMethodOffsets* methods_pointer);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700191
Ian Rogers97b52f82014-08-14 11:34:07 -0700192 const OatFile* const oat_file_;
Brian Carlstromba150c32013-08-27 17:31:03 -0700193
Ian Rogers97b52f82014-08-14 11:34:07 -0700194 const mirror::Class::Status status_;
Brian Carlstromba150c32013-08-27 17:31:03 -0700195
Ian Rogers97b52f82014-08-14 11:34:07 -0700196 const OatClassType type_;
Brian Carlstromba150c32013-08-27 17:31:03 -0700197
Ian Rogers97b52f82014-08-14 11:34:07 -0700198 const uint32_t* const bitmap_;
Brian Carlstromba150c32013-08-27 17:31:03 -0700199
Ian Rogers97b52f82014-08-14 11:34:07 -0700200 const OatMethodOffsets* const methods_pointer_;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700201
202 friend class OatDexFile;
203 };
204
205 class OatDexFile {
206 public:
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700207 // Opens the DexFile referred to by this OatDexFile from within the containing OatFile.
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800208 std::unique_ptr<const DexFile> OpenDexFile(std::string* error_msg) const;
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700209
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100210 const OatFile* GetOatFile() const {
211 return oat_file_;
212 }
213
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700214 // Returns the size of the DexFile refered to by this OatDexFile.
Ian Rogers05f28c62012-10-23 18:12:13 -0700215 size_t FileSize() const;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700216
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700217 // Returns original path of DexFile that was the source of this OatDexFile.
Brian Carlstromaded5f72011-10-07 17:15:04 -0700218 const std::string& GetDexFileLocation() const {
219 return dex_file_location_;
220 }
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700221
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100222 // Returns the canonical location of DexFile that was the source of this OatDexFile.
223 const std::string& GetCanonicalDexFileLocation() const {
224 return canonical_dex_file_location_;
225 }
226
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700227 // Returns checksum of original DexFile that was the source of this OatDexFile;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800228 uint32_t GetDexFileLocationChecksum() const {
229 return dex_file_location_checksum_;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700230 }
231
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700232 // Returns the OatClass for the class specified by the given DexFile class_def_index.
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100233 OatClass GetOatClass(uint16_t class_def_index) const;
Brian Carlstrom56d947f2013-07-15 13:14:23 -0700234
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700235 // Returns the offset to the OatClass information. Most callers should use GetOatClass.
236 uint32_t GetOatClassOffset(uint16_t class_def_index) const;
237
Brian Carlstrome24fa612011-09-29 00:53:55 -0700238 ~OatDexFile();
Elliott Hughesa21039c2012-06-21 12:09:25 -0700239
Brian Carlstrome24fa612011-09-29 00:53:55 -0700240 private:
241 OatDexFile(const OatFile* oat_file,
Elliott Hughesaa6a5882012-01-13 19:39:16 -0800242 const std::string& dex_file_location,
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100243 const std::string& canonical_dex_file_location,
Brian Carlstrome24fa612011-09-29 00:53:55 -0700244 uint32_t dex_file_checksum,
Ian Rogers13735952014-10-08 12:43:28 -0700245 const uint8_t* dex_file_pointer,
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800246 const uint32_t* oat_class_offsets_pointer);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700247
Vladimir Marko539690a2014-06-05 18:36:42 +0100248 const OatFile* const oat_file_;
249 const std::string dex_file_location_;
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100250 const std::string canonical_dex_file_location_;
Vladimir Marko539690a2014-06-05 18:36:42 +0100251 const uint32_t dex_file_location_checksum_;
Ian Rogers13735952014-10-08 12:43:28 -0700252 const uint8_t* const dex_file_pointer_;
Vladimir Marko539690a2014-06-05 18:36:42 +0100253 const uint32_t* const oat_class_offsets_pointer_;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700254
255 friend class OatFile;
256 DISALLOW_COPY_AND_ASSIGN(OatDexFile);
257 };
258
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700259 const OatDexFile* GetOatDexFile(const char* dex_location,
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700260 const uint32_t* const dex_location_checksum,
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100261 bool exception_if_not_found = true) const
262 LOCKS_EXCLUDED(secondary_lookup_lock_);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700263
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100264 const std::vector<const OatDexFile*>& GetOatDexFiles() const {
265 return oat_dex_files_storage_;
266 }
Brian Carlstrome24fa612011-09-29 00:53:55 -0700267
Ian Rogers30fab402012-01-23 15:43:46 -0800268 size_t Size() const {
269 return End() - Begin();
Brian Carlstrome24fa612011-09-29 00:53:55 -0700270 }
271
Vladimir Marko5c42c292015-02-25 12:02:49 +0000272 size_t BssSize() const {
273 return BssEnd() - BssBegin();
274 }
275
Ian Rogers13735952014-10-08 12:43:28 -0700276 const uint8_t* Begin() const;
277 const uint8_t* End() const;
Alex Light53cb16b2014-06-12 11:26:29 -0700278
Vladimir Marko5c42c292015-02-25 12:02:49 +0000279 const uint8_t* BssBegin() const;
280 const uint8_t* BssEnd() const;
281
Brian Carlstrome24fa612011-09-29 00:53:55 -0700282 private:
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800283 static void CheckLocation(const std::string& location);
284
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800285 static OatFile* OpenElfFile(File* file,
286 const std::string& location,
Ian Rogers13735952014-10-08 12:43:28 -0700287 uint8_t* requested_base,
Igor Murashkin46774762014-10-22 11:37:02 -0700288 uint8_t* oat_file_begin, // Override base if not null
Brian Carlstromf1d34552013-07-12 20:22:23 -0700289 bool writable,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700290 bool executable,
291 std::string* error_msg);
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800292
Alex Light9dcc4572014-08-14 14:16:26 -0700293 explicit OatFile(const std::string& filename, bool executable);
Igor Murashkin46774762014-10-22 11:37:02 -0700294 bool ElfFileOpen(File* file, uint8_t* requested_base,
295 uint8_t* oat_file_begin, // Override where the file is loaded to if not null
296 bool writable, bool executable,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700297 std::string* error_msg);
298 bool Setup(std::string* error_msg);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700299
Brian Carlstrome24fa612011-09-29 00:53:55 -0700300 // The oat file name.
301 //
302 // The image will embed this to link its associated oat file.
303 const std::string location_;
304
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800305 // Pointer to OatHeader.
Ian Rogers13735952014-10-08 12:43:28 -0700306 const uint8_t* begin_;
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800307
308 // Pointer to end of oat region for bounds checking.
Ian Rogers13735952014-10-08 12:43:28 -0700309 const uint8_t* end_;
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800310
Vladimir Marko5c42c292015-02-25 12:02:49 +0000311 // Pointer to the .bss section, if present, otherwise nullptr.
312 const uint8_t* bss_begin_;
313
314 // Pointer to the end of the .bss section, if present, otherwise nullptr.
315 const uint8_t* bss_end_;
316
Alex Light9dcc4572014-08-14 14:16:26 -0700317 // Was this oat_file loaded executable?
318 const bool is_executable_;
319
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800320 // Backing memory map for oat file during when opened by ElfWriter during initial compilation.
Ian Rogers700a4022014-05-19 16:49:03 -0700321 std::unique_ptr<MemMap> mem_map_;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700322
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800323 // Backing memory map for oat file during cross compilation.
Ian Rogers700a4022014-05-19 16:49:03 -0700324 std::unique_ptr<ElfFile> elf_file_;
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800325
326 // dlopen handle during runtime.
327 void* dlopen_handle_;
328
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100329 // Owning storage for the OatDexFile objects.
330 std::vector<const OatDexFile*> oat_dex_files_storage_;
331
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100332 // NOTE: We use a StringPiece as the key type to avoid a memory allocation on every
333 // lookup with a const char* key. The StringPiece doesn't own its backing storage,
334 // therefore we're using the OatDexFile::dex_file_location_ as the backing storage
335 // for keys in oat_dex_files_ and the string_cache_ entries for the backing storage
336 // of keys in secondary_oat_dex_files_ and oat_dex_files_by_canonical_location_.
Mathieu Chartierbad02672014-08-25 13:08:22 -0700337 typedef AllocationTrackingSafeMap<StringPiece, const OatDexFile*, kAllocatorTagOatFile> Table;
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100338
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100339 // Map each location and canonical location (if different) retrieved from the
340 // oat file to its OatDexFile. This map doesn't change after it's constructed in Setup()
341 // and therefore doesn't need any locking and provides the cheapest dex file lookup
342 // for GetOatDexFile() for a very frequent use case. Never contains a nullptr value.
343 Table oat_dex_files_;
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100344
345 // Lock guarding all members needed for secondary lookup in GetOatDexFile().
346 mutable Mutex secondary_lookup_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
347
348 // If the primary oat_dex_files_ lookup fails, use a secondary map. This map stores
349 // the results of all previous secondary lookups, whether successful (non-null) or
350 // failed (null). If it doesn't contain an entry we need to calculate the canonical
351 // location and use oat_dex_files_by_canonical_location_.
352 mutable Table secondary_oat_dex_files_ GUARDED_BY(secondary_lookup_lock_);
353
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100354 // Cache of strings. Contains the backing storage for keys in the secondary_oat_dex_files_
355 // and the lazily initialized oat_dex_files_by_canonical_location_.
356 // NOTE: We're keeping references to contained strings in form of StringPiece and adding
357 // new strings to the end. The adding of a new element must not touch any previously stored
358 // elements. std::list<> and std::deque<> satisfy this requirement, std::vector<> doesn't.
359 mutable std::list<std::string> string_cache_ GUARDED_BY(secondary_lookup_lock_);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700360
361 friend class OatClass;
362 friend class OatDexFile;
Elliott Hughese3c845c2012-02-28 17:23:01 -0800363 friend class OatDumper; // For GetBase and GetLimit
Brian Carlstrome24fa612011-09-29 00:53:55 -0700364 DISALLOW_COPY_AND_ASSIGN(OatFile);
365};
366
367} // namespace art
368
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700369#endif // ART_RUNTIME_OAT_FILE_H_