1 /* 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 */ 16 17 #ifndef ART_COMPILER_OAT_WRITER_H_ 18 #define ART_COMPILER_OAT_WRITER_H_ 19 20 #include <stdint.h> 21 #include <cstddef> 22 #include <memory> 23 24 #include "base/dchecked_vector.h" 25 #include "linker/relative_patcher.h" // For linker::RelativePatcherTargetProvider. 26 #include "mem_map.h" 27 #include "method_reference.h" 28 #include "mirror/class.h" 29 #include "oat.h" 30 #include "os.h" 31 #include "safe_map.h" 32 #include "ScopedFd.h" 33 #include "utils/array_ref.h" 34 35 namespace art { 36 37 class BitVector; 38 class CompiledMethod; 39 class CompilerDriver; 40 class ImageWriter; 41 class OutputStream; 42 class TimingLogger; 43 class TypeLookupTable; 44 class ZipEntry; 45 46 namespace debug { 47 struct MethodDebugInfo; 48 } // namespace debug 49 50 namespace linker { 51 class MultiOatRelativePatcher; 52 } // namespace linker 53 54 // OatHeader variable length with count of D OatDexFiles 55 // 56 // OatDexFile[0] one variable sized OatDexFile with offsets to Dex and OatClasses 57 // OatDexFile[1] 58 // ... 59 // OatDexFile[D] 60 // 61 // Dex[0] one variable sized DexFile for each OatDexFile. 62 // Dex[1] these are literal copies of the input .dex files. 63 // ... 64 // Dex[D] 65 // 66 // TypeLookupTable[0] one descriptor to class def index hash table for each OatDexFile. 67 // TypeLookupTable[1] 68 // ... 69 // TypeLookupTable[D] 70 // 71 // ClassOffsets[0] one table of OatClass offsets for each class def for each OatDexFile. 72 // ClassOffsets[1] 73 // ... 74 // ClassOffsets[D] 75 // 76 // OatClass[0] one variable sized OatClass for each of C DexFile::ClassDefs 77 // OatClass[1] contains OatClass entries with class status, offsets to code, etc. 78 // ... 79 // OatClass[C] 80 // 81 // GcMap one variable sized blob with GC map. 82 // GcMap GC maps are deduplicated. 83 // ... 84 // GcMap 85 // 86 // VmapTable one variable sized VmapTable blob (quick compiler only). 87 // VmapTable VmapTables are deduplicated. 88 // ... 89 // VmapTable 90 // 91 // MappingTable one variable sized blob with MappingTable (quick compiler only). 92 // MappingTable MappingTables are deduplicated. 93 // ... 94 // MappingTable 95 // 96 // padding if necessary so that the following code will be page aligned 97 // 98 // OatMethodHeader fixed size header for a CompiledMethod including the size of the MethodCode. 99 // MethodCode one variable sized blob with the code of a CompiledMethod. 100 // OatMethodHeader (OatMethodHeader, MethodCode) pairs are deduplicated. 101 // MethodCode 102 // ... 103 // OatMethodHeader 104 // MethodCode 105 // 106 class OatWriter { 107 public: 108 enum class CreateTypeLookupTable { 109 kCreate, 110 kDontCreate, 111 kDefault = kCreate 112 }; 113 114 OatWriter(bool compiling_boot_image, TimingLogger* timings); 115 116 // To produce a valid oat file, the user must first add sources with any combination of 117 // - AddDexFileSource(), 118 // - AddZippedDexFilesSource(), 119 // - AddRawDexFileSource(). 120 // Then the user must call in order 121 // - WriteAndOpenDexFiles() 122 // - PrepareLayout(), 123 // - WriteRodata(), 124 // - WriteCode(), 125 // - WriteHeader(). 126 127 // Add dex file source(s) from a file, either a plain dex file or 128 // a zip file with one or more dex files. 129 bool AddDexFileSource( 130 const char* filename, 131 const char* location, 132 CreateTypeLookupTable create_type_lookup_table = CreateTypeLookupTable::kDefault); 133 // Add dex file source(s) from a zip file specified by a file handle. 134 bool AddZippedDexFilesSource( 135 ScopedFd&& zip_fd, 136 const char* location, 137 CreateTypeLookupTable create_type_lookup_table = CreateTypeLookupTable::kDefault); 138 // Add dex file source from raw memory. 139 bool AddRawDexFileSource( 140 const ArrayRef<const uint8_t>& data, 141 const char* location, 142 uint32_t location_checksum, 143 CreateTypeLookupTable create_type_lookup_table = CreateTypeLookupTable::kDefault); 144 dchecked_vector<const char*> GetSourceLocations() const; 145 146 // Write raw dex files to the .rodata section and open them from the oat file. The verify 147 // setting dictates whether the dex file verifier should check the dex files. This is generally 148 // the case, and should only be false for tests. 149 bool WriteAndOpenDexFiles(OutputStream* rodata, 150 File* file, 151 InstructionSet instruction_set, 152 const InstructionSetFeatures* instruction_set_features, 153 SafeMap<std::string, std::string>* key_value_store, 154 bool verify, 155 /*out*/ std::unique_ptr<MemMap>* opened_dex_files_map, 156 /*out*/ std::vector<std::unique_ptr<const DexFile>>* opened_dex_files); 157 // Prepare layout of remaining data. 158 void PrepareLayout(const CompilerDriver* compiler, 159 ImageWriter* image_writer, 160 const std::vector<const DexFile*>& dex_files, 161 linker::MultiOatRelativePatcher* relative_patcher); 162 // Write the rest of .rodata section (ClassOffsets[], OatClass[], maps). 163 bool WriteRodata(OutputStream* out); 164 // Write the code to the .text section. 165 bool WriteCode(OutputStream* out); 166 // Write the oat header. This finalizes the oat file. 167 bool WriteHeader(OutputStream* out, 168 uint32_t image_file_location_oat_checksum, 169 uintptr_t image_file_location_oat_begin, 170 int32_t image_patch_delta); 171 172 // Returns whether the oat file has an associated image. HasImage()173 bool HasImage() const { 174 // Since the image is being created at the same time as the oat file, 175 // check if there's an image writer. 176 return image_writer_ != nullptr; 177 } 178 HasBootImage()179 bool HasBootImage() const { 180 return compiling_boot_image_; 181 } 182 GetOatHeader()183 const OatHeader& GetOatHeader() const { 184 return *oat_header_; 185 } 186 GetSize()187 size_t GetSize() const { 188 return size_; 189 } 190 GetBssSize()191 size_t GetBssSize() const { 192 return bss_size_; 193 } 194 GetOatDataOffset()195 size_t GetOatDataOffset() const { 196 return oat_data_offset_; 197 } 198 GetAbsolutePatchLocations()199 ArrayRef<const uintptr_t> GetAbsolutePatchLocations() const { 200 return ArrayRef<const uintptr_t>(absolute_patch_locations_); 201 } 202 203 ~OatWriter(); 204 AddMethodDebugInfos(const std::vector<debug::MethodDebugInfo> & infos)205 void AddMethodDebugInfos(const std::vector<debug::MethodDebugInfo>& infos) { 206 method_info_.insert(method_info_.end(), infos.begin(), infos.end()); 207 } 208 GetMethodDebugInfo()209 ArrayRef<const debug::MethodDebugInfo> GetMethodDebugInfo() const { 210 return ArrayRef<const debug::MethodDebugInfo>(method_info_); 211 } 212 GetCompilerDriver()213 const CompilerDriver* GetCompilerDriver() { 214 return compiler_driver_; 215 } 216 217 private: 218 class DexFileSource; 219 class OatClass; 220 class OatDexFile; 221 222 // The function VisitDexMethods() below iterates through all the methods in all 223 // the compiled dex files in order of their definitions. The method visitor 224 // classes provide individual bits of processing for each of the passes we need to 225 // first collect the data we want to write to the oat file and then, in later passes, 226 // to actually write it. 227 class DexMethodVisitor; 228 class OatDexMethodVisitor; 229 class InitOatClassesMethodVisitor; 230 class InitCodeMethodVisitor; 231 class InitMapMethodVisitor; 232 class InitImageMethodVisitor; 233 class WriteCodeMethodVisitor; 234 class WriteMapMethodVisitor; 235 236 // Visit all the methods in all the compiled dex files in their definition order 237 // with a given DexMethodVisitor. 238 bool VisitDexMethods(DexMethodVisitor* visitor); 239 240 size_t InitOatHeader(InstructionSet instruction_set, 241 const InstructionSetFeatures* instruction_set_features, 242 uint32_t num_dex_files, 243 SafeMap<std::string, std::string>* key_value_store); 244 size_t InitOatDexFiles(size_t offset); 245 size_t InitOatClasses(size_t offset); 246 size_t InitOatMaps(size_t offset); 247 size_t InitOatCode(size_t offset); 248 size_t InitOatCodeDexFiles(size_t offset); 249 250 bool WriteClassOffsets(OutputStream* out); 251 bool WriteClasses(OutputStream* out); 252 size_t WriteMaps(OutputStream* out, const size_t file_offset, size_t relative_offset); 253 size_t WriteCode(OutputStream* out, const size_t file_offset, size_t relative_offset); 254 size_t WriteCodeDexFiles(OutputStream* out, const size_t file_offset, size_t relative_offset); 255 256 bool RecordOatDataOffset(OutputStream* out); 257 bool ReadDexFileHeader(File* file, OatDexFile* oat_dex_file); 258 bool ValidateDexFileHeader(const uint8_t* raw_header, const char* location); 259 bool WriteDexFiles(OutputStream* rodata, File* file); 260 bool WriteDexFile(OutputStream* rodata, File* file, OatDexFile* oat_dex_file); 261 bool SeekToDexFile(OutputStream* rodata, File* file, OatDexFile* oat_dex_file); 262 bool WriteDexFile(OutputStream* rodata, File* file, OatDexFile* oat_dex_file, ZipEntry* dex_file); 263 bool WriteDexFile(OutputStream* rodata, File* file, OatDexFile* oat_dex_file, File* dex_file); 264 bool WriteDexFile(OutputStream* rodata, OatDexFile* oat_dex_file, const uint8_t* dex_file); 265 bool WriteOatDexFiles(OutputStream* rodata); 266 bool ExtendForTypeLookupTables(OutputStream* rodata, File* file, size_t offset); 267 bool OpenDexFiles(File* file, 268 bool verify, 269 /*out*/ std::unique_ptr<MemMap>* opened_dex_files_map, 270 /*out*/ std::vector<std::unique_ptr<const DexFile>>* opened_dex_files); 271 bool WriteTypeLookupTables(MemMap* opened_dex_files_map, 272 const std::vector<std::unique_ptr<const DexFile>>& opened_dex_files); 273 bool WriteCodeAlignment(OutputStream* out, uint32_t aligned_code_delta); 274 void SetMultiOatRelativePatcherAdjustment(); 275 276 enum class WriteState { 277 kAddingDexFileSources, 278 kPrepareLayout, 279 kWriteRoData, 280 kWriteText, 281 kWriteHeader, 282 kDone 283 }; 284 285 WriteState write_state_; 286 TimingLogger* timings_; 287 288 std::vector<std::unique_ptr<File>> raw_dex_files_; 289 std::vector<std::unique_ptr<ZipArchive>> zip_archives_; 290 std::vector<std::unique_ptr<ZipEntry>> zipped_dex_files_; 291 292 // Using std::list<> which doesn't move elements around on push/emplace_back(). 293 // We need this because we keep plain pointers to the strings' c_str(). 294 std::list<std::string> zipped_dex_file_locations_; 295 296 dchecked_vector<debug::MethodDebugInfo> method_info_; 297 298 const CompilerDriver* compiler_driver_; 299 ImageWriter* image_writer_; 300 const bool compiling_boot_image_; 301 302 // note OatFile does not take ownership of the DexFiles 303 const std::vector<const DexFile*>* dex_files_; 304 305 // Size required for Oat data structures. 306 size_t size_; 307 308 // The size of the required .bss section holding the DexCache data. 309 size_t bss_size_; 310 311 // Offsets of the dex cache arrays for each app dex file. For the 312 // boot image, this information is provided by the ImageWriter. 313 SafeMap<const DexFile*, size_t> dex_cache_arrays_offsets_; // DexFiles not owned. 314 315 // Offset of the oat data from the start of the mmapped region of the elf file. 316 size_t oat_data_offset_; 317 318 // data to write 319 std::unique_ptr<OatHeader> oat_header_; 320 dchecked_vector<OatDexFile> oat_dex_files_; 321 dchecked_vector<OatClass> oat_classes_; 322 std::unique_ptr<const std::vector<uint8_t>> jni_dlsym_lookup_; 323 std::unique_ptr<const std::vector<uint8_t>> quick_generic_jni_trampoline_; 324 std::unique_ptr<const std::vector<uint8_t>> quick_imt_conflict_trampoline_; 325 std::unique_ptr<const std::vector<uint8_t>> quick_resolution_trampoline_; 326 std::unique_ptr<const std::vector<uint8_t>> quick_to_interpreter_bridge_; 327 328 // output stats 329 uint32_t size_dex_file_alignment_; 330 uint32_t size_executable_offset_alignment_; 331 uint32_t size_oat_header_; 332 uint32_t size_oat_header_key_value_store_; 333 uint32_t size_dex_file_; 334 uint32_t size_interpreter_to_interpreter_bridge_; 335 uint32_t size_interpreter_to_compiled_code_bridge_; 336 uint32_t size_jni_dlsym_lookup_; 337 uint32_t size_quick_generic_jni_trampoline_; 338 uint32_t size_quick_imt_conflict_trampoline_; 339 uint32_t size_quick_resolution_trampoline_; 340 uint32_t size_quick_to_interpreter_bridge_; 341 uint32_t size_trampoline_alignment_; 342 uint32_t size_method_header_; 343 uint32_t size_code_; 344 uint32_t size_code_alignment_; 345 uint32_t size_relative_call_thunks_; 346 uint32_t size_misc_thunks_; 347 uint32_t size_vmap_table_; 348 uint32_t size_oat_dex_file_location_size_; 349 uint32_t size_oat_dex_file_location_data_; 350 uint32_t size_oat_dex_file_location_checksum_; 351 uint32_t size_oat_dex_file_offset_; 352 uint32_t size_oat_dex_file_class_offsets_offset_; 353 uint32_t size_oat_dex_file_lookup_table_offset_; 354 uint32_t size_oat_lookup_table_alignment_; 355 uint32_t size_oat_lookup_table_; 356 uint32_t size_oat_class_offsets_alignment_; 357 uint32_t size_oat_class_offsets_; 358 uint32_t size_oat_class_type_; 359 uint32_t size_oat_class_status_; 360 uint32_t size_oat_class_method_bitmaps_; 361 uint32_t size_oat_class_method_offsets_; 362 363 // The helper for processing relative patches is external so that we can patch across oat files. 364 linker::MultiOatRelativePatcher* relative_patcher_; 365 366 // The locations of absolute patches relative to the start of the executable section. 367 dchecked_vector<uintptr_t> absolute_patch_locations_; 368 369 DISALLOW_COPY_AND_ASSIGN(OatWriter); 370 }; 371 372 } // namespace art 373 374 #endif // ART_COMPILER_OAT_WRITER_H_ 375