blob: e71db4714d30618ccd3b16563b16fd887841e299 [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
17#ifndef ART_SRC_OAT_FILE_H_
18#define ART_SRC_OAT_FILE_H_
19
Brian Carlstrom700c8d32012-11-05 10:42:02 -080020#include <string>
Brian Carlstrome24fa612011-09-29 00:53:55 -070021#include <vector>
22
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080023#include "dex_file.h"
24#include "invoke_type.h"
25#include "mem_map.h"
26#include "mirror/abstract_method.h"
27#include "oat.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080028#include "os.h"
Brian Carlstrome24fa612011-09-29 00:53:55 -070029
30namespace art {
31
Brian Carlstrom700c8d32012-11-05 10:42:02 -080032class ElfFile;
33class MemMap;
34class OatMethodOffsets;
35struct OatHeader;
36
Brian Carlstrome24fa612011-09-29 00:53:55 -070037class OatFile {
38 public:
Brian Carlstromb7bbba42011-10-13 14:58:47 -070039 // Returns an OatFile name based on a DexFile location
jeffhao262bf462011-10-20 18:36:32 -070040 static std::string DexFilenameToOatFilename(const std::string& location);
Brian Carlstromb7bbba42011-10-13 14:58:47 -070041
Brian Carlstrome24fa612011-09-29 00:53:55 -070042 // Open an oat file. Returns NULL on failure. Requested base can
43 // optionally be used to request where the file should be loaded.
44 static OatFile* Open(const std::string& filename,
Brian Carlstroma004aa92012-02-08 18:05:09 -080045 const std::string& location,
Brian Carlstrom700c8d32012-11-05 10:42:02 -080046 byte* requested_base);
Brian Carlstrome24fa612011-09-29 00:53:55 -070047
Brian Carlstrom700c8d32012-11-05 10:42:02 -080048 // Open an oat file from an already opened File.
Brian Carlstrom265091e2013-01-30 14:08:26 -080049 // Does not use dlopen underneath so cannot be used for runtime use
50 // where relocations may be required. Currently used from
51 // ImageWriter which wants to open a writable version from an existing
52 // file descriptor for patching.
53 static OatFile* OpenWritable(File* file, const std::string& location);
Brian Carlstrom700c8d32012-11-05 10:42:02 -080054
55 // Open an oat file backed by a std::vector with the given location.
Brian Carlstrom265091e2013-01-30 14:08:26 -080056 static OatFile* OpenMemory(std::vector<uint8_t>& oat_contents,
57 const std::string& location);
Brian Carlstrom5b332c82012-02-01 15:02:31 -080058
Brian Carlstrome24fa612011-09-29 00:53:55 -070059 ~OatFile();
60
61 const std::string& GetLocation() const {
62 return location_;
63 }
64
65 const OatHeader& GetOatHeader() const;
66
67 class OatDexFile;
68
Brian Carlstrom3320cf42011-10-04 14:58:28 -070069 class OatMethod {
70 public:
Brian Carlstrom265091e2013-01-30 14:08:26 -080071 void LinkMethod(mirror::AbstractMethod* method) const;
Brian Carlstromae826982011-11-09 01:33:42 -080072
73 uint32_t GetCodeOffset() const {
74 return code_offset_;
75 }
76 size_t GetFrameSizeInBytes() const {
77 return frame_size_in_bytes_;
78 }
79 uint32_t GetCoreSpillMask() const {
80 return core_spill_mask_;
81 }
82 uint32_t GetFpSpillMask() const {
83 return fp_spill_mask_;
84 }
85 uint32_t GetMappingTableOffset() const {
86 return mapping_table_offset_;
87 }
88 uint32_t GetVmapTableOffset() const {
89 return vmap_table_offset_;
90 }
Ian Rogers0c7abda2012-09-19 13:33:42 -070091 uint32_t GetNativeGcMapOffset() const {
92 return native_gc_map_offset_;
Brian Carlstrome7d856b2012-01-11 18:10:55 -080093 }
Brian Carlstromae826982011-11-09 01:33:42 -080094
Logan Chien0c717dd2012-03-28 18:31:07 +080095 const void* GetCode() const;
96 uint32_t GetCodeSize() const;
97
Brian Carlstromae826982011-11-09 01:33:42 -080098 const uint32_t* GetMappingTable() const {
99 return GetOatPointer<const uint32_t*>(mapping_table_offset_);
100 }
101 const uint16_t* GetVmapTable() const {
102 return GetOatPointer<const uint16_t*>(vmap_table_offset_);
103 }
Ian Rogers0c7abda2012-09-19 13:33:42 -0700104 const uint8_t* GetNativeGcMap() const {
105 return GetOatPointer<const uint8_t*>(native_gc_map_offset_);
Brian Carlstrome7d856b2012-01-11 18:10:55 -0800106 }
Logan Chien0c717dd2012-03-28 18:31:07 +0800107
Ian Rogersc928de92013-02-27 14:30:44 -0800108#if defined(ART_USE_PORTABLE_COMPILER)
TDYa127eead4ac2012-06-03 07:15:25 -0700109 const void* GetProxyStub() const;
110#endif
111
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700112 ~OatMethod();
113
Brian Carlstromae826982011-11-09 01:33:42 -0800114 // Create an OatMethod with offsets relative to the given base address
115 OatMethod(const byte* base,
116 const uint32_t code_offset,
117 const size_t frame_size_in_bytes,
118 const uint32_t core_spill_mask,
119 const uint32_t fp_spill_mask,
120 const uint32_t mapping_table_offset,
121 const uint32_t vmap_table_offset,
Jeff Hao74180ca2013-03-27 15:29:11 -0700122 const uint32_t gc_map_offset
Ian Rogersc928de92013-02-27 14:30:44 -0800123#if defined(ART_USE_PORTABLE_COMPILER)
Logan Chien971bf3f2012-05-01 15:47:55 +0800124 , const uint32_t proxy_stub_offset
Logan Chien0c717dd2012-03-28 18:31:07 +0800125#endif
126 );
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700127
Brian Carlstromae826982011-11-09 01:33:42 -0800128 private:
129 template<class T>
130 T GetOatPointer(uint32_t offset) const {
131 if (offset == 0) {
132 return NULL;
133 }
Ian Rogers30fab402012-01-23 15:43:46 -0800134 return reinterpret_cast<T>(begin_ + offset);
Brian Carlstromae826982011-11-09 01:33:42 -0800135 }
136
Ian Rogers30fab402012-01-23 15:43:46 -0800137 const byte* begin_;
Brian Carlstromae826982011-11-09 01:33:42 -0800138
139 uint32_t code_offset_;
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700140 size_t frame_size_in_bytes_;
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700141 uint32_t core_spill_mask_;
142 uint32_t fp_spill_mask_;
Brian Carlstromae826982011-11-09 01:33:42 -0800143 uint32_t mapping_table_offset_;
144 uint32_t vmap_table_offset_;
Ian Rogers0c7abda2012-09-19 13:33:42 -0700145 uint32_t native_gc_map_offset_;
Brian Carlstromae826982011-11-09 01:33:42 -0800146
Ian Rogersc928de92013-02-27 14:30:44 -0800147#if defined(ART_USE_PORTABLE_COMPILER)
Logan Chien971bf3f2012-05-01 15:47:55 +0800148 uint32_t proxy_stub_offset_;
Logan Chien0c717dd2012-03-28 18:31:07 +0800149#endif
150
Brian Carlstromae826982011-11-09 01:33:42 -0800151 friend class OatClass;
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700152 };
153
Brian Carlstrome24fa612011-09-29 00:53:55 -0700154 class OatClass {
155 public:
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800156 mirror::Class::Status GetStatus() const;
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800157
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700158 // get the OatMethod entry based on its index into the class
Brian Carlstrome24fa612011-09-29 00:53:55 -0700159 // defintion. direct methods come first, followed by virtual
160 // methods. note that runtime created methods such as miranda
161 // methods are not included.
Brian Carlstromaded5f72011-10-07 17:15:04 -0700162 const OatMethod GetOatMethod(uint32_t method_index) const;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700163 ~OatClass();
164
165 private:
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800166 OatClass(const OatFile* oat_file,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800167 mirror::Class::Status status,
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800168 const OatMethodOffsets* methods_pointer);
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700169
Brian Carlstrome24fa612011-09-29 00:53:55 -0700170 const OatFile* oat_file_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800171 const mirror::Class::Status status_;
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700172 const OatMethodOffsets* methods_pointer_;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700173
174 friend class OatDexFile;
175 };
176
177 class OatDexFile {
178 public:
Brian Carlstrom89521892011-12-07 22:05:07 -0800179 const DexFile* OpenDexFile() const;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700180 const OatClass* GetOatClass(uint32_t class_def_index) const;
Ian Rogers05f28c62012-10-23 18:12:13 -0700181 size_t FileSize() const;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700182
183 const std::string& GetDexFileLocation() const {
184 return dex_file_location_;
185 }
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700186
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800187 uint32_t GetDexFileLocationChecksum() const {
188 return dex_file_location_checksum_;
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700189 }
190
Brian Carlstrome24fa612011-09-29 00:53:55 -0700191 ~OatDexFile();
Elliott Hughesa21039c2012-06-21 12:09:25 -0700192
Brian Carlstrome24fa612011-09-29 00:53:55 -0700193 private:
194 OatDexFile(const OatFile* oat_file,
Elliott Hughesaa6a5882012-01-13 19:39:16 -0800195 const std::string& dex_file_location,
Brian Carlstrome24fa612011-09-29 00:53:55 -0700196 uint32_t dex_file_checksum,
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800197 const byte* dex_file_pointer,
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800198 const uint32_t* oat_class_offsets_pointer);
Brian Carlstrome24fa612011-09-29 00:53:55 -0700199
200 const OatFile* oat_file_;
201 std::string dex_file_location_;
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800202 uint32_t dex_file_location_checksum_;
Brian Carlstrom89521892011-12-07 22:05:07 -0800203 const byte* dex_file_pointer_;
Brian Carlstrom0755ec52012-01-11 15:19:46 -0800204 const uint32_t* oat_class_offsets_pointer_;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700205
206 friend class OatFile;
207 DISALLOW_COPY_AND_ASSIGN(OatDexFile);
208 };
209
Ian Rogers7fe2c692011-12-06 16:35:59 -0800210 const OatDexFile* GetOatDexFile(const std::string& dex_file_location,
211 bool warn_if_not_found = true) const;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700212 std::vector<const OatDexFile*> GetOatDexFiles() const;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700213
Ian Rogers30fab402012-01-23 15:43:46 -0800214 size_t Size() const {
215 return End() - Begin();
Brian Carlstrome24fa612011-09-29 00:53:55 -0700216 }
217
218 private:
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800219 static void CheckLocation(const std::string& location);
220
221 static OatFile* OpenDlopen(const std::string& elf_filename,
222 const std::string& location,
223 byte* requested_base);
224
225 static OatFile* OpenElfFile(File* file,
226 const std::string& location,
227 byte* requested_base,
228 bool writable);
229
Elliott Hughesa51a3dd2011-10-17 15:19:26 -0700230 explicit OatFile(const std::string& filename);
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800231 bool Dlopen(const std::string& elf_filename, byte* requested_base);
232 bool ElfFileOpen(File* file, byte* requested_base, bool writable);
233 void Setup();
Brian Carlstrome24fa612011-09-29 00:53:55 -0700234
Ian Rogers30fab402012-01-23 15:43:46 -0800235 const byte* Begin() const;
236 const byte* End() const;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700237
238 // The oat file name.
239 //
240 // The image will embed this to link its associated oat file.
241 const std::string location_;
242
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800243 // Pointer to OatHeader.
244 const byte* begin_;
245
246 // Pointer to end of oat region for bounds checking.
247 const byte* end_;
248
249 // Backing memory map for oat file during when opened by ElfWriter during initial compilation.
Brian Carlstrome24fa612011-09-29 00:53:55 -0700250 UniquePtr<MemMap> mem_map_;
251
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800252 // Backing memory map for oat file during cross compilation.
253 UniquePtr<ElfFile> elf_file_;
254
255 // dlopen handle during runtime.
256 void* dlopen_handle_;
257
Elliott Hughesa0e18062012-04-13 15:59:59 -0700258 typedef SafeMap<std::string, const OatDexFile*> Table;
Brian Carlstrome24fa612011-09-29 00:53:55 -0700259 Table oat_dex_files_;
260
261 friend class OatClass;
262 friend class OatDexFile;
Elliott Hughese3c845c2012-02-28 17:23:01 -0800263 friend class OatDumper; // For GetBase and GetLimit
Brian Carlstrome24fa612011-09-29 00:53:55 -0700264 DISALLOW_COPY_AND_ASSIGN(OatFile);
265};
266
267} // namespace art
268
269#endif // ART_SRC_OAT_WRITER_H_