compiler_driver.h revision 70bef0d8f6aa30b0da5c6ca56e1bc5729f74654b
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/mutex.h" 28#include "base/timing_logger.h" 29#include "class_reference.h" 30#include "compiler.h" 31#include "dex_file.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/array_ref.h" 41#include "utils/dedupe_set.h" 42#include "utils/dex_cache_arrays_layout.h" 43#include "utils/swap_space.h" 44#include "utils.h" 45 46namespace art { 47 48namespace mirror { 49class DexCache; 50} // namespace mirror 51 52namespace verifier { 53class MethodVerifier; 54} // namespace verifier 55 56class CompiledClass; 57class CompiledMethod; 58class CompilerOptions; 59class DexCompilationUnit; 60class DexFileToMethodInlinerMap; 61struct InlineIGetIPutData; 62class InstructionSetFeatures; 63class OatWriter; 64class ParallelCompilationManager; 65class ScopedObjectAccess; 66template <class Allocator> class SrcMap; 67class SrcMapElem; 68using SwapSrcMap = SrcMap<SwapAllocator<SrcMapElem>>; 69template<class T> class Handle; 70class TimingLogger; 71class VerificationResults; 72class VerifiedMethod; 73 74enum 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 83enum 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}; 88std::ostream& operator<<(std::ostream& os, const DexToDexCompilationLevel& rhs); 89 90static constexpr bool kUseMurmur3Hash = true; 91 92class 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 nullptr 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, mirror::ArtMethod*) 120 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) WARN_UNUSED; 121 122 // Compile a single Method. 123 void CompileOne(Thread* self, mirror::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 nullptr 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 nullptr 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 // Is static field's in referrer's class? 285 bool IsStaticFieldInReferrerClass(mirror::Class* referrer_class, ArtField* resolved_field) 286 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 287 288 // Is static field's class initialized? 289 bool IsStaticFieldsClassInitialized(mirror::Class* referrer_class, 290 ArtField* resolved_field) 291 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 292 293 // Resolve a method. Returns nullptr on failure, including incompatible class change. 294 mirror::ArtMethod* ResolveMethod( 295 ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 296 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, 297 uint32_t method_idx, InvokeType invoke_type, bool check_incompatible_class_change = true) 298 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 299 300 // Get declaration location of a resolved field. 301 void GetResolvedMethodDexFileLocation( 302 mirror::ArtMethod* resolved_method, const DexFile** declaring_dex_file, 303 uint16_t* declaring_class_idx, uint16_t* declaring_method_idx) 304 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 305 306 // Get the index in the vtable of the method. 307 uint16_t GetResolvedMethodVTableIndex( 308 mirror::ArtMethod* resolved_method, InvokeType type) 309 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 310 311 // Can we fast-path an INVOKE? If no, returns 0. If yes, returns a non-zero opaque flags value 312 // for ProcessedInvoke() and computes the necessary lowering info. 313 int IsFastInvoke( 314 ScopedObjectAccess& soa, Handle<mirror::DexCache> dex_cache, 315 Handle<mirror::ClassLoader> class_loader, const DexCompilationUnit* mUnit, 316 mirror::Class* referrer_class, mirror::ArtMethod* resolved_method, InvokeType* invoke_type, 317 MethodReference* target_method, const MethodReference* devirt_target, 318 uintptr_t* direct_code, uintptr_t* direct_method) 319 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 320 321 // Is method's class initialized for an invoke? 322 // For static invokes to determine whether we need to consider potential call to <clinit>(). 323 // For non-static invokes, assuming a non-null reference, the class is always initialized. 324 bool IsMethodsClassInitialized(mirror::Class* referrer_class, mirror::ArtMethod* resolved_method) 325 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 326 327 // Get the layout of dex cache arrays for a dex file. Returns invalid layout if the 328 // dex cache arrays don't have a fixed layout. 329 DexCacheArraysLayout GetDexCacheArraysLayout(const DexFile* dex_file); 330 331 void ProcessedInstanceField(bool resolved); 332 void ProcessedStaticField(bool resolved, bool local); 333 void ProcessedInvoke(InvokeType invoke_type, int flags); 334 335 void ComputeFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, 336 const ScopedObjectAccess& soa, bool is_static, 337 ArtField** resolved_field, 338 mirror::Class** referrer_class, 339 mirror::DexCache** dex_cache) 340 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 341 342 // Can we fast path instance field access? Computes field's offset and volatility. 343 bool ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, 344 MemberOffset* field_offset, bool* is_volatile) 345 LOCKS_EXCLUDED(Locks::mutator_lock_); 346 347 ArtField* ComputeInstanceFieldInfo(uint32_t field_idx, 348 const DexCompilationUnit* mUnit, 349 bool is_put, 350 const ScopedObjectAccess& soa) 351 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 352 353 354 // Can we fastpath static field access? Computes field's offset, volatility and whether the 355 // field is within the referrer (which can avoid checking class initialization). 356 bool ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, bool is_put, 357 MemberOffset* field_offset, uint32_t* storage_index, 358 bool* is_referrers_class, bool* is_volatile, bool* is_initialized, 359 Primitive::Type* type) 360 LOCKS_EXCLUDED(Locks::mutator_lock_); 361 362 // Can we fastpath a interface, super class or virtual method call? Computes method's vtable 363 // index. 364 bool ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc, 365 bool update_stats, bool enable_devirtualization, 366 InvokeType* type, MethodReference* target_method, int* vtable_idx, 367 uintptr_t* direct_code, uintptr_t* direct_method) 368 LOCKS_EXCLUDED(Locks::mutator_lock_); 369 370 const VerifiedMethod* GetVerifiedMethod(const DexFile* dex_file, uint32_t method_idx) const; 371 bool IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc); 372 373 bool GetSupportBootImageFixup() const { 374 return support_boot_image_fixup_; 375 } 376 377 void SetSupportBootImageFixup(bool support_boot_image_fixup) { 378 support_boot_image_fixup_ = support_boot_image_fixup; 379 } 380 381 SwapAllocator<void>& GetSwapSpaceAllocator() { 382 return *swap_space_allocator_.get(); 383 } 384 385 bool WriteElf(const std::string& android_root, 386 bool is_host, 387 const std::vector<const DexFile*>& dex_files, 388 OatWriter* oat_writer, 389 File* file); 390 391 void SetCompilerContext(void* compiler_context) { 392 compiler_context_ = compiler_context; 393 } 394 395 void* GetCompilerContext() const { 396 return compiler_context_; 397 } 398 399 size_t GetThreadCount() const { 400 return thread_count_; 401 } 402 403 bool GetDumpStats() const { 404 return dump_stats_; 405 } 406 407 bool GetDumpPasses() const { 408 return dump_passes_; 409 } 410 411 const std::string& GetDumpCfgFileName() const { 412 return dump_cfg_file_name_; 413 } 414 415 CumulativeLogger* GetTimingsLogger() const { 416 return timings_logger_; 417 } 418 419 void SetDedupeEnabled(bool dedupe_enabled) { 420 dedupe_enabled_ = dedupe_enabled; 421 } 422 bool DedupeEnabled() const { 423 return dedupe_enabled_; 424 } 425 426 // Checks if class specified by type_idx is one of the image_classes_ 427 bool IsImageClass(const char* descriptor) const; 428 429 // Checks whether the provided class should be compiled, i.e., is in classes_to_compile_. 430 bool IsClassToCompile(const char* descriptor) const; 431 432 // Checks whether the provided method should be compiled, i.e., is in method_to_compile_. 433 bool IsMethodToCompile(const MethodReference& method_ref) const; 434 435 void RecordClassStatus(ClassReference ref, mirror::Class::Status status) 436 LOCKS_EXCLUDED(compiled_classes_lock_); 437 438 // Checks if the specified method has been verified without failures. Returns 439 // false if the method is not in the verification results (GetVerificationResults). 440 bool IsMethodVerifiedWithoutFailures(uint32_t method_idx, 441 uint16_t class_def_idx, 442 const DexFile& dex_file) const; 443 444 SwapVector<uint8_t>* DeduplicateCode(const ArrayRef<const uint8_t>& code); 445 SwapSrcMap* DeduplicateSrcMappingTable(const ArrayRef<SrcMapElem>& src_map); 446 SwapVector<uint8_t>* DeduplicateMappingTable(const ArrayRef<const uint8_t>& code); 447 SwapVector<uint8_t>* DeduplicateVMapTable(const ArrayRef<const uint8_t>& code); 448 SwapVector<uint8_t>* DeduplicateGCMap(const ArrayRef<const uint8_t>& code); 449 SwapVector<uint8_t>* DeduplicateCFIInfo(const ArrayRef<const uint8_t>& cfi_info); 450 451 // Should the compiler run on this method given profile information? 452 bool SkipCompilation(const std::string& method_name); 453 454 // Get memory usage during compilation. 455 std::string GetMemoryUsageString(bool extended) const; 456 457 void SetHadHardVerifierFailure() { 458 had_hard_verifier_failure_ = true; 459 } 460 461 private: 462 // These flags are internal to CompilerDriver for collecting INVOKE resolution statistics. 463 // The only external contract is that unresolved method has flags 0 and resolved non-0. 464 enum { 465 kBitMethodResolved = 0, 466 kBitVirtualMadeDirect, 467 kBitPreciseTypeDevirtualization, 468 kBitDirectCallToBoot, 469 kBitDirectMethodToBoot 470 }; 471 static constexpr int kFlagMethodResolved = 1 << kBitMethodResolved; 472 static constexpr int kFlagVirtualMadeDirect = 1 << kBitVirtualMadeDirect; 473 static constexpr int kFlagPreciseTypeDevirtualization = 1 << kBitPreciseTypeDevirtualization; 474 static constexpr int kFlagDirectCallToBoot = 1 << kBitDirectCallToBoot; 475 static constexpr int kFlagDirectMethodToBoot = 1 << kBitDirectMethodToBoot; 476 static constexpr int kFlagsMethodResolvedVirtualMadeDirect = 477 kFlagMethodResolved | kFlagVirtualMadeDirect; 478 static constexpr int kFlagsMethodResolvedPreciseTypeDevirtualization = 479 kFlagsMethodResolvedVirtualMadeDirect | kFlagPreciseTypeDevirtualization; 480 481 public: // TODO make private or eliminate. 482 // Compute constant code and method pointers when possible. 483 void GetCodeAndMethodForDirectCall(/*out*/InvokeType* type, 484 InvokeType sharp_type, 485 bool no_guarantee_of_dex_cache_entry, 486 const mirror::Class* referrer_class, 487 mirror::ArtMethod* method, 488 /*out*/int* stats_flags, 489 MethodReference* target_method, 490 uintptr_t* direct_code, uintptr_t* direct_method) 491 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 492 493 private: 494 DexToDexCompilationLevel GetDexToDexCompilationlevel( 495 Thread* self, Handle<mirror::ClassLoader> class_loader, const DexFile& dex_file, 496 const DexFile::ClassDef& class_def) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 497 498 void PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 499 ThreadPool* thread_pool, TimingLogger* timings) 500 LOCKS_EXCLUDED(Locks::mutator_lock_); 501 502 void LoadImageClasses(TimingLogger* timings); 503 504 // Attempt to resolve all type, methods, fields, and strings 505 // referenced from code in the dex file following PathClassLoader 506 // ordering semantics. 507 void Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files, 508 ThreadPool* thread_pool, TimingLogger* timings) 509 LOCKS_EXCLUDED(Locks::mutator_lock_); 510 void ResolveDexFile(jobject class_loader, const DexFile& dex_file, 511 const std::vector<const DexFile*>& dex_files, 512 ThreadPool* thread_pool, TimingLogger* timings) 513 LOCKS_EXCLUDED(Locks::mutator_lock_); 514 515 void Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files, 516 ThreadPool* thread_pool, TimingLogger* timings); 517 void VerifyDexFile(jobject class_loader, const DexFile& dex_file, 518 const std::vector<const DexFile*>& dex_files, 519 ThreadPool* thread_pool, TimingLogger* timings) 520 LOCKS_EXCLUDED(Locks::mutator_lock_); 521 522 void SetVerified(jobject class_loader, const std::vector<const DexFile*>& dex_files, 523 ThreadPool* thread_pool, TimingLogger* timings); 524 void SetVerifiedDexFile(jobject class_loader, const DexFile& dex_file, 525 const std::vector<const DexFile*>& dex_files, 526 ThreadPool* thread_pool, TimingLogger* timings) 527 LOCKS_EXCLUDED(Locks::mutator_lock_); 528 529 void InitializeClasses(jobject class_loader, const std::vector<const DexFile*>& dex_files, 530 ThreadPool* thread_pool, TimingLogger* timings) 531 LOCKS_EXCLUDED(Locks::mutator_lock_); 532 void InitializeClasses(jobject class_loader, const DexFile& dex_file, 533 const std::vector<const DexFile*>& dex_files, 534 ThreadPool* thread_pool, TimingLogger* timings) 535 LOCKS_EXCLUDED(Locks::mutator_lock_, compiled_classes_lock_); 536 537 void UpdateImageClasses(TimingLogger* timings) LOCKS_EXCLUDED(Locks::mutator_lock_); 538 static void FindClinitImageClassesCallback(mirror::Object* object, void* arg) 539 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 540 541 void Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 542 ThreadPool* thread_pool, TimingLogger* timings); 543 void CompileDexFile(jobject class_loader, const DexFile& dex_file, 544 const std::vector<const DexFile*>& dex_files, 545 ThreadPool* thread_pool, TimingLogger* timings) 546 LOCKS_EXCLUDED(Locks::mutator_lock_); 547 void CompileMethod(Thread* self, const DexFile::CodeItem* code_item, uint32_t access_flags, 548 InvokeType invoke_type, uint16_t class_def_idx, uint32_t method_idx, 549 jobject class_loader, const DexFile& dex_file, 550 DexToDexCompilationLevel dex_to_dex_compilation_level, 551 bool compilation_enabled) 552 LOCKS_EXCLUDED(compiled_methods_lock_); 553 554 static void CompileClass(const ParallelCompilationManager* context, size_t class_def_index) 555 LOCKS_EXCLUDED(Locks::mutator_lock_); 556 557 // Swap pool and allocator used for native allocations. May be file-backed. Needs to be first 558 // as other fields rely on this. 559 std::unique_ptr<SwapSpace> swap_space_; 560 std::unique_ptr<SwapAllocator<void> > swap_space_allocator_; 561 562 ProfileFile profile_file_; 563 bool profile_present_; 564 565 const CompilerOptions* const compiler_options_; 566 VerificationResults* const verification_results_; 567 DexFileToMethodInlinerMap* const method_inliner_map_; 568 569 std::unique_ptr<Compiler> compiler_; 570 Compiler::Kind compiler_kind_; 571 572 const InstructionSet instruction_set_; 573 const InstructionSetFeatures* const instruction_set_features_; 574 575 // All class references that require 576 mutable ReaderWriterMutex freezing_constructor_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 577 std::set<ClassReference> freezing_constructor_classes_ GUARDED_BY(freezing_constructor_lock_); 578 579 typedef SafeMap<const ClassReference, CompiledClass*> ClassTable; 580 // All class references that this compiler has compiled. 581 mutable Mutex compiled_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 582 ClassTable compiled_classes_ GUARDED_BY(compiled_classes_lock_); 583 584 typedef SafeMap<const MethodReference, CompiledMethod*, MethodReferenceComparator> MethodTable; 585 // All method references that this compiler has compiled. 586 mutable Mutex compiled_methods_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 587 MethodTable compiled_methods_ GUARDED_BY(compiled_methods_lock_); 588 // Number of non-relative patches in all compiled methods. These patches need space 589 // in the .oat_patches ELF section if requested in the compiler options. 590 size_t non_relative_linker_patch_count_ GUARDED_BY(compiled_methods_lock_); 591 592 const bool image_; 593 594 // If image_ is true, specifies the classes that will be included in 595 // the image. Note if image_classes_ is nullptr, all classes are 596 // included in the image. 597 std::unique_ptr<std::unordered_set<std::string>> image_classes_; 598 599 // Specifies the classes that will be compiled. Note that if classes_to_compile_ is nullptr, 600 // all classes are eligible for compilation (duplication filters etc. will still apply). 601 // This option may be restricted to the boot image, depending on a flag in the implementation. 602 std::unique_ptr<std::unordered_set<std::string>> classes_to_compile_; 603 604 // Specifies the methods that will be compiled. Note that if methods_to_compile_ is nullptr, 605 // all methods are eligible for compilation (compilation filters etc. will still apply). 606 // This option may be restricted to the boot image, depending on a flag in the implementation. 607 std::unique_ptr<std::unordered_set<std::string>> methods_to_compile_; 608 609 bool had_hard_verifier_failure_; 610 611 size_t thread_count_; 612 613 class AOTCompilationStats; 614 std::unique_ptr<AOTCompilationStats> stats_; 615 616 bool dedupe_enabled_; 617 bool dump_stats_; 618 const bool dump_passes_; 619 const std::string& dump_cfg_file_name_; 620 621 CumulativeLogger* const timings_logger_; 622 623 typedef void (*CompilerCallbackFn)(CompilerDriver& driver); 624 typedef MutexLock* (*CompilerMutexLockFn)(CompilerDriver& driver); 625 626 typedef void (*DexToDexCompilerFn)(CompilerDriver& driver, 627 const DexFile::CodeItem* code_item, 628 uint32_t access_flags, InvokeType invoke_type, 629 uint32_t class_dex_idx, uint32_t method_idx, 630 jobject class_loader, const DexFile& dex_file, 631 DexToDexCompilationLevel dex_to_dex_compilation_level); 632 DexToDexCompilerFn dex_to_dex_compiler_; 633 634 void* compiler_context_; 635 636 bool support_boot_image_fixup_; 637 638 // DeDuplication data structures, these own the corresponding byte arrays. 639 template <typename ContentType> 640 class DedupeHashFunc { 641 public: 642 size_t operator()(const ArrayRef<ContentType>& array) const { 643 const uint8_t* data = reinterpret_cast<const uint8_t*>(array.data()); 644 static_assert(IsPowerOfTwo(sizeof(ContentType)), 645 "ContentType is not power of two, don't know whether array layout is as assumed"); 646 uint32_t len = sizeof(ContentType) * array.size(); 647 if (kUseMurmur3Hash) { 648 static constexpr uint32_t c1 = 0xcc9e2d51; 649 static constexpr uint32_t c2 = 0x1b873593; 650 static constexpr uint32_t r1 = 15; 651 static constexpr uint32_t r2 = 13; 652 static constexpr uint32_t m = 5; 653 static constexpr uint32_t n = 0xe6546b64; 654 655 uint32_t hash = 0; 656 657 const int nblocks = len / 4; 658 typedef __attribute__((__aligned__(1))) uint32_t unaligned_uint32_t; 659 const unaligned_uint32_t *blocks = reinterpret_cast<const uint32_t*>(data); 660 int i; 661 for (i = 0; i < nblocks; i++) { 662 uint32_t k = blocks[i]; 663 k *= c1; 664 k = (k << r1) | (k >> (32 - r1)); 665 k *= c2; 666 667 hash ^= k; 668 hash = ((hash << r2) | (hash >> (32 - r2))) * m + n; 669 } 670 671 const uint8_t *tail = reinterpret_cast<const uint8_t*>(data + nblocks * 4); 672 uint32_t k1 = 0; 673 674 switch (len & 3) { 675 case 3: 676 k1 ^= tail[2] << 16; 677 FALLTHROUGH_INTENDED; 678 case 2: 679 k1 ^= tail[1] << 8; 680 FALLTHROUGH_INTENDED; 681 case 1: 682 k1 ^= tail[0]; 683 684 k1 *= c1; 685 k1 = (k1 << r1) | (k1 >> (32 - r1)); 686 k1 *= c2; 687 hash ^= k1; 688 } 689 690 hash ^= len; 691 hash ^= (hash >> 16); 692 hash *= 0x85ebca6b; 693 hash ^= (hash >> 13); 694 hash *= 0xc2b2ae35; 695 hash ^= (hash >> 16); 696 697 return hash; 698 } else { 699 size_t hash = 0x811c9dc5; 700 for (uint32_t i = 0; i < len; ++i) { 701 hash = (hash * 16777619) ^ data[i]; 702 } 703 hash += hash << 13; 704 hash ^= hash >> 7; 705 hash += hash << 3; 706 hash ^= hash >> 17; 707 hash += hash << 5; 708 return hash; 709 } 710 } 711 }; 712 713 DedupeSet<ArrayRef<const uint8_t>, 714 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_code_; 715 DedupeSet<ArrayRef<SrcMapElem>, 716 SwapSrcMap, size_t, DedupeHashFunc<SrcMapElem>, 4> dedupe_src_mapping_table_; 717 DedupeSet<ArrayRef<const uint8_t>, 718 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_mapping_table_; 719 DedupeSet<ArrayRef<const uint8_t>, 720 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_vmap_table_; 721 DedupeSet<ArrayRef<const uint8_t>, 722 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_gc_map_; 723 DedupeSet<ArrayRef<const uint8_t>, 724 SwapVector<uint8_t>, size_t, DedupeHashFunc<const uint8_t>, 4> dedupe_cfi_info_; 725 726 DISALLOW_COPY_AND_ASSIGN(CompilerDriver); 727}; 728 729} // namespace art 730 731#endif // ART_COMPILER_DRIVER_COMPILER_DRIVER_H_ 732