compiler_driver.h revision e982f0b8e809cece6f460fa2d8df25873aa69de4
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 "base/mutex.h" 25#include "base/timing_logger.h" 26#include "class_reference.h" 27#include "compiled_method.h" 28#include "compiler.h" 29#include "dex_file.h" 30#include "driver/compiler_options.h" 31#include "instruction_set.h" 32#include "invoke_type.h" 33#include "method_reference.h" 34#include "mirror/class.h" // For mirror::Class::Status. 35#include "os.h" 36#include "profiler.h" 37#include "runtime.h" 38#include "safe_map.h" 39#include "thread_pool.h" 40#include "utils/arena_allocator.h" 41#include "utils/dedupe_set.h" 42 43namespace art { 44 45namespace verifier { 46class MethodVerifier; 47} // namespace verifier 48 49class CompiledClass; 50class CompilerOptions; 51class DexCompilationUnit; 52class DexFileToMethodInlinerMap; 53struct InlineIGetIPutData; 54class OatWriter; 55class ParallelCompilationManager; 56class ScopedObjectAccess; 57template<class T> class Handle; 58class TimingLogger; 59class VerificationResults; 60class VerifiedMethod; 61 62enum EntryPointCallingConvention { 63 // ABI of invocations to a method's interpreter entry point. 64 kInterpreterAbi, 65 // ABI of calls to a method's native code, only used for native methods. 66 kJniAbi, 67 // ABI of calls to a method's portable code entry point. 68 kPortableAbi, 69 // ABI of calls to a method's quick code entry point. 70 kQuickAbi 71}; 72 73enum DexToDexCompilationLevel { 74 kDontDexToDexCompile, // Only meaning wrt image time interpretation. 75 kRequired, // Dex-to-dex compilation required for correctness. 76 kOptimize // Perform required transformation and peep-hole optimizations. 77}; 78 79class CompilerDriver { 80 public: 81 // Create a compiler targeting the requested "instruction_set". 82 // "image" should be true if image specific optimizations should be 83 // enabled. "image_classes" lets the compiler know what classes it 84 // can assume will be in the image, with nullptr implying all available 85 // classes. 86 explicit CompilerDriver(const CompilerOptions* compiler_options, 87 VerificationResults* verification_results, 88 DexFileToMethodInlinerMap* method_inliner_map, 89 Compiler::Kind compiler_kind, 90 InstructionSet instruction_set, 91 InstructionSetFeatures instruction_set_features, 92 bool image, std::set<std::string>* image_classes, 93 size_t thread_count, bool dump_stats, bool dump_passes, 94 CumulativeLogger* timer, std::string profile_file = ""); 95 96 ~CompilerDriver(); 97 98 void CompileAll(jobject class_loader, const std::vector<const DexFile*>& dex_files, 99 TimingLogger* timings) 100 LOCKS_EXCLUDED(Locks::mutator_lock_); 101 102 // Compile a single Method. 103 void CompileOne(mirror::ArtMethod* method, TimingLogger* timings) 104 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 105 106 VerificationResults* GetVerificationResults() const { 107 return verification_results_; 108 } 109 110 DexFileToMethodInlinerMap* GetMethodInlinerMap() const { 111 return method_inliner_map_; 112 } 113 114 InstructionSet GetInstructionSet() const { 115 return instruction_set_; 116 } 117 118 InstructionSetFeatures GetInstructionSetFeatures() const { 119 return instruction_set_features_; 120 } 121 122 const CompilerOptions& GetCompilerOptions() const { 123 return *compiler_options_; 124 } 125 126 Compiler* GetCompiler() const { 127 return compiler_.get(); 128 } 129 130 bool ProfilePresent() const { 131 return profile_present_; 132 } 133 134 // Are we compiling and creating an image file? 135 bool IsImage() const { 136 return image_; 137 } 138 139 const std::set<std::string>* GetImageClasses() const { 140 return image_classes_.get(); 141 } 142 143 CompilerTls* GetTls(); 144 145 // Generate the trampolines that are invoked by unresolved direct methods. 146 const std::vector<uint8_t>* CreateInterpreterToInterpreterBridge() const 147 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 148 const std::vector<uint8_t>* CreateInterpreterToCompiledCodeBridge() const 149 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 150 const std::vector<uint8_t>* CreateJniDlsymLookup() const 151 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 152 const std::vector<uint8_t>* CreatePortableImtConflictTrampoline() const 153 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 154 const std::vector<uint8_t>* CreatePortableResolutionTrampoline() const 155 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 156 const std::vector<uint8_t>* CreatePortableToInterpreterBridge() 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 173 void AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, 174 uint16_t class_def_index); 175 bool RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, uint16_t class_def_index); 176 177 // Callbacks from compiler to see what runtime checks must be generated. 178 179 bool CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx); 180 181 bool CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, uint32_t string_idx) 182 LOCKS_EXCLUDED(Locks::mutator_lock_); 183 184 // Are runtime access checks necessary in the compiled code? 185 bool CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, 186 uint32_t type_idx, bool* type_known_final = nullptr, 187 bool* type_known_abstract = nullptr, 188 bool* equals_referrers_class = nullptr) 189 LOCKS_EXCLUDED(Locks::mutator_lock_); 190 191 // Are runtime access and instantiable checks necessary in the code? 192 bool CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, 193 uint32_t type_idx) 194 LOCKS_EXCLUDED(Locks::mutator_lock_); 195 196 bool CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx, 197 bool* is_type_initialized, bool* use_direct_type_ptr, 198 uintptr_t* direct_type_ptr, bool* out_is_finalizable); 199 200 // Query methods for the java.lang.ref.Reference class. 201 bool CanEmbedReferenceTypeInCode(ClassReference* ref, 202 bool* use_direct_type_ptr, uintptr_t* direct_type_ptr); 203 uint32_t GetReferenceSlowFlagOffset() const; 204 uint32_t GetReferenceDisableFlagOffset() const; 205 206 // Get the DexCache for the 207 mirror::DexCache* GetDexCache(const DexCompilationUnit* mUnit) 208 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 209 210 mirror::ClassLoader* GetClassLoader(ScopedObjectAccess& soa, const DexCompilationUnit* mUnit) 211 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 212 213 // Resolve compiling method's class. Returns nullptr on failure. 214 mirror::Class* ResolveCompilingMethodsClass( 215 const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 216 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit) 217 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 218 219 // Resolve a field. Returns nullptr on failure, including incompatible class change. 220 // NOTE: Unlike ClassLinker's ResolveField(), this method enforces is_static. 221 mirror::ArtField* ResolveField( 222 const ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 223 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, 224 uint32_t field_idx, bool is_static) 225 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 226 227 // Get declaration location of a resolved field. 228 void GetResolvedFieldDexFileLocation( 229 mirror::ArtField* resolved_field, const DexFile** declaring_dex_file, 230 uint16_t* declaring_class_idx, uint16_t* declaring_field_idx) 231 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 232 233 bool IsFieldVolatile(mirror::ArtField* field) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 234 235 // Can we fast-path an IGET/IPUT access to an instance field? If yes, compute the field offset. 236 std::pair<bool, bool> IsFastInstanceField( 237 mirror::DexCache* dex_cache, mirror::Class* referrer_class, 238 mirror::ArtField* resolved_field, uint16_t field_idx) 239 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 240 241 // Can we fast-path an SGET/SPUT access to a static field? If yes, compute the field offset, 242 // the type index of the declaring class in the referrer's dex file and whether the declaring 243 // class is the referrer's class or at least can be assumed to be initialized. 244 std::pair<bool, bool> IsFastStaticField( 245 mirror::DexCache* dex_cache, mirror::Class* referrer_class, 246 mirror::ArtField* resolved_field, uint16_t field_idx, MemberOffset* field_offset, 247 uint32_t* storage_index, bool* is_referrers_class, bool* is_initialized) 248 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 249 250 // Resolve a method. Returns nullptr on failure, including incompatible class change. 251 mirror::ArtMethod* ResolveMethod( 252 ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 253 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, 254 uint32_t method_idx, InvokeType invoke_type) 255 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 256 257 // Get declaration location of a resolved field. 258 void GetResolvedMethodDexFileLocation( 259 mirror::ArtMethod* resolved_method, const DexFile** declaring_dex_file, 260 uint16_t* declaring_class_idx, uint16_t* declaring_method_idx) 261 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 262 263 // Get the index in the vtable of the method. 264 uint16_t GetResolvedMethodVTableIndex( 265 mirror::ArtMethod* resolved_method, InvokeType type) 266 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 267 268 // Can we fast-path an INVOKE? If no, returns 0. If yes, returns a non-zero opaque flags value 269 // for ProcessedInvoke() and computes the necessary lowering info. 270 int IsFastInvoke( 271 ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 272 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, 273 mirror::Class* referrer_class, mirror::ArtMethod* resolved_method, InvokeType* invoke_type, 274 MethodReference* target_method, const MethodReference* devirt_target, 275 uintptr_t* direct_code, uintptr_t* direct_method) 276 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 277 278 // Does invokation of the resolved method need class initialization? 279 bool NeedsClassInitialization(mirror::Class* referrer_class, mirror::ArtMethod* resolved_method) 280 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 281 282 void ProcessedInstanceField(bool resolved); 283 void ProcessedStaticField(bool resolved, bool local); 284 void ProcessedInvoke(InvokeType invoke_type, int flags); 285 286 // Can we fast path instance field access? Computes field's offset and volatility. 287 bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, 288 MemberOffset* field_offset, bool* is_volatile) 289 LOCKS_EXCLUDED(Locks::mutator_lock_); 290 291 mirror::ArtField* ComputeInstanceFieldInfo(uint32_t field_idx, 292 const DexCompilationUnit* mUnit, 293 bool is_put, 294 const ScopedObjectAccess& soa) 295 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 296 297 298 // Can we fastpath static field access? Computes field's offset, volatility and whether the 299 // field is within the referrer (which can avoid checking class initialization). 300 bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, 301 MemberOffset* field_offset, uint32_t* storage_index, 302 bool* is_referrers_class, bool* is_volatile, bool* is_initialized) 303 LOCKS_EXCLUDED(Locks::mutator_lock_); 304 305 // Can we fastpath a interface, super class or virtual method call? Computes method's vtable 306 // index. 307 bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc, 308 bool update_stats, bool enable_devirtualization, 309 InvokeType* type, MethodReference* target_method, int* vtable_idx, 310 uintptr_t* direct_code, uintptr_t* direct_method) 311 LOCKS_EXCLUDED(Locks::mutator_lock_); 312 313 const VerifiedMethod* GetVerifiedMethod(const DexFile* dex_file, uint32_t method_idx) const; 314 bool IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc); 315 316 // Record patch information for later fix up. 317 void AddCodePatch(const DexFile* dex_file, 318 uint16_t referrer_class_def_idx, 319 uint32_t referrer_method_idx, 320 InvokeType referrer_invoke_type, 321 uint32_t target_method_idx, 322 const DexFile* target_dex_file, 323 InvokeType target_invoke_type, 324 size_t literal_offset) 325 LOCKS_EXCLUDED(compiled_methods_lock_); 326 void AddRelativeCodePatch(const DexFile* dex_file, 327 uint16_t referrer_class_def_idx, 328 uint32_t referrer_method_idx, 329 InvokeType referrer_invoke_type, 330 uint32_t target_method_idx, 331 const DexFile* target_dex_file, 332 InvokeType target_invoke_type, 333 size_t literal_offset, 334 int32_t pc_relative_offset) 335 LOCKS_EXCLUDED(compiled_methods_lock_); 336 void AddMethodPatch(const DexFile* dex_file, 337 uint16_t referrer_class_def_idx, 338 uint32_t referrer_method_idx, 339 InvokeType referrer_invoke_type, 340 uint32_t target_method_idx, 341 const DexFile* target_dex_file, 342 InvokeType target_invoke_type, 343 size_t literal_offset) 344 LOCKS_EXCLUDED(compiled_methods_lock_); 345 void AddClassPatch(const DexFile* dex_file, 346 uint16_t referrer_class_def_idx, 347 uint32_t referrer_method_idx, 348 uint32_t target_method_idx, 349 const DexFile* target_dex_file, 350 size_t literal_offset) 351 LOCKS_EXCLUDED(compiled_methods_lock_); 352 353 bool GetSupportBootImageFixup() const { 354 return support_boot_image_fixup_; 355 } 356 357 void SetSupportBootImageFixup(bool support_boot_image_fixup) { 358 support_boot_image_fixup_ = support_boot_image_fixup; 359 } 360 361 ArenaPool* GetArenaPool() { 362 return &arena_pool_; 363 } 364 365 bool WriteElf(const std::string& android_root, 366 bool is_host, 367 const std::vector<const DexFile*>& dex_files, 368 OatWriter* oat_writer, 369 File* file); 370 371 // TODO: move to a common home for llvm helpers once quick/portable are merged. 372 static void InstructionSetToLLVMTarget(InstructionSet instruction_set, 373 std::string* target_triple, 374 std::string* target_cpu, 375 std::string* target_attr); 376 377 void SetCompilerContext(void* compiler_context) { 378 compiler_context_ = compiler_context; 379 } 380 381 void* GetCompilerContext() const { 382 return compiler_context_; 383 } 384 385 size_t GetThreadCount() const { 386 return thread_count_; 387 } 388 389 class CallPatchInformation; 390 class TypePatchInformation; 391 392 bool GetDumpPasses() const { 393 return dump_passes_; 394 } 395 396 CumulativeLogger* GetTimingsLogger() const { 397 return timings_logger_; 398 } 399 400 class PatchInformation { 401 public: 402 const DexFile& GetDexFile() const { 403 return *dex_file_; 404 } 405 uint16_t GetReferrerClassDefIdx() const { 406 return referrer_class_def_idx_; 407 } 408 uint32_t GetReferrerMethodIdx() const { 409 return referrer_method_idx_; 410 } 411 size_t GetLiteralOffset() const { 412 return literal_offset_; 413 } 414 415 virtual bool IsCall() const { 416 return false; 417 } 418 virtual bool IsType() const { 419 return false; 420 } 421 virtual const CallPatchInformation* AsCall() const { 422 LOG(FATAL) << "Unreachable"; 423 return nullptr; 424 } 425 virtual const TypePatchInformation* AsType() const { 426 LOG(FATAL) << "Unreachable"; 427 return nullptr; 428 } 429 430 protected: 431 PatchInformation(const DexFile* dex_file, 432 uint16_t referrer_class_def_idx, 433 uint32_t referrer_method_idx, 434 size_t literal_offset) 435 : dex_file_(dex_file), 436 referrer_class_def_idx_(referrer_class_def_idx), 437 referrer_method_idx_(referrer_method_idx), 438 literal_offset_(literal_offset) { 439 CHECK(dex_file_ != nullptr); 440 } 441 virtual ~PatchInformation() {} 442 443 const DexFile* const dex_file_; 444 const uint16_t referrer_class_def_idx_; 445 const uint32_t referrer_method_idx_; 446 const size_t literal_offset_; 447 448 friend class CompilerDriver; 449 }; 450 451 class CallPatchInformation : public PatchInformation { 452 public: 453 InvokeType GetReferrerInvokeType() const { 454 return referrer_invoke_type_; 455 } 456 uint32_t GetTargetMethodIdx() const { 457 return target_method_idx_; 458 } 459 const DexFile* GetTargetDexFile() const { 460 return target_dex_file_; 461 } 462 InvokeType GetTargetInvokeType() const { 463 return target_invoke_type_; 464 } 465 466 const CallPatchInformation* AsCall() const { 467 return this; 468 } 469 bool IsCall() const { 470 return true; 471 } 472 virtual bool IsRelative() const { 473 return false; 474 } 475 virtual int RelativeOffset() const { 476 return 0; 477 } 478 479 protected: 480 CallPatchInformation(const DexFile* dex_file, 481 uint16_t referrer_class_def_idx, 482 uint32_t referrer_method_idx, 483 InvokeType referrer_invoke_type, 484 uint32_t target_method_idx, 485 const DexFile* target_dex_file, 486 InvokeType target_invoke_type, 487 size_t literal_offset) 488 : PatchInformation(dex_file, referrer_class_def_idx, 489 referrer_method_idx, literal_offset), 490 referrer_invoke_type_(referrer_invoke_type), 491 target_method_idx_(target_method_idx), 492 target_dex_file_(target_dex_file), 493 target_invoke_type_(target_invoke_type) { 494 } 495 496 private: 497 const InvokeType referrer_invoke_type_; 498 const uint32_t target_method_idx_; 499 const DexFile* target_dex_file_; 500 const InvokeType target_invoke_type_; 501 502 friend class CompilerDriver; 503 DISALLOW_COPY_AND_ASSIGN(CallPatchInformation); 504 }; 505 506 class RelativeCallPatchInformation : public CallPatchInformation { 507 public: 508 bool IsRelative() const { 509 return true; 510 } 511 int RelativeOffset() const { 512 return offset_; 513 } 514 515 private: 516 RelativeCallPatchInformation(const DexFile* dex_file, 517 uint16_t referrer_class_def_idx, 518 uint32_t referrer_method_idx, 519 InvokeType referrer_invoke_type, 520 uint32_t target_method_idx, 521 const DexFile* target_dex_file, 522 InvokeType target_invoke_type, 523 size_t literal_offset, 524 int32_t pc_relative_offset) 525 : CallPatchInformation(dex_file, referrer_class_def_idx, 526 referrer_method_idx, referrer_invoke_type, target_method_idx, 527 target_dex_file, target_invoke_type, literal_offset), 528 offset_(pc_relative_offset) { 529 } 530 531 const int offset_; 532 533 friend class CompilerDriver; 534 DISALLOW_COPY_AND_ASSIGN(RelativeCallPatchInformation); 535 }; 536 537 class TypePatchInformation : public PatchInformation { 538 public: 539 const DexFile& GetTargetTypeDexFile() const { 540 return *target_type_dex_file_; 541 } 542 543 uint32_t GetTargetTypeIdx() const { 544 return target_type_idx_; 545 } 546 547 bool IsType() const { 548 return true; 549 } 550 const TypePatchInformation* AsType() const { 551 return this; 552 } 553 554 private: 555 TypePatchInformation(const DexFile* dex_file, 556 uint16_t referrer_class_def_idx, 557 uint32_t referrer_method_idx, 558 uint32_t target_type_idx, 559 const DexFile* target_type_dex_file, 560 size_t literal_offset) 561 : PatchInformation(dex_file, referrer_class_def_idx, 562 referrer_method_idx, literal_offset), 563 target_type_idx_(target_type_idx), target_type_dex_file_(target_type_dex_file) { 564 } 565 566 const uint32_t target_type_idx_; 567 const DexFile* target_type_dex_file_; 568 569 friend class CompilerDriver; 570 DISALLOW_COPY_AND_ASSIGN(TypePatchInformation); 571 }; 572 573 const std::vector<const CallPatchInformation*>& GetCodeToPatch() const { 574 return code_to_patch_; 575 } 576 const std::vector<const CallPatchInformation*>& GetMethodsToPatch() const { 577 return methods_to_patch_; 578 } 579 const std::vector<const TypePatchInformation*>& GetClassesToPatch() const { 580 return classes_to_patch_; 581 } 582 583 // Checks if class specified by type_idx is one of the image_classes_ 584 bool IsImageClass(const char* descriptor) const; 585 586 void RecordClassStatus(ClassReference ref, mirror::Class::Status status) 587 LOCKS_EXCLUDED(compiled_classes_lock_); 588 589 std::vector<uint8_t>* DeduplicateCode(const std::vector<uint8_t>& code); 590 SrcMap* DeduplicateSrcMappingTable(const SrcMap& src_map); 591 std::vector<uint8_t>* DeduplicateMappingTable(const std::vector<uint8_t>& code); 592 std::vector<uint8_t>* DeduplicateVMapTable(const std::vector<uint8_t>& code); 593 std::vector<uint8_t>* DeduplicateGCMap(const std::vector<uint8_t>& code); 594 std::vector<uint8_t>* DeduplicateCFIInfo(const std::vector<uint8_t>* cfi_info); 595 596 ProfileFile profile_file_; 597 bool profile_present_; 598 599 // Should the compiler run on this method given profile information? 600 bool SkipCompilation(const std::string& method_name); 601 602 private: 603 // These flags are internal to CompilerDriver for collecting INVOKE resolution statistics. 604 // The only external contract is that unresolved method has flags 0 and resolved non-0. 605 enum { 606 kBitMethodResolved = 0, 607 kBitVirtualMadeDirect, 608 kBitPreciseTypeDevirtualization, 609 kBitDirectCallToBoot, 610 kBitDirectMethodToBoot 611 }; 612 static constexpr int kFlagMethodResolved = 1 << kBitMethodResolved; 613 static constexpr int kFlagVirtualMadeDirect = 1 << kBitVirtualMadeDirect; 614 static constexpr int kFlagPreciseTypeDevirtualization = 1 << kBitPreciseTypeDevirtualization; 615 static constexpr int kFlagDirectCallToBoot = 1 << kBitDirectCallToBoot; 616 static constexpr int kFlagDirectMethodToBoot = 1 << kBitDirectMethodToBoot; 617 static constexpr int kFlagsMethodResolvedVirtualMadeDirect = 618 kFlagMethodResolved | kFlagVirtualMadeDirect; 619 static constexpr int kFlagsMethodResolvedPreciseTypeDevirtualization = 620 kFlagsMethodResolvedVirtualMadeDirect | kFlagPreciseTypeDevirtualization; 621 622 public: // TODO make private or eliminate. 623 // Compute constant code and method pointers when possible. 624 void GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type, 625 bool no_guarantee_of_dex_cache_entry, 626 mirror::Class* referrer_class, 627 mirror::ArtMethod* method, 628 int* stats_flags, 629 MethodReference* target_method, 630 uintptr_t* direct_code, uintptr_t* direct_method) 631 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 632 633 private: 634 void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 635 ThreadPool* thread_pool, TimingLogger* timings) 636 LOCKS_EXCLUDED(Locks::mutator_lock_); 637 638 void LoadImageClasses(TimingLogger* timings); 639 640 // Attempt to resolve all type, methods, fields, and strings 641 // referenced from code in the dex file following PathClassLoader 642 // ordering semantics. 643 void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files, 644 ThreadPool* thread_pool, TimingLogger* timings) 645 LOCKS_EXCLUDED(Locks::mutator_lock_); 646 void ResolveDexFile(jobject class_loader, const DexFile& dex_file, 647 const std::vector<const DexFile*>& dex_files, 648 ThreadPool* thread_pool, TimingLogger* timings) 649 LOCKS_EXCLUDED(Locks::mutator_lock_); 650 651 void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files, 652 ThreadPool* thread_pool, TimingLogger* timings); 653 void VerifyDexFile(jobject class_loader, const DexFile& dex_file, 654 const std::vector<const DexFile*>& dex_files, 655 ThreadPool* thread_pool, TimingLogger* timings) 656 LOCKS_EXCLUDED(Locks::mutator_lock_); 657 658 void SetVerified(jobject class_loader, const std::vector<const DexFile*>& dex_files, 659 ThreadPool* thread_pool, TimingLogger* timings); 660 void SetVerifiedDexFile(jobject class_loader, const DexFile& dex_file, 661 const std::vector<const DexFile*>& dex_files, 662 ThreadPool* thread_pool, TimingLogger* timings) 663 LOCKS_EXCLUDED(Locks::mutator_lock_); 664 665 void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files, 666 ThreadPool* thread_pool, TimingLogger* timings) 667 LOCKS_EXCLUDED(Locks::mutator_lock_); 668 void InitializeClasses(jobject class_loader, const DexFile& dex_file, 669 const std::vector<const DexFile*>& dex_files, 670 ThreadPool* thread_pool, TimingLogger* timings) 671 LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_); 672 673 void UpdateImageClasses(TimingLogger* timings) LOCKS_EXCLUDED(Locks::mutator_lock_); 674 static void FindClinitImageClassesCallback(mirror::Object* object, void* arg) 675 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 676 677 void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 678 ThreadPool* thread_pool, TimingLogger* timings); 679 void CompileDexFile(jobject class_loader, const DexFile& dex_file, 680 const std::vector<const DexFile*>& dex_files, 681 ThreadPool* thread_pool, TimingLogger* timings) 682 LOCKS_EXCLUDED(Locks::mutator_lock_); 683 void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, 684 InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx, 685 jobject class_loader, const DexFile& dex_file, 686 DexToDexCompilationLevel dex_to_dex_compilation_level) 687 LOCKS_EXCLUDED(compiled_methods_lock_); 688 689 static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index) 690 LOCKS_EXCLUDED(Locks::mutator_lock_); 691 692 std::vector<const CallPatchInformation*> code_to_patch_; 693 std::vector<const CallPatchInformation*> methods_to_patch_; 694 std::vector<const TypePatchInformation*> classes_to_patch_; 695 696 const CompilerOptions* const compiler_options_; 697 VerificationResults* const verification_results_; 698 DexFileToMethodInlinerMap* const method_inliner_map_; 699 700 std::unique_ptr<Compiler> compiler_; 701 702 const InstructionSet instruction_set_; 703 const InstructionSetFeatures instruction_set_features_; 704 705 // All class references that require 706 mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 707 std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_); 708 709 typedef SafeMap<const ClassReference, CompiledClass*> ClassTable; 710 // All class references that this compiler has compiled. 711 mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 712 ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_); 713 714 typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable; 715 // All method references that this compiler has compiled. 716 mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 717 MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_); 718 719 const bool image_; 720 721 // If image_ is true, specifies the classes that will be included in 722 // the image. Note if image_classes_ is nullptr, all classes are 723 // included in the image. 724 std::unique_ptr<std::set<std::string>> image_classes_; 725 726 size_t thread_count_; 727 uint64_t start_ns_; 728 729 class AOTCompilationStats; 730 std::unique_ptr<AOTCompilationStats> stats_; 731 732 bool dump_stats_; 733 const bool dump_passes_; 734 735 CumulativeLogger* const timings_logger_; 736 737 typedef void (*CompilerCallbackFn)(CompilerDriver& driver); 738 typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver); 739 740 void* compiler_library_; 741 742 typedef void (*DexToDexCompilerFn)(CompilerDriver& driver, 743 const DexFile::CodeItem* code_item, 744 uint32_t access_flags, InvokeType invoke_type, 745 uint32_t class_dex_idx, uint32_t method_idx, 746 jobject class_loader, const DexFile& dex_file, 747 DexToDexCompilationLevel dex_to_dex_compilation_level); 748 DexToDexCompilerFn dex_to_dex_compiler_; 749 750 void* compiler_context_; 751 752 pthread_key_t tls_key_; 753 754 // Arena pool used by the compiler. 755 ArenaPool arena_pool_; 756 757 typedef void (*CompilerEnableAutoElfLoadingFn)(CompilerDriver& driver); 758 CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_; 759 760 typedef const void* (*CompilerGetMethodCodeAddrFn) 761 (const CompilerDriver& driver, const CompiledMethod* cm, const mirror::ArtMethod* method); 762 CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_; 763 764 bool support_boot_image_fixup_; 765 766 // DeDuplication data structures, these own the corresponding byte arrays. 767 template <typename ByteArray> 768 class DedupeHashFunc { 769 public: 770 size_t operator()(const ByteArray& array) const { 771 // For small arrays compute a hash using every byte. 772 static const size_t kSmallArrayThreshold = 16; 773 size_t hash = 0x811c9dc5; 774 if (array.size() <= kSmallArrayThreshold) { 775 for (auto b : array) { 776 hash = (hash * 16777619) ^ static_cast<uint8_t>(b); 777 } 778 } else { 779 // For larger arrays use the 2 bytes at 6 bytes (the location of a push registers 780 // instruction field for quick generated code on ARM) and then select a number of other 781 // values at random. 782 static const size_t kRandomHashCount = 16; 783 for (size_t i = 0; i < 2; ++i) { 784 uint8_t b = static_cast<uint8_t>(array[i + 6]); 785 hash = (hash * 16777619) ^ b; 786 } 787 for (size_t i = 2; i < kRandomHashCount; ++i) { 788 size_t r = i * 1103515245 + 12345; 789 uint8_t b = static_cast<uint8_t>(array[r % array.size()]); 790 hash = (hash * 16777619) ^ b; 791 } 792 } 793 hash += hash << 13; 794 hash ^= hash >> 7; 795 hash += hash << 3; 796 hash ^= hash >> 17; 797 hash += hash << 5; 798 return hash; 799 } 800 }; 801 802 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc<std::vector<uint8_t>>, 4> dedupe_code_; 803 DedupeSet<SrcMap, size_t, DedupeHashFunc<SrcMap>, 4> dedupe_src_mapping_table_; 804 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc<std::vector<uint8_t>>, 4> dedupe_mapping_table_; 805 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc<std::vector<uint8_t>>, 4> dedupe_vmap_table_; 806 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc<std::vector<uint8_t>>, 4> dedupe_gc_map_; 807 DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc<std::vector<uint8_t>>, 4> dedupe_cfi_info_; 808 809 DISALLOW_COPY_AND_ASSIGN(CompilerDriver); 810}; 811 812} // namespace art 813 814#endif // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_ 815