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