compiler_driver.h revision b666f4805c8ae707ea6fd7f6c7f375e0b000dba8
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_DRIVER_COMPILER_DRIVER_H_ 18#define ART_COMPILER_DRIVER_COMPILER_DRIVER_H_ 19 20#include <set> 21#include <string> 22#include <vector> 23 24#include "arch/instruction_set.h" 25#include "base/arena_allocator.h" 26#include "base/mutex.h" 27#include "base/timing_logger.h" 28#include "class_reference.h" 29#include "compiled_method.h" 30#include "compiler.h" 31#include "dex_file.h" 32#include "dex/verified_method.h" 33#include "driver/compiler_options.h" 34#include "invoke_type.h" 35#include "method_reference.h" 36#include "mirror/class.h" // For mirror::Class::Status. 37#include "os.h" 38#include "profiler.h" 39#include "runtime.h" 40#include "safe_map.h" 41#include "thread_pool.h" 42#include "utils/dedupe_set.h" 43#include "utils/swap_space.h" 44#include "utils.h" 45 46namespace art { 47 48namespace verifier { 49class MethodVerifier; 50} // namespace verifier 51 52class CompiledClass; 53class CompilerOptions; 54class DexCompilationUnit; 55class DexFileToMethodInlinerMap; 56struct InlineIGetIPutData; 57class InstructionSetFeatures; 58class OatWriter; 59class ParallelCompilationManager; 60class ScopedObjectAccess; 61template<class T> class Handle; 62class TimingLogger; 63class VerificationResults; 64class VerifiedMethod; 65 66enum EntryPointCallingConvention { 67 // ABI of invocations to a method's interpreter entry point. 68 kInterpreterAbi, 69 // ABI of calls to a method's native code, only used for native methods. 70 kJniAbi, 71 // ABI of calls to a method's quick code entry point. 72 kQuickAbi 73}; 74 75enum DexToDexCompilationLevel { 76 kDontDexToDexCompile, // Only meaning wrt image time interpretation. 77 kRequired, // Dex-to-dex compilation required for correctness. 78 kOptimize // Perform required transformation and peep-hole optimizations. 79}; 80std::ostream& operator<<(std::ostream& os, const DexToDexCompilationLevel& rhs); 81 82static constexpr bool kUseMurmur3Hash = true; 83 84class CompilerDriver { 85 public: 86 // Create a compiler targeting the requested "instruction_set". 87 // "image" should be true if image specific optimizations should be 88 // enabled. "image_classes" lets the compiler know what classes it 89 // can assume will be in the image, with nullptr implying all available 90 // classes. 91 explicit CompilerDriver(const CompilerOptions* compiler_options, 92 VerificationResults* verification_results, 93 DexFileToMethodInlinerMap* method_inliner_map, 94 Compiler::Kind compiler_kind, 95 InstructionSet instruction_set, 96 const InstructionSetFeatures* instruction_set_features, 97 bool image, std::set<std::string>* image_classes, 98 std::set<std::string>* compiled_classes, 99 size_t thread_count, bool dump_stats, bool dump_passes, 100 const std::string& dump_cfg_file_name, 101 CumulativeLogger* timer, int swap_fd, 102 const std::string& profile_file); 103 104 ~CompilerDriver(); 105 106 void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files, 107 TimingLogger* timings) 108 LOCKS_EXCLUDED(Locks::mutator_lock_); 109 110 // Compile a single Method. 111 void CompileOne(mirror::ArtMethod* method, TimingLogger* timings) 112 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 113 114 VerificationResults* GetVerificationResults() const { 115 return verification_results_; 116 } 117 118 DexFileToMethodInlinerMap* GetMethodInlinerMap() const { 119 return method_inliner_map_; 120 } 121 122 InstructionSet GetInstructionSet() const { 123 return instruction_set_; 124 } 125 126 const InstructionSetFeatures* GetInstructionSetFeatures() const { 127 return instruction_set_features_; 128 } 129 130 const CompilerOptions& GetCompilerOptions() const { 131 return *compiler_options_; 132 } 133 134 Compiler* GetCompiler() const { 135 return compiler_.get(); 136 } 137 138 bool ProfilePresent() const { 139 return profile_present_; 140 } 141 142 // Are we compiling and creating an image file? 143 bool IsImage() const { 144 return image_; 145 } 146 147 const std::set<std::string>* GetImageClasses() const { 148 return image_classes_.get(); 149 } 150 151 // Generate the trampolines that are invoked by unresolved direct methods. 152 const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const 153 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 154 const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const 155 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 156 const std::vector<uint8_t>* CreateJniDlsymLookup() const 157 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 158 const std::vector<uint8_t>* CreateQuickGenericJniTrampoline() const 159 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 160 const std::vector<uint8_t>* CreateQuickImtConflictTrampoline() const 161 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 162 const std::vector<uint8_t>* CreateQuickResolutionTrampoline() const 163 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 164 const std::vector<uint8_t>* CreateQuickToInterpreterBridge() const 165 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 166 167 CompiledClass* GetCompiledClass(ClassReference ref) const 168 LOCKS_EXCLUDED(compiled_classes_lock_); 169 170 CompiledMethod* GetCompiledMethod(MethodReference ref) const 171 LOCKS_EXCLUDED(compiled_methods_lock_); 172 size_t GetNonRelativeLinkerPatchCount() const 173 LOCKS_EXCLUDED(compiled_methods_lock_); 174 175 void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, 176 uint16_t class_def_index); 177 bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, uint16_t class_def_index); 178 179 // Callbacks from compiler to see what runtime checks must be generated. 180 181 bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx); 182 183 bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx) 184 LOCKS_EXCLUDED(Locks::mutator_lock_); 185 186 // Are runtime access checks necessary in the compiled code? 187 bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, 188 uint32_t type_idx, bool* type_known_final = nullptr, 189 bool* type_known_abstract = nullptr, 190 bool* equals_referrers_class = nullptr) 191 LOCKS_EXCLUDED(Locks::mutator_lock_); 192 193 // Are runtime access and instantiable checks necessary in the code? 194 bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, 195 uint32_t type_idx) 196 LOCKS_EXCLUDED(Locks::mutator_lock_); 197 198 bool CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx, 199 bool* is_type_initialized, bool* use_direct_type_ptr, 200 uintptr_t* direct_type_ptr, bool* out_is_finalizable); 201 202 // Query methods for the java.lang.ref.Reference class. 203 bool CanEmbedReferenceTypeInCode(ClassReference* ref, 204 bool* use_direct_type_ptr, uintptr_t* direct_type_ptr); 205 uint32_t GetReferenceSlowFlagOffset() const; 206 uint32_t GetReferenceDisableFlagOffset() const; 207 208 // Get the DexCache for the 209 mirror::DexCache* GetDexCache(const DexCompilationUnit* mUnit) 210 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 211 212 mirror::ClassLoader* GetClassLoader(ScopedObjectAccess& soa, const DexCompilationUnit* mUnit) 213 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 214 215 // Resolve compiling method's class. Returns nullptr on failure. 216 mirror::Class* ResolveCompilingMethodsClass( 217 const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 218 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit) 219 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 220 221 // Resolve a field. Returns nullptr on failure, including incompatible class change. 222 // NOTE: Unlike ClassLinker's ResolveField(), this method enforces is_static. 223 mirror::ArtField* ResolveField( 224 const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 225 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, 226 uint32_t field_idx, bool is_static) 227 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 228 229 // Get declaration location of a resolved field. 230 void GetResolvedFieldDexFileLocation( 231 mirror::ArtField* resolved_field, const DexFile** declaring_dex_file, 232 uint16_t* declaring_class_idx, uint16_t* declaring_field_idx) 233 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 234 235 bool IsFieldVolatile(mirror::ArtField* field) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 236 MemberOffset GetFieldOffset(mirror::ArtField* field) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 237 238 // Can we fast-path an IGET/IPUT access to an instance field? If yes, compute the field offset. 239 std::pair<bool, bool> IsFastInstanceField( 240 mirror::DexCache* dex_cache, mirror::Class* referrer_class, 241 mirror::ArtField* resolved_field, uint16_t field_idx) 242 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 243 244 // Can we fast-path an SGET/SPUT access to a static field? If yes, compute the type index 245 // of the declaring class in the referrer's dex file. 246 std::pair<bool, bool> IsFastStaticField( 247 mirror::DexCache* dex_cache, mirror::Class* referrer_class, 248 mirror::ArtField* resolved_field, uint16_t field_idx, uint32_t* storage_index) 249 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 250 251 // Is static field's in referrer's class? 252 bool IsStaticFieldInReferrerClass(mirror::Class* referrer_class, mirror::ArtField* resolved_field) 253 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 254 255 // Is static field's class initialized? 256 bool IsStaticFieldsClassInitialized(mirror::Class* referrer_class, 257 mirror::ArtField* resolved_field) 258 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 259 260 // Resolve a method. Returns nullptr on failure, including incompatible class change. 261 mirror::ArtMethod* ResolveMethod( 262 ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 263 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, 264 uint32_t method_idx, InvokeType invoke_type) 265 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 266 267 // Get declaration location of a resolved field. 268 void GetResolvedMethodDexFileLocation( 269 mirror::ArtMethod* resolved_method, const DexFile** declaring_dex_file, 270 uint16_t* declaring_class_idx, uint16_t* declaring_method_idx) 271 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 272 273 // Get the index in the vtable of the method. 274 uint16_t GetResolvedMethodVTableIndex( 275 mirror::ArtMethod* resolved_method, InvokeType type) 276 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 277 278 // Can we fast-path an INVOKE? If no, returns 0. If yes, returns a non-zero opaque flags value 279 // for ProcessedInvoke() and computes the necessary lowering info. 280 int IsFastInvoke( 281 ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 282 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, 283 mirror::Class* referrer_class, mirror::ArtMethod* resolved_method, InvokeType* invoke_type, 284 MethodReference* target_method, const MethodReference* devirt_target, 285 uintptr_t* direct_code, uintptr_t* direct_method) 286 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 287 288 // Is method's class initialized for an invoke? 289 // For static invokes to determine whether we need to consider potential call to <clinit>(). 290 // For non-static invokes, assuming a non-null reference, the class is always initialized. 291 bool IsMethodsClassInitialized(mirror::Class* referrer_class, mirror::ArtMethod* resolved_method) 292 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 293 294 void ProcessedInstanceField(bool resolved); 295 void ProcessedStaticField(bool resolved, bool local); 296 void ProcessedInvoke(InvokeType invoke_type, int flags); 297 298 // Can we fast path instance field access? Computes field's offset and volatility. 299 bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, 300 MemberOffset* field_offset, bool* is_volatile) 301 LOCKS_EXCLUDED(Locks::mutator_lock_); 302 303 mirror::ArtField* ComputeInstanceFieldInfo(uint32_t field_idx, 304 const DexCompilationUnit* mUnit, 305 bool is_put, 306 const ScopedObjectAccess& soa) 307 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 308 309 310 // Can we fastpath static field access? Computes field's offset, volatility and whether the 311 // field is within the referrer (which can avoid checking class initialization). 312 bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, 313 MemberOffset* field_offset, uint32_t* storage_index, 314 bool* is_referrers_class, bool* is_volatile, bool* is_initialized, 315 Primitive::Type* type) 316 LOCKS_EXCLUDED(Locks::mutator_lock_); 317 318 // Can we fastpath a interface, super class or virtual method call? Computes method's vtable 319 // index. 320 bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc, 321 bool update_stats, bool enable_devirtualization, 322 InvokeType* type, MethodReference* target_method, int* vtable_idx, 323 uintptr_t* direct_code, uintptr_t* direct_method) 324 LOCKS_EXCLUDED(Locks::mutator_lock_); 325 326 const VerifiedMethod* GetVerifiedMethod(const DexFile* dex_file, uint32_t method_idx) const; 327 bool IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc); 328 329 bool GetSupportBootImageFixup() const { 330 return support_boot_image_fixup_; 331 } 332 333 void SetSupportBootImageFixup(bool support_boot_image_fixup) { 334 support_boot_image_fixup_ = support_boot_image_fixup; 335 } 336 337 ArenaPool* GetArenaPool() { 338 return &arena_pool_; 339 } 340 const ArenaPool* GetArenaPool() const { 341 return &arena_pool_; 342 } 343 SwapAllocator<void>& GetSwapSpaceAllocator() { 344 return *swap_space_allocator_.get(); 345 } 346 347 bool WriteElf(const std::string& android_root, 348 bool is_host, 349 const std::vector<const DexFile*>& dex_files, 350 OatWriter* oat_writer, 351 File* file); 352 353 // TODO: move to a common home for llvm helpers once quick/portable are merged. 354 static void InstructionSetToLLVMTarget(InstructionSet instruction_set, 355 std::string* target_triple, 356 std::string* target_cpu, 357 std::string* target_attr); 358 359 void SetCompilerContext(void* compiler_context) { 360 compiler_context_ = compiler_context; 361 } 362 363 void* GetCompilerContext() const { 364 return compiler_context_; 365 } 366 367 size_t GetThreadCount() const { 368 return thread_count_; 369 } 370 371 bool GetDumpPasses() const { 372 return dump_passes_; 373 } 374 375 const std::string& GetDumpCfgFileName() const { 376 return dump_cfg_file_name_; 377 } 378 379 CumulativeLogger* GetTimingsLogger() const { 380 return timings_logger_; 381 } 382 383 // Checks if class specified by type_idx is one of the image_classes_ 384 bool IsImageClass(const char* descriptor) const; 385 386 // Checks if the provided class should be compiled, i.e., is in classes_to_compile_. 387 bool IsClassToCompile(const char* descriptor) const; 388 389 void RecordClassStatus(ClassReference ref, mirror::Class::Status status) 390 LOCKS_EXCLUDED(compiled_classes_lock_); 391 392 SwapVector<uint8_t>* DeduplicateCode(const ArrayRef<const uint8_t>& code); 393 SwapSrcMap* DeduplicateSrcMappingTable(const ArrayRef<SrcMapElem>& src_map); 394 SwapVector<uint8_t>* DeduplicateMappingTable(const ArrayRef<const uint8_t>& code); 395 SwapVector<uint8_t>* DeduplicateVMapTable(const ArrayRef<const uint8_t>& code); 396 SwapVector<uint8_t>* DeduplicateGCMap(const ArrayRef<const uint8_t>& code); 397 SwapVector<uint8_t>* DeduplicateCFIInfo(const ArrayRef<const uint8_t>& cfi_info); 398 399 // Should the compiler run on this method given profile information? 400 bool SkipCompilation(const std::string& method_name); 401 402 // Get memory usage during compilation. 403 std::string GetMemoryUsageString(bool extended) const; 404 405 private: 406 // These flags are internal to CompilerDriver for collecting INVOKE resolution statistics. 407 // The only external contract is that unresolved method has flags 0 and resolved non-0. 408 enum { 409 kBitMethodResolved = 0, 410 kBitVirtualMadeDirect, 411 kBitPreciseTypeDevirtualization, 412 kBitDirectCallToBoot, 413 kBitDirectMethodToBoot 414 }; 415 static constexpr int kFlagMethodResolved = 1 << kBitMethodResolved; 416 static constexpr int kFlagVirtualMadeDirect = 1 << kBitVirtualMadeDirect; 417 static constexpr int kFlagPreciseTypeDevirtualization = 1 << kBitPreciseTypeDevirtualization; 418 static constexpr int kFlagDirectCallToBoot = 1 << kBitDirectCallToBoot; 419 static constexpr int kFlagDirectMethodToBoot = 1 << kBitDirectMethodToBoot; 420 static constexpr int kFlagsMethodResolvedVirtualMadeDirect = 421 kFlagMethodResolved | kFlagVirtualMadeDirect; 422 static constexpr int kFlagsMethodResolvedPreciseTypeDevirtualization = 423 kFlagsMethodResolvedVirtualMadeDirect | kFlagPreciseTypeDevirtualization; 424 425 public: // TODO make private or eliminate. 426 // Compute constant code and method pointers when possible. 427 void GetCodeAndMethodForDirectCall(/*out*/InvokeType* type, 428 InvokeType sharp_type, 429 bool no_guarantee_of_dex_cache_entry, 430 const mirror::Class* referrer_class, 431 mirror::ArtMethod* method, 432 /*out*/int* stats_flags, 433 MethodReference* target_method, 434 uintptr_t* direct_code, uintptr_t* direct_method) 435 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 436 437 private: 438 void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 439 ThreadPool* thread_pool, TimingLogger* timings) 440 LOCKS_EXCLUDED(Locks::mutator_lock_); 441 442 void LoadImageClasses(TimingLogger* timings); 443 444 // Attempt to resolve all type, methods, fields, and strings 445 // referenced from code in the dex file following PathClassLoader 446 // ordering semantics. 447 void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files, 448 ThreadPool* thread_pool, TimingLogger* timings) 449 LOCKS_EXCLUDED(Locks::mutator_lock_); 450 void ResolveDexFile(jobject class_loader, const DexFile& dex_file, 451 const std::vector<const DexFile*>& dex_files, 452 ThreadPool* thread_pool, TimingLogger* timings) 453 LOCKS_EXCLUDED(Locks::mutator_lock_); 454 455 void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files, 456 ThreadPool* thread_pool, TimingLogger* timings); 457 void VerifyDexFile(jobject class_loader, const DexFile& dex_file, 458 const std::vector<const DexFile*>& dex_files, 459 ThreadPool* thread_pool, TimingLogger* timings) 460 LOCKS_EXCLUDED(Locks::mutator_lock_); 461 462 void SetVerified(jobject class_loader, const std::vector<const DexFile*>& dex_files, 463 ThreadPool* thread_pool, TimingLogger* timings); 464 void SetVerifiedDexFile(jobject class_loader, const DexFile& dex_file, 465 const std::vector<const DexFile*>& dex_files, 466 ThreadPool* thread_pool, TimingLogger* timings) 467 LOCKS_EXCLUDED(Locks::mutator_lock_); 468 469 void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files, 470 ThreadPool* thread_pool, TimingLogger* timings) 471 LOCKS_EXCLUDED(Locks::mutator_lock_); 472 void InitializeClasses(jobject class_loader, const DexFile& dex_file, 473 const std::vector<const DexFile*>& dex_files, 474 ThreadPool* thread_pool, TimingLogger* timings) 475 LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_); 476 477 void UpdateImageClasses(TimingLogger* timings) LOCKS_EXCLUDED(Locks::mutator_lock_); 478 static void FindClinitImageClassesCallback(mirror::Object* object, void* arg) 479 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 480 481 void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 482 ThreadPool* thread_pool, TimingLogger* timings); 483 void CompileDexFile(jobject class_loader, const DexFile& dex_file, 484 const std::vector<const DexFile*>& dex_files, 485 ThreadPool* thread_pool, TimingLogger* timings) 486 LOCKS_EXCLUDED(Locks::mutator_lock_); 487 void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, 488 InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx, 489 jobject class_loader, const DexFile& dex_file, 490 DexToDexCompilationLevel dex_to_dex_compilation_level, 491 bool compilation_enabled) 492 LOCKS_EXCLUDED(compiled_methods_lock_); 493 494 static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index) 495 LOCKS_EXCLUDED(Locks::mutator_lock_); 496 497 // Swap pool and allocator used for native allocations. May be file-backed. Needs to be first 498 // as other fields rely on this. 499 std::unique_ptr<SwapSpace> swap_space_; 500 std::unique_ptr<SwapAllocator<void> > swap_space_allocator_; 501 502 ProfileFile profile_file_; 503 bool profile_present_; 504 505 const CompilerOptions* const compiler_options_; 506 VerificationResults* const verification_results_; 507 DexFileToMethodInlinerMap* const method_inliner_map_; 508 509 std::unique_ptr<Compiler> compiler_; 510 511 const InstructionSet instruction_set_; 512 const InstructionSetFeatures* const instruction_set_features_; 513 514 // All class references that require 515 mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 516 std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_); 517 518 typedef SafeMap<const ClassReference, CompiledClass*> ClassTable; 519 // All class references that this compiler has compiled. 520 mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 521 ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_); 522 523 typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable; 524 // All method references that this compiler has compiled. 525 mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 526 MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_); 527 // Number of non-relative patches in all compiled methods. These patches need space 528 // in the .oat_patches ELF section if requested in the compiler options. 529 size_t non_relative_linker_patch_count_ GUARDED_BY(compiled_methods_lock_); 530 531 const bool image_; 532 533 // If image_ is true, specifies the classes that will be included in 534 // the image. Note if image_classes_ is nullptr, all classes are 535 // included in the image. 536 std::unique_ptr<std::set<std::string>> image_classes_; 537 538 // If image_ is true, specifies the classes that will be compiled in 539 // the image. Note if classes_to_compile_ is nullptr, all classes are 540 // included in the image. 541 std::unique_ptr<std::set<std::string>> classes_to_compile_; 542 543 size_t thread_count_; 544 545 class AOTCompilationStats; 546 std::unique_ptr<AOTCompilationStats> stats_; 547 548 bool dump_stats_; 549 const bool dump_passes_; 550 const std::string& dump_cfg_file_name_; 551 552 CumulativeLogger* const timings_logger_; 553 554 typedef void (*CompilerCallbackFn)(CompilerDriver& driver); 555 typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver); 556 557 typedef void (*DexToDexCompilerFn)(CompilerDriver& driver, 558 const DexFile::CodeItem* code_item, 559 uint32_t access_flags, InvokeType invoke_type, 560 uint32_t class_dex_idx, uint32_t method_idx, 561 jobject class_loader, const DexFile& dex_file, 562 DexToDexCompilationLevel dex_to_dex_compilation_level); 563 DexToDexCompilerFn dex_to_dex_compiler_; 564 565 void* compiler_context_; 566 567 // Arena pool used by the compiler. 568 ArenaPool arena_pool_; 569 570 bool support_boot_image_fixup_; 571 572 // DeDuplication data structures, these own the corresponding byte arrays. 573 template <typename ContentType> 574 class DedupeHashFunc { 575 public: 576 size_t operator()(const ArrayRef<ContentType>& array) const { 577 const uint8_t* data = reinterpret_cast<const uint8_t*>(array.data()); 578 static_assert(IsPowerOfTwo(sizeof(ContentType)), 579 "ContentType is not power of two, don't know whether array layout is as assumed"); 580 uint32_t len = sizeof(ContentType) * array.size(); 581 if (kUseMurmur3Hash) { 582 static constexpr uint32_t c1 = 0xcc9e2d51; 583 static constexpr uint32_t c2 = 0x1b873593; 584 static constexpr uint32_t r1 = 15; 585 static constexpr uint32_t r2 = 13; 586 static constexpr uint32_t m = 5; 587 static constexpr uint32_t n = 0xe6546b64; 588 589 uint32_t hash = 0; 590 591 const int nblocks = len / 4; 592 typedef __attribute__((__aligned__(1))) uint32_t unaligned_uint32_t; 593 const unaligned_uint32_t *blocks = reinterpret_cast<const uint32_t*>(data); 594 int i; 595 for (i = 0; i < nblocks; i++) { 596 uint32_t k = blocks[i]; 597 k *= c1; 598 k = (k << r1) | (k >> (32 - r1)); 599 k *= c2; 600 601 hash ^= k; 602 hash = ((hash << r2) | (hash >> (32 - r2))) * m + n; 603 } 604 605 const uint8_t *tail = reinterpret_cast<const uint8_t*>(data + nblocks * 4); 606 uint32_t k1 = 0; 607 608 switch (len & 3) { 609 case 3: 610 k1 ^= tail[2] << 16; 611 FALLTHROUGH_INTENDED; 612 case 2: 613 k1 ^= tail[1] << 8; 614 FALLTHROUGH_INTENDED; 615 case 1: 616 k1 ^= tail[0]; 617 618 k1 *= c1; 619 k1 = (k1 << r1) | (k1 >> (32 - r1)); 620 k1 *= c2; 621 hash ^= k1; 622 } 623 624 hash ^= len; 625 hash ^= (hash >> 16); 626 hash *= 0x85ebca6b; 627 hash ^= (hash >> 13); 628 hash *= 0xc2b2ae35; 629 hash ^= (hash >> 16); 630 631 return hash; 632 } else { 633 size_t hash = 0x811c9dc5; 634 for (uint32_t i = 0; i < len; ++i) { 635 hash = (hash * 16777619) ^ data[i]; 636 } 637 hash += hash << 13; 638 hash ^= hash >> 7; 639 hash += hash << 3; 640 hash ^= hash >> 17; 641 hash += hash << 5; 642 return hash; 643 } 644 } 645 }; 646 647 DedupeSet<ArrayRef<const uint8_t>, 648 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_code_; 649 DedupeSet<ArrayRef<SrcMapElem>, 650 SwapSrcMap, size_t, DedupeHashFunc<SrcMapElem>, 4> dedupe_src_mapping_table_; 651 DedupeSet<ArrayRef<const uint8_t>, 652 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_mapping_table_; 653 DedupeSet<ArrayRef<const uint8_t>, 654 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_vmap_table_; 655 DedupeSet<ArrayRef<const uint8_t>, 656 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_gc_map_; 657 DedupeSet<ArrayRef<const uint8_t>, 658 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_cfi_info_; 659 660 DISALLOW_COPY_AND_ASSIGN(CompilerDriver); 661}; 662 663} // namespace art 664 665#endif // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_ 666