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