compiler_driver.cc revision 486dda03900a215650f71a9068759978aa77c699
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#include "compiler_driver.h" 18 19#include <unistd.h> 20#include <unordered_set> 21#include <vector> 22 23#ifndef __APPLE__ 24#include <malloc.h> // For mallinfo 25#endif 26 27#include "android-base/strings.h" 28 29#include "art_field-inl.h" 30#include "art_method-inl.h" 31#include "base/arena_allocator.h" 32#include "base/array_ref.h" 33#include "base/bit_vector.h" 34#include "base/enums.h" 35#include "base/stl_util.h" 36#include "base/systrace.h" 37#include "base/time_utils.h" 38#include "base/timing_logger.h" 39#include "class_linker-inl.h" 40#include "compiled_method.h" 41#include "compiler.h" 42#include "compiler_callbacks.h" 43#include "compiler_driver-inl.h" 44#include "dex/dex_to_dex_compiler.h" 45#include "dex/verification_results.h" 46#include "dex/verified_method.h" 47#include "dex_compilation_unit.h" 48#include "dex_file-inl.h" 49#include "dex_instruction-inl.h" 50#include "driver/compiler_options.h" 51#include "gc/accounting/card_table-inl.h" 52#include "gc/accounting/heap_bitmap.h" 53#include "gc/space/image_space.h" 54#include "gc/space/space.h" 55#include "handle_scope-inl.h" 56#include "intrinsics_enum.h" 57#include "jni_internal.h" 58#include "mirror/class-inl.h" 59#include "mirror/class_loader.h" 60#include "mirror/dex_cache-inl.h" 61#include "mirror/object-inl.h" 62#include "mirror/object-refvisitor-inl.h" 63#include "mirror/object_array-inl.h" 64#include "mirror/throwable.h" 65#include "nativehelper/ScopedLocalRef.h" 66#include "object_lock.h" 67#include "runtime.h" 68#include "scoped_thread_state_change-inl.h" 69#include "thread.h" 70#include "thread_list.h" 71#include "thread_pool.h" 72#include "trampolines/trampoline_compiler.h" 73#include "transaction.h" 74#include "utils/atomic_dex_ref_map-inl.h" 75#include "utils/dex_cache_arrays_layout-inl.h" 76#include "utils/swap_space.h" 77#include "vdex_file.h" 78#include "verifier/method_verifier-inl.h" 79#include "verifier/method_verifier.h" 80#include "verifier/verifier_deps.h" 81#include "verifier/verifier_enums.h" 82 83namespace art { 84 85static constexpr bool kTimeCompileMethod = !kIsDebugBuild; 86 87// Print additional info during profile guided compilation. 88static constexpr bool kDebugProfileGuidedCompilation = false; 89 90// Max encoded fields allowed for initializing app image. Hardcode the number for now 91// because 5000 should be large enough. 92static constexpr uint32_t kMaxEncodedFields = 5000; 93 94static double Percentage(size_t x, size_t y) { 95 return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y)); 96} 97 98static void DumpStat(size_t x, size_t y, const char* str) { 99 if (x == 0 && y == 0) { 100 return; 101 } 102 LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases"; 103} 104 105class CompilerDriver::AOTCompilationStats { 106 public: 107 AOTCompilationStats() 108 : stats_lock_("AOT compilation statistics lock"), 109 resolved_types_(0), unresolved_types_(0), 110 resolved_instance_fields_(0), unresolved_instance_fields_(0), 111 resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0), 112 type_based_devirtualization_(0), 113 safe_casts_(0), not_safe_casts_(0) { 114 for (size_t i = 0; i <= kMaxInvokeType; i++) { 115 resolved_methods_[i] = 0; 116 unresolved_methods_[i] = 0; 117 virtual_made_direct_[i] = 0; 118 direct_calls_to_boot_[i] = 0; 119 direct_methods_to_boot_[i] = 0; 120 } 121 } 122 123 void Dump() { 124 DumpStat(resolved_types_, unresolved_types_, "types resolved"); 125 DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved"); 126 DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_, 127 "static fields resolved"); 128 DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_, 129 "static fields local to a class"); 130 DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information"); 131 // Note, the code below subtracts the stat value so that when added to the stat value we have 132 // 100% of samples. TODO: clean this up. 133 DumpStat(type_based_devirtualization_, 134 resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] + 135 resolved_methods_[kInterface] + unresolved_methods_[kInterface] - 136 type_based_devirtualization_, 137 "virtual/interface calls made direct based on type information"); 138 139 for (size_t i = 0; i <= kMaxInvokeType; i++) { 140 std::ostringstream oss; 141 oss << static_cast<InvokeType>(i) << " methods were AOT resolved"; 142 DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str()); 143 if (virtual_made_direct_[i] > 0) { 144 std::ostringstream oss2; 145 oss2 << static_cast<InvokeType>(i) << " methods made direct"; 146 DumpStat(virtual_made_direct_[i], 147 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i], 148 oss2.str().c_str()); 149 } 150 if (direct_calls_to_boot_[i] > 0) { 151 std::ostringstream oss2; 152 oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot"; 153 DumpStat(direct_calls_to_boot_[i], 154 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i], 155 oss2.str().c_str()); 156 } 157 if (direct_methods_to_boot_[i] > 0) { 158 std::ostringstream oss2; 159 oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot"; 160 DumpStat(direct_methods_to_boot_[i], 161 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i], 162 oss2.str().c_str()); 163 } 164 } 165 } 166 167// Allow lossy statistics in non-debug builds. 168#ifndef NDEBUG 169#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_) 170#else 171#define STATS_LOCK() 172#endif 173 174 void TypeDoesntNeedAccessCheck() REQUIRES(!stats_lock_) { 175 STATS_LOCK(); 176 resolved_types_++; 177 } 178 179 void TypeNeedsAccessCheck() REQUIRES(!stats_lock_) { 180 STATS_LOCK(); 181 unresolved_types_++; 182 } 183 184 void ResolvedInstanceField() REQUIRES(!stats_lock_) { 185 STATS_LOCK(); 186 resolved_instance_fields_++; 187 } 188 189 void UnresolvedInstanceField() REQUIRES(!stats_lock_) { 190 STATS_LOCK(); 191 unresolved_instance_fields_++; 192 } 193 194 void ResolvedLocalStaticField() REQUIRES(!stats_lock_) { 195 STATS_LOCK(); 196 resolved_local_static_fields_++; 197 } 198 199 void ResolvedStaticField() REQUIRES(!stats_lock_) { 200 STATS_LOCK(); 201 resolved_static_fields_++; 202 } 203 204 void UnresolvedStaticField() REQUIRES(!stats_lock_) { 205 STATS_LOCK(); 206 unresolved_static_fields_++; 207 } 208 209 // Indicate that type information from the verifier led to devirtualization. 210 void PreciseTypeDevirtualization() REQUIRES(!stats_lock_) { 211 STATS_LOCK(); 212 type_based_devirtualization_++; 213 } 214 215 // A check-cast could be eliminated due to verifier type analysis. 216 void SafeCast() REQUIRES(!stats_lock_) { 217 STATS_LOCK(); 218 safe_casts_++; 219 } 220 221 // A check-cast couldn't be eliminated due to verifier type analysis. 222 void NotASafeCast() REQUIRES(!stats_lock_) { 223 STATS_LOCK(); 224 not_safe_casts_++; 225 } 226 227 private: 228 Mutex stats_lock_; 229 230 size_t resolved_types_; 231 size_t unresolved_types_; 232 233 size_t resolved_instance_fields_; 234 size_t unresolved_instance_fields_; 235 236 size_t resolved_local_static_fields_; 237 size_t resolved_static_fields_; 238 size_t unresolved_static_fields_; 239 // Type based devirtualization for invoke interface and virtual. 240 size_t type_based_devirtualization_; 241 242 size_t resolved_methods_[kMaxInvokeType + 1]; 243 size_t unresolved_methods_[kMaxInvokeType + 1]; 244 size_t virtual_made_direct_[kMaxInvokeType + 1]; 245 size_t direct_calls_to_boot_[kMaxInvokeType + 1]; 246 size_t direct_methods_to_boot_[kMaxInvokeType + 1]; 247 248 size_t safe_casts_; 249 size_t not_safe_casts_; 250 251 DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats); 252}; 253 254class CompilerDriver::DexFileMethodSet { 255 public: 256 explicit DexFileMethodSet(const DexFile& dex_file) 257 : dex_file_(dex_file), 258 method_indexes_(dex_file.NumMethodIds(), false, Allocator::GetMallocAllocator()) { 259 } 260 DexFileMethodSet(DexFileMethodSet&& other) = default; 261 262 const DexFile& GetDexFile() const { return dex_file_; } 263 264 BitVector& GetMethodIndexes() { return method_indexes_; } 265 const BitVector& GetMethodIndexes() const { return method_indexes_; } 266 267 private: 268 const DexFile& dex_file_; 269 BitVector method_indexes_; 270}; 271 272CompilerDriver::CompilerDriver( 273 const CompilerOptions* compiler_options, 274 VerificationResults* verification_results, 275 Compiler::Kind compiler_kind, 276 InstructionSet instruction_set, 277 const InstructionSetFeatures* instruction_set_features, 278 std::unordered_set<std::string>* image_classes, 279 std::unordered_set<std::string>* compiled_classes, 280 std::unordered_set<std::string>* compiled_methods, 281 size_t thread_count, 282 bool dump_stats, 283 bool dump_passes, 284 CumulativeLogger* timer, 285 int swap_fd, 286 const ProfileCompilationInfo* profile_compilation_info) 287 : compiler_options_(compiler_options), 288 verification_results_(verification_results), 289 compiler_(Compiler::Create(this, compiler_kind)), 290 compiler_kind_(compiler_kind), 291 instruction_set_(instruction_set == kArm ? kThumb2 : instruction_set), 292 instruction_set_features_(instruction_set_features), 293 requires_constructor_barrier_lock_("constructor barrier lock"), 294 non_relative_linker_patch_count_(0u), 295 image_classes_(image_classes), 296 classes_to_compile_(compiled_classes), 297 methods_to_compile_(compiled_methods), 298 had_hard_verifier_failure_(false), 299 parallel_thread_count_(thread_count), 300 stats_(new AOTCompilationStats), 301 dump_stats_(dump_stats), 302 dump_passes_(dump_passes), 303 timings_logger_(timer), 304 compiler_context_(nullptr), 305 support_boot_image_fixup_(true), 306 compiled_method_storage_(swap_fd), 307 profile_compilation_info_(profile_compilation_info), 308 max_arena_alloc_(0), 309 dex_to_dex_references_lock_("dex-to-dex references lock"), 310 dex_to_dex_references_(), 311 current_dex_to_dex_methods_(nullptr) { 312 DCHECK(compiler_options_ != nullptr); 313 314 compiler_->Init(); 315 316 if (GetCompilerOptions().IsBootImage()) { 317 CHECK(image_classes_.get() != nullptr) << "Expected image classes for boot image"; 318 } 319} 320 321CompilerDriver::~CompilerDriver() { 322 compiled_methods_.Visit([this](const DexFileReference& ref ATTRIBUTE_UNUSED, 323 CompiledMethod* method) { 324 if (method != nullptr) { 325 CompiledMethod::ReleaseSwapAllocatedCompiledMethod(this, method); 326 } 327 }); 328 compiler_->UnInit(); 329} 330 331 332#define CREATE_TRAMPOLINE(type, abi, offset) \ 333 if (Is64BitInstructionSet(instruction_set_)) { \ 334 return CreateTrampoline64(instruction_set_, abi, \ 335 type ## _ENTRYPOINT_OFFSET(PointerSize::k64, offset)); \ 336 } else { \ 337 return CreateTrampoline32(instruction_set_, abi, \ 338 type ## _ENTRYPOINT_OFFSET(PointerSize::k32, offset)); \ 339 } 340 341std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateJniDlsymLookup() const { 342 CREATE_TRAMPOLINE(JNI, kJniAbi, pDlsymLookup) 343} 344 345std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickGenericJniTrampoline() 346 const { 347 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickGenericJniTrampoline) 348} 349 350std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickImtConflictTrampoline() 351 const { 352 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickImtConflictTrampoline) 353} 354 355std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickResolutionTrampoline() 356 const { 357 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickResolutionTrampoline) 358} 359 360std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickToInterpreterBridge() 361 const { 362 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickToInterpreterBridge) 363} 364#undef CREATE_TRAMPOLINE 365 366static void SetupIntrinsic(Thread* self, 367 Intrinsics intrinsic, 368 InvokeType invoke_type, 369 const char* class_name, 370 const char* method_name, 371 const char* signature) 372 REQUIRES_SHARED(Locks::mutator_lock_) { 373 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 374 PointerSize image_size = class_linker->GetImagePointerSize(); 375 ObjPtr<mirror::Class> cls = class_linker->FindSystemClass(self, class_name); 376 if (cls == nullptr) { 377 LOG(FATAL) << "Could not find class of intrinsic " << class_name; 378 } 379 ArtMethod* method = cls->FindClassMethod(method_name, signature, image_size); 380 if (method == nullptr || method->GetDeclaringClass() != cls) { 381 LOG(FATAL) << "Could not find method of intrinsic " 382 << class_name << " " << method_name << " " << signature; 383 } 384 DCHECK_EQ(method->GetInvokeType(), invoke_type); 385 method->SetIntrinsic(static_cast<uint32_t>(intrinsic)); 386} 387 388void CompilerDriver::CompileAll(jobject class_loader, 389 const std::vector<const DexFile*>& dex_files, 390 TimingLogger* timings) { 391 DCHECK(!Runtime::Current()->IsStarted()); 392 393 InitializeThreadPools(); 394 395 VLOG(compiler) << "Before precompile " << GetMemoryUsageString(false); 396 // Precompile: 397 // 1) Load image classes 398 // 2) Resolve all classes 399 // 3) Attempt to verify all classes 400 // 4) Attempt to initialize image classes, and trivially initialized classes 401 PreCompile(class_loader, dex_files, timings); 402 if (GetCompilerOptions().IsBootImage()) { 403 // We don't need to setup the intrinsics for non boot image compilation, as 404 // those compilations will pick up a boot image that have the ArtMethod already 405 // set with the intrinsics flag. 406 ScopedObjectAccess soa(Thread::Current()); 407#define SETUP_INTRINSICS(Name, InvokeType, NeedsEnvironmentOrCache, SideEffects, Exceptions, \ 408 ClassName, MethodName, Signature) \ 409 SetupIntrinsic(soa.Self(), Intrinsics::k##Name, InvokeType, ClassName, MethodName, Signature); 410#include "intrinsics_list.h" 411 INTRINSICS_LIST(SETUP_INTRINSICS) 412#undef INTRINSICS_LIST 413#undef SETUP_INTRINSICS 414 } 415 // Compile: 416 // 1) Compile all classes and methods enabled for compilation. May fall back to dex-to-dex 417 // compilation. 418 if (GetCompilerOptions().IsAnyCompilationEnabled()) { 419 Compile(class_loader, dex_files, timings); 420 } 421 if (dump_stats_) { 422 stats_->Dump(); 423 } 424 425 FreeThreadPools(); 426} 427 428static optimizer::DexToDexCompilationLevel GetDexToDexCompilationLevel( 429 Thread* self, const CompilerDriver& driver, Handle<mirror::ClassLoader> class_loader, 430 const DexFile& dex_file, const DexFile::ClassDef& class_def) 431 REQUIRES_SHARED(Locks::mutator_lock_) { 432 auto* const runtime = Runtime::Current(); 433 DCHECK(driver.GetCompilerOptions().IsQuickeningCompilationEnabled()); 434 const char* descriptor = dex_file.GetClassDescriptor(class_def); 435 ClassLinker* class_linker = runtime->GetClassLinker(); 436 mirror::Class* klass = class_linker->FindClass(self, descriptor, class_loader); 437 if (klass == nullptr) { 438 CHECK(self->IsExceptionPending()); 439 self->ClearException(); 440 return optimizer::DexToDexCompilationLevel::kDontDexToDexCompile; 441 } 442 // DexToDex at the kOptimize level may introduce quickened opcodes, which replace symbolic 443 // references with actual offsets. We cannot re-verify such instructions. 444 // 445 // We store the verification information in the class status in the oat file, which the linker 446 // can validate (checksums) and use to skip load-time verification. It is thus safe to 447 // optimize when a class has been fully verified before. 448 optimizer::DexToDexCompilationLevel max_level = optimizer::DexToDexCompilationLevel::kOptimize; 449 if (driver.GetCompilerOptions().GetDebuggable()) { 450 // We are debuggable so definitions of classes might be changed. We don't want to do any 451 // optimizations that could break that. 452 max_level = optimizer::DexToDexCompilationLevel::kDontDexToDexCompile; 453 } 454 if (klass->IsVerified()) { 455 // Class is verified so we can enable DEX-to-DEX compilation for performance. 456 return max_level; 457 } else { 458 // Class verification has failed: do not run DEX-to-DEX optimizations. 459 return optimizer::DexToDexCompilationLevel::kDontDexToDexCompile; 460 } 461} 462 463static optimizer::DexToDexCompilationLevel GetDexToDexCompilationLevel( 464 Thread* self, 465 const CompilerDriver& driver, 466 jobject jclass_loader, 467 const DexFile& dex_file, 468 const DexFile::ClassDef& class_def) { 469 ScopedObjectAccess soa(self); 470 StackHandleScope<1> hs(soa.Self()); 471 Handle<mirror::ClassLoader> class_loader( 472 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 473 return GetDexToDexCompilationLevel(self, driver, class_loader, dex_file, class_def); 474} 475 476// Does the runtime for the InstructionSet provide an implementation returned by 477// GetQuickGenericJniStub allowing down calls that aren't compiled using a JNI compiler? 478static bool InstructionSetHasGenericJniStub(InstructionSet isa) { 479 switch (isa) { 480 case kArm: 481 case kArm64: 482 case kThumb2: 483 case kMips: 484 case kMips64: 485 case kX86: 486 case kX86_64: return true; 487 default: return false; 488 } 489} 490 491static void CompileMethod(Thread* self, 492 CompilerDriver* driver, 493 const DexFile::CodeItem* code_item, 494 uint32_t access_flags, 495 InvokeType invoke_type, 496 uint16_t class_def_idx, 497 uint32_t method_idx, 498 Handle<mirror::ClassLoader> class_loader, 499 const DexFile& dex_file, 500 optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level, 501 bool compilation_enabled, 502 Handle<mirror::DexCache> dex_cache) { 503 DCHECK(driver != nullptr); 504 CompiledMethod* compiled_method = nullptr; 505 uint64_t start_ns = kTimeCompileMethod ? NanoTime() : 0; 506 MethodReference method_ref(&dex_file, method_idx); 507 508 if (driver->GetCurrentDexToDexMethods() != nullptr) { 509 // This is the second pass when we dex-to-dex compile previously marked methods. 510 // TODO: Refactor the compilation to avoid having to distinguish the two passes 511 // here. That should be done on a higher level. http://b/29089975 512 if (driver->GetCurrentDexToDexMethods()->IsBitSet(method_idx)) { 513 VerificationResults* results = driver->GetVerificationResults(); 514 DCHECK(results != nullptr); 515 const VerifiedMethod* verified_method = results->GetVerifiedMethod(method_ref); 516 // Do not optimize if a VerifiedMethod is missing. SafeCast elision, 517 // for example, relies on it. 518 compiled_method = optimizer::ArtCompileDEX( 519 driver, 520 code_item, 521 access_flags, 522 invoke_type, 523 class_def_idx, 524 method_idx, 525 class_loader, 526 dex_file, 527 (verified_method != nullptr) 528 ? dex_to_dex_compilation_level 529 : optimizer::DexToDexCompilationLevel::kDontDexToDexCompile); 530 } 531 } else if ((access_flags & kAccNative) != 0) { 532 // Are we extracting only and have support for generic JNI down calls? 533 if (!driver->GetCompilerOptions().IsJniCompilationEnabled() && 534 InstructionSetHasGenericJniStub(driver->GetInstructionSet())) { 535 // Leaving this empty will trigger the generic JNI version 536 } else { 537 // Look-up the ArtMethod associated with this code_item (if any) 538 // -- It is later used to lookup any [optimization] annotations for this method. 539 ScopedObjectAccess soa(self); 540 541 // TODO: Lookup annotation from DexFile directly without resolving method. 542 ArtMethod* method = 543 Runtime::Current()->GetClassLinker()->ResolveMethod<ClassLinker::ResolveMode::kNoChecks>( 544 dex_file, 545 method_idx, 546 dex_cache, 547 class_loader, 548 /* referrer */ nullptr, 549 invoke_type); 550 551 // Query any JNI optimization annotations such as @FastNative or @CriticalNative. 552 Compiler::JniOptimizationFlags optimization_flags = Compiler::kNone; 553 if (UNLIKELY(method == nullptr)) { 554 // Failed method resolutions happen very rarely, e.g. ancestor class cannot be resolved. 555 DCHECK(self->IsExceptionPending()); 556 self->ClearException(); 557 } else if (method->IsAnnotatedWithFastNative()) { 558 // TODO: Will no longer need this CHECK once we have verifier checking this. 559 CHECK(!method->IsAnnotatedWithCriticalNative()); 560 optimization_flags = Compiler::kFastNative; 561 } else if (method->IsAnnotatedWithCriticalNative()) { 562 // TODO: Will no longer need this CHECK once we have verifier checking this. 563 CHECK(!method->IsAnnotatedWithFastNative()); 564 optimization_flags = Compiler::kCriticalNative; 565 } 566 567 compiled_method = driver->GetCompiler()->JniCompile(access_flags, 568 method_idx, 569 dex_file, 570 optimization_flags); 571 CHECK(compiled_method != nullptr); 572 } 573 } else if ((access_flags & kAccAbstract) != 0) { 574 // Abstract methods don't have code. 575 } else { 576 VerificationResults* results = driver->GetVerificationResults(); 577 DCHECK(results != nullptr); 578 const VerifiedMethod* verified_method = results->GetVerifiedMethod(method_ref); 579 bool compile = compilation_enabled && 580 // Basic checks, e.g., not <clinit>. 581 results->IsCandidateForCompilation(method_ref, access_flags) && 582 // Did not fail to create VerifiedMethod metadata. 583 verified_method != nullptr && 584 // Do not have failures that should punt to the interpreter. 585 !verified_method->HasRuntimeThrow() && 586 (verified_method->GetEncounteredVerificationFailures() & 587 (verifier::VERIFY_ERROR_FORCE_INTERPRETER | verifier::VERIFY_ERROR_LOCKING)) == 0 && 588 // Is eligable for compilation by methods-to-compile filter. 589 driver->IsMethodToCompile(method_ref) && 590 driver->ShouldCompileBasedOnProfile(method_ref); 591 592 if (compile) { 593 // NOTE: if compiler declines to compile this method, it will return null. 594 compiled_method = driver->GetCompiler()->Compile(code_item, 595 access_flags, 596 invoke_type, 597 class_def_idx, 598 method_idx, 599 class_loader, 600 dex_file, 601 dex_cache); 602 } 603 if (compiled_method == nullptr && 604 dex_to_dex_compilation_level != optimizer::DexToDexCompilationLevel::kDontDexToDexCompile) { 605 DCHECK(!Runtime::Current()->UseJitCompilation()); 606 // TODO: add a command-line option to disable DEX-to-DEX compilation ? 607 driver->MarkForDexToDexCompilation(self, method_ref); 608 } 609 } 610 if (kTimeCompileMethod) { 611 uint64_t duration_ns = NanoTime() - start_ns; 612 if (duration_ns > MsToNs(driver->GetCompiler()->GetMaximumCompilationTimeBeforeWarning())) { 613 LOG(WARNING) << "Compilation of " << dex_file.PrettyMethod(method_idx) 614 << " took " << PrettyDuration(duration_ns); 615 } 616 } 617 618 if (compiled_method != nullptr) { 619 // Count non-relative linker patches. 620 size_t non_relative_linker_patch_count = 0u; 621 for (const LinkerPatch& patch : compiled_method->GetPatches()) { 622 if (!patch.IsPcRelative()) { 623 ++non_relative_linker_patch_count; 624 } 625 } 626 bool compile_pic = driver->GetCompilerOptions().GetCompilePic(); // Off by default 627 // When compiling with PIC, there should be zero non-relative linker patches 628 CHECK(!compile_pic || non_relative_linker_patch_count == 0u); 629 630 driver->AddCompiledMethod(method_ref, compiled_method, non_relative_linker_patch_count); 631 } 632 633 if (self->IsExceptionPending()) { 634 ScopedObjectAccess soa(self); 635 LOG(FATAL) << "Unexpected exception compiling: " << dex_file.PrettyMethod(method_idx) << "\n" 636 << self->GetException()->Dump(); 637 } 638} 639 640void CompilerDriver::CompileOne(Thread* self, ArtMethod* method, TimingLogger* timings) { 641 DCHECK(!Runtime::Current()->IsStarted()); 642 jobject jclass_loader; 643 const DexFile* dex_file; 644 uint16_t class_def_idx; 645 uint32_t method_idx = method->GetDexMethodIndex(); 646 uint32_t access_flags = method->GetAccessFlags(); 647 InvokeType invoke_type = method->GetInvokeType(); 648 StackHandleScope<2> hs(self); 649 Handle<mirror::DexCache> dex_cache(hs.NewHandle(method->GetDexCache())); 650 Handle<mirror::ClassLoader> class_loader( 651 hs.NewHandle(method->GetDeclaringClass()->GetClassLoader())); 652 { 653 ScopedObjectAccessUnchecked soa(self); 654 ScopedLocalRef<jobject> local_class_loader( 655 soa.Env(), soa.AddLocalReference<jobject>(class_loader.Get())); 656 jclass_loader = soa.Env()->NewGlobalRef(local_class_loader.get()); 657 // Find the dex_file 658 dex_file = method->GetDexFile(); 659 class_def_idx = method->GetClassDefIndex(); 660 } 661 const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset()); 662 663 // Go to native so that we don't block GC during compilation. 664 ScopedThreadSuspension sts(self, kNative); 665 666 std::vector<const DexFile*> dex_files; 667 dex_files.push_back(dex_file); 668 669 InitializeThreadPools(); 670 671 PreCompile(jclass_loader, dex_files, timings); 672 673 // Can we run DEX-to-DEX compiler on this class ? 674 optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level = 675 GetDexToDexCompilationLevel(self, 676 *this, 677 jclass_loader, 678 *dex_file, 679 dex_file->GetClassDef(class_def_idx)); 680 681 DCHECK(current_dex_to_dex_methods_ == nullptr); 682 CompileMethod(self, 683 this, 684 code_item, 685 access_flags, 686 invoke_type, 687 class_def_idx, 688 method_idx, 689 class_loader, 690 *dex_file, 691 dex_to_dex_compilation_level, 692 true, 693 dex_cache); 694 695 ArrayRef<DexFileMethodSet> dex_to_dex_references; 696 { 697 // From this point on, we shall not modify dex_to_dex_references_, so 698 // just grab a reference to it that we use without holding the mutex. 699 MutexLock lock(Thread::Current(), dex_to_dex_references_lock_); 700 dex_to_dex_references = ArrayRef<DexFileMethodSet>(dex_to_dex_references_); 701 } 702 if (!dex_to_dex_references.empty()) { 703 DCHECK_EQ(dex_to_dex_references.size(), 1u); 704 DCHECK(&dex_to_dex_references[0].GetDexFile() == dex_file); 705 current_dex_to_dex_methods_ = &dex_to_dex_references.front().GetMethodIndexes(); 706 DCHECK(current_dex_to_dex_methods_->IsBitSet(method_idx)); 707 DCHECK_EQ(current_dex_to_dex_methods_->NumSetBits(), 1u); 708 CompileMethod(self, 709 this, 710 code_item, 711 access_flags, 712 invoke_type, 713 class_def_idx, 714 method_idx, 715 class_loader, 716 *dex_file, 717 dex_to_dex_compilation_level, 718 true, 719 dex_cache); 720 current_dex_to_dex_methods_ = nullptr; 721 } 722 723 FreeThreadPools(); 724 725 self->GetJniEnv()->DeleteGlobalRef(jclass_loader); 726} 727 728void CompilerDriver::Resolve(jobject class_loader, 729 const std::vector<const DexFile*>& dex_files, 730 TimingLogger* timings) { 731 // Resolution allocates classes and needs to run single-threaded to be deterministic. 732 bool force_determinism = GetCompilerOptions().IsForceDeterminism(); 733 ThreadPool* resolve_thread_pool = force_determinism 734 ? single_thread_pool_.get() 735 : parallel_thread_pool_.get(); 736 size_t resolve_thread_count = force_determinism ? 1U : parallel_thread_count_; 737 738 for (size_t i = 0; i != dex_files.size(); ++i) { 739 const DexFile* dex_file = dex_files[i]; 740 CHECK(dex_file != nullptr); 741 ResolveDexFile(class_loader, 742 *dex_file, 743 dex_files, 744 resolve_thread_pool, 745 resolve_thread_count, 746 timings); 747 } 748} 749 750// Resolve const-strings in the code. Done to have deterministic allocation behavior. Right now 751// this is single-threaded for simplicity. 752// TODO: Collect the relevant string indices in parallel, then allocate them sequentially in a 753// stable order. 754 755static void ResolveConstStrings(Handle<mirror::DexCache> dex_cache, 756 const DexFile& dex_file, 757 const DexFile::CodeItem* code_item) 758 REQUIRES_SHARED(Locks::mutator_lock_) { 759 if (code_item == nullptr) { 760 // Abstract or native method. 761 return; 762 } 763 764 const uint16_t* code_ptr = code_item->insns_; 765 const uint16_t* code_end = code_item->insns_ + code_item->insns_size_in_code_units_; 766 ClassLinker* const class_linker = Runtime::Current()->GetClassLinker(); 767 768 while (code_ptr < code_end) { 769 const Instruction* inst = Instruction::At(code_ptr); 770 switch (inst->Opcode()) { 771 case Instruction::CONST_STRING: 772 case Instruction::CONST_STRING_JUMBO: { 773 dex::StringIndex string_index((inst->Opcode() == Instruction::CONST_STRING) 774 ? inst->VRegB_21c() 775 : inst->VRegB_31c()); 776 mirror::String* string = class_linker->ResolveString(dex_file, string_index, dex_cache); 777 CHECK(string != nullptr) << "Could not allocate a string when forcing determinism"; 778 break; 779 } 780 781 default: 782 break; 783 } 784 785 code_ptr += inst->SizeInCodeUnits(); 786 } 787} 788 789static void ResolveConstStrings(CompilerDriver* driver, 790 const std::vector<const DexFile*>& dex_files, 791 TimingLogger* timings) { 792 ScopedObjectAccess soa(Thread::Current()); 793 StackHandleScope<1> hs(soa.Self()); 794 ClassLinker* const class_linker = Runtime::Current()->GetClassLinker(); 795 MutableHandle<mirror::DexCache> dex_cache(hs.NewHandle<mirror::DexCache>(nullptr)); 796 797 for (const DexFile* dex_file : dex_files) { 798 dex_cache.Assign(class_linker->FindDexCache(soa.Self(), *dex_file)); 799 TimingLogger::ScopedTiming t("Resolve const-string Strings", timings); 800 801 size_t class_def_count = dex_file->NumClassDefs(); 802 for (size_t class_def_index = 0; class_def_index < class_def_count; ++class_def_index) { 803 const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index); 804 805 const uint8_t* class_data = dex_file->GetClassData(class_def); 806 if (class_data == nullptr) { 807 // empty class, probably a marker interface 808 continue; 809 } 810 811 ClassDataItemIterator it(*dex_file, class_data); 812 it.SkipAllFields(); 813 814 bool compilation_enabled = driver->IsClassToCompile( 815 dex_file->StringByTypeIdx(class_def.class_idx_)); 816 if (!compilation_enabled) { 817 // Compilation is skipped, do not resolve const-string in code of this class. 818 // TODO: Make sure that inlining honors this. 819 continue; 820 } 821 822 // Direct methods. 823 int64_t previous_direct_method_idx = -1; 824 while (it.HasNextDirectMethod()) { 825 uint32_t method_idx = it.GetMemberIndex(); 826 if (method_idx == previous_direct_method_idx) { 827 // smali can create dex files with two encoded_methods sharing the same method_idx 828 // http://code.google.com/p/smali/issues/detail?id=119 829 it.Next(); 830 continue; 831 } 832 previous_direct_method_idx = method_idx; 833 ResolveConstStrings(dex_cache, *dex_file, it.GetMethodCodeItem()); 834 it.Next(); 835 } 836 // Virtual methods. 837 int64_t previous_virtual_method_idx = -1; 838 while (it.HasNextVirtualMethod()) { 839 uint32_t method_idx = it.GetMemberIndex(); 840 if (method_idx == previous_virtual_method_idx) { 841 // smali can create dex files with two encoded_methods sharing the same method_idx 842 // http://code.google.com/p/smali/issues/detail?id=119 843 it.Next(); 844 continue; 845 } 846 previous_virtual_method_idx = method_idx; 847 ResolveConstStrings(dex_cache, *dex_file, it.GetMethodCodeItem()); 848 it.Next(); 849 } 850 DCHECK(!it.HasNext()); 851 } 852 } 853} 854 855inline void CompilerDriver::CheckThreadPools() { 856 DCHECK(parallel_thread_pool_ != nullptr); 857 DCHECK(single_thread_pool_ != nullptr); 858} 859 860static void EnsureVerifiedOrVerifyAtRuntime(jobject jclass_loader, 861 const std::vector<const DexFile*>& dex_files) { 862 ScopedObjectAccess soa(Thread::Current()); 863 StackHandleScope<2> hs(soa.Self()); 864 Handle<mirror::ClassLoader> class_loader( 865 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 866 MutableHandle<mirror::Class> cls(hs.NewHandle<mirror::Class>(nullptr)); 867 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 868 869 for (const DexFile* dex_file : dex_files) { 870 for (uint32_t i = 0; i < dex_file->NumClassDefs(); ++i) { 871 const DexFile::ClassDef& class_def = dex_file->GetClassDef(i); 872 const char* descriptor = dex_file->GetClassDescriptor(class_def); 873 cls.Assign(class_linker->FindClass(soa.Self(), descriptor, class_loader)); 874 if (cls == nullptr) { 875 soa.Self()->ClearException(); 876 } else if (&cls->GetDexFile() == dex_file) { 877 DCHECK(cls->IsErroneous() || cls->IsVerified() || cls->ShouldVerifyAtRuntime()) 878 << cls->PrettyClass() 879 << " " << cls->GetStatus(); 880 } 881 } 882 } 883} 884 885void CompilerDriver::PreCompile(jobject class_loader, 886 const std::vector<const DexFile*>& dex_files, 887 TimingLogger* timings) { 888 CheckThreadPools(); 889 890 LoadImageClasses(timings); 891 VLOG(compiler) << "LoadImageClasses: " << GetMemoryUsageString(false); 892 893 if (compiler_options_->IsAnyCompilationEnabled()) { 894 // Avoid adding the dex files in the case where we aren't going to add compiled methods. 895 // This reduces RAM usage for this case. 896 for (const DexFile* dex_file : dex_files) { 897 // Can be already inserted if the caller is CompileOne. This happens for gtests. 898 if (!compiled_methods_.HaveDexFile(dex_file)) { 899 compiled_methods_.AddDexFile(dex_file, dex_file->NumMethodIds()); 900 } 901 } 902 // Resolve eagerly to prepare for compilation. 903 Resolve(class_loader, dex_files, timings); 904 VLOG(compiler) << "Resolve: " << GetMemoryUsageString(false); 905 } 906 907 if (compiler_options_->AssumeClassesAreVerified()) { 908 VLOG(compiler) << "Verify none mode specified, skipping verification."; 909 SetVerified(class_loader, dex_files, timings); 910 } 911 912 if (!compiler_options_->IsVerificationEnabled()) { 913 return; 914 } 915 916 if (GetCompilerOptions().IsForceDeterminism() && GetCompilerOptions().IsBootImage()) { 917 // Resolve strings from const-string. Do this now to have a deterministic image. 918 ResolveConstStrings(this, dex_files, timings); 919 VLOG(compiler) << "Resolve const-strings: " << GetMemoryUsageString(false); 920 } 921 922 Verify(class_loader, dex_files, timings); 923 VLOG(compiler) << "Verify: " << GetMemoryUsageString(false); 924 925 if (had_hard_verifier_failure_ && GetCompilerOptions().AbortOnHardVerifierFailure()) { 926 // Avoid dumping threads. Even if we shut down the thread pools, there will still be three 927 // instances of this thread's stack. 928 LOG(FATAL_WITHOUT_ABORT) << "Had a hard failure verifying all classes, and was asked to abort " 929 << "in such situations. Please check the log."; 930 abort(); 931 } 932 933 if (compiler_options_->IsAnyCompilationEnabled()) { 934 if (kIsDebugBuild) { 935 EnsureVerifiedOrVerifyAtRuntime(class_loader, dex_files); 936 } 937 InitializeClasses(class_loader, dex_files, timings); 938 VLOG(compiler) << "InitializeClasses: " << GetMemoryUsageString(false); 939 } 940 941 UpdateImageClasses(timings); 942 VLOG(compiler) << "UpdateImageClasses: " << GetMemoryUsageString(false); 943} 944 945bool CompilerDriver::IsImageClass(const char* descriptor) const { 946 if (image_classes_ != nullptr) { 947 // If we have a set of image classes, use those. 948 return image_classes_->find(descriptor) != image_classes_->end(); 949 } 950 // No set of image classes, assume we include all the classes. 951 // NOTE: Currently only reachable from InitImageMethodVisitor for the app image case. 952 return !GetCompilerOptions().IsBootImage(); 953} 954 955bool CompilerDriver::IsClassToCompile(const char* descriptor) const { 956 if (classes_to_compile_ == nullptr) { 957 return true; 958 } 959 return classes_to_compile_->find(descriptor) != classes_to_compile_->end(); 960} 961 962bool CompilerDriver::IsMethodToCompile(const MethodReference& method_ref) const { 963 if (methods_to_compile_ == nullptr) { 964 return true; 965 } 966 967 std::string tmp = method_ref.dex_file->PrettyMethod(method_ref.dex_method_index, true); 968 return methods_to_compile_->find(tmp.c_str()) != methods_to_compile_->end(); 969} 970 971bool CompilerDriver::ShouldCompileBasedOnProfile(const MethodReference& method_ref) const { 972 // Profile compilation info may be null if no profile is passed. 973 if (!CompilerFilter::DependsOnProfile(compiler_options_->GetCompilerFilter())) { 974 // Use the compiler filter instead of the presence of profile_compilation_info_ since 975 // we may want to have full speed compilation along with profile based layout optimizations. 976 return true; 977 } 978 // If we are using a profile filter but do not have a profile compilation info, compile nothing. 979 if (profile_compilation_info_ == nullptr) { 980 return false; 981 } 982 // Compile only hot methods, it is the profile saver's job to decide what startup methods to mark 983 // as hot. 984 bool result = profile_compilation_info_->GetMethodHotness(method_ref).IsHot(); 985 986 if (kDebugProfileGuidedCompilation) { 987 LOG(INFO) << "[ProfileGuidedCompilation] " 988 << (result ? "Compiled" : "Skipped") << " method:" 989 << method_ref.dex_file->PrettyMethod(method_ref.dex_method_index, true); 990 } 991 return result; 992} 993 994class ResolveCatchBlockExceptionsClassVisitor : public ClassVisitor { 995 public: 996 ResolveCatchBlockExceptionsClassVisitor() : classes_() {} 997 998 virtual bool operator()(ObjPtr<mirror::Class> c) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) { 999 classes_.push_back(c); 1000 return true; 1001 } 1002 1003 void FindExceptionTypesToResolve( 1004 std::set<std::pair<dex::TypeIndex, const DexFile*>>* exceptions_to_resolve) 1005 REQUIRES_SHARED(Locks::mutator_lock_) { 1006 const auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); 1007 for (ObjPtr<mirror::Class> klass : classes_) { 1008 for (ArtMethod& method : klass->GetMethods(pointer_size)) { 1009 FindExceptionTypesToResolveForMethod(&method, exceptions_to_resolve); 1010 } 1011 } 1012 } 1013 1014 private: 1015 void FindExceptionTypesToResolveForMethod( 1016 ArtMethod* method, 1017 std::set<std::pair<dex::TypeIndex, const DexFile*>>* exceptions_to_resolve) 1018 REQUIRES_SHARED(Locks::mutator_lock_) { 1019 const DexFile::CodeItem* code_item = method->GetCodeItem(); 1020 if (code_item == nullptr) { 1021 return; // native or abstract method 1022 } 1023 if (code_item->tries_size_ == 0) { 1024 return; // nothing to process 1025 } 1026 const uint8_t* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0); 1027 size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list); 1028 for (size_t i = 0; i < num_encoded_catch_handlers; i++) { 1029 int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list); 1030 bool has_catch_all = false; 1031 if (encoded_catch_handler_size <= 0) { 1032 encoded_catch_handler_size = -encoded_catch_handler_size; 1033 has_catch_all = true; 1034 } 1035 for (int32_t j = 0; j < encoded_catch_handler_size; j++) { 1036 dex::TypeIndex encoded_catch_handler_handlers_type_idx = 1037 dex::TypeIndex(DecodeUnsignedLeb128(&encoded_catch_handler_list)); 1038 // Add to set of types to resolve if not already in the dex cache resolved types 1039 if (!method->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) { 1040 exceptions_to_resolve->emplace(encoded_catch_handler_handlers_type_idx, 1041 method->GetDexFile()); 1042 } 1043 // ignore address associated with catch handler 1044 DecodeUnsignedLeb128(&encoded_catch_handler_list); 1045 } 1046 if (has_catch_all) { 1047 // ignore catch all address 1048 DecodeUnsignedLeb128(&encoded_catch_handler_list); 1049 } 1050 } 1051 } 1052 1053 std::vector<ObjPtr<mirror::Class>> classes_; 1054}; 1055 1056class RecordImageClassesVisitor : public ClassVisitor { 1057 public: 1058 explicit RecordImageClassesVisitor(std::unordered_set<std::string>* image_classes) 1059 : image_classes_(image_classes) {} 1060 1061 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) { 1062 std::string temp; 1063 image_classes_->insert(klass->GetDescriptor(&temp)); 1064 return true; 1065 } 1066 1067 private: 1068 std::unordered_set<std::string>* const image_classes_; 1069}; 1070 1071// Make a list of descriptors for classes to include in the image 1072void CompilerDriver::LoadImageClasses(TimingLogger* timings) { 1073 CHECK(timings != nullptr); 1074 if (!GetCompilerOptions().IsBootImage()) { 1075 return; 1076 } 1077 1078 TimingLogger::ScopedTiming t("LoadImageClasses", timings); 1079 // Make a first class to load all classes explicitly listed in the file 1080 Thread* self = Thread::Current(); 1081 ScopedObjectAccess soa(self); 1082 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1083 CHECK(image_classes_.get() != nullptr); 1084 for (auto it = image_classes_->begin(), end = image_classes_->end(); it != end;) { 1085 const std::string& descriptor(*it); 1086 StackHandleScope<1> hs(self); 1087 Handle<mirror::Class> klass( 1088 hs.NewHandle(class_linker->FindSystemClass(self, descriptor.c_str()))); 1089 if (klass == nullptr) { 1090 VLOG(compiler) << "Failed to find class " << descriptor; 1091 image_classes_->erase(it++); 1092 self->ClearException(); 1093 } else { 1094 ++it; 1095 } 1096 } 1097 1098 // Resolve exception classes referenced by the loaded classes. The catch logic assumes 1099 // exceptions are resolved by the verifier when there is a catch block in an interested method. 1100 // Do this here so that exception classes appear to have been specified image classes. 1101 std::set<std::pair<dex::TypeIndex, const DexFile*>> unresolved_exception_types; 1102 StackHandleScope<1> hs(self); 1103 Handle<mirror::Class> java_lang_Throwable( 1104 hs.NewHandle(class_linker->FindSystemClass(self, "Ljava/lang/Throwable;"))); 1105 do { 1106 unresolved_exception_types.clear(); 1107 { 1108 // Thread suspension is not allowed while ResolveCatchBlockExceptionsClassVisitor 1109 // is using a std::vector<ObjPtr<mirror::Class>>. 1110 ScopedAssertNoThreadSuspension ants(__FUNCTION__); 1111 ResolveCatchBlockExceptionsClassVisitor visitor; 1112 class_linker->VisitClasses(&visitor); 1113 visitor.FindExceptionTypesToResolve(&unresolved_exception_types); 1114 } 1115 for (const auto& exception_type : unresolved_exception_types) { 1116 dex::TypeIndex exception_type_idx = exception_type.first; 1117 const DexFile* dex_file = exception_type.second; 1118 StackHandleScope<2> hs2(self); 1119 Handle<mirror::DexCache> dex_cache(hs2.NewHandle(class_linker->RegisterDexFile(*dex_file, 1120 nullptr))); 1121 Handle<mirror::Class> klass(hs2.NewHandle( 1122 (dex_cache != nullptr) 1123 ? class_linker->ResolveType(*dex_file, 1124 exception_type_idx, 1125 dex_cache, 1126 ScopedNullHandle<mirror::ClassLoader>()) 1127 : nullptr)); 1128 if (klass == nullptr) { 1129 const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx); 1130 const char* descriptor = dex_file->GetTypeDescriptor(type_id); 1131 LOG(FATAL) << "Failed to resolve class " << descriptor; 1132 } 1133 DCHECK(java_lang_Throwable->IsAssignableFrom(klass.Get())); 1134 } 1135 // Resolving exceptions may load classes that reference more exceptions, iterate until no 1136 // more are found 1137 } while (!unresolved_exception_types.empty()); 1138 1139 // We walk the roots looking for classes so that we'll pick up the 1140 // above classes plus any classes them depend on such super 1141 // classes, interfaces, and the required ClassLinker roots. 1142 RecordImageClassesVisitor visitor(image_classes_.get()); 1143 class_linker->VisitClasses(&visitor); 1144 1145 CHECK_NE(image_classes_->size(), 0U); 1146} 1147 1148static void MaybeAddToImageClasses(Thread* self, 1149 ObjPtr<mirror::Class> klass, 1150 std::unordered_set<std::string>* image_classes) 1151 REQUIRES_SHARED(Locks::mutator_lock_) { 1152 DCHECK_EQ(self, Thread::Current()); 1153 StackHandleScope<1> hs(self); 1154 std::string temp; 1155 const PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); 1156 while (!klass->IsObjectClass()) { 1157 const char* descriptor = klass->GetDescriptor(&temp); 1158 std::pair<std::unordered_set<std::string>::iterator, bool> result = 1159 image_classes->insert(descriptor); 1160 if (!result.second) { // Previously inserted. 1161 break; 1162 } 1163 VLOG(compiler) << "Adding " << descriptor << " to image classes"; 1164 for (size_t i = 0, num_interfaces = klass->NumDirectInterfaces(); i != num_interfaces; ++i) { 1165 ObjPtr<mirror::Class> interface = mirror::Class::GetDirectInterface(self, klass, i); 1166 DCHECK(interface != nullptr); 1167 MaybeAddToImageClasses(self, interface, image_classes); 1168 } 1169 for (auto& m : klass->GetVirtualMethods(pointer_size)) { 1170 MaybeAddToImageClasses(self, m.GetDeclaringClass(), image_classes); 1171 } 1172 if (klass->IsArrayClass()) { 1173 MaybeAddToImageClasses(self, klass->GetComponentType(), image_classes); 1174 } 1175 klass.Assign(klass->GetSuperClass()); 1176 } 1177} 1178 1179// Keeps all the data for the update together. Also doubles as the reference visitor. 1180// Note: we can use object pointers because we suspend all threads. 1181class ClinitImageUpdate { 1182 public: 1183 static ClinitImageUpdate* Create(VariableSizedHandleScope& hs, 1184 std::unordered_set<std::string>* image_class_descriptors, 1185 Thread* self, 1186 ClassLinker* linker) { 1187 std::unique_ptr<ClinitImageUpdate> res(new ClinitImageUpdate(hs, 1188 image_class_descriptors, 1189 self, 1190 linker)); 1191 return res.release(); 1192 } 1193 1194 ~ClinitImageUpdate() { 1195 // Allow others to suspend again. 1196 self_->EndAssertNoThreadSuspension(old_cause_); 1197 } 1198 1199 // Visitor for VisitReferences. 1200 void operator()(ObjPtr<mirror::Object> object, 1201 MemberOffset field_offset, 1202 bool /* is_static */) const 1203 REQUIRES_SHARED(Locks::mutator_lock_) { 1204 mirror::Object* ref = object->GetFieldObject<mirror::Object>(field_offset); 1205 if (ref != nullptr) { 1206 VisitClinitClassesObject(ref); 1207 } 1208 } 1209 1210 // java.lang.ref.Reference visitor for VisitReferences. 1211 void operator()(ObjPtr<mirror::Class> klass ATTRIBUTE_UNUSED, 1212 ObjPtr<mirror::Reference> ref ATTRIBUTE_UNUSED) const {} 1213 1214 // Ignore class native roots. 1215 void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) 1216 const {} 1217 void VisitRoot(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) const {} 1218 1219 void Walk() REQUIRES_SHARED(Locks::mutator_lock_) { 1220 // Use the initial classes as roots for a search. 1221 for (Handle<mirror::Class> klass_root : image_classes_) { 1222 VisitClinitClassesObject(klass_root.Get()); 1223 } 1224 Thread* self = Thread::Current(); 1225 ScopedAssertNoThreadSuspension ants(__FUNCTION__); 1226 for (Handle<mirror::Class> h_klass : to_insert_) { 1227 MaybeAddToImageClasses(self, h_klass.Get(), image_class_descriptors_); 1228 } 1229 } 1230 1231 private: 1232 class FindImageClassesVisitor : public ClassVisitor { 1233 public: 1234 explicit FindImageClassesVisitor(VariableSizedHandleScope& hs, 1235 ClinitImageUpdate* data) 1236 : data_(data), 1237 hs_(hs) {} 1238 1239 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) { 1240 std::string temp; 1241 const char* name = klass->GetDescriptor(&temp); 1242 if (data_->image_class_descriptors_->find(name) != data_->image_class_descriptors_->end()) { 1243 data_->image_classes_.push_back(hs_.NewHandle(klass)); 1244 } else { 1245 // Check whether it is initialized and has a clinit. They must be kept, too. 1246 if (klass->IsInitialized() && klass->FindClassInitializer( 1247 Runtime::Current()->GetClassLinker()->GetImagePointerSize()) != nullptr) { 1248 data_->image_classes_.push_back(hs_.NewHandle(klass)); 1249 } 1250 } 1251 return true; 1252 } 1253 1254 private: 1255 ClinitImageUpdate* const data_; 1256 VariableSizedHandleScope& hs_; 1257 }; 1258 1259 ClinitImageUpdate(VariableSizedHandleScope& hs, 1260 std::unordered_set<std::string>* image_class_descriptors, 1261 Thread* self, 1262 ClassLinker* linker) REQUIRES_SHARED(Locks::mutator_lock_) 1263 : hs_(hs), 1264 image_class_descriptors_(image_class_descriptors), 1265 self_(self) { 1266 CHECK(linker != nullptr); 1267 CHECK(image_class_descriptors != nullptr); 1268 1269 // Make sure nobody interferes with us. 1270 old_cause_ = self->StartAssertNoThreadSuspension("Boot image closure"); 1271 1272 // Find all the already-marked classes. 1273 WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); 1274 FindImageClassesVisitor visitor(hs_, this); 1275 linker->VisitClasses(&visitor); 1276 } 1277 1278 void VisitClinitClassesObject(mirror::Object* object) const 1279 REQUIRES_SHARED(Locks::mutator_lock_) { 1280 DCHECK(object != nullptr); 1281 if (marked_objects_.find(object) != marked_objects_.end()) { 1282 // Already processed. 1283 return; 1284 } 1285 1286 // Mark it. 1287 marked_objects_.insert(object); 1288 1289 if (object->IsClass()) { 1290 // Add to the TODO list since MaybeAddToImageClasses may cause thread suspension. Thread 1291 // suspensionb is not safe to do in VisitObjects or VisitReferences. 1292 to_insert_.push_back(hs_.NewHandle(object->AsClass())); 1293 } else { 1294 // Else visit the object's class. 1295 VisitClinitClassesObject(object->GetClass()); 1296 } 1297 1298 // If it is not a DexCache, visit all references. 1299 if (!object->IsDexCache()) { 1300 object->VisitReferences(*this, *this); 1301 } 1302 } 1303 1304 VariableSizedHandleScope& hs_; 1305 mutable std::vector<Handle<mirror::Class>> to_insert_; 1306 mutable std::unordered_set<mirror::Object*> marked_objects_; 1307 std::unordered_set<std::string>* const image_class_descriptors_; 1308 std::vector<Handle<mirror::Class>> image_classes_; 1309 Thread* const self_; 1310 const char* old_cause_; 1311 1312 DISALLOW_COPY_AND_ASSIGN(ClinitImageUpdate); 1313}; 1314 1315void CompilerDriver::UpdateImageClasses(TimingLogger* timings) { 1316 if (GetCompilerOptions().IsBootImage()) { 1317 TimingLogger::ScopedTiming t("UpdateImageClasses", timings); 1318 1319 Runtime* runtime = Runtime::Current(); 1320 1321 // Suspend all threads. 1322 ScopedSuspendAll ssa(__FUNCTION__); 1323 1324 VariableSizedHandleScope hs(Thread::Current()); 1325 std::string error_msg; 1326 std::unique_ptr<ClinitImageUpdate> update(ClinitImageUpdate::Create(hs, 1327 image_classes_.get(), 1328 Thread::Current(), 1329 runtime->GetClassLinker())); 1330 1331 // Do the marking. 1332 update->Walk(); 1333 } 1334} 1335 1336bool CompilerDriver::CanAssumeClassIsLoaded(mirror::Class* klass) { 1337 Runtime* runtime = Runtime::Current(); 1338 if (!runtime->IsAotCompiler()) { 1339 DCHECK(runtime->UseJitCompilation()); 1340 // Having the klass reference here implies that the klass is already loaded. 1341 return true; 1342 } 1343 if (!GetCompilerOptions().IsBootImage()) { 1344 // Assume loaded only if klass is in the boot image. App classes cannot be assumed 1345 // loaded because we don't even know what class loader will be used to load them. 1346 bool class_in_image = runtime->GetHeap()->FindSpaceFromObject(klass, false)->IsImageSpace(); 1347 return class_in_image; 1348 } 1349 std::string temp; 1350 const char* descriptor = klass->GetDescriptor(&temp); 1351 return IsImageClass(descriptor); 1352} 1353 1354void CompilerDriver::MarkForDexToDexCompilation(Thread* self, const MethodReference& method_ref) { 1355 MutexLock lock(self, dex_to_dex_references_lock_); 1356 // Since we're compiling one dex file at a time, we need to look for the 1357 // current dex file entry only at the end of dex_to_dex_references_. 1358 if (dex_to_dex_references_.empty() || 1359 &dex_to_dex_references_.back().GetDexFile() != method_ref.dex_file) { 1360 dex_to_dex_references_.emplace_back(*method_ref.dex_file); 1361 } 1362 dex_to_dex_references_.back().GetMethodIndexes().SetBit(method_ref.dex_method_index); 1363} 1364 1365bool CompilerDriver::CanAccessTypeWithoutChecks(ObjPtr<mirror::Class> referrer_class, 1366 ObjPtr<mirror::Class> resolved_class) { 1367 if (resolved_class == nullptr) { 1368 stats_->TypeNeedsAccessCheck(); 1369 return false; // Unknown class needs access checks. 1370 } 1371 bool is_accessible = resolved_class->IsPublic(); // Public classes are always accessible. 1372 if (!is_accessible) { 1373 if (referrer_class == nullptr) { 1374 stats_->TypeNeedsAccessCheck(); 1375 return false; // Incomplete referrer knowledge needs access check. 1376 } 1377 // Perform access check, will return true if access is ok or false if we're going to have to 1378 // check this at runtime (for example for class loaders). 1379 is_accessible = referrer_class->CanAccess(resolved_class); 1380 } 1381 if (is_accessible) { 1382 stats_->TypeDoesntNeedAccessCheck(); 1383 } else { 1384 stats_->TypeNeedsAccessCheck(); 1385 } 1386 return is_accessible; 1387} 1388 1389bool CompilerDriver::CanAccessInstantiableTypeWithoutChecks(ObjPtr<mirror::Class> referrer_class, 1390 ObjPtr<mirror::Class> resolved_class, 1391 bool* finalizable) { 1392 if (resolved_class == nullptr) { 1393 stats_->TypeNeedsAccessCheck(); 1394 // Be conservative. 1395 *finalizable = true; 1396 return false; // Unknown class needs access checks. 1397 } 1398 *finalizable = resolved_class->IsFinalizable(); 1399 bool is_accessible = resolved_class->IsPublic(); // Public classes are always accessible. 1400 if (!is_accessible) { 1401 if (referrer_class == nullptr) { 1402 stats_->TypeNeedsAccessCheck(); 1403 return false; // Incomplete referrer knowledge needs access check. 1404 } 1405 // Perform access and instantiable checks, will return true if access is ok or false if we're 1406 // going to have to check this at runtime (for example for class loaders). 1407 is_accessible = referrer_class->CanAccess(resolved_class); 1408 } 1409 bool result = is_accessible && resolved_class->IsInstantiable(); 1410 if (result) { 1411 stats_->TypeDoesntNeedAccessCheck(); 1412 } else { 1413 stats_->TypeNeedsAccessCheck(); 1414 } 1415 return result; 1416} 1417 1418void CompilerDriver::ProcessedInstanceField(bool resolved) { 1419 if (!resolved) { 1420 stats_->UnresolvedInstanceField(); 1421 } else { 1422 stats_->ResolvedInstanceField(); 1423 } 1424} 1425 1426void CompilerDriver::ProcessedStaticField(bool resolved, bool local) { 1427 if (!resolved) { 1428 stats_->UnresolvedStaticField(); 1429 } else if (local) { 1430 stats_->ResolvedLocalStaticField(); 1431 } else { 1432 stats_->ResolvedStaticField(); 1433 } 1434} 1435 1436ArtField* CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, 1437 const DexCompilationUnit* mUnit, bool is_put, 1438 const ScopedObjectAccess& soa) { 1439 // Try to resolve the field and compiling method's class. 1440 ArtField* resolved_field; 1441 mirror::Class* referrer_class; 1442 Handle<mirror::DexCache> dex_cache(mUnit->GetDexCache()); 1443 { 1444 Handle<mirror::ClassLoader> class_loader_handle = mUnit->GetClassLoader(); 1445 resolved_field = ResolveField(soa, dex_cache, class_loader_handle, mUnit, field_idx, false); 1446 referrer_class = resolved_field != nullptr 1447 ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader_handle, mUnit) : nullptr; 1448 } 1449 bool can_link = false; 1450 if (resolved_field != nullptr && referrer_class != nullptr) { 1451 std::pair<bool, bool> fast_path = IsFastInstanceField( 1452 dex_cache.Get(), referrer_class, resolved_field, field_idx); 1453 can_link = is_put ? fast_path.second : fast_path.first; 1454 } 1455 ProcessedInstanceField(can_link); 1456 return can_link ? resolved_field : nullptr; 1457} 1458 1459bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, 1460 bool is_put, MemberOffset* field_offset, 1461 bool* is_volatile) { 1462 ScopedObjectAccess soa(Thread::Current()); 1463 ArtField* resolved_field = ComputeInstanceFieldInfo(field_idx, mUnit, is_put, soa); 1464 1465 if (resolved_field == nullptr) { 1466 // Conservative defaults. 1467 *is_volatile = true; 1468 *field_offset = MemberOffset(static_cast<size_t>(-1)); 1469 return false; 1470 } else { 1471 *is_volatile = resolved_field->IsVolatile(); 1472 *field_offset = resolved_field->GetOffset(); 1473 return true; 1474 } 1475} 1476 1477const VerifiedMethod* CompilerDriver::GetVerifiedMethod(const DexFile* dex_file, 1478 uint32_t method_idx) const { 1479 MethodReference ref(dex_file, method_idx); 1480 return verification_results_->GetVerifiedMethod(ref); 1481} 1482 1483bool CompilerDriver::IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc) { 1484 if (!compiler_options_->IsVerificationEnabled()) { 1485 // If we didn't verify, every cast has to be treated as non-safe. 1486 return false; 1487 } 1488 DCHECK(mUnit->GetVerifiedMethod() != nullptr); 1489 bool result = mUnit->GetVerifiedMethod()->IsSafeCast(dex_pc); 1490 if (result) { 1491 stats_->SafeCast(); 1492 } else { 1493 stats_->NotASafeCast(); 1494 } 1495 return result; 1496} 1497 1498class CompilationVisitor { 1499 public: 1500 virtual ~CompilationVisitor() {} 1501 virtual void Visit(size_t index) = 0; 1502}; 1503 1504class ParallelCompilationManager { 1505 public: 1506 ParallelCompilationManager(ClassLinker* class_linker, 1507 jobject class_loader, 1508 CompilerDriver* compiler, 1509 const DexFile* dex_file, 1510 const std::vector<const DexFile*>& dex_files, 1511 ThreadPool* thread_pool) 1512 : index_(0), 1513 class_linker_(class_linker), 1514 class_loader_(class_loader), 1515 compiler_(compiler), 1516 dex_file_(dex_file), 1517 dex_files_(dex_files), 1518 thread_pool_(thread_pool) {} 1519 1520 ClassLinker* GetClassLinker() const { 1521 CHECK(class_linker_ != nullptr); 1522 return class_linker_; 1523 } 1524 1525 jobject GetClassLoader() const { 1526 return class_loader_; 1527 } 1528 1529 CompilerDriver* GetCompiler() const { 1530 CHECK(compiler_ != nullptr); 1531 return compiler_; 1532 } 1533 1534 const DexFile* GetDexFile() const { 1535 CHECK(dex_file_ != nullptr); 1536 return dex_file_; 1537 } 1538 1539 const std::vector<const DexFile*>& GetDexFiles() const { 1540 return dex_files_; 1541 } 1542 1543 void ForAll(size_t begin, size_t end, CompilationVisitor* visitor, size_t work_units) 1544 REQUIRES(!*Locks::mutator_lock_) { 1545 Thread* self = Thread::Current(); 1546 self->AssertNoPendingException(); 1547 CHECK_GT(work_units, 0U); 1548 1549 index_.StoreRelaxed(begin); 1550 for (size_t i = 0; i < work_units; ++i) { 1551 thread_pool_->AddTask(self, new ForAllClosure(this, end, visitor)); 1552 } 1553 thread_pool_->StartWorkers(self); 1554 1555 // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker 1556 // thread destructor's called below perform join). 1557 CHECK_NE(self->GetState(), kRunnable); 1558 1559 // Wait for all the worker threads to finish. 1560 thread_pool_->Wait(self, true, false); 1561 1562 // And stop the workers accepting jobs. 1563 thread_pool_->StopWorkers(self); 1564 } 1565 1566 size_t NextIndex() { 1567 return index_.FetchAndAddSequentiallyConsistent(1); 1568 } 1569 1570 private: 1571 class ForAllClosure : public Task { 1572 public: 1573 ForAllClosure(ParallelCompilationManager* manager, size_t end, CompilationVisitor* visitor) 1574 : manager_(manager), 1575 end_(end), 1576 visitor_(visitor) {} 1577 1578 virtual void Run(Thread* self) { 1579 while (true) { 1580 const size_t index = manager_->NextIndex(); 1581 if (UNLIKELY(index >= end_)) { 1582 break; 1583 } 1584 visitor_->Visit(index); 1585 self->AssertNoPendingException(); 1586 } 1587 } 1588 1589 virtual void Finalize() { 1590 delete this; 1591 } 1592 1593 private: 1594 ParallelCompilationManager* const manager_; 1595 const size_t end_; 1596 CompilationVisitor* const visitor_; 1597 }; 1598 1599 AtomicInteger index_; 1600 ClassLinker* const class_linker_; 1601 const jobject class_loader_; 1602 CompilerDriver* const compiler_; 1603 const DexFile* const dex_file_; 1604 const std::vector<const DexFile*>& dex_files_; 1605 ThreadPool* const thread_pool_; 1606 1607 DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager); 1608}; 1609 1610// A fast version of SkipClass above if the class pointer is available 1611// that avoids the expensive FindInClassPath search. 1612static bool SkipClass(jobject class_loader, const DexFile& dex_file, mirror::Class* klass) 1613 REQUIRES_SHARED(Locks::mutator_lock_) { 1614 DCHECK(klass != nullptr); 1615 const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile(); 1616 if (&dex_file != &original_dex_file) { 1617 if (class_loader == nullptr) { 1618 LOG(WARNING) << "Skipping class " << klass->PrettyDescriptor() << " from " 1619 << dex_file.GetLocation() << " previously found in " 1620 << original_dex_file.GetLocation(); 1621 } 1622 return true; 1623 } 1624 return false; 1625} 1626 1627static void CheckAndClearResolveException(Thread* self) 1628 REQUIRES_SHARED(Locks::mutator_lock_) { 1629 CHECK(self->IsExceptionPending()); 1630 mirror::Throwable* exception = self->GetException(); 1631 std::string temp; 1632 const char* descriptor = exception->GetClass()->GetDescriptor(&temp); 1633 const char* expected_exceptions[] = { 1634 "Ljava/lang/IllegalAccessError;", 1635 "Ljava/lang/IncompatibleClassChangeError;", 1636 "Ljava/lang/InstantiationError;", 1637 "Ljava/lang/LinkageError;", 1638 "Ljava/lang/NoClassDefFoundError;", 1639 "Ljava/lang/NoSuchFieldError;", 1640 "Ljava/lang/NoSuchMethodError;" 1641 }; 1642 bool found = false; 1643 for (size_t i = 0; (found == false) && (i < arraysize(expected_exceptions)); ++i) { 1644 if (strcmp(descriptor, expected_exceptions[i]) == 0) { 1645 found = true; 1646 } 1647 } 1648 if (!found) { 1649 LOG(FATAL) << "Unexpected exception " << exception->Dump(); 1650 } 1651 self->ClearException(); 1652} 1653 1654bool CompilerDriver::RequiresConstructorBarrier(const DexFile& dex_file, 1655 uint16_t class_def_idx) const { 1656 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_idx); 1657 const uint8_t* class_data = dex_file.GetClassData(class_def); 1658 if (class_data == nullptr) { 1659 // Empty class such as a marker interface. 1660 return false; 1661 } 1662 ClassDataItemIterator it(dex_file, class_data); 1663 it.SkipStaticFields(); 1664 // We require a constructor barrier if there are final instance fields. 1665 while (it.HasNextInstanceField()) { 1666 if (it.MemberIsFinal()) { 1667 return true; 1668 } 1669 it.Next(); 1670 } 1671 return false; 1672} 1673 1674class ResolveClassFieldsAndMethodsVisitor : public CompilationVisitor { 1675 public: 1676 explicit ResolveClassFieldsAndMethodsVisitor(const ParallelCompilationManager* manager) 1677 : manager_(manager) {} 1678 1679 void Visit(size_t class_def_index) OVERRIDE REQUIRES(!Locks::mutator_lock_) { 1680 ATRACE_CALL(); 1681 Thread* const self = Thread::Current(); 1682 jobject jclass_loader = manager_->GetClassLoader(); 1683 const DexFile& dex_file = *manager_->GetDexFile(); 1684 ClassLinker* class_linker = manager_->GetClassLinker(); 1685 1686 // If an instance field is final then we need to have a barrier on the return, static final 1687 // fields are assigned within the lock held for class initialization. Conservatively assume 1688 // constructor barriers are always required. 1689 bool requires_constructor_barrier = true; 1690 1691 // Method and Field are the worst. We can't resolve without either 1692 // context from the code use (to disambiguate virtual vs direct 1693 // method and instance vs static field) or from class 1694 // definitions. While the compiler will resolve what it can as it 1695 // needs it, here we try to resolve fields and methods used in class 1696 // definitions, since many of them many never be referenced by 1697 // generated code. 1698 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1699 ScopedObjectAccess soa(self); 1700 StackHandleScope<2> hs(soa.Self()); 1701 Handle<mirror::ClassLoader> class_loader( 1702 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 1703 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache( 1704 soa.Self(), dex_file))); 1705 // Resolve the class. 1706 mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache, 1707 class_loader); 1708 bool resolve_fields_and_methods; 1709 if (klass == nullptr) { 1710 // Class couldn't be resolved, for example, super-class is in a different dex file. Don't 1711 // attempt to resolve methods and fields when there is no declaring class. 1712 CheckAndClearResolveException(soa.Self()); 1713 resolve_fields_and_methods = false; 1714 } else { 1715 // We successfully resolved a class, should we skip it? 1716 if (SkipClass(jclass_loader, dex_file, klass)) { 1717 return; 1718 } 1719 // We want to resolve the methods and fields eagerly. 1720 resolve_fields_and_methods = true; 1721 } 1722 // Note the class_data pointer advances through the headers, 1723 // static fields, instance fields, direct methods, and virtual 1724 // methods. 1725 const uint8_t* class_data = dex_file.GetClassData(class_def); 1726 if (class_data == nullptr) { 1727 // Empty class such as a marker interface. 1728 requires_constructor_barrier = false; 1729 } else { 1730 ClassDataItemIterator it(dex_file, class_data); 1731 while (it.HasNextStaticField()) { 1732 if (resolve_fields_and_methods) { 1733 ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), 1734 dex_cache, class_loader, true); 1735 if (field == nullptr) { 1736 CheckAndClearResolveException(soa.Self()); 1737 } 1738 } 1739 it.Next(); 1740 } 1741 // We require a constructor barrier if there are final instance fields. 1742 requires_constructor_barrier = false; 1743 while (it.HasNextInstanceField()) { 1744 if (it.MemberIsFinal()) { 1745 requires_constructor_barrier = true; 1746 } 1747 if (resolve_fields_and_methods) { 1748 ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), 1749 dex_cache, class_loader, false); 1750 if (field == nullptr) { 1751 CheckAndClearResolveException(soa.Self()); 1752 } 1753 } 1754 it.Next(); 1755 } 1756 if (resolve_fields_and_methods) { 1757 while (it.HasNextDirectMethod()) { 1758 ArtMethod* method = class_linker->ResolveMethod<ClassLinker::ResolveMode::kNoChecks>( 1759 dex_file, it.GetMemberIndex(), dex_cache, class_loader, nullptr, 1760 it.GetMethodInvokeType(class_def)); 1761 if (method == nullptr) { 1762 CheckAndClearResolveException(soa.Self()); 1763 } 1764 it.Next(); 1765 } 1766 while (it.HasNextVirtualMethod()) { 1767 ArtMethod* method = class_linker->ResolveMethod<ClassLinker::ResolveMode::kNoChecks>( 1768 dex_file, it.GetMemberIndex(), dex_cache, class_loader, nullptr, 1769 it.GetMethodInvokeType(class_def)); 1770 if (method == nullptr) { 1771 CheckAndClearResolveException(soa.Self()); 1772 } 1773 it.Next(); 1774 } 1775 DCHECK(!it.HasNext()); 1776 } 1777 } 1778 manager_->GetCompiler()->SetRequiresConstructorBarrier(self, 1779 &dex_file, 1780 class_def_index, 1781 requires_constructor_barrier); 1782 } 1783 1784 private: 1785 const ParallelCompilationManager* const manager_; 1786}; 1787 1788class ResolveTypeVisitor : public CompilationVisitor { 1789 public: 1790 explicit ResolveTypeVisitor(const ParallelCompilationManager* manager) : manager_(manager) { 1791 } 1792 void Visit(size_t type_idx) OVERRIDE REQUIRES(!Locks::mutator_lock_) { 1793 // Class derived values are more complicated, they require the linker and loader. 1794 ScopedObjectAccess soa(Thread::Current()); 1795 ClassLinker* class_linker = manager_->GetClassLinker(); 1796 const DexFile& dex_file = *manager_->GetDexFile(); 1797 StackHandleScope<2> hs(soa.Self()); 1798 Handle<mirror::ClassLoader> class_loader( 1799 hs.NewHandle(soa.Decode<mirror::ClassLoader>(manager_->GetClassLoader()))); 1800 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->RegisterDexFile( 1801 dex_file, 1802 class_loader.Get()))); 1803 ObjPtr<mirror::Class> klass = (dex_cache != nullptr) 1804 ? class_linker->ResolveType(dex_file, dex::TypeIndex(type_idx), dex_cache, class_loader) 1805 : nullptr; 1806 1807 if (klass == nullptr) { 1808 soa.Self()->AssertPendingException(); 1809 mirror::Throwable* exception = soa.Self()->GetException(); 1810 VLOG(compiler) << "Exception during type resolution: " << exception->Dump(); 1811 if (exception->GetClass()->DescriptorEquals("Ljava/lang/OutOfMemoryError;")) { 1812 // There's little point continuing compilation if the heap is exhausted. 1813 LOG(FATAL) << "Out of memory during type resolution for compilation"; 1814 } 1815 soa.Self()->ClearException(); 1816 } 1817 } 1818 1819 private: 1820 const ParallelCompilationManager* const manager_; 1821}; 1822 1823void CompilerDriver::ResolveDexFile(jobject class_loader, 1824 const DexFile& dex_file, 1825 const std::vector<const DexFile*>& dex_files, 1826 ThreadPool* thread_pool, 1827 size_t thread_count, 1828 TimingLogger* timings) { 1829 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1830 1831 // TODO: we could resolve strings here, although the string table is largely filled with class 1832 // and method names. 1833 1834 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files, 1835 thread_pool); 1836 if (GetCompilerOptions().IsBootImage()) { 1837 // For images we resolve all types, such as array, whereas for applications just those with 1838 // classdefs are resolved by ResolveClassFieldsAndMethods. 1839 TimingLogger::ScopedTiming t("Resolve Types", timings); 1840 ResolveTypeVisitor visitor(&context); 1841 context.ForAll(0, dex_file.NumTypeIds(), &visitor, thread_count); 1842 } 1843 1844 TimingLogger::ScopedTiming t("Resolve MethodsAndFields", timings); 1845 ResolveClassFieldsAndMethodsVisitor visitor(&context); 1846 context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count); 1847} 1848 1849void CompilerDriver::SetVerified(jobject class_loader, 1850 const std::vector<const DexFile*>& dex_files, 1851 TimingLogger* timings) { 1852 // This can be run in parallel. 1853 for (const DexFile* dex_file : dex_files) { 1854 CHECK(dex_file != nullptr); 1855 SetVerifiedDexFile(class_loader, 1856 *dex_file, 1857 dex_files, 1858 parallel_thread_pool_.get(), 1859 parallel_thread_count_, 1860 timings); 1861 } 1862} 1863 1864static void PopulateVerifiedMethods(const DexFile& dex_file, 1865 uint32_t class_def_index, 1866 VerificationResults* verification_results) { 1867 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1868 const uint8_t* class_data = dex_file.GetClassData(class_def); 1869 if (class_data == nullptr) { 1870 return; 1871 } 1872 ClassDataItemIterator it(dex_file, class_data); 1873 it.SkipAllFields(); 1874 1875 while (it.HasNextDirectMethod()) { 1876 verification_results->CreateVerifiedMethodFor(MethodReference(&dex_file, it.GetMemberIndex())); 1877 it.Next(); 1878 } 1879 1880 while (it.HasNextVirtualMethod()) { 1881 verification_results->CreateVerifiedMethodFor(MethodReference(&dex_file, it.GetMemberIndex())); 1882 it.Next(); 1883 } 1884 DCHECK(!it.HasNext()); 1885} 1886 1887static void LoadAndUpdateStatus(const DexFile& dex_file, 1888 const DexFile::ClassDef& class_def, 1889 mirror::Class::Status status, 1890 Handle<mirror::ClassLoader> class_loader, 1891 Thread* self) 1892 REQUIRES_SHARED(Locks::mutator_lock_) { 1893 StackHandleScope<1> hs(self); 1894 const char* descriptor = dex_file.GetClassDescriptor(class_def); 1895 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1896 Handle<mirror::Class> cls(hs.NewHandle<mirror::Class>( 1897 class_linker->FindClass(self, descriptor, class_loader))); 1898 if (cls != nullptr) { 1899 // Check that the class is resolved with the current dex file. We might get 1900 // a boot image class, or a class in a different dex file for multidex, and 1901 // we should not update the status in that case. 1902 if (&cls->GetDexFile() == &dex_file) { 1903 ObjectLock<mirror::Class> lock(self, cls); 1904 mirror::Class::SetStatus(cls, status, self); 1905 } 1906 } else { 1907 DCHECK(self->IsExceptionPending()); 1908 self->ClearException(); 1909 } 1910} 1911 1912bool CompilerDriver::FastVerify(jobject jclass_loader, 1913 const std::vector<const DexFile*>& dex_files, 1914 TimingLogger* timings) { 1915 verifier::VerifierDeps* verifier_deps = 1916 Runtime::Current()->GetCompilerCallbacks()->GetVerifierDeps(); 1917 // If there exist VerifierDeps that aren't the ones we just created to output, use them to verify. 1918 if (verifier_deps == nullptr || verifier_deps->OutputOnly()) { 1919 return false; 1920 } 1921 TimingLogger::ScopedTiming t("Fast Verify", timings); 1922 ScopedObjectAccess soa(Thread::Current()); 1923 StackHandleScope<2> hs(soa.Self()); 1924 Handle<mirror::ClassLoader> class_loader( 1925 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 1926 if (!verifier_deps->ValidateDependencies(class_loader, soa.Self())) { 1927 return false; 1928 } 1929 1930 bool compiler_only_verifies = !GetCompilerOptions().IsAnyCompilationEnabled(); 1931 1932 // We successfully validated the dependencies, now update class status 1933 // of verified classes. Note that the dependencies also record which classes 1934 // could not be fully verified; we could try again, but that would hurt verification 1935 // time. So instead we assume these classes still need to be verified at 1936 // runtime. 1937 for (const DexFile* dex_file : dex_files) { 1938 // Fetch the list of unverified classes. 1939 const std::set<dex::TypeIndex>& unverified_classes = 1940 verifier_deps->GetUnverifiedClasses(*dex_file); 1941 for (uint32_t i = 0; i < dex_file->NumClassDefs(); ++i) { 1942 const DexFile::ClassDef& class_def = dex_file->GetClassDef(i); 1943 if (unverified_classes.find(class_def.class_idx_) == unverified_classes.end()) { 1944 if (compiler_only_verifies) { 1945 // Just update the compiled_classes_ map. The compiler doesn't need to resolve 1946 // the type. 1947 DexFileReference ref(dex_file, i); 1948 mirror::Class::Status existing = mirror::Class::kStatusNotReady; 1949 DCHECK(compiled_classes_.Get(ref, &existing)) << ref.dex_file->GetLocation(); 1950 ClassStateTable::InsertResult result = 1951 compiled_classes_.Insert(ref, existing, mirror::Class::kStatusVerified); 1952 CHECK_EQ(result, ClassStateTable::kInsertResultSuccess); 1953 } else { 1954 // Update the class status, so later compilation stages know they don't need to verify 1955 // the class. 1956 LoadAndUpdateStatus( 1957 *dex_file, class_def, mirror::Class::kStatusVerified, class_loader, soa.Self()); 1958 // Create `VerifiedMethod`s for each methods, the compiler expects one for 1959 // quickening or compiling. 1960 // Note that this means: 1961 // - We're only going to compile methods that did verify. 1962 // - Quickening will not do checkcast ellision. 1963 // TODO(ngeoffray): Reconsider this once we refactor compiler filters. 1964 PopulateVerifiedMethods(*dex_file, i, verification_results_); 1965 } 1966 } else if (!compiler_only_verifies) { 1967 // Make sure later compilation stages know they should not try to verify 1968 // this class again. 1969 LoadAndUpdateStatus(*dex_file, 1970 class_def, 1971 mirror::Class::kStatusRetryVerificationAtRuntime, 1972 class_loader, 1973 soa.Self()); 1974 } 1975 } 1976 } 1977 return true; 1978} 1979 1980void CompilerDriver::Verify(jobject jclass_loader, 1981 const std::vector<const DexFile*>& dex_files, 1982 TimingLogger* timings) { 1983 if (FastVerify(jclass_loader, dex_files, timings)) { 1984 return; 1985 } 1986 1987 // If there is no existing `verifier_deps` (because of non-existing vdex), or 1988 // the existing `verifier_deps` is not valid anymore, create a new one for 1989 // non boot image compilation. The verifier will need it to record the new dependencies. 1990 // Then dex2oat can update the vdex file with these new dependencies. 1991 if (!GetCompilerOptions().IsBootImage()) { 1992 // Dex2oat creates the verifier deps. 1993 // Create the main VerifierDeps, and set it to this thread. 1994 verifier::VerifierDeps* verifier_deps = 1995 Runtime::Current()->GetCompilerCallbacks()->GetVerifierDeps(); 1996 CHECK(verifier_deps != nullptr); 1997 Thread::Current()->SetVerifierDeps(verifier_deps); 1998 // Create per-thread VerifierDeps to avoid contention on the main one. 1999 // We will merge them after verification. 2000 for (ThreadPoolWorker* worker : parallel_thread_pool_->GetWorkers()) { 2001 worker->GetThread()->SetVerifierDeps(new verifier::VerifierDeps(dex_files_for_oat_file_)); 2002 } 2003 } 2004 2005 // Verification updates VerifierDeps and needs to run single-threaded to be deterministic. 2006 bool force_determinism = GetCompilerOptions().IsForceDeterminism(); 2007 ThreadPool* verify_thread_pool = 2008 force_determinism ? single_thread_pool_.get() : parallel_thread_pool_.get(); 2009 size_t verify_thread_count = force_determinism ? 1U : parallel_thread_count_; 2010 for (const DexFile* dex_file : dex_files) { 2011 CHECK(dex_file != nullptr); 2012 VerifyDexFile(jclass_loader, 2013 *dex_file, 2014 dex_files, 2015 verify_thread_pool, 2016 verify_thread_count, 2017 timings); 2018 } 2019 2020 if (!GetCompilerOptions().IsBootImage()) { 2021 // Merge all VerifierDeps into the main one. 2022 verifier::VerifierDeps* verifier_deps = Thread::Current()->GetVerifierDeps(); 2023 for (ThreadPoolWorker* worker : parallel_thread_pool_->GetWorkers()) { 2024 verifier::VerifierDeps* thread_deps = worker->GetThread()->GetVerifierDeps(); 2025 worker->GetThread()->SetVerifierDeps(nullptr); 2026 verifier_deps->MergeWith(*thread_deps, dex_files_for_oat_file_); 2027 delete thread_deps; 2028 } 2029 Thread::Current()->SetVerifierDeps(nullptr); 2030 } 2031} 2032 2033class VerifyClassVisitor : public CompilationVisitor { 2034 public: 2035 VerifyClassVisitor(const ParallelCompilationManager* manager, verifier::HardFailLogMode log_level) 2036 : manager_(manager), log_level_(log_level) {} 2037 2038 virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE { 2039 ATRACE_CALL(); 2040 ScopedObjectAccess soa(Thread::Current()); 2041 const DexFile& dex_file = *manager_->GetDexFile(); 2042 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2043 const char* descriptor = dex_file.GetClassDescriptor(class_def); 2044 ClassLinker* class_linker = manager_->GetClassLinker(); 2045 jobject jclass_loader = manager_->GetClassLoader(); 2046 StackHandleScope<3> hs(soa.Self()); 2047 Handle<mirror::ClassLoader> class_loader( 2048 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 2049 Handle<mirror::Class> klass( 2050 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader))); 2051 verifier::FailureKind failure_kind; 2052 if (klass == nullptr) { 2053 CHECK(soa.Self()->IsExceptionPending()); 2054 soa.Self()->ClearException(); 2055 2056 /* 2057 * At compile time, we can still structurally verify the class even if FindClass fails. 2058 * This is to ensure the class is structurally sound for compilation. An unsound class 2059 * will be rejected by the verifier and later skipped during compilation in the compiler. 2060 */ 2061 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache( 2062 soa.Self(), dex_file))); 2063 std::string error_msg; 2064 failure_kind = 2065 verifier::MethodVerifier::VerifyClass(soa.Self(), 2066 &dex_file, 2067 dex_cache, 2068 class_loader, 2069 class_def, 2070 Runtime::Current()->GetCompilerCallbacks(), 2071 true /* allow soft failures */, 2072 log_level_, 2073 &error_msg); 2074 if (failure_kind == verifier::FailureKind::kHardFailure) { 2075 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor) 2076 << " because: " << error_msg; 2077 manager_->GetCompiler()->SetHadHardVerifierFailure(); 2078 } else { 2079 // Force a soft failure for the VerifierDeps. This is a sanity measure, as 2080 // the vdex file already records that the class hasn't been resolved. It avoids 2081 // trying to do future verification optimizations when processing the vdex file. 2082 DCHECK(failure_kind == verifier::FailureKind::kSoftFailure || 2083 failure_kind == verifier::FailureKind::kNoFailure) 2084 << failure_kind; 2085 failure_kind = verifier::FailureKind::kSoftFailure; 2086 } 2087 } else if (!SkipClass(jclass_loader, dex_file, klass.Get())) { 2088 CHECK(klass->IsResolved()) << klass->PrettyClass(); 2089 failure_kind = class_linker->VerifyClass(soa.Self(), klass, log_level_); 2090 2091 if (klass->IsErroneous()) { 2092 // ClassLinker::VerifyClass throws, which isn't useful in the compiler. 2093 CHECK(soa.Self()->IsExceptionPending()); 2094 soa.Self()->ClearException(); 2095 manager_->GetCompiler()->SetHadHardVerifierFailure(); 2096 } 2097 2098 CHECK(klass->ShouldVerifyAtRuntime() || klass->IsVerified() || klass->IsErroneous()) 2099 << klass->PrettyDescriptor() << ": state=" << klass->GetStatus(); 2100 2101 // Class has a meaningful status for the compiler now, record it. 2102 ClassReference ref(manager_->GetDexFile(), class_def_index); 2103 manager_->GetCompiler()->RecordClassStatus(ref, klass->GetStatus()); 2104 2105 // It is *very* problematic if there are verification errors in the boot classpath. 2106 // For example, we rely on things working OK without verification when the decryption dialog 2107 // is brought up. So abort in a debug build if we find this violated. 2108 if (kIsDebugBuild) { 2109 if (manager_->GetCompiler()->GetCompilerOptions().IsBootImage()) { 2110 if (!klass->IsVerified()) { 2111 // Re-run verification to get all failure messages if it soft-failed. 2112 if (!klass->IsErroneous()) { 2113 gLogVerbosity.verifier = true; 2114 // Note: We can't call ClassLinker::VerifyClass, as it will elide the second 2115 // verification. 2116 Runtime* runtime = Runtime::Current(); 2117 std::string v_error; 2118 verifier::MethodVerifier::VerifyClass(soa.Self(), 2119 klass.Get(), 2120 runtime->GetCompilerCallbacks(), 2121 runtime->IsAotCompiler(), 2122 verifier::HardFailLogMode::kLogInternalFatal, 2123 &v_error); 2124 } 2125 LOG(FATAL) << "Boot classpath class " << klass->PrettyClass() 2126 << " failed to fully verify: state= " << klass->GetStatus(); 2127 } 2128 } 2129 if (klass->IsVerified()) { 2130 DCHECK_EQ(failure_kind, verifier::FailureKind::kNoFailure); 2131 } else if (klass->ShouldVerifyAtRuntime()) { 2132 DCHECK_EQ(failure_kind, verifier::FailureKind::kSoftFailure); 2133 } else { 2134 DCHECK_EQ(failure_kind, verifier::FailureKind::kHardFailure); 2135 } 2136 } 2137 } else { 2138 // Make the skip a soft failure, essentially being considered as verify at runtime. 2139 failure_kind = verifier::FailureKind::kSoftFailure; 2140 } 2141 verifier::VerifierDeps::MaybeRecordVerificationStatus( 2142 dex_file, class_def.class_idx_, failure_kind); 2143 soa.Self()->AssertNoPendingException(); 2144 } 2145 2146 private: 2147 const ParallelCompilationManager* const manager_; 2148 const verifier::HardFailLogMode log_level_; 2149}; 2150 2151void CompilerDriver::VerifyDexFile(jobject class_loader, 2152 const DexFile& dex_file, 2153 const std::vector<const DexFile*>& dex_files, 2154 ThreadPool* thread_pool, 2155 size_t thread_count, 2156 TimingLogger* timings) { 2157 TimingLogger::ScopedTiming t("Verify Dex File", timings); 2158 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2159 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files, 2160 thread_pool); 2161 verifier::HardFailLogMode log_level = GetCompilerOptions().AbortOnHardVerifierFailure() 2162 ? verifier::HardFailLogMode::kLogInternalFatal 2163 : verifier::HardFailLogMode::kLogWarning; 2164 VerifyClassVisitor visitor(&context, log_level); 2165 context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count); 2166} 2167 2168class SetVerifiedClassVisitor : public CompilationVisitor { 2169 public: 2170 explicit SetVerifiedClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {} 2171 2172 virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE { 2173 ATRACE_CALL(); 2174 ScopedObjectAccess soa(Thread::Current()); 2175 const DexFile& dex_file = *manager_->GetDexFile(); 2176 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2177 const char* descriptor = dex_file.GetClassDescriptor(class_def); 2178 ClassLinker* class_linker = manager_->GetClassLinker(); 2179 jobject jclass_loader = manager_->GetClassLoader(); 2180 StackHandleScope<3> hs(soa.Self()); 2181 Handle<mirror::ClassLoader> class_loader( 2182 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 2183 Handle<mirror::Class> klass( 2184 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader))); 2185 // Class might have failed resolution. Then don't set it to verified. 2186 if (klass != nullptr) { 2187 // Only do this if the class is resolved. If even resolution fails, quickening will go very, 2188 // very wrong. 2189 if (klass->IsResolved() && !klass->IsErroneousResolved()) { 2190 if (klass->GetStatus() < mirror::Class::kStatusVerified) { 2191 ObjectLock<mirror::Class> lock(soa.Self(), klass); 2192 // Set class status to verified. 2193 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, soa.Self()); 2194 // Mark methods as pre-verified. If we don't do this, the interpreter will run with 2195 // access checks. 2196 klass->SetSkipAccessChecksFlagOnAllMethods( 2197 GetInstructionSetPointerSize(manager_->GetCompiler()->GetInstructionSet())); 2198 klass->SetVerificationAttempted(); 2199 } 2200 // Record the final class status if necessary. 2201 ClassReference ref(manager_->GetDexFile(), class_def_index); 2202 manager_->GetCompiler()->RecordClassStatus(ref, klass->GetStatus()); 2203 } 2204 } else { 2205 Thread* self = soa.Self(); 2206 DCHECK(self->IsExceptionPending()); 2207 self->ClearException(); 2208 } 2209 } 2210 2211 private: 2212 const ParallelCompilationManager* const manager_; 2213}; 2214 2215void CompilerDriver::SetVerifiedDexFile(jobject class_loader, 2216 const DexFile& dex_file, 2217 const std::vector<const DexFile*>& dex_files, 2218 ThreadPool* thread_pool, 2219 size_t thread_count, 2220 TimingLogger* timings) { 2221 TimingLogger::ScopedTiming t("Verify Dex File", timings); 2222 if (!compiled_classes_.HaveDexFile(&dex_file)) { 2223 compiled_classes_.AddDexFile(&dex_file, dex_file.NumClassDefs()); 2224 } 2225 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2226 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files, 2227 thread_pool); 2228 SetVerifiedClassVisitor visitor(&context); 2229 context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count); 2230} 2231 2232class InitializeClassVisitor : public CompilationVisitor { 2233 public: 2234 explicit InitializeClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {} 2235 2236 void Visit(size_t class_def_index) OVERRIDE { 2237 ATRACE_CALL(); 2238 jobject jclass_loader = manager_->GetClassLoader(); 2239 const DexFile& dex_file = *manager_->GetDexFile(); 2240 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2241 const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_); 2242 const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_); 2243 2244 ScopedObjectAccess soa(Thread::Current()); 2245 StackHandleScope<3> hs(soa.Self()); 2246 Handle<mirror::ClassLoader> class_loader( 2247 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 2248 Handle<mirror::Class> klass( 2249 hs.NewHandle(manager_->GetClassLinker()->FindClass(soa.Self(), descriptor, class_loader))); 2250 2251 if (klass != nullptr && !SkipClass(manager_->GetClassLoader(), dex_file, klass.Get())) { 2252 TryInitializeClass(klass, class_loader); 2253 } 2254 // Clear any class not found or verification exceptions. 2255 soa.Self()->ClearException(); 2256 } 2257 2258 // A helper function for initializing klass. 2259 void TryInitializeClass(Handle<mirror::Class> klass, Handle<mirror::ClassLoader>& class_loader) 2260 REQUIRES_SHARED(Locks::mutator_lock_) { 2261 const DexFile& dex_file = klass->GetDexFile(); 2262 const DexFile::ClassDef* class_def = klass->GetClassDef(); 2263 const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def->class_idx_); 2264 const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_); 2265 ScopedObjectAccessUnchecked soa(Thread::Current()); 2266 StackHandleScope<3> hs(soa.Self()); 2267 const bool is_boot_image = manager_->GetCompiler()->GetCompilerOptions().IsBootImage(); 2268 const bool is_app_image = manager_->GetCompiler()->GetCompilerOptions().IsAppImage(); 2269 2270 mirror::Class::Status old_status = klass->GetStatus(); 2271 // Don't initialize classes in boot space when compiling app image 2272 if (is_app_image && klass->IsBootStrapClassLoaded()) { 2273 // Also return early and don't store the class status in the recorded class status. 2274 return; 2275 } 2276 // Only try to initialize classes that were successfully verified. 2277 if (klass->IsVerified()) { 2278 // Attempt to initialize the class but bail if we either need to initialize the super-class 2279 // or static fields. 2280 manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, false, false); 2281 old_status = klass->GetStatus(); 2282 if (!klass->IsInitialized()) { 2283 // We don't want non-trivial class initialization occurring on multiple threads due to 2284 // deadlock problems. For example, a parent class is initialized (holding its lock) that 2285 // refers to a sub-class in its static/class initializer causing it to try to acquire the 2286 // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock) 2287 // after first initializing its parents, whose locks are acquired. This leads to a 2288 // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock. 2289 // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather 2290 // than use a special Object for the purpose we use the Class of java.lang.Class. 2291 Handle<mirror::Class> h_klass(hs.NewHandle(klass->GetClass())); 2292 ObjectLock<mirror::Class> lock(soa.Self(), h_klass); 2293 // Attempt to initialize allowing initialization of parent classes but still not static 2294 // fields. 2295 // Initialize dependencies first only for app image, to make TryInitialize recursive. 2296 bool is_superclass_initialized = !is_app_image ? true : 2297 InitializeDependencies(klass, class_loader, soa.Self()); 2298 if (!is_app_image || (is_app_image && is_superclass_initialized)) { 2299 manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, false, true); 2300 } 2301 // Otherwise it's in app image but superclasses can't be initialized, no need to proceed. 2302 old_status = klass->GetStatus(); 2303 2304 bool too_many_encoded_fields = false; 2305 if (!is_boot_image && klass->NumStaticFields() > kMaxEncodedFields) { 2306 too_many_encoded_fields = true; 2307 } 2308 // If the class was not initialized, we can proceed to see if we can initialize static 2309 // fields. Limit the max number of encoded fields. 2310 if (!klass->IsInitialized() && 2311 (is_app_image || is_boot_image) && 2312 is_superclass_initialized && 2313 !too_many_encoded_fields && 2314 manager_->GetCompiler()->IsImageClass(descriptor)) { 2315 bool can_init_static_fields = false; 2316 if (is_boot_image) { 2317 // We need to initialize static fields, we only do this for image classes that aren't 2318 // marked with the $NoPreloadHolder (which implies this should not be initialized 2319 // early). 2320 can_init_static_fields = !StringPiece(descriptor).ends_with("$NoPreloadHolder;"); 2321 } else { 2322 CHECK(is_app_image); 2323 // The boot image case doesn't need to recursively initialize the dependencies with 2324 // special logic since the class linker already does this. 2325 can_init_static_fields = 2326 !soa.Self()->IsExceptionPending() && 2327 is_superclass_initialized && 2328 NoClinitInDependency(klass, soa.Self(), &class_loader); 2329 // TODO The checking for clinit can be removed since it's already 2330 // checked when init superclass. Currently keep it because it contains 2331 // processing of intern strings. Will be removed later when intern strings 2332 // and clinit are both initialized. 2333 } 2334 2335 if (can_init_static_fields) { 2336 VLOG(compiler) << "Initializing: " << descriptor; 2337 // TODO multithreading support. We should ensure the current compilation thread has 2338 // exclusive access to the runtime and the transaction. To achieve this, we could use 2339 // a ReaderWriterMutex but we're holding the mutator lock so we fail mutex sanity 2340 // checks in Thread::AssertThreadSuspensionIsAllowable. 2341 Runtime* const runtime = Runtime::Current(); 2342 // Run the class initializer in transaction mode. 2343 runtime->EnterTransactionMode(is_app_image, klass.Get()); 2344 bool success = manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, true, 2345 true); 2346 // TODO we detach transaction from runtime to indicate we quit the transactional 2347 // mode which prevents the GC from visiting objects modified during the transaction. 2348 // Ensure GC is not run so don't access freed objects when aborting transaction. 2349 2350 { 2351 ScopedAssertNoThreadSuspension ants("Transaction end"); 2352 2353 if (success) { 2354 runtime->ExitTransactionMode(); 2355 DCHECK(!runtime->IsActiveTransaction()); 2356 } 2357 2358 if (!success) { 2359 CHECK(soa.Self()->IsExceptionPending()); 2360 mirror::Throwable* exception = soa.Self()->GetException(); 2361 VLOG(compiler) << "Initialization of " << descriptor << " aborted because of " 2362 << exception->Dump(); 2363 std::ostream* file_log = manager_->GetCompiler()-> 2364 GetCompilerOptions().GetInitFailureOutput(); 2365 if (file_log != nullptr) { 2366 *file_log << descriptor << "\n"; 2367 *file_log << exception->Dump() << "\n"; 2368 } 2369 soa.Self()->ClearException(); 2370 runtime->RollbackAllTransactions(); 2371 CHECK_EQ(old_status, klass->GetStatus()) << "Previous class status not restored"; 2372 } else if (is_boot_image) { 2373 // For boot image, we want to put the updated status in the oat class since we can't 2374 // reject the image anyways. 2375 old_status = klass->GetStatus(); 2376 } 2377 } 2378 2379 if (!success) { 2380 // On failure, still intern strings of static fields and seen in <clinit>, as these 2381 // will be created in the zygote. This is separated from the transaction code just 2382 // above as we will allocate strings, so must be allowed to suspend. 2383 if (&klass->GetDexFile() == manager_->GetDexFile()) { 2384 InternStrings(klass, class_loader); 2385 } else { 2386 DCHECK(!is_boot_image) << "Boot image must have equal dex files"; 2387 } 2388 } 2389 } 2390 } 2391 // If the class still isn't initialized, at least try some checks that initialization 2392 // would do so they can be skipped at runtime. 2393 if (!klass->IsInitialized() && 2394 manager_->GetClassLinker()->ValidateSuperClassDescriptors(klass)) { 2395 old_status = mirror::Class::kStatusSuperclassValidated; 2396 } else { 2397 soa.Self()->ClearException(); 2398 } 2399 soa.Self()->AssertNoPendingException(); 2400 } 2401 } 2402 // Record the final class status if necessary. 2403 ClassReference ref(&dex_file, klass->GetDexClassDefIndex()); 2404 // Back up the status before doing initialization for static encoded fields, 2405 // because the static encoded branch wants to keep the status to uninitialized. 2406 manager_->GetCompiler()->RecordClassStatus(ref, old_status); 2407 } 2408 2409 private: 2410 void InternStrings(Handle<mirror::Class> klass, Handle<mirror::ClassLoader> class_loader) 2411 REQUIRES_SHARED(Locks::mutator_lock_) { 2412 DCHECK(manager_->GetCompiler()->GetCompilerOptions().IsBootImage()); 2413 DCHECK(klass->IsVerified()); 2414 DCHECK(!klass->IsInitialized()); 2415 2416 StackHandleScope<1> hs(Thread::Current()); 2417 Handle<mirror::DexCache> h_dex_cache = hs.NewHandle(klass->GetDexCache()); 2418 const DexFile* dex_file = manager_->GetDexFile(); 2419 const DexFile::ClassDef* class_def = klass->GetClassDef(); 2420 ClassLinker* class_linker = manager_->GetClassLinker(); 2421 2422 // Check encoded final field values for strings and intern. 2423 annotations::RuntimeEncodedStaticFieldValueIterator value_it(*dex_file, 2424 &h_dex_cache, 2425 &class_loader, 2426 manager_->GetClassLinker(), 2427 *class_def); 2428 for ( ; value_it.HasNext(); value_it.Next()) { 2429 if (value_it.GetValueType() == annotations::RuntimeEncodedStaticFieldValueIterator::kString) { 2430 // Resolve the string. This will intern the string. 2431 art::ObjPtr<mirror::String> resolved = class_linker->ResolveString( 2432 *dex_file, dex::StringIndex(value_it.GetJavaValue().i), h_dex_cache); 2433 CHECK(resolved != nullptr); 2434 } 2435 } 2436 2437 // Intern strings seen in <clinit>. 2438 ArtMethod* clinit = klass->FindClassInitializer(class_linker->GetImagePointerSize()); 2439 if (clinit != nullptr) { 2440 const DexFile::CodeItem* code_item = clinit->GetCodeItem(); 2441 DCHECK(code_item != nullptr); 2442 const Instruction* inst = Instruction::At(code_item->insns_); 2443 2444 const uint32_t insns_size = code_item->insns_size_in_code_units_; 2445 for (uint32_t dex_pc = 0; dex_pc < insns_size;) { 2446 if (inst->Opcode() == Instruction::CONST_STRING) { 2447 ObjPtr<mirror::String> s = class_linker->ResolveString( 2448 *dex_file, dex::StringIndex(inst->VRegB_21c()), h_dex_cache); 2449 CHECK(s != nullptr); 2450 } else if (inst->Opcode() == Instruction::CONST_STRING_JUMBO) { 2451 ObjPtr<mirror::String> s = class_linker->ResolveString( 2452 *dex_file, dex::StringIndex(inst->VRegB_31c()), h_dex_cache); 2453 CHECK(s != nullptr); 2454 } 2455 dex_pc += inst->SizeInCodeUnits(); 2456 inst = inst->Next(); 2457 } 2458 } 2459 } 2460 2461 bool ResolveTypesOfMethods(Thread* self, ArtMethod* m) 2462 REQUIRES_SHARED(Locks::mutator_lock_) { 2463 // Return value of ResolveReturnType() is discarded because resolve will be done internally. 2464 ObjPtr<mirror::Class> rtn_type = m->ResolveReturnType(); 2465 if (rtn_type == nullptr) { 2466 self->ClearException(); 2467 return false; 2468 } 2469 const DexFile::TypeList* types = m->GetParameterTypeList(); 2470 if (types != nullptr) { 2471 for (uint32_t i = 0; i < types->Size(); ++i) { 2472 dex::TypeIndex param_type_idx = types->GetTypeItem(i).type_idx_; 2473 ObjPtr<mirror::Class> param_type = m->ResolveClassFromTypeIndex(param_type_idx); 2474 if (param_type == nullptr) { 2475 self->ClearException(); 2476 return false; 2477 } 2478 } 2479 } 2480 return true; 2481 } 2482 2483 // Pre resolve types mentioned in all method signatures before start a transaction 2484 // since ResolveType doesn't work in transaction mode. 2485 bool PreResolveTypes(Thread* self, const Handle<mirror::Class>& klass) 2486 REQUIRES_SHARED(Locks::mutator_lock_) { 2487 PointerSize pointer_size = manager_->GetClassLinker()->GetImagePointerSize(); 2488 for (ArtMethod& m : klass->GetMethods(pointer_size)) { 2489 if (!ResolveTypesOfMethods(self, &m)) { 2490 return false; 2491 } 2492 } 2493 if (klass->IsInterface()) { 2494 return true; 2495 } else if (klass->HasSuperClass()) { 2496 StackHandleScope<1> hs(self); 2497 MutableHandle<mirror::Class> super_klass(hs.NewHandle<mirror::Class>(klass->GetSuperClass())); 2498 for (int i = super_klass->GetVTableLength() - 1; i >= 0; --i) { 2499 ArtMethod* m = klass->GetVTableEntry(i, pointer_size); 2500 ArtMethod* super_m = super_klass->GetVTableEntry(i, pointer_size); 2501 if (!ResolveTypesOfMethods(self, m) || !ResolveTypesOfMethods(self, super_m)) { 2502 return false; 2503 } 2504 } 2505 for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) { 2506 super_klass.Assign(klass->GetIfTable()->GetInterface(i)); 2507 if (klass->GetClassLoader() != super_klass->GetClassLoader()) { 2508 uint32_t num_methods = super_klass->NumVirtualMethods(); 2509 for (uint32_t j = 0; j < num_methods; ++j) { 2510 ArtMethod* m = klass->GetIfTable()->GetMethodArray(i)->GetElementPtrSize<ArtMethod*>( 2511 j, pointer_size); 2512 ArtMethod* super_m = super_klass->GetVirtualMethod(j, pointer_size); 2513 if (!ResolveTypesOfMethods(self, m) || !ResolveTypesOfMethods(self, super_m)) { 2514 return false; 2515 } 2516 } 2517 } 2518 } 2519 } 2520 return true; 2521 } 2522 2523 // Initialize the klass's dependencies recursively before initializing itself. 2524 // Checking for interfaces is also necessary since interfaces can contain 2525 // both default methods and static encoded fields. 2526 bool InitializeDependencies(const Handle<mirror::Class>& klass, 2527 Handle<mirror::ClassLoader> class_loader, 2528 Thread* self) 2529 REQUIRES_SHARED(Locks::mutator_lock_) { 2530 if (klass->HasSuperClass()) { 2531 ObjPtr<mirror::Class> super_class = klass->GetSuperClass(); 2532 StackHandleScope<1> hs(self); 2533 Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class)); 2534 if (!handle_scope_super->IsInitialized()) { 2535 this->TryInitializeClass(handle_scope_super, class_loader); 2536 if (!handle_scope_super->IsInitialized()) { 2537 return false; 2538 } 2539 } 2540 } 2541 2542 uint32_t num_if = klass->NumDirectInterfaces(); 2543 for (size_t i = 0; i < num_if; i++) { 2544 ObjPtr<mirror::Class> 2545 interface = mirror::Class::GetDirectInterface(self, klass.Get(), i); 2546 StackHandleScope<1> hs(self); 2547 Handle<mirror::Class> handle_interface(hs.NewHandle(interface)); 2548 2549 TryInitializeClass(handle_interface, class_loader); 2550 2551 if (!handle_interface->IsInitialized()) { 2552 return false; 2553 } 2554 } 2555 2556 return PreResolveTypes(self, klass); 2557 } 2558 2559 // In this phase the classes containing class initializers are ignored. Make sure no 2560 // clinit appears in kalss's super class chain and interfaces. 2561 bool NoClinitInDependency(const Handle<mirror::Class>& klass, 2562 Thread* self, 2563 Handle<mirror::ClassLoader>* class_loader) 2564 REQUIRES_SHARED(Locks::mutator_lock_) { 2565 ArtMethod* clinit = 2566 klass->FindClassInitializer(manager_->GetClassLinker()->GetImagePointerSize()); 2567 if (clinit != nullptr) { 2568 VLOG(compiler) << klass->PrettyClass() << ' ' << clinit->PrettyMethod(true); 2569 return false; 2570 } 2571 if (klass->HasSuperClass()) { 2572 ObjPtr<mirror::Class> super_class = klass->GetSuperClass(); 2573 StackHandleScope<1> hs(self); 2574 Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class)); 2575 if (!NoClinitInDependency(handle_scope_super, self, class_loader)) { 2576 return false; 2577 } 2578 } 2579 2580 uint32_t num_if = klass->NumDirectInterfaces(); 2581 for (size_t i = 0; i < num_if; i++) { 2582 ObjPtr<mirror::Class> 2583 interface = mirror::Class::GetDirectInterface(self, klass.Get(), i); 2584 StackHandleScope<1> hs(self); 2585 Handle<mirror::Class> handle_interface(hs.NewHandle(interface)); 2586 if (!NoClinitInDependency(handle_interface, self, class_loader)) { 2587 return false; 2588 } 2589 } 2590 2591 return true; 2592 } 2593 2594 const ParallelCompilationManager* const manager_; 2595}; 2596 2597void CompilerDriver::InitializeClasses(jobject jni_class_loader, 2598 const DexFile& dex_file, 2599 const std::vector<const DexFile*>& dex_files, 2600 TimingLogger* timings) { 2601 TimingLogger::ScopedTiming t("InitializeNoClinit", timings); 2602 2603 // Initialization allocates objects and needs to run single-threaded to be deterministic. 2604 bool force_determinism = GetCompilerOptions().IsForceDeterminism(); 2605 ThreadPool* init_thread_pool = force_determinism 2606 ? single_thread_pool_.get() 2607 : parallel_thread_pool_.get(); 2608 size_t init_thread_count = force_determinism ? 1U : parallel_thread_count_; 2609 2610 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2611 ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, dex_files, 2612 init_thread_pool); 2613 2614 if (GetCompilerOptions().IsBootImage() || GetCompilerOptions().IsAppImage()) { 2615 // Set the concurrency thread to 1 to support initialization for App Images since transaction 2616 // doesn't support multithreading now. 2617 // TODO: remove this when transactional mode supports multithreading. 2618 init_thread_count = 1U; 2619 } 2620 InitializeClassVisitor visitor(&context); 2621 context.ForAll(0, dex_file.NumClassDefs(), &visitor, init_thread_count); 2622} 2623 2624class InitializeArrayClassesAndCreateConflictTablesVisitor : public ClassVisitor { 2625 public: 2626 explicit InitializeArrayClassesAndCreateConflictTablesVisitor(VariableSizedHandleScope& hs) 2627 : hs_(hs) {} 2628 2629 virtual bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE 2630 REQUIRES_SHARED(Locks::mutator_lock_) { 2631 if (Runtime::Current()->GetHeap()->ObjectIsInBootImageSpace(klass)) { 2632 return true; 2633 } 2634 if (klass->IsArrayClass()) { 2635 StackHandleScope<1> hs(Thread::Current()); 2636 auto h_klass = hs.NewHandleWrapper(&klass); 2637 Runtime::Current()->GetClassLinker()->EnsureInitialized(hs.Self(), h_klass, true, true); 2638 } 2639 // Collect handles since there may be thread suspension in future EnsureInitialized. 2640 to_visit_.push_back(hs_.NewHandle(klass)); 2641 return true; 2642 } 2643 2644 void FillAllIMTAndConflictTables() REQUIRES_SHARED(Locks::mutator_lock_) { 2645 for (Handle<mirror::Class> c : to_visit_) { 2646 // Create the conflict tables. 2647 FillIMTAndConflictTables(c.Get()); 2648 } 2649 } 2650 2651 private: 2652 void FillIMTAndConflictTables(ObjPtr<mirror::Class> klass) 2653 REQUIRES_SHARED(Locks::mutator_lock_) { 2654 if (!klass->ShouldHaveImt()) { 2655 return; 2656 } 2657 if (visited_classes_.find(klass) != visited_classes_.end()) { 2658 return; 2659 } 2660 if (klass->HasSuperClass()) { 2661 FillIMTAndConflictTables(klass->GetSuperClass()); 2662 } 2663 if (!klass->IsTemp()) { 2664 Runtime::Current()->GetClassLinker()->FillIMTAndConflictTables(klass); 2665 } 2666 visited_classes_.insert(klass); 2667 } 2668 2669 VariableSizedHandleScope& hs_; 2670 std::vector<Handle<mirror::Class>> to_visit_; 2671 std::unordered_set<ObjPtr<mirror::Class>, HashObjPtr> visited_classes_; 2672}; 2673 2674void CompilerDriver::InitializeClasses(jobject class_loader, 2675 const std::vector<const DexFile*>& dex_files, 2676 TimingLogger* timings) { 2677 for (size_t i = 0; i != dex_files.size(); ++i) { 2678 const DexFile* dex_file = dex_files[i]; 2679 CHECK(dex_file != nullptr); 2680 InitializeClasses(class_loader, *dex_file, dex_files, timings); 2681 } 2682 if (GetCompilerOptions().IsBootImage() || GetCompilerOptions().IsAppImage()) { 2683 // Make sure that we call EnsureIntiailized on all the array classes to call 2684 // SetVerificationAttempted so that the access flags are set. If we do not do this they get 2685 // changed at runtime resulting in more dirty image pages. 2686 // Also create conflict tables. 2687 // Only useful if we are compiling an image (image_classes_ is not null). 2688 ScopedObjectAccess soa(Thread::Current()); 2689 VariableSizedHandleScope hs(soa.Self()); 2690 InitializeArrayClassesAndCreateConflictTablesVisitor visitor(hs); 2691 Runtime::Current()->GetClassLinker()->VisitClassesWithoutClassesLock(&visitor); 2692 visitor.FillAllIMTAndConflictTables(); 2693 } 2694 if (GetCompilerOptions().IsBootImage()) { 2695 // Prune garbage objects created during aborted transactions. 2696 Runtime::Current()->GetHeap()->CollectGarbage(true); 2697 } 2698} 2699 2700void CompilerDriver::Compile(jobject class_loader, 2701 const std::vector<const DexFile*>& dex_files, 2702 TimingLogger* timings) { 2703 if (kDebugProfileGuidedCompilation) { 2704 LOG(INFO) << "[ProfileGuidedCompilation] " << 2705 ((profile_compilation_info_ == nullptr) 2706 ? "null" 2707 : profile_compilation_info_->DumpInfo(&dex_files)); 2708 } 2709 2710 current_dex_to_dex_methods_ = nullptr; 2711 Thread* const self = Thread::Current(); 2712 { 2713 // Clear in case we aren't the first call to Compile. 2714 MutexLock mu(self, dex_to_dex_references_lock_); 2715 dex_to_dex_references_.clear(); 2716 } 2717 2718 for (const DexFile* dex_file : dex_files) { 2719 CHECK(dex_file != nullptr); 2720 CompileDexFile(class_loader, 2721 *dex_file, 2722 dex_files, 2723 parallel_thread_pool_.get(), 2724 parallel_thread_count_, 2725 timings); 2726 const ArenaPool* const arena_pool = Runtime::Current()->GetArenaPool(); 2727 const size_t arena_alloc = arena_pool->GetBytesAllocated(); 2728 max_arena_alloc_ = std::max(arena_alloc, max_arena_alloc_); 2729 Runtime::Current()->ReclaimArenaPoolMemory(); 2730 } 2731 2732 ArrayRef<DexFileMethodSet> dex_to_dex_references; 2733 { 2734 // From this point on, we shall not modify dex_to_dex_references_, so 2735 // just grab a reference to it that we use without holding the mutex. 2736 MutexLock lock(self, dex_to_dex_references_lock_); 2737 dex_to_dex_references = ArrayRef<DexFileMethodSet>(dex_to_dex_references_); 2738 } 2739 for (const auto& method_set : dex_to_dex_references) { 2740 current_dex_to_dex_methods_ = &method_set.GetMethodIndexes(); 2741 CompileDexFile(class_loader, 2742 method_set.GetDexFile(), 2743 dex_files, 2744 parallel_thread_pool_.get(), 2745 parallel_thread_count_, 2746 timings); 2747 } 2748 current_dex_to_dex_methods_ = nullptr; 2749 2750 VLOG(compiler) << "Compile: " << GetMemoryUsageString(false); 2751} 2752 2753class CompileClassVisitor : public CompilationVisitor { 2754 public: 2755 explicit CompileClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {} 2756 2757 virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE { 2758 ATRACE_CALL(); 2759 const DexFile& dex_file = *manager_->GetDexFile(); 2760 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2761 ClassLinker* class_linker = manager_->GetClassLinker(); 2762 jobject jclass_loader = manager_->GetClassLoader(); 2763 ClassReference ref(&dex_file, class_def_index); 2764 // Skip compiling classes with generic verifier failures since they will still fail at runtime 2765 if (manager_->GetCompiler()->verification_results_->IsClassRejected(ref)) { 2766 return; 2767 } 2768 // Use a scoped object access to perform to the quick SkipClass check. 2769 const char* descriptor = dex_file.GetClassDescriptor(class_def); 2770 ScopedObjectAccess soa(Thread::Current()); 2771 StackHandleScope<3> hs(soa.Self()); 2772 Handle<mirror::ClassLoader> class_loader( 2773 hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader))); 2774 Handle<mirror::Class> klass( 2775 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader))); 2776 Handle<mirror::DexCache> dex_cache; 2777 if (klass == nullptr) { 2778 soa.Self()->AssertPendingException(); 2779 soa.Self()->ClearException(); 2780 dex_cache = hs.NewHandle(class_linker->FindDexCache(soa.Self(), dex_file)); 2781 } else if (SkipClass(jclass_loader, dex_file, klass.Get())) { 2782 return; 2783 } else { 2784 dex_cache = hs.NewHandle(klass->GetDexCache()); 2785 } 2786 2787 const uint8_t* class_data = dex_file.GetClassData(class_def); 2788 if (class_data == nullptr) { 2789 // empty class, probably a marker interface 2790 return; 2791 } 2792 2793 // Go to native so that we don't block GC during compilation. 2794 ScopedThreadSuspension sts(soa.Self(), kNative); 2795 2796 CompilerDriver* const driver = manager_->GetCompiler(); 2797 2798 // Can we run DEX-to-DEX compiler on this class ? 2799 optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level = 2800 GetDexToDexCompilationLevel(soa.Self(), *driver, jclass_loader, dex_file, class_def); 2801 2802 ClassDataItemIterator it(dex_file, class_data); 2803 it.SkipAllFields(); 2804 2805 bool compilation_enabled = driver->IsClassToCompile( 2806 dex_file.StringByTypeIdx(class_def.class_idx_)); 2807 2808 // Compile direct methods 2809 int64_t previous_direct_method_idx = -1; 2810 while (it.HasNextDirectMethod()) { 2811 uint32_t method_idx = it.GetMemberIndex(); 2812 if (method_idx == previous_direct_method_idx) { 2813 // smali can create dex files with two encoded_methods sharing the same method_idx 2814 // http://code.google.com/p/smali/issues/detail?id=119 2815 it.Next(); 2816 continue; 2817 } 2818 previous_direct_method_idx = method_idx; 2819 CompileMethod(soa.Self(), 2820 driver, 2821 it.GetMethodCodeItem(), 2822 it.GetMethodAccessFlags(), 2823 it.GetMethodInvokeType(class_def), 2824 class_def_index, 2825 method_idx, 2826 class_loader, 2827 dex_file, 2828 dex_to_dex_compilation_level, 2829 compilation_enabled, 2830 dex_cache); 2831 it.Next(); 2832 } 2833 // Compile virtual methods 2834 int64_t previous_virtual_method_idx = -1; 2835 while (it.HasNextVirtualMethod()) { 2836 uint32_t method_idx = it.GetMemberIndex(); 2837 if (method_idx == previous_virtual_method_idx) { 2838 // smali can create dex files with two encoded_methods sharing the same method_idx 2839 // http://code.google.com/p/smali/issues/detail?id=119 2840 it.Next(); 2841 continue; 2842 } 2843 previous_virtual_method_idx = method_idx; 2844 CompileMethod(soa.Self(), 2845 driver, it.GetMethodCodeItem(), 2846 it.GetMethodAccessFlags(), 2847 it.GetMethodInvokeType(class_def), 2848 class_def_index, 2849 method_idx, 2850 class_loader, 2851 dex_file, 2852 dex_to_dex_compilation_level, 2853 compilation_enabled, 2854 dex_cache); 2855 it.Next(); 2856 } 2857 DCHECK(!it.HasNext()); 2858 } 2859 2860 private: 2861 const ParallelCompilationManager* const manager_; 2862}; 2863 2864void CompilerDriver::CompileDexFile(jobject class_loader, 2865 const DexFile& dex_file, 2866 const std::vector<const DexFile*>& dex_files, 2867 ThreadPool* thread_pool, 2868 size_t thread_count, 2869 TimingLogger* timings) { 2870 TimingLogger::ScopedTiming t("Compile Dex File", timings); 2871 ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this, 2872 &dex_file, dex_files, thread_pool); 2873 CompileClassVisitor visitor(&context); 2874 context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count); 2875} 2876 2877void CompilerDriver::AddCompiledMethod(const MethodReference& method_ref, 2878 CompiledMethod* const compiled_method, 2879 size_t non_relative_linker_patch_count) { 2880 DCHECK(GetCompiledMethod(method_ref) == nullptr) 2881 << method_ref.dex_file->PrettyMethod(method_ref.dex_method_index); 2882 MethodTable::InsertResult result = compiled_methods_.Insert( 2883 DexFileReference(method_ref.dex_file, method_ref.dex_method_index), 2884 /*expected*/ nullptr, 2885 compiled_method); 2886 CHECK(result == MethodTable::kInsertResultSuccess); 2887 non_relative_linker_patch_count_.FetchAndAddRelaxed(non_relative_linker_patch_count); 2888 DCHECK(GetCompiledMethod(method_ref) != nullptr) 2889 << method_ref.dex_file->PrettyMethod(method_ref.dex_method_index); 2890} 2891 2892bool CompilerDriver::GetCompiledClass(ClassReference ref, mirror::Class::Status* status) const { 2893 DCHECK(status != nullptr); 2894 // The table doesn't know if something wasn't inserted. For this case it will return 2895 // kStatusNotReady. To handle this, just assume anything we didn't try to verify is not compiled. 2896 if (!compiled_classes_.Get(DexFileReference(ref.first, ref.second), status) || 2897 *status < mirror::Class::kStatusRetryVerificationAtRuntime) { 2898 return false; 2899 } 2900 return true; 2901} 2902 2903mirror::Class::Status CompilerDriver::GetClassStatus(ClassReference ref) const { 2904 mirror::Class::Status status = ClassStatus::kStatusNotReady; 2905 if (!GetCompiledClass(ref, &status)) { 2906 classpath_classes_.Get(DexFileReference(ref.first, ref.second), &status); 2907 } 2908 return status; 2909} 2910 2911void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) { 2912 switch (status) { 2913 case mirror::Class::kStatusErrorResolved: 2914 case mirror::Class::kStatusErrorUnresolved: 2915 case mirror::Class::kStatusNotReady: 2916 case mirror::Class::kStatusResolved: 2917 case mirror::Class::kStatusRetryVerificationAtRuntime: 2918 case mirror::Class::kStatusVerified: 2919 case mirror::Class::kStatusSuperclassValidated: 2920 case mirror::Class::kStatusInitialized: 2921 break; // Expected states. 2922 default: 2923 LOG(FATAL) << "Unexpected class status for class " 2924 << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second))) 2925 << " of " << status; 2926 } 2927 2928 ClassStateTable::InsertResult result; 2929 ClassStateTable* table = &compiled_classes_; 2930 do { 2931 DexFileReference dex_ref(ref.first, ref.second); 2932 mirror::Class::Status existing = mirror::Class::kStatusNotReady; 2933 if (!table->Get(dex_ref, &existing)) { 2934 // A classpath class. 2935 if (kIsDebugBuild) { 2936 // Check to make sure it's not a dex file for an oat file we are compiling since these 2937 // should always succeed. These do not include classes in for used libraries. 2938 for (const DexFile* dex_file : GetDexFilesForOatFile()) { 2939 CHECK_NE(dex_ref.dex_file, dex_file) << dex_ref.dex_file->GetLocation(); 2940 } 2941 } 2942 if (!classpath_classes_.HaveDexFile(ref.first)) { 2943 // Boot classpath dex file. 2944 return; 2945 } 2946 table = &classpath_classes_; 2947 table->Get(dex_ref, &existing); 2948 } 2949 if (existing >= status) { 2950 // Existing status is already better than we expect, break. 2951 break; 2952 } 2953 // Update the status if we now have a greater one. This happens with vdex, 2954 // which records a class is verified, but does not resolve it. 2955 result = table->Insert(dex_ref, existing, status); 2956 CHECK(result != ClassStateTable::kInsertResultInvalidDexFile) << ref.first->GetLocation(); 2957 } while (result != ClassStateTable::kInsertResultSuccess); 2958} 2959 2960CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const { 2961 CompiledMethod* compiled_method = nullptr; 2962 compiled_methods_.Get(DexFileReference(ref.dex_file, ref.dex_method_index), &compiled_method); 2963 return compiled_method; 2964} 2965 2966bool CompilerDriver::IsMethodVerifiedWithoutFailures(uint32_t method_idx, 2967 uint16_t class_def_idx, 2968 const DexFile& dex_file) const { 2969 const VerifiedMethod* verified_method = GetVerifiedMethod(&dex_file, method_idx); 2970 if (verified_method != nullptr) { 2971 return !verified_method->HasVerificationFailures(); 2972 } 2973 2974 // If we can't find verification metadata, check if this is a system class (we trust that system 2975 // classes have their methods verified). If it's not, be conservative and assume the method 2976 // has not been verified successfully. 2977 2978 // TODO: When compiling the boot image it should be safe to assume that everything is verified, 2979 // even if methods are not found in the verification cache. 2980 const char* descriptor = dex_file.GetClassDescriptor(dex_file.GetClassDef(class_def_idx)); 2981 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2982 Thread* self = Thread::Current(); 2983 ScopedObjectAccess soa(self); 2984 bool is_system_class = class_linker->FindSystemClass(self, descriptor) != nullptr; 2985 if (!is_system_class) { 2986 self->ClearException(); 2987 } 2988 return is_system_class; 2989} 2990 2991size_t CompilerDriver::GetNonRelativeLinkerPatchCount() const { 2992 return non_relative_linker_patch_count_.LoadRelaxed(); 2993} 2994 2995void CompilerDriver::SetRequiresConstructorBarrier(Thread* self, 2996 const DexFile* dex_file, 2997 uint16_t class_def_index, 2998 bool requires) { 2999 WriterMutexLock mu(self, requires_constructor_barrier_lock_); 3000 requires_constructor_barrier_.emplace(ClassReference(dex_file, class_def_index), requires); 3001} 3002 3003bool CompilerDriver::RequiresConstructorBarrier(Thread* self, 3004 const DexFile* dex_file, 3005 uint16_t class_def_index) { 3006 ClassReference class_ref(dex_file, class_def_index); 3007 { 3008 ReaderMutexLock mu(self, requires_constructor_barrier_lock_); 3009 auto it = requires_constructor_barrier_.find(class_ref); 3010 if (it != requires_constructor_barrier_.end()) { 3011 return it->second; 3012 } 3013 } 3014 WriterMutexLock mu(self, requires_constructor_barrier_lock_); 3015 const bool requires = RequiresConstructorBarrier(*dex_file, class_def_index); 3016 requires_constructor_barrier_.emplace(class_ref, requires); 3017 return requires; 3018} 3019 3020std::string CompilerDriver::GetMemoryUsageString(bool extended) const { 3021 std::ostringstream oss; 3022 const gc::Heap* const heap = Runtime::Current()->GetHeap(); 3023 const size_t java_alloc = heap->GetBytesAllocated(); 3024 oss << "arena alloc=" << PrettySize(max_arena_alloc_) << " (" << max_arena_alloc_ << "B)"; 3025 oss << " java alloc=" << PrettySize(java_alloc) << " (" << java_alloc << "B)"; 3026#if defined(__BIONIC__) || defined(__GLIBC__) 3027 const struct mallinfo info = mallinfo(); 3028 const size_t allocated_space = static_cast<size_t>(info.uordblks); 3029 const size_t free_space = static_cast<size_t>(info.fordblks); 3030 oss << " native alloc=" << PrettySize(allocated_space) << " (" << allocated_space << "B)" 3031 << " free=" << PrettySize(free_space) << " (" << free_space << "B)"; 3032#endif 3033 compiled_method_storage_.DumpMemoryUsage(oss, extended); 3034 return oss.str(); 3035} 3036 3037bool CompilerDriver::MayInlineInternal(const DexFile* inlined_from, 3038 const DexFile* inlined_into) const { 3039 // We're not allowed to inline across dex files if we're the no-inline-from dex file. 3040 if (inlined_from != inlined_into && 3041 compiler_options_->GetNoInlineFromDexFile() != nullptr && 3042 ContainsElement(*compiler_options_->GetNoInlineFromDexFile(), inlined_from)) { 3043 return false; 3044 } 3045 3046 return true; 3047} 3048 3049void CompilerDriver::InitializeThreadPools() { 3050 size_t parallel_count = parallel_thread_count_ > 0 ? parallel_thread_count_ - 1 : 0; 3051 parallel_thread_pool_.reset( 3052 new ThreadPool("Compiler driver thread pool", parallel_count)); 3053 single_thread_pool_.reset(new ThreadPool("Single-threaded Compiler driver thread pool", 0)); 3054} 3055 3056void CompilerDriver::FreeThreadPools() { 3057 parallel_thread_pool_.reset(); 3058 single_thread_pool_.reset(); 3059} 3060 3061void CompilerDriver::SetDexFilesForOatFile(const std::vector<const DexFile*>& dex_files) { 3062 dex_files_for_oat_file_ = dex_files; 3063 compiled_classes_.AddDexFiles(dex_files); 3064} 3065 3066void CompilerDriver::SetClasspathDexFiles(const std::vector<const DexFile*>& dex_files) { 3067 classpath_classes_.AddDexFiles(dex_files); 3068} 3069 3070} // namespace art 3071