blob: 7c4ef8be88c77a462d1b27d822907558623e4d6e [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;
Richard Uhler07b3c232015-03-31 15:57:54 -070040class OatDexFile;
Brian Carlstrom700c8d32012-11-05 10:42:02 -080041
Richard Uhler07b3c232015-03-31 15:57:54 -070042class OatFile FINAL {
Brian Carlstrome24fa612011-09-29 00:53:55 -070043 public:
Richard Uhler07b3c232015-03-31 15:57:54 -070044 typedef art::OatDexFile OatDexFile;
45
Alex Light84d76052014-08-22 17:49:35 -070046 // Opens an oat file contained within the given elf file. This is always opened as
47 // non-executable at the moment.
48 static OatFile* OpenWithElfFile(ElfFile* elf_file, const std::string& location,
Richard Uhlere5fed032015-03-18 08:21:11 -070049 const char* abs_dex_location,
Alex Light84d76052014-08-22 17:49:35 -070050 std::string* error_msg);
Mathieu Chartier2cebb242015-04-21 16:50:40 -070051 // Open an oat file. Returns null on failure. Requested base can
Brian Carlstrome24fa612011-09-29 00:53:55 -070052 // optionally be used to request where the file should be loaded.
Richard Uhlere5fed032015-03-18 08:21:11 -070053 // See the ResolveRelativeEncodedDexLocation for a description of how the
54 // abs_dex_location argument is used.
Brian Carlstrome24fa612011-09-29 00:53:55 -070055 static OatFile* Open(const std::string& filename,
Brian Carlstroma004aa92012-02-08 18:05:09 -080056 const std::string& location,
Ian Rogers13735952014-10-08 12:43:28 -070057 uint8_t* requested_base,
Igor Murashkin46774762014-10-22 11:37:02 -070058 uint8_t* oat_file_begin,
Ian Rogers8d31bbd2013-10-13 10:44:14 -070059 bool executable,
Richard Uhlere5fed032015-03-18 08:21:11 -070060 const char* abs_dex_location,
Ian Rogers8d31bbd2013-10-13 10:44:14 -070061 std::string* error_msg);
Brian Carlstrome24fa612011-09-29 00:53:55 -070062
Brian Carlstrom700c8d32012-11-05 10:42:02 -080063 // Open an oat file from an already opened File.
Brian Carlstrom265091e2013-01-30 14:08:26 -080064 // Does not use dlopen underneath so cannot be used for runtime use
65 // where relocations may be required. Currently used from
66 // ImageWriter which wants to open a writable version from an existing
67 // file descriptor for patching.
Richard Uhlere5fed032015-03-18 08:21:11 -070068 static OatFile* OpenWritable(File* file, const std::string& location,
69 const char* abs_dex_location,
70 std::string* error_msg);
Alex Lighta59dd802014-07-02 16:28:08 -070071 // Opens an oat file from an already opened File. Maps it PROT_READ, MAP_PRIVATE.
Richard Uhlere5fed032015-03-18 08:21:11 -070072 static OatFile* OpenReadable(File* file, const std::string& location,
73 const char* abs_dex_location,
74 std::string* error_msg);
Brian Carlstrom700c8d32012-11-05 10:42:02 -080075
Brian Carlstrome24fa612011-09-29 00:53:55 -070076 ~OatFile();
77
Alex Light9dcc4572014-08-14 14:16:26 -070078 bool IsExecutable() const {
79 return is_executable_;
80 }
81
Andreas Gampe7ba64962014-10-23 11:37:40 -070082 bool IsPic() const;
83
Sebastien Hertz0de11332015-05-13 12:14:05 +020084 // Indicates whether the oat file was compiled with full debugging capability.
85 bool IsDebuggable() const;
86
Alex Light53cb16b2014-06-12 11:26:29 -070087 ElfFile* GetElfFile() const {
88 CHECK_NE(reinterpret_cast<uintptr_t>(elf_file_.get()), reinterpret_cast<uintptr_t>(nullptr))
89 << "Cannot get an elf file from " << GetLocation();
90 return elf_file_.get();
91 }
92
Brian Carlstrome24fa612011-09-29 00:53:55 -070093 const std::string& GetLocation() const {
94 return location_;
95 }
96
97 const OatHeader& GetOatHeader() const;
98
Richard Uhler07b3c232015-03-31 15:57:54 -070099 class OatMethod FINAL {
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700100 public:
Mathieu Chartiere401d142015-04-22 13:56:20 -0700101 void LinkMethod(ArtMethod* method) const;
Brian Carlstromae826982011-11-09 01:33:42 -0800102
Nicolas Geoffrayc04c8002015-07-14 11:37:54 +0100103 uint32_t GetCodeOffset() const;
Brian Carlstromae826982011-11-09 01:33:42 -0800104
Nicolas Geoffrayc04c8002015-07-14 11:37:54 +0100105 const void* GetQuickCode() const;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700106
107 // Returns size of quick code.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800108 uint32_t GetQuickCodeSize() const;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700109 uint32_t GetQuickCodeSizeOffset() const;
110
111 // Returns OatQuickMethodHeader for debugging. Most callers should
112 // use more specific methods such as GetQuickCodeSize.
113 const OatQuickMethodHeader* GetOatQuickMethodHeader() const;
114 uint32_t GetOatQuickMethodHeaderOffset() const;
Logan Chien0c717dd2012-03-28 18:31:07 +0800115
Vladimir Marko7624d252014-05-02 14:40:15 +0100116 size_t GetFrameSizeInBytes() const;
117 uint32_t GetCoreSpillMask() const;
118 uint32_t GetFpSpillMask() const;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700119
Vladimir Marko8a630572014-04-09 18:45:35 +0100120 const uint8_t* GetMappingTable() const;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700121 uint32_t GetMappingTableOffset() const;
122 uint32_t GetMappingTableOffsetOffset() const;
123
Vladimir Marko8a630572014-04-09 18:45:35 +0100124 const uint8_t* GetVmapTable() const;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700125 uint32_t GetVmapTableOffset() const;
126 uint32_t GetVmapTableOffsetOffset() const;
Vladimir Marko8a630572014-04-09 18:45:35 +0100127
Mathieu Chartier957ca1c2014-11-21 16:51:29 -0800128 const uint8_t* GetGcMap() const;
129 uint32_t GetGcMapOffset() const;
130 uint32_t GetGcMapOffsetOffset() const;
131
Brian Carlstromae826982011-11-09 01:33:42 -0800132 // Create an OatMethod with offsets relative to the given base address
Mathieu Chartier957ca1c2014-11-21 16:51:29 -0800133 OatMethod(const uint8_t* base, const uint32_t code_offset)
134 : begin_(base), code_offset_(code_offset) {
Ian Rogers97b52f82014-08-14 11:34:07 -0700135 }
Andreas Gampe758a8012015-04-03 21:28:42 -0700136 OatMethod(const OatMethod&) = default;
Ian Rogers97b52f82014-08-14 11:34:07 -0700137 ~OatMethod() {}
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700138
Andreas Gampe758a8012015-04-03 21:28:42 -0700139 OatMethod& operator=(const OatMethod&) = default;
140
Ian Rogers97b52f82014-08-14 11:34:07 -0700141 // A representation of an invalid OatMethod, used when an OatMethod or OatClass can't be found.
142 // See ClassLinker::FindOatMethodFor.
143 static const OatMethod Invalid() {
Mathieu Chartier957ca1c2014-11-21 16:51:29 -0800144 return OatMethod(nullptr, -1);
Ian Rogers97b52f82014-08-14 11:34:07 -0700145 }
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100146
Brian Carlstromae826982011-11-09 01:33:42 -0800147 private:
148 template<class T>
149 T GetOatPointer(uint32_t offset) const {
150 if (offset == 0) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700151 return nullptr;
Brian Carlstromae826982011-11-09 01:33:42 -0800152 }
Ian Rogers30fab402012-01-23 15:43:46 -0800153 return reinterpret_cast<T>(begin_ + offset);
Brian Carlstromae826982011-11-09 01:33:42 -0800154 }
155
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800156 const uint8_t* begin_;
157 uint32_t code_offset_;
Brian Carlstromae826982011-11-09 01:33:42 -0800158
159 friend class OatClass;
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700160 };
161
Richard Uhler07b3c232015-03-31 15:57:54 -0700162 class OatClass FINAL {
Brian Carlstrome24fa612011-09-29 00:53:55 -0700163 public:
Brian Carlstromba150c32013-08-27 17:31:03 -0700164 mirror::Class::Status GetStatus() const {
165 return status_;
166 }
167
168 OatClassType GetType() const {
169 return type_;
170 }
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800171
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700172 // Get the OatMethod entry based on its index into the class
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700173 // defintion. Direct methods come first, followed by virtual
174 // methods. Note that runtime created methods such as miranda
Brian Carlstrome24fa612011-09-29 00:53:55 -0700175 // methods are not included.
Brian Carlstromaded5f72011-10-07 17:15:04 -0700176 const OatMethod GetOatMethod(uint32_t method_index) const;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700177
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700178 // Return a pointer to the OatMethodOffsets for the requested
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700179 // method_index, or null if none is present. Note that most
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700180 // callers should use GetOatMethod.
181 const OatMethodOffsets* GetOatMethodOffsets(uint32_t method_index) const;
182
183 // Return the offset from the start of the OatFile to the
184 // OatMethodOffsets for the requested method_index, or 0 if none
185 // is present. Note that most callers should use GetOatMethod.
186 uint32_t GetOatMethodOffsetsOffset(uint32_t method_index) const;
187
Ian Rogers97b52f82014-08-14 11:34:07 -0700188 // A representation of an invalid OatClass, used when an OatClass can't be found.
189 // See ClassLinker::FindOatClass.
190 static OatClass Invalid() {
191 return OatClass(nullptr, mirror::Class::kStatusError, kOatClassNoneCompiled, 0, nullptr,
192 nullptr);
193 }
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100194
Brian Carlstrome24fa612011-09-29 00:53:55 -0700195 private:
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800196 OatClass(const OatFile* oat_file,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800197 mirror::Class::Status status,
Brian Carlstromba150c32013-08-27 17:31:03 -0700198 OatClassType type,
199 uint32_t bitmap_size,
200 const uint32_t* bitmap_pointer,
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800201 const OatMethodOffsets* methods_pointer);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700202
Ian Rogers97b52f82014-08-14 11:34:07 -0700203 const OatFile* const oat_file_;
Brian Carlstromba150c32013-08-27 17:31:03 -0700204
Ian Rogers97b52f82014-08-14 11:34:07 -0700205 const mirror::Class::Status status_;
Brian Carlstromba150c32013-08-27 17:31:03 -0700206
Ian Rogers97b52f82014-08-14 11:34:07 -0700207 const OatClassType type_;
Brian Carlstromba150c32013-08-27 17:31:03 -0700208
Ian Rogers97b52f82014-08-14 11:34:07 -0700209 const uint32_t* const bitmap_;
Brian Carlstromba150c32013-08-27 17:31:03 -0700210
Ian Rogers97b52f82014-08-14 11:34:07 -0700211 const OatMethodOffsets* const methods_pointer_;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700212
Richard Uhler07b3c232015-03-31 15:57:54 -0700213 friend class art::OatDexFile;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700214 };
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700215 const OatDexFile* GetOatDexFile(const char* dex_location,
Brian Carlstrom756ee4e2013-10-03 15:46:12 -0700216 const uint32_t* const dex_location_checksum,
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100217 bool exception_if_not_found = true) const
218 LOCKS_EXCLUDED(secondary_lookup_lock_);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700219
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100220 const std::vector<const OatDexFile*>& GetOatDexFiles() const {
221 return oat_dex_files_storage_;
222 }
Brian Carlstrome24fa612011-09-29 00:53:55 -0700223
Ian Rogers30fab402012-01-23 15:43:46 -0800224 size_t Size() const {
225 return End() - Begin();
Brian Carlstrome24fa612011-09-29 00:53:55 -0700226 }
227
Vladimir Marko5c42c292015-02-25 12:02:49 +0000228 size_t BssSize() const {
229 return BssEnd() - BssBegin();
230 }
231
Ian Rogers13735952014-10-08 12:43:28 -0700232 const uint8_t* Begin() const;
233 const uint8_t* End() const;
Alex Light53cb16b2014-06-12 11:26:29 -0700234
Vladimir Marko5c42c292015-02-25 12:02:49 +0000235 const uint8_t* BssBegin() const;
236 const uint8_t* BssEnd() const;
237
Richard Uhlere5fed032015-03-18 08:21:11 -0700238 // Returns the absolute dex location for the encoded relative dex location.
239 //
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700240 // If not null, abs_dex_location is used to resolve the absolute dex
Richard Uhlere5fed032015-03-18 08:21:11 -0700241 // location of relative dex locations encoded in the oat file.
242 // For example, given absolute location "/data/app/foo/base.apk", encoded
243 // dex locations "base.apk", "base.apk:classes2.dex", etc. would be resolved
244 // to "/data/app/foo/base.apk", "/data/app/foo/base.apk:classes2.dex", etc.
245 // Relative encoded dex locations that don't match the given abs_dex_location
246 // are left unchanged.
247 static std::string ResolveRelativeEncodedDexLocation(
248 const char* abs_dex_location, const std::string& rel_dex_location);
249
Andreas Gampe7848da42015-04-09 11:15:04 -0700250 // Create a dependency list (dex locations and checksums) for the given dex files.
251 static std::string EncodeDexFileDependencies(const std::vector<const DexFile*>& dex_files);
252
253 // Check the given dependency list against their dex files - thus the name "Static," this does
254 // not check the class-loader environment, only whether there have been file updates.
255 static bool CheckStaticDexFileDependencies(const char* dex_dependencies, std::string* msg);
256
257 // Get the dex locations of a dependency list. Note: this is *not* cleaned for synthetic
258 // locations of multidex files.
259 static bool GetDexLocationsFromDependencies(const char* dex_dependencies,
260 std::vector<std::string>* locations);
261
Brian Carlstrome24fa612011-09-29 00:53:55 -0700262 private:
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800263 static void CheckLocation(const std::string& location);
264
Andreas Gampefa8429b2015-04-07 18:34:42 -0700265 static OatFile* OpenDlopen(const std::string& elf_filename,
266 const std::string& location,
267 uint8_t* requested_base,
268 const char* abs_dex_location,
269 std::string* error_msg);
270
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800271 static OatFile* OpenElfFile(File* file,
272 const std::string& location,
Ian Rogers13735952014-10-08 12:43:28 -0700273 uint8_t* requested_base,
Igor Murashkin46774762014-10-22 11:37:02 -0700274 uint8_t* oat_file_begin, // Override base if not null
Brian Carlstromf1d34552013-07-12 20:22:23 -0700275 bool writable,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700276 bool executable,
Richard Uhlere5fed032015-03-18 08:21:11 -0700277 const char* abs_dex_location,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700278 std::string* error_msg);
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800279
Alex Light9dcc4572014-08-14 14:16:26 -0700280 explicit OatFile(const std::string& filename, bool executable);
Andreas Gampefa8429b2015-04-07 18:34:42 -0700281 bool Dlopen(const std::string& elf_filename, uint8_t* requested_base,
282 const char* abs_dex_location, std::string* error_msg);
Igor Murashkin46774762014-10-22 11:37:02 -0700283 bool ElfFileOpen(File* file, uint8_t* requested_base,
284 uint8_t* oat_file_begin, // Override where the file is loaded to if not null
285 bool writable, bool executable,
Richard Uhlere5fed032015-03-18 08:21:11 -0700286 const char* abs_dex_location,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700287 std::string* error_msg);
Richard Uhlere5fed032015-03-18 08:21:11 -0700288
289 bool Setup(const char* abs_dex_location, std::string* error_msg);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700290
Brian Carlstrome24fa612011-09-29 00:53:55 -0700291 // The oat file name.
292 //
293 // The image will embed this to link its associated oat file.
294 const std::string location_;
295
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800296 // Pointer to OatHeader.
Ian Rogers13735952014-10-08 12:43:28 -0700297 const uint8_t* begin_;
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800298
299 // Pointer to end of oat region for bounds checking.
Ian Rogers13735952014-10-08 12:43:28 -0700300 const uint8_t* end_;
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800301
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700302 // Pointer to the .bss section, if present, otherwise null.
Vladimir Marko5c42c292015-02-25 12:02:49 +0000303 const uint8_t* bss_begin_;
304
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700305 // Pointer to the end of the .bss section, if present, otherwise null.
Vladimir Marko5c42c292015-02-25 12:02:49 +0000306 const uint8_t* bss_end_;
307
Alex Light9dcc4572014-08-14 14:16:26 -0700308 // Was this oat_file loaded executable?
309 const bool is_executable_;
310
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800311 // Backing memory map for oat file during when opened by ElfWriter during initial compilation.
Ian Rogers700a4022014-05-19 16:49:03 -0700312 std::unique_ptr<MemMap> mem_map_;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700313
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800314 // Backing memory map for oat file during cross compilation.
Ian Rogers700a4022014-05-19 16:49:03 -0700315 std::unique_ptr<ElfFile> elf_file_;
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800316
317 // dlopen handle during runtime.
318 void* dlopen_handle_;
319
David Srbecky82e73dc2015-06-17 18:36:23 +0100320 // Dummy memory map objects corresponding to the regions mapped by dlopen.
321 std::vector<std::unique_ptr<MemMap>> dlopen_mmaps_;
322
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100323 // Owning storage for the OatDexFile objects.
324 std::vector<const OatDexFile*> oat_dex_files_storage_;
325
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100326 // NOTE: We use a StringPiece as the key type to avoid a memory allocation on every
327 // lookup with a const char* key. The StringPiece doesn't own its backing storage,
328 // therefore we're using the OatDexFile::dex_file_location_ as the backing storage
329 // for keys in oat_dex_files_ and the string_cache_ entries for the backing storage
330 // of keys in secondary_oat_dex_files_ and oat_dex_files_by_canonical_location_.
Mathieu Chartierbad02672014-08-25 13:08:22 -0700331 typedef AllocationTrackingSafeMap<StringPiece, const OatDexFile*, kAllocatorTagOatFile> Table;
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100332
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100333 // Map each location and canonical location (if different) retrieved from the
334 // oat file to its OatDexFile. This map doesn't change after it's constructed in Setup()
335 // and therefore doesn't need any locking and provides the cheapest dex file lookup
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700336 // for GetOatDexFile() for a very frequent use case. Never contains a null value.
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100337 Table oat_dex_files_;
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100338
339 // Lock guarding all members needed for secondary lookup in GetOatDexFile().
340 mutable Mutex secondary_lookup_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
341
342 // If the primary oat_dex_files_ lookup fails, use a secondary map. This map stores
343 // the results of all previous secondary lookups, whether successful (non-null) or
344 // failed (null). If it doesn't contain an entry we need to calculate the canonical
345 // location and use oat_dex_files_by_canonical_location_.
346 mutable Table secondary_oat_dex_files_ GUARDED_BY(secondary_lookup_lock_);
347
Vladimir Marko3f5838d2014-08-07 18:07:18 +0100348 // Cache of strings. Contains the backing storage for keys in the secondary_oat_dex_files_
349 // and the lazily initialized oat_dex_files_by_canonical_location_.
350 // NOTE: We're keeping references to contained strings in form of StringPiece and adding
351 // new strings to the end. The adding of a new element must not touch any previously stored
352 // elements. std::list<> and std::deque<> satisfy this requirement, std::vector<> doesn't.
353 mutable std::list<std::string> string_cache_ GUARDED_BY(secondary_lookup_lock_);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700354
355 friend class OatClass;
Richard Uhler07b3c232015-03-31 15:57:54 -0700356 friend class art::OatDexFile;
Elliott Hughese3c845c2012-02-28 17:23:01 -0800357 friend class OatDumper; // For GetBase and GetLimit
Brian Carlstrome24fa612011-09-29 00:53:55 -0700358 DISALLOW_COPY_AND_ASSIGN(OatFile);
359};
360
Richard Uhler07b3c232015-03-31 15:57:54 -0700361// OatDexFile should be an inner class of OatFile. Unfortunately, C++ doesn't
362// support forward declarations of inner classes, and we want to
363// forward-declare OatDexFile so that we can store an opaque pointer to an
364// OatDexFile in DexFile.
365class OatDexFile FINAL {
366 public:
367 // Opens the DexFile referred to by this OatDexFile from within the containing OatFile.
368 std::unique_ptr<const DexFile> OpenDexFile(std::string* error_msg) const;
369
370 const OatFile* GetOatFile() const {
371 return oat_file_;
372 }
373
374 // Returns the size of the DexFile refered to by this OatDexFile.
375 size_t FileSize() const;
376
377 // Returns original path of DexFile that was the source of this OatDexFile.
378 const std::string& GetDexFileLocation() const {
379 return dex_file_location_;
380 }
381
382 // Returns the canonical location of DexFile that was the source of this OatDexFile.
383 const std::string& GetCanonicalDexFileLocation() const {
384 return canonical_dex_file_location_;
385 }
386
387 // Returns checksum of original DexFile that was the source of this OatDexFile;
388 uint32_t GetDexFileLocationChecksum() const {
389 return dex_file_location_checksum_;
390 }
391
392 // Returns the OatClass for the class specified by the given DexFile class_def_index.
393 OatFile::OatClass GetOatClass(uint16_t class_def_index) const;
394
395 // Returns the offset to the OatClass information. Most callers should use GetOatClass.
396 uint32_t GetOatClassOffset(uint16_t class_def_index) const;
397
398 ~OatDexFile();
399
400 private:
401 OatDexFile(const OatFile* oat_file,
402 const std::string& dex_file_location,
403 const std::string& canonical_dex_file_location,
404 uint32_t dex_file_checksum,
405 const uint8_t* dex_file_pointer,
406 const uint32_t* oat_class_offsets_pointer);
407
408 const OatFile* const oat_file_;
409 const std::string dex_file_location_;
410 const std::string canonical_dex_file_location_;
411 const uint32_t dex_file_location_checksum_;
412 const uint8_t* const dex_file_pointer_;
413 const uint32_t* const oat_class_offsets_pointer_;
414
415 friend class OatFile;
416 DISALLOW_COPY_AND_ASSIGN(OatDexFile);
417};
418
Brian Carlstrome24fa612011-09-29 00:53:55 -0700419} // namespace art
420
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700421#endif // ART_RUNTIME_OAT_FILE_H_