compiler_driver.cc revision 1bc977cf2f8199311a97f2ba9431a184540e3e9c
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#define ATRACE_TAG ATRACE_TAG_DALVIK 20#include <utils/Trace.h> 21 22#include <unordered_set> 23#include <vector> 24#include <unistd.h> 25 26#ifndef __APPLE__ 27#include <malloc.h> // For mallinfo 28#endif 29 30#include "art_field-inl.h" 31#include "art_method-inl.h" 32#include "base/stl_util.h" 33#include "base/time_utils.h" 34#include "base/timing_logger.h" 35#include "class_linker-inl.h" 36#include "compiled_class.h" 37#include "compiled_method.h" 38#include "compiler.h" 39#include "compiler_driver-inl.h" 40#include "dex_compilation_unit.h" 41#include "dex_file-inl.h" 42#include "dex/dex_to_dex_compiler.h" 43#include "dex/verification_results.h" 44#include "dex/verified_method.h" 45#include "dex/quick/dex_file_method_inliner.h" 46#include "dex/quick/dex_file_to_method_inliner_map.h" 47#include "driver/compiler_options.h" 48#include "jni_internal.h" 49#include "object_lock.h" 50#include "profiler.h" 51#include "runtime.h" 52#include "gc/accounting/card_table-inl.h" 53#include "gc/accounting/heap_bitmap.h" 54#include "gc/space/image_space.h" 55#include "gc/space/space.h" 56#include "mirror/class_loader.h" 57#include "mirror/class-inl.h" 58#include "mirror/dex_cache-inl.h" 59#include "mirror/object-inl.h" 60#include "mirror/object_array-inl.h" 61#include "mirror/throwable.h" 62#include "scoped_thread_state_change.h" 63#include "ScopedLocalRef.h" 64#include "handle_scope-inl.h" 65#include "thread.h" 66#include "thread_list.h" 67#include "thread_pool.h" 68#include "trampolines/trampoline_compiler.h" 69#include "transaction.h" 70#include "utils/dex_cache_arrays_layout-inl.h" 71#include "utils/swap_space.h" 72#include "verifier/method_verifier.h" 73#include "verifier/method_verifier-inl.h" 74 75namespace art { 76 77static constexpr bool kTimeCompileMethod = !kIsDebugBuild; 78 79// Whether classes-to-compile and methods-to-compile are only applied to the boot image, or, when 80// given, too all compilations. 81static constexpr bool kRestrictCompilationFiltersToImage = true; 82 83// Print additional info during profile guided compilation. 84static constexpr bool kDebugProfileGuidedCompilation = false; 85 86static double Percentage(size_t x, size_t y) { 87 return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y)); 88} 89 90static void DumpStat(size_t x, size_t y, const char* str) { 91 if (x == 0 && y == 0) { 92 return; 93 } 94 LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases"; 95} 96 97class CompilerDriver::AOTCompilationStats { 98 public: 99 AOTCompilationStats() 100 : stats_lock_("AOT compilation statistics lock"), 101 types_in_dex_cache_(0), types_not_in_dex_cache_(0), 102 strings_in_dex_cache_(0), strings_not_in_dex_cache_(0), 103 resolved_types_(0), unresolved_types_(0), 104 resolved_instance_fields_(0), unresolved_instance_fields_(0), 105 resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0), 106 type_based_devirtualization_(0), 107 safe_casts_(0), not_safe_casts_(0) { 108 for (size_t i = 0; i <= kMaxInvokeType; i++) { 109 resolved_methods_[i] = 0; 110 unresolved_methods_[i] = 0; 111 virtual_made_direct_[i] = 0; 112 direct_calls_to_boot_[i] = 0; 113 direct_methods_to_boot_[i] = 0; 114 } 115 } 116 117 void Dump() { 118 DumpStat(types_in_dex_cache_, types_not_in_dex_cache_, "types known to be in dex cache"); 119 DumpStat(strings_in_dex_cache_, strings_not_in_dex_cache_, "strings known to be in dex cache"); 120 DumpStat(resolved_types_, unresolved_types_, "types resolved"); 121 DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved"); 122 DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_, 123 "static fields resolved"); 124 DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_, 125 "static fields local to a class"); 126 DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information"); 127 // Note, the code below subtracts the stat value so that when added to the stat value we have 128 // 100% of samples. TODO: clean this up. 129 DumpStat(type_based_devirtualization_, 130 resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] + 131 resolved_methods_[kInterface] + unresolved_methods_[kInterface] - 132 type_based_devirtualization_, 133 "virtual/interface calls made direct based on type information"); 134 135 for (size_t i = 0; i <= kMaxInvokeType; i++) { 136 std::ostringstream oss; 137 oss << static_cast<InvokeType>(i) << " methods were AOT resolved"; 138 DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str()); 139 if (virtual_made_direct_[i] > 0) { 140 std::ostringstream oss2; 141 oss2 << static_cast<InvokeType>(i) << " methods made direct"; 142 DumpStat(virtual_made_direct_[i], 143 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i], 144 oss2.str().c_str()); 145 } 146 if (direct_calls_to_boot_[i] > 0) { 147 std::ostringstream oss2; 148 oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot"; 149 DumpStat(direct_calls_to_boot_[i], 150 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i], 151 oss2.str().c_str()); 152 } 153 if (direct_methods_to_boot_[i] > 0) { 154 std::ostringstream oss2; 155 oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot"; 156 DumpStat(direct_methods_to_boot_[i], 157 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i], 158 oss2.str().c_str()); 159 } 160 } 161 } 162 163// Allow lossy statistics in non-debug builds. 164#ifndef NDEBUG 165#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_) 166#else 167#define STATS_LOCK() 168#endif 169 170 void TypeInDexCache() REQUIRES(!stats_lock_) { 171 STATS_LOCK(); 172 types_in_dex_cache_++; 173 } 174 175 void TypeNotInDexCache() REQUIRES(!stats_lock_) { 176 STATS_LOCK(); 177 types_not_in_dex_cache_++; 178 } 179 180 void StringInDexCache() REQUIRES(!stats_lock_) { 181 STATS_LOCK(); 182 strings_in_dex_cache_++; 183 } 184 185 void StringNotInDexCache() REQUIRES(!stats_lock_) { 186 STATS_LOCK(); 187 strings_not_in_dex_cache_++; 188 } 189 190 void TypeDoesntNeedAccessCheck() REQUIRES(!stats_lock_) { 191 STATS_LOCK(); 192 resolved_types_++; 193 } 194 195 void TypeNeedsAccessCheck() REQUIRES(!stats_lock_) { 196 STATS_LOCK(); 197 unresolved_types_++; 198 } 199 200 void ResolvedInstanceField() REQUIRES(!stats_lock_) { 201 STATS_LOCK(); 202 resolved_instance_fields_++; 203 } 204 205 void UnresolvedInstanceField() REQUIRES(!stats_lock_) { 206 STATS_LOCK(); 207 unresolved_instance_fields_++; 208 } 209 210 void ResolvedLocalStaticField() REQUIRES(!stats_lock_) { 211 STATS_LOCK(); 212 resolved_local_static_fields_++; 213 } 214 215 void ResolvedStaticField() REQUIRES(!stats_lock_) { 216 STATS_LOCK(); 217 resolved_static_fields_++; 218 } 219 220 void UnresolvedStaticField() REQUIRES(!stats_lock_) { 221 STATS_LOCK(); 222 unresolved_static_fields_++; 223 } 224 225 // Indicate that type information from the verifier led to devirtualization. 226 void PreciseTypeDevirtualization() REQUIRES(!stats_lock_) { 227 STATS_LOCK(); 228 type_based_devirtualization_++; 229 } 230 231 // Indicate that a method of the given type was resolved at compile time. 232 void ResolvedMethod(InvokeType type) REQUIRES(!stats_lock_) { 233 DCHECK_LE(type, kMaxInvokeType); 234 STATS_LOCK(); 235 resolved_methods_[type]++; 236 } 237 238 // Indicate that a method of the given type was unresolved at compile time as it was in an 239 // unknown dex file. 240 void UnresolvedMethod(InvokeType type) REQUIRES(!stats_lock_) { 241 DCHECK_LE(type, kMaxInvokeType); 242 STATS_LOCK(); 243 unresolved_methods_[type]++; 244 } 245 246 // Indicate that a type of virtual method dispatch has been converted into a direct method 247 // dispatch. 248 void VirtualMadeDirect(InvokeType type) REQUIRES(!stats_lock_) { 249 DCHECK(type == kVirtual || type == kInterface || type == kSuper); 250 STATS_LOCK(); 251 virtual_made_direct_[type]++; 252 } 253 254 // Indicate that a method of the given type was able to call directly into boot. 255 void DirectCallsToBoot(InvokeType type) REQUIRES(!stats_lock_) { 256 DCHECK_LE(type, kMaxInvokeType); 257 STATS_LOCK(); 258 direct_calls_to_boot_[type]++; 259 } 260 261 // Indicate that a method of the given type was able to be resolved directly from boot. 262 void DirectMethodsToBoot(InvokeType type) REQUIRES(!stats_lock_) { 263 DCHECK_LE(type, kMaxInvokeType); 264 STATS_LOCK(); 265 direct_methods_to_boot_[type]++; 266 } 267 268 void ProcessedInvoke(InvokeType type, int flags) REQUIRES(!stats_lock_) { 269 STATS_LOCK(); 270 if (flags == 0) { 271 unresolved_methods_[type]++; 272 } else { 273 DCHECK_NE((flags & kFlagMethodResolved), 0); 274 resolved_methods_[type]++; 275 if ((flags & kFlagVirtualMadeDirect) != 0) { 276 virtual_made_direct_[type]++; 277 if ((flags & kFlagPreciseTypeDevirtualization) != 0) { 278 type_based_devirtualization_++; 279 } 280 } else { 281 DCHECK_EQ((flags & kFlagPreciseTypeDevirtualization), 0); 282 } 283 if ((flags & kFlagDirectCallToBoot) != 0) { 284 direct_calls_to_boot_[type]++; 285 } 286 if ((flags & kFlagDirectMethodToBoot) != 0) { 287 direct_methods_to_boot_[type]++; 288 } 289 } 290 } 291 292 // A check-cast could be eliminated due to verifier type analysis. 293 void SafeCast() REQUIRES(!stats_lock_) { 294 STATS_LOCK(); 295 safe_casts_++; 296 } 297 298 // A check-cast couldn't be eliminated due to verifier type analysis. 299 void NotASafeCast() REQUIRES(!stats_lock_) { 300 STATS_LOCK(); 301 not_safe_casts_++; 302 } 303 304 private: 305 Mutex stats_lock_; 306 307 size_t types_in_dex_cache_; 308 size_t types_not_in_dex_cache_; 309 310 size_t strings_in_dex_cache_; 311 size_t strings_not_in_dex_cache_; 312 313 size_t resolved_types_; 314 size_t unresolved_types_; 315 316 size_t resolved_instance_fields_; 317 size_t unresolved_instance_fields_; 318 319 size_t resolved_local_static_fields_; 320 size_t resolved_static_fields_; 321 size_t unresolved_static_fields_; 322 // Type based devirtualization for invoke interface and virtual. 323 size_t type_based_devirtualization_; 324 325 size_t resolved_methods_[kMaxInvokeType + 1]; 326 size_t unresolved_methods_[kMaxInvokeType + 1]; 327 size_t virtual_made_direct_[kMaxInvokeType + 1]; 328 size_t direct_calls_to_boot_[kMaxInvokeType + 1]; 329 size_t direct_methods_to_boot_[kMaxInvokeType + 1]; 330 331 size_t safe_casts_; 332 size_t not_safe_casts_; 333 334 DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats); 335}; 336 337CompilerDriver::CompilerDriver( 338 const CompilerOptions* compiler_options, 339 VerificationResults* verification_results, 340 DexFileToMethodInlinerMap* method_inliner_map, 341 Compiler::Kind compiler_kind, 342 InstructionSet instruction_set, 343 const InstructionSetFeatures* instruction_set_features, 344 bool boot_image, std::unordered_set<std::string>* image_classes, 345 std::unordered_set<std::string>* compiled_classes, 346 std::unordered_set<std::string>* compiled_methods, 347 size_t thread_count, bool dump_stats, bool dump_passes, 348 CumulativeLogger* timer, int swap_fd, 349 const std::unordered_map<const DexFile*, const char*>* dex_to_oat_map, 350 const ProfileCompilationInfo* profile_compilation_info) 351 : compiler_options_(compiler_options), 352 verification_results_(verification_results), 353 method_inliner_map_(method_inliner_map), 354 compiler_(Compiler::Create(this, compiler_kind)), 355 compiler_kind_(compiler_kind), 356 instruction_set_(instruction_set), 357 instruction_set_features_(instruction_set_features), 358 freezing_constructor_lock_("freezing constructor lock"), 359 compiled_classes_lock_("compiled classes lock"), 360 compiled_methods_lock_("compiled method lock"), 361 compiled_methods_(MethodTable::key_compare()), 362 non_relative_linker_patch_count_(0u), 363 boot_image_(boot_image), 364 image_classes_(image_classes), 365 classes_to_compile_(compiled_classes), 366 methods_to_compile_(compiled_methods), 367 had_hard_verifier_failure_(false), 368 thread_count_(thread_count), 369 stats_(new AOTCompilationStats), 370 dump_stats_(dump_stats), 371 dump_passes_(dump_passes), 372 timings_logger_(timer), 373 compiler_context_(nullptr), 374 support_boot_image_fixup_(instruction_set != kMips && instruction_set != kMips64), 375 dex_files_for_oat_file_(nullptr), 376 dex_file_oat_filename_map_(dex_to_oat_map), 377 compiled_method_storage_(swap_fd), 378 profile_compilation_info_(profile_compilation_info) { 379 DCHECK(compiler_options_ != nullptr); 380 DCHECK(verification_results_ != nullptr); 381 DCHECK(method_inliner_map_ != nullptr); 382 383 compiler_->Init(); 384 385 CHECK_EQ(boot_image_, image_classes_.get() != nullptr); 386} 387 388CompilerDriver::~CompilerDriver() { 389 Thread* self = Thread::Current(); 390 { 391 MutexLock mu(self, compiled_classes_lock_); 392 STLDeleteValues(&compiled_classes_); 393 } 394 { 395 MutexLock mu(self, compiled_methods_lock_); 396 for (auto& pair : compiled_methods_) { 397 CompiledMethod::ReleaseSwapAllocatedCompiledMethod(this, pair.second); 398 } 399 } 400 compiler_->UnInit(); 401} 402 403 404#define CREATE_TRAMPOLINE(type, abi, offset) \ 405 if (Is64BitInstructionSet(instruction_set_)) { \ 406 return CreateTrampoline64(instruction_set_, abi, \ 407 type ## _ENTRYPOINT_OFFSET(8, offset)); \ 408 } else { \ 409 return CreateTrampoline32(instruction_set_, abi, \ 410 type ## _ENTRYPOINT_OFFSET(4, offset)); \ 411 } 412 413const std::vector<uint8_t>* CompilerDriver::CreateJniDlsymLookup() const { 414 CREATE_TRAMPOLINE(JNI, kJniAbi, pDlsymLookup) 415} 416 417const std::vector<uint8_t>* CompilerDriver::CreateQuickGenericJniTrampoline() const { 418 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickGenericJniTrampoline) 419} 420 421const std::vector<uint8_t>* CompilerDriver::CreateQuickImtConflictTrampoline() const { 422 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickImtConflictTrampoline) 423} 424 425const std::vector<uint8_t>* CompilerDriver::CreateQuickResolutionTrampoline() const { 426 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickResolutionTrampoline) 427} 428 429const std::vector<uint8_t>* CompilerDriver::CreateQuickToInterpreterBridge() const { 430 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickToInterpreterBridge) 431} 432#undef CREATE_TRAMPOLINE 433 434void CompilerDriver::CompileAll(jobject class_loader, 435 const std::vector<const DexFile*>& dex_files, 436 TimingLogger* timings) { 437 DCHECK(!Runtime::Current()->IsStarted()); 438 std::unique_ptr<ThreadPool> thread_pool( 439 new ThreadPool("Compiler driver thread pool", thread_count_ - 1)); 440 VLOG(compiler) << "Before precompile " << GetMemoryUsageString(false); 441 // Precompile: 442 // 1) Load image classes 443 // 2) Resolve all classes 444 // 3) Attempt to verify all classes 445 // 4) Attempt to initialize image classes, and trivially initialized classes 446 PreCompile(class_loader, dex_files, thread_pool.get(), timings); 447 // Compile: 448 // 1) Compile all classes and methods enabled for compilation. May fall back to dex-to-dex 449 // compilation. 450 if (!GetCompilerOptions().VerifyAtRuntime()) { 451 Compile(class_loader, dex_files, thread_pool.get(), timings); 452 } 453 if (dump_stats_) { 454 stats_->Dump(); 455 } 456} 457 458static optimizer::DexToDexCompilationLevel GetDexToDexCompilationLevel( 459 Thread* self, const CompilerDriver& driver, Handle<mirror::ClassLoader> class_loader, 460 const DexFile& dex_file, const DexFile::ClassDef& class_def) 461 SHARED_REQUIRES(Locks::mutator_lock_) { 462 auto* const runtime = Runtime::Current(); 463 if (runtime->UseJit() || driver.GetCompilerOptions().VerifyAtRuntime()) { 464 // Verify at runtime shouldn't dex to dex since we didn't resolve of verify. 465 return optimizer::DexToDexCompilationLevel::kDontDexToDexCompile; 466 } 467 const char* descriptor = dex_file.GetClassDescriptor(class_def); 468 ClassLinker* class_linker = runtime->GetClassLinker(); 469 mirror::Class* klass = class_linker->FindClass(self, descriptor, class_loader); 470 if (klass == nullptr) { 471 CHECK(self->IsExceptionPending()); 472 self->ClearException(); 473 return optimizer::DexToDexCompilationLevel::kDontDexToDexCompile; 474 } 475 // DexToDex at the kOptimize level may introduce quickened opcodes, which replace symbolic 476 // references with actual offsets. We cannot re-verify such instructions. 477 // 478 // We store the verification information in the class status in the oat file, which the linker 479 // can validate (checksums) and use to skip load-time verification. It is thus safe to 480 // optimize when a class has been fully verified before. 481 if (klass->IsVerified()) { 482 // Class is verified so we can enable DEX-to-DEX compilation for performance. 483 return optimizer::DexToDexCompilationLevel::kOptimize; 484 } else if (klass->IsCompileTimeVerified()) { 485 // Class verification has soft-failed. Anyway, ensure at least correctness. 486 DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime); 487 return optimizer::DexToDexCompilationLevel::kRequired; 488 } else { 489 // Class verification has failed: do not run DEX-to-DEX compilation. 490 return optimizer::DexToDexCompilationLevel::kDontDexToDexCompile; 491 } 492} 493 494static optimizer::DexToDexCompilationLevel GetDexToDexCompilationLevel( 495 Thread* self, 496 const CompilerDriver& driver, 497 jobject jclass_loader, 498 const DexFile& dex_file, 499 const DexFile::ClassDef& class_def) { 500 ScopedObjectAccess soa(self); 501 StackHandleScope<1> hs(soa.Self()); 502 Handle<mirror::ClassLoader> class_loader( 503 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 504 return GetDexToDexCompilationLevel(self, driver, class_loader, dex_file, class_def); 505} 506 507// Does the runtime for the InstructionSet provide an implementation returned by 508// GetQuickGenericJniStub allowing down calls that aren't compiled using a JNI compiler? 509static bool InstructionSetHasGenericJniStub(InstructionSet isa) { 510 switch (isa) { 511 case kArm: 512 case kArm64: 513 case kThumb2: 514 case kMips: 515 case kMips64: 516 case kX86: 517 case kX86_64: return true; 518 default: return false; 519 } 520} 521 522static void CompileMethod(Thread* self, 523 CompilerDriver* driver, 524 const DexFile::CodeItem* code_item, 525 uint32_t access_flags, 526 InvokeType invoke_type, 527 uint16_t class_def_idx, 528 uint32_t method_idx, 529 jobject class_loader, 530 const DexFile& dex_file, 531 optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level, 532 bool compilation_enabled, 533 Handle<mirror::DexCache> dex_cache) 534 REQUIRES(!driver->compiled_methods_lock_) { 535 DCHECK(driver != nullptr); 536 CompiledMethod* compiled_method = nullptr; 537 uint64_t start_ns = kTimeCompileMethod ? NanoTime() : 0; 538 MethodReference method_ref(&dex_file, method_idx); 539 540 if ((access_flags & kAccNative) != 0) { 541 // Are we interpreting only and have support for generic JNI down calls? 542 if (!driver->GetCompilerOptions().IsCompilationEnabled() && 543 InstructionSetHasGenericJniStub(driver->GetInstructionSet())) { 544 // Leaving this empty will trigger the generic JNI version 545 } else { 546 compiled_method = driver->GetCompiler()->JniCompile(access_flags, method_idx, dex_file); 547 CHECK(compiled_method != nullptr); 548 } 549 } else if ((access_flags & kAccAbstract) != 0) { 550 // Abstract methods don't have code. 551 } else { 552 const VerifiedMethod* verified_method = 553 driver->GetVerificationResults()->GetVerifiedMethod(method_ref); 554 bool compile = compilation_enabled && 555 // Basic checks, e.g., not <clinit>. 556 driver->GetVerificationResults() 557 ->IsCandidateForCompilation(method_ref, access_flags) && 558 // Did not fail to create VerifiedMethod metadata. 559 verified_method != nullptr && 560 // Do not have failures that should punt to the interpreter. 561 !verified_method->HasRuntimeThrow() && 562 (verified_method->GetEncounteredVerificationFailures() & 563 (verifier::VERIFY_ERROR_FORCE_INTERPRETER | verifier::VERIFY_ERROR_LOCKING)) == 0 && 564 // Is eligable for compilation by methods-to-compile filter. 565 driver->IsMethodToCompile(method_ref) && 566 driver->ShouldCompileBasedOnProfile(method_ref); 567 568 if (compile) { 569 // NOTE: if compiler declines to compile this method, it will return null. 570 compiled_method = driver->GetCompiler()->Compile(code_item, access_flags, invoke_type, 571 class_def_idx, method_idx, class_loader, 572 dex_file, dex_cache); 573 } 574 if (compiled_method == nullptr && 575 dex_to_dex_compilation_level != optimizer::DexToDexCompilationLevel::kDontDexToDexCompile) { 576 // TODO: add a command-line option to disable DEX-to-DEX compilation ? 577 // Do not optimize if a VerifiedMethod is missing. SafeCast elision, for example, relies on 578 // it. 579 compiled_method = optimizer::ArtCompileDEX( 580 driver, 581 code_item, 582 access_flags, 583 invoke_type, 584 class_def_idx, 585 method_idx, 586 class_loader, 587 dex_file, 588 (verified_method != nullptr) 589 ? dex_to_dex_compilation_level 590 : optimizer::DexToDexCompilationLevel::kRequired); 591 } 592 } 593 if (kTimeCompileMethod) { 594 uint64_t duration_ns = NanoTime() - start_ns; 595 if (duration_ns > MsToNs(driver->GetCompiler()->GetMaximumCompilationTimeBeforeWarning())) { 596 LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file) 597 << " took " << PrettyDuration(duration_ns); 598 } 599 } 600 601 if (compiled_method != nullptr) { 602 // Count non-relative linker patches. 603 size_t non_relative_linker_patch_count = 0u; 604 for (const LinkerPatch& patch : compiled_method->GetPatches()) { 605 if (!patch.IsPcRelative()) { 606 ++non_relative_linker_patch_count; 607 } 608 } 609 bool compile_pic = driver->GetCompilerOptions().GetCompilePic(); // Off by default 610 // When compiling with PIC, there should be zero non-relative linker patches 611 CHECK(!compile_pic || non_relative_linker_patch_count == 0u); 612 613 driver->AddCompiledMethod(method_ref, compiled_method, non_relative_linker_patch_count); 614 } 615 616 // Done compiling, delete the verified method to reduce native memory usage. Do not delete in 617 // optimizing compiler, which may need the verified method again for inlining. 618 if (driver->GetCompilerKind() != Compiler::kOptimizing) { 619 driver->GetVerificationResults()->RemoveVerifiedMethod(method_ref); 620 } 621 622 if (self->IsExceptionPending()) { 623 ScopedObjectAccess soa(self); 624 LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n" 625 << self->GetException()->Dump(); 626 } 627} 628 629void CompilerDriver::CompileOne(Thread* self, ArtMethod* method, TimingLogger* timings) { 630 DCHECK(!Runtime::Current()->IsStarted()); 631 jobject jclass_loader; 632 const DexFile* dex_file; 633 uint16_t class_def_idx; 634 uint32_t method_idx = method->GetDexMethodIndex(); 635 uint32_t access_flags = method->GetAccessFlags(); 636 InvokeType invoke_type = method->GetInvokeType(); 637 StackHandleScope<1> hs(self); 638 Handle<mirror::DexCache> dex_cache(hs.NewHandle(method->GetDexCache())); 639 { 640 ScopedObjectAccessUnchecked soa(self); 641 ScopedLocalRef<jobject> local_class_loader( 642 soa.Env(), soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader())); 643 jclass_loader = soa.Env()->NewGlobalRef(local_class_loader.get()); 644 // Find the dex_file 645 dex_file = method->GetDexFile(); 646 class_def_idx = method->GetClassDefIndex(); 647 } 648 const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset()); 649 650 // Go to native so that we don't block GC during compilation. 651 ScopedThreadSuspension sts(self, kNative); 652 653 std::vector<const DexFile*> dex_files; 654 dex_files.push_back(dex_file); 655 656 std::unique_ptr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", 0U)); 657 PreCompile(jclass_loader, dex_files, thread_pool.get(), timings); 658 659 // Can we run DEX-to-DEX compiler on this class ? 660 optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level = 661 GetDexToDexCompilationLevel(self, 662 *this, 663 jclass_loader, 664 *dex_file, 665 dex_file->GetClassDef(class_def_idx)); 666 667 CompileMethod(self, 668 this, 669 code_item, 670 access_flags, 671 invoke_type, 672 class_def_idx, 673 method_idx, 674 jclass_loader, 675 *dex_file, 676 dex_to_dex_compilation_level, 677 true, 678 dex_cache); 679 680 self->GetJniEnv()->DeleteGlobalRef(jclass_loader); 681} 682 683void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files, 684 ThreadPool* thread_pool, TimingLogger* timings) { 685 for (size_t i = 0; i != dex_files.size(); ++i) { 686 const DexFile* dex_file = dex_files[i]; 687 CHECK(dex_file != nullptr); 688 ResolveDexFile(class_loader, *dex_file, dex_files, thread_pool, timings); 689 } 690} 691 692void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 693 ThreadPool* thread_pool, TimingLogger* timings) { 694 LoadImageClasses(timings); 695 VLOG(compiler) << "LoadImageClasses: " << GetMemoryUsageString(false); 696 697 const bool verification_enabled = compiler_options_->IsVerificationEnabled(); 698 const bool never_verify = compiler_options_->NeverVerify(); 699 700 // We need to resolve for never_verify since it needs to run dex to dex to add the 701 // RETURN_VOID_NO_BARRIER. 702 if (never_verify || verification_enabled) { 703 Resolve(class_loader, dex_files, thread_pool, timings); 704 VLOG(compiler) << "Resolve: " << GetMemoryUsageString(false); 705 } 706 707 if (never_verify) { 708 VLOG(compiler) << "Verify none mode specified, skipping verification."; 709 SetVerified(class_loader, dex_files, thread_pool, timings); 710 } 711 712 if (!verification_enabled) { 713 return; 714 } 715 716 Verify(class_loader, dex_files, thread_pool, timings); 717 VLOG(compiler) << "Verify: " << GetMemoryUsageString(false); 718 719 if (had_hard_verifier_failure_ && GetCompilerOptions().AbortOnHardVerifierFailure()) { 720 LOG(FATAL) << "Had a hard failure verifying all classes, and was asked to abort in such " 721 << "situations. Please check the log."; 722 } 723 724 InitializeClasses(class_loader, dex_files, thread_pool, timings); 725 VLOG(compiler) << "InitializeClasses: " << GetMemoryUsageString(false); 726 727 UpdateImageClasses(timings); 728 VLOG(compiler) << "UpdateImageClasses: " << GetMemoryUsageString(false); 729} 730 731bool CompilerDriver::IsImageClass(const char* descriptor) const { 732 if (!IsBootImage()) { 733 // NOTE: Currently unreachable, all callers check IsImage(). 734 return false; 735 } else { 736 return image_classes_->find(descriptor) != image_classes_->end(); 737 } 738} 739 740bool CompilerDriver::IsClassToCompile(const char* descriptor) const { 741 if (kRestrictCompilationFiltersToImage && !IsBootImage()) { 742 return true; 743 } 744 745 if (classes_to_compile_ == nullptr) { 746 return true; 747 } 748 return classes_to_compile_->find(descriptor) != classes_to_compile_->end(); 749} 750 751bool CompilerDriver::IsMethodToCompile(const MethodReference& method_ref) const { 752 if (kRestrictCompilationFiltersToImage && !IsBootImage()) { 753 return true; 754 } 755 756 if (methods_to_compile_ == nullptr) { 757 return true; 758 } 759 760 std::string tmp = PrettyMethod(method_ref.dex_method_index, *method_ref.dex_file, true); 761 return methods_to_compile_->find(tmp.c_str()) != methods_to_compile_->end(); 762} 763 764bool CompilerDriver::ShouldCompileBasedOnProfile(const MethodReference& method_ref) const { 765 if (profile_compilation_info_ == nullptr) { 766 // If we miss profile information it means that we don't do a profile guided compilation. 767 // Return true, and let the other filters decide if the method should be compiled. 768 return true; 769 } 770 bool result = profile_compilation_info_->ContainsMethod(method_ref); 771 772 if (kDebugProfileGuidedCompilation) { 773 LOG(INFO) << "[ProfileGuidedCompilation] " 774 << (result ? "Compiled" : "Skipped") << " method:" 775 << PrettyMethod(method_ref.dex_method_index, *method_ref.dex_file, true); 776 } 777 return result; 778} 779 780class ResolveCatchBlockExceptionsClassVisitor : public ClassVisitor { 781 public: 782 ResolveCatchBlockExceptionsClassVisitor( 783 std::set<std::pair<uint16_t, const DexFile*>>& exceptions_to_resolve) 784 : exceptions_to_resolve_(exceptions_to_resolve) {} 785 786 virtual bool Visit(mirror::Class* c) OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) { 787 const auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); 788 for (auto& m : c->GetMethods(pointer_size)) { 789 ResolveExceptionsForMethod(&m, pointer_size); 790 } 791 return true; 792 } 793 794 private: 795 void ResolveExceptionsForMethod(ArtMethod* method_handle, size_t pointer_size) 796 SHARED_REQUIRES(Locks::mutator_lock_) { 797 const DexFile::CodeItem* code_item = method_handle->GetCodeItem(); 798 if (code_item == nullptr) { 799 return; // native or abstract method 800 } 801 if (code_item->tries_size_ == 0) { 802 return; // nothing to process 803 } 804 const uint8_t* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0); 805 size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list); 806 for (size_t i = 0; i < num_encoded_catch_handlers; i++) { 807 int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list); 808 bool has_catch_all = false; 809 if (encoded_catch_handler_size <= 0) { 810 encoded_catch_handler_size = -encoded_catch_handler_size; 811 has_catch_all = true; 812 } 813 for (int32_t j = 0; j < encoded_catch_handler_size; j++) { 814 uint16_t encoded_catch_handler_handlers_type_idx = 815 DecodeUnsignedLeb128(&encoded_catch_handler_list); 816 // Add to set of types to resolve if not already in the dex cache resolved types 817 if (!method_handle->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx, 818 pointer_size)) { 819 exceptions_to_resolve_.emplace(encoded_catch_handler_handlers_type_idx, 820 method_handle->GetDexFile()); 821 } 822 // ignore address associated with catch handler 823 DecodeUnsignedLeb128(&encoded_catch_handler_list); 824 } 825 if (has_catch_all) { 826 // ignore catch all address 827 DecodeUnsignedLeb128(&encoded_catch_handler_list); 828 } 829 } 830 } 831 832 std::set<std::pair<uint16_t, const DexFile*>>& exceptions_to_resolve_; 833}; 834 835class RecordImageClassesVisitor : public ClassVisitor { 836 public: 837 explicit RecordImageClassesVisitor(std::unordered_set<std::string>* image_classes) 838 : image_classes_(image_classes) {} 839 840 bool Visit(mirror::Class* klass) OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) { 841 std::string temp; 842 image_classes_->insert(klass->GetDescriptor(&temp)); 843 return true; 844 } 845 846 private: 847 std::unordered_set<std::string>* const image_classes_; 848}; 849 850// Make a list of descriptors for classes to include in the image 851void CompilerDriver::LoadImageClasses(TimingLogger* timings) { 852 CHECK(timings != nullptr); 853 if (!IsBootImage()) { 854 return; 855 } 856 857 TimingLogger::ScopedTiming t("LoadImageClasses", timings); 858 // Make a first class to load all classes explicitly listed in the file 859 Thread* self = Thread::Current(); 860 ScopedObjectAccess soa(self); 861 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 862 CHECK(image_classes_.get() != nullptr); 863 for (auto it = image_classes_->begin(), end = image_classes_->end(); it != end;) { 864 const std::string& descriptor(*it); 865 StackHandleScope<1> hs(self); 866 Handle<mirror::Class> klass( 867 hs.NewHandle(class_linker->FindSystemClass(self, descriptor.c_str()))); 868 if (klass.Get() == nullptr) { 869 VLOG(compiler) << "Failed to find class " << descriptor; 870 image_classes_->erase(it++); 871 self->ClearException(); 872 } else { 873 ++it; 874 } 875 } 876 877 // Resolve exception classes referenced by the loaded classes. The catch logic assumes 878 // exceptions are resolved by the verifier when there is a catch block in an interested method. 879 // Do this here so that exception classes appear to have been specified image classes. 880 std::set<std::pair<uint16_t, const DexFile*>> unresolved_exception_types; 881 StackHandleScope<1> hs(self); 882 Handle<mirror::Class> java_lang_Throwable( 883 hs.NewHandle(class_linker->FindSystemClass(self, "Ljava/lang/Throwable;"))); 884 do { 885 unresolved_exception_types.clear(); 886 ResolveCatchBlockExceptionsClassVisitor visitor(unresolved_exception_types); 887 class_linker->VisitClasses(&visitor); 888 for (const std::pair<uint16_t, const DexFile*>& exception_type : unresolved_exception_types) { 889 uint16_t exception_type_idx = exception_type.first; 890 const DexFile* dex_file = exception_type.second; 891 StackHandleScope<2> hs2(self); 892 Handle<mirror::DexCache> dex_cache(hs2.NewHandle(class_linker->RegisterDexFile( 893 *dex_file, 894 Runtime::Current()->GetLinearAlloc()))); 895 Handle<mirror::Class> klass(hs2.NewHandle( 896 class_linker->ResolveType(*dex_file, 897 exception_type_idx, 898 dex_cache, 899 ScopedNullHandle<mirror::ClassLoader>()))); 900 if (klass.Get() == nullptr) { 901 const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx); 902 const char* descriptor = dex_file->GetTypeDescriptor(type_id); 903 LOG(FATAL) << "Failed to resolve class " << descriptor; 904 } 905 DCHECK(java_lang_Throwable->IsAssignableFrom(klass.Get())); 906 } 907 // Resolving exceptions may load classes that reference more exceptions, iterate until no 908 // more are found 909 } while (!unresolved_exception_types.empty()); 910 911 // We walk the roots looking for classes so that we'll pick up the 912 // above classes plus any classes them depend on such super 913 // classes, interfaces, and the required ClassLinker roots. 914 RecordImageClassesVisitor visitor(image_classes_.get()); 915 class_linker->VisitClasses(&visitor); 916 917 CHECK_NE(image_classes_->size(), 0U); 918} 919 920static void MaybeAddToImageClasses(Handle<mirror::Class> c, 921 std::unordered_set<std::string>* image_classes) 922 SHARED_REQUIRES(Locks::mutator_lock_) { 923 Thread* self = Thread::Current(); 924 StackHandleScope<1> hs(self); 925 // Make a copy of the handle so that we don't clobber it doing Assign. 926 MutableHandle<mirror::Class> klass(hs.NewHandle(c.Get())); 927 std::string temp; 928 const size_t pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); 929 while (!klass->IsObjectClass()) { 930 const char* descriptor = klass->GetDescriptor(&temp); 931 std::pair<std::unordered_set<std::string>::iterator, bool> result = 932 image_classes->insert(descriptor); 933 if (!result.second) { // Previously inserted. 934 break; 935 } 936 VLOG(compiler) << "Adding " << descriptor << " to image classes"; 937 for (size_t i = 0; i < klass->NumDirectInterfaces(); ++i) { 938 StackHandleScope<1> hs2(self); 939 MaybeAddToImageClasses(hs2.NewHandle(mirror::Class::GetDirectInterface(self, klass, i)), 940 image_classes); 941 } 942 for (auto& m : c->GetVirtualMethods(pointer_size)) { 943 if (m.IsMiranda() || (true)) { 944 StackHandleScope<1> hs2(self); 945 MaybeAddToImageClasses(hs2.NewHandle(m.GetDeclaringClass()), image_classes); 946 } 947 } 948 if (klass->IsArrayClass()) { 949 StackHandleScope<1> hs2(self); 950 MaybeAddToImageClasses(hs2.NewHandle(klass->GetComponentType()), image_classes); 951 } 952 klass.Assign(klass->GetSuperClass()); 953 } 954} 955 956// Keeps all the data for the update together. Also doubles as the reference visitor. 957// Note: we can use object pointers because we suspend all threads. 958class ClinitImageUpdate { 959 public: 960 static ClinitImageUpdate* Create(std::unordered_set<std::string>* image_class_descriptors, 961 Thread* self, ClassLinker* linker, std::string* error_msg) { 962 std::unique_ptr<ClinitImageUpdate> res(new ClinitImageUpdate(image_class_descriptors, self, 963 linker)); 964 if (res->dex_cache_class_ == nullptr) { 965 *error_msg = "Could not find DexCache class."; 966 return nullptr; 967 } 968 969 return res.release(); 970 } 971 972 ~ClinitImageUpdate() { 973 // Allow others to suspend again. 974 self_->EndAssertNoThreadSuspension(old_cause_); 975 } 976 977 // Visitor for VisitReferences. 978 void operator()(mirror::Object* object, MemberOffset field_offset, bool /* is_static */) const 979 SHARED_REQUIRES(Locks::mutator_lock_) { 980 mirror::Object* ref = object->GetFieldObject<mirror::Object>(field_offset); 981 if (ref != nullptr) { 982 VisitClinitClassesObject(ref); 983 } 984 } 985 986 // java.lang.Reference visitor for VisitReferences. 987 void operator()(mirror::Class* klass ATTRIBUTE_UNUSED, mirror::Reference* ref ATTRIBUTE_UNUSED) 988 const {} 989 990 // Ignore class native roots. 991 void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) 992 const {} 993 void VisitRoot(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) const {} 994 995 void Walk() SHARED_REQUIRES(Locks::mutator_lock_) { 996 // Use the initial classes as roots for a search. 997 for (mirror::Class* klass_root : image_classes_) { 998 VisitClinitClassesObject(klass_root); 999 } 1000 } 1001 1002 private: 1003 class FindImageClassesVisitor : public ClassVisitor { 1004 public: 1005 explicit FindImageClassesVisitor(ClinitImageUpdate* data) : data_(data) {} 1006 1007 bool Visit(mirror::Class* klass) OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) { 1008 std::string temp; 1009 const char* name = klass->GetDescriptor(&temp); 1010 if (data_->image_class_descriptors_->find(name) != data_->image_class_descriptors_->end()) { 1011 data_->image_classes_.push_back(klass); 1012 } else { 1013 // Check whether it is initialized and has a clinit. They must be kept, too. 1014 if (klass->IsInitialized() && klass->FindClassInitializer( 1015 Runtime::Current()->GetClassLinker()->GetImagePointerSize()) != nullptr) { 1016 data_->image_classes_.push_back(klass); 1017 } 1018 } 1019 return true; 1020 } 1021 1022 private: 1023 ClinitImageUpdate* const data_; 1024 }; 1025 1026 ClinitImageUpdate(std::unordered_set<std::string>* image_class_descriptors, Thread* self, 1027 ClassLinker* linker) 1028 SHARED_REQUIRES(Locks::mutator_lock_) : 1029 image_class_descriptors_(image_class_descriptors), self_(self) { 1030 CHECK(linker != nullptr); 1031 CHECK(image_class_descriptors != nullptr); 1032 1033 // Make sure nobody interferes with us. 1034 old_cause_ = self->StartAssertNoThreadSuspension("Boot image closure"); 1035 1036 // Find the interesting classes. 1037 dex_cache_class_ = linker->LookupClass(self, "Ljava/lang/DexCache;", 1038 ComputeModifiedUtf8Hash("Ljava/lang/DexCache;"), nullptr); 1039 1040 // Find all the already-marked classes. 1041 WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); 1042 FindImageClassesVisitor visitor(this); 1043 linker->VisitClasses(&visitor); 1044 } 1045 1046 void VisitClinitClassesObject(mirror::Object* object) const 1047 SHARED_REQUIRES(Locks::mutator_lock_) { 1048 DCHECK(object != nullptr); 1049 if (marked_objects_.find(object) != marked_objects_.end()) { 1050 // Already processed. 1051 return; 1052 } 1053 1054 // Mark it. 1055 marked_objects_.insert(object); 1056 1057 if (object->IsClass()) { 1058 // If it is a class, add it. 1059 StackHandleScope<1> hs(self_); 1060 MaybeAddToImageClasses(hs.NewHandle(object->AsClass()), image_class_descriptors_); 1061 } else { 1062 // Else visit the object's class. 1063 VisitClinitClassesObject(object->GetClass()); 1064 } 1065 1066 // If it is not a DexCache, visit all references. 1067 mirror::Class* klass = object->GetClass(); 1068 if (klass != dex_cache_class_) { 1069 object->VisitReferences(*this, *this); 1070 } 1071 } 1072 1073 mutable std::unordered_set<mirror::Object*> marked_objects_; 1074 std::unordered_set<std::string>* const image_class_descriptors_; 1075 std::vector<mirror::Class*> image_classes_; 1076 const mirror::Class* dex_cache_class_; 1077 Thread* const self_; 1078 const char* old_cause_; 1079 1080 DISALLOW_COPY_AND_ASSIGN(ClinitImageUpdate); 1081}; 1082 1083void CompilerDriver::UpdateImageClasses(TimingLogger* timings) { 1084 if (IsBootImage()) { 1085 TimingLogger::ScopedTiming t("UpdateImageClasses", timings); 1086 1087 Runtime* runtime = Runtime::Current(); 1088 1089 // Suspend all threads. 1090 ScopedSuspendAll ssa(__FUNCTION__); 1091 1092 std::string error_msg; 1093 std::unique_ptr<ClinitImageUpdate> update(ClinitImageUpdate::Create(image_classes_.get(), 1094 Thread::Current(), 1095 runtime->GetClassLinker(), 1096 &error_msg)); 1097 CHECK(update.get() != nullptr) << error_msg; // TODO: Soft failure? 1098 1099 // Do the marking. 1100 update->Walk(); 1101 } 1102} 1103 1104bool CompilerDriver::CanAssumeClassIsLoaded(mirror::Class* klass) { 1105 Runtime* runtime = Runtime::Current(); 1106 if (!runtime->IsAotCompiler()) { 1107 DCHECK(runtime->UseJit()); 1108 // Having the klass reference here implies that the klass is already loaded. 1109 return true; 1110 } 1111 if (!IsBootImage()) { 1112 // Assume loaded only if klass is in the boot image. App classes cannot be assumed 1113 // loaded because we don't even know what class loader will be used to load them. 1114 bool class_in_image = runtime->GetHeap()->FindSpaceFromObject(klass, false)->IsImageSpace(); 1115 return class_in_image; 1116 } 1117 std::string temp; 1118 const char* descriptor = klass->GetDescriptor(&temp); 1119 return IsImageClass(descriptor); 1120} 1121 1122bool CompilerDriver::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx) { 1123 bool result = false; 1124 if ((IsBootImage() && 1125 IsImageClass(dex_file.StringDataByIdx(dex_file.GetTypeId(type_idx).descriptor_idx_))) || 1126 Runtime::Current()->UseJit()) { 1127 ScopedObjectAccess soa(Thread::Current()); 1128 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache( 1129 soa.Self(), dex_file, false); 1130 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 1131 result = (resolved_class != nullptr); 1132 } 1133 1134 if (result) { 1135 stats_->TypeInDexCache(); 1136 } else { 1137 stats_->TypeNotInDexCache(); 1138 } 1139 return result; 1140} 1141 1142bool CompilerDriver::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, 1143 uint32_t string_idx) { 1144 // See also Compiler::ResolveDexFile 1145 1146 bool result = false; 1147 if (IsBootImage() || Runtime::Current()->UseJit()) { 1148 ScopedObjectAccess soa(Thread::Current()); 1149 StackHandleScope<1> hs(soa.Self()); 1150 ClassLinker* const class_linker = Runtime::Current()->GetClassLinker(); 1151 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache( 1152 soa.Self(), dex_file, false))); 1153 if (IsBootImage()) { 1154 // We resolve all const-string strings when building for the image. 1155 class_linker->ResolveString(dex_file, string_idx, dex_cache); 1156 result = true; 1157 } else { 1158 // Just check whether the dex cache already has the string. 1159 DCHECK(Runtime::Current()->UseJit()); 1160 result = (dex_cache->GetResolvedString(string_idx) != nullptr); 1161 } 1162 } 1163 if (result) { 1164 stats_->StringInDexCache(); 1165 } else { 1166 stats_->StringNotInDexCache(); 1167 } 1168 return result; 1169} 1170 1171bool CompilerDriver::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, 1172 uint32_t type_idx, 1173 bool* type_known_final, bool* type_known_abstract, 1174 bool* equals_referrers_class) { 1175 if (type_known_final != nullptr) { 1176 *type_known_final = false; 1177 } 1178 if (type_known_abstract != nullptr) { 1179 *type_known_abstract = false; 1180 } 1181 if (equals_referrers_class != nullptr) { 1182 *equals_referrers_class = false; 1183 } 1184 ScopedObjectAccess soa(Thread::Current()); 1185 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache( 1186 soa.Self(), dex_file, false); 1187 // Get type from dex cache assuming it was populated by the verifier 1188 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 1189 if (resolved_class == nullptr) { 1190 stats_->TypeNeedsAccessCheck(); 1191 return false; // Unknown class needs access checks. 1192 } 1193 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx); 1194 if (equals_referrers_class != nullptr) { 1195 *equals_referrers_class = (method_id.class_idx_ == type_idx); 1196 } 1197 bool is_accessible = resolved_class->IsPublic(); // Public classes are always accessible. 1198 if (!is_accessible) { 1199 mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_); 1200 if (referrer_class == nullptr) { 1201 stats_->TypeNeedsAccessCheck(); 1202 return false; // Incomplete referrer knowledge needs access check. 1203 } 1204 // Perform access check, will return true if access is ok or false if we're going to have to 1205 // check this at runtime (for example for class loaders). 1206 is_accessible = referrer_class->CanAccess(resolved_class); 1207 } 1208 if (is_accessible) { 1209 stats_->TypeDoesntNeedAccessCheck(); 1210 if (type_known_final != nullptr) { 1211 *type_known_final = resolved_class->IsFinal() && !resolved_class->IsArrayClass(); 1212 } 1213 if (type_known_abstract != nullptr) { 1214 *type_known_abstract = resolved_class->IsAbstract() && !resolved_class->IsArrayClass(); 1215 } 1216 } else { 1217 stats_->TypeNeedsAccessCheck(); 1218 } 1219 return is_accessible; 1220} 1221 1222bool CompilerDriver::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, 1223 const DexFile& dex_file, 1224 uint32_t type_idx, 1225 bool* finalizable) { 1226 ScopedObjectAccess soa(Thread::Current()); 1227 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache( 1228 soa.Self(), dex_file, false); 1229 // Get type from dex cache assuming it was populated by the verifier. 1230 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 1231 if (resolved_class == nullptr) { 1232 stats_->TypeNeedsAccessCheck(); 1233 // Be conservative. 1234 *finalizable = true; 1235 return false; // Unknown class needs access checks. 1236 } 1237 *finalizable = resolved_class->IsFinalizable(); 1238 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx); 1239 bool is_accessible = resolved_class->IsPublic(); // Public classes are always accessible. 1240 if (!is_accessible) { 1241 mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_); 1242 if (referrer_class == nullptr) { 1243 stats_->TypeNeedsAccessCheck(); 1244 return false; // Incomplete referrer knowledge needs access check. 1245 } 1246 // Perform access and instantiable checks, will return true if access is ok or false if we're 1247 // going to have to check this at runtime (for example for class loaders). 1248 is_accessible = referrer_class->CanAccess(resolved_class); 1249 } 1250 bool result = is_accessible && resolved_class->IsInstantiable(); 1251 if (result) { 1252 stats_->TypeDoesntNeedAccessCheck(); 1253 } else { 1254 stats_->TypeNeedsAccessCheck(); 1255 } 1256 return result; 1257} 1258 1259bool CompilerDriver::CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx, 1260 bool* is_type_initialized, bool* use_direct_type_ptr, 1261 uintptr_t* direct_type_ptr, bool* out_is_finalizable) { 1262 ScopedObjectAccess soa(Thread::Current()); 1263 Runtime* runtime = Runtime::Current(); 1264 mirror::DexCache* dex_cache = runtime->GetClassLinker()->FindDexCache( 1265 soa.Self(), dex_file, false); 1266 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 1267 if (resolved_class == nullptr) { 1268 return false; 1269 } 1270 if (GetCompilerOptions().GetCompilePic()) { 1271 // Do not allow a direct class pointer to be used when compiling for position-independent 1272 return false; 1273 } 1274 *out_is_finalizable = resolved_class->IsFinalizable(); 1275 gc::Heap* heap = runtime->GetHeap(); 1276 const bool compiling_boot = heap->IsCompilingBoot(); 1277 const bool support_boot_image_fixup = GetSupportBootImageFixup(); 1278 if (compiling_boot) { 1279 // boot -> boot class pointers. 1280 // True if the class is in the image at boot compiling time. 1281 const bool is_image_class = IsBootImage() && IsImageClass( 1282 dex_file.StringDataByIdx(dex_file.GetTypeId(type_idx).descriptor_idx_)); 1283 // True if pc relative load works. 1284 if (is_image_class && support_boot_image_fixup) { 1285 *is_type_initialized = resolved_class->IsInitialized(); 1286 *use_direct_type_ptr = false; 1287 *direct_type_ptr = 0; 1288 return true; 1289 } else { 1290 return false; 1291 } 1292 } else if (runtime->UseJit() && !heap->IsMovableObject(resolved_class)) { 1293 *is_type_initialized = resolved_class->IsInitialized(); 1294 // If the class may move around, then don't embed it as a direct pointer. 1295 *use_direct_type_ptr = true; 1296 *direct_type_ptr = reinterpret_cast<uintptr_t>(resolved_class); 1297 return true; 1298 } else { 1299 // True if the class is in the image at app compiling time. 1300 const bool class_in_image = heap->FindSpaceFromObject(resolved_class, false)->IsImageSpace(); 1301 if (class_in_image && support_boot_image_fixup) { 1302 // boot -> app class pointers. 1303 *is_type_initialized = resolved_class->IsInitialized(); 1304 // TODO This is somewhat hacky. We should refactor all of this invoke codepath. 1305 *use_direct_type_ptr = !GetCompilerOptions().GetIncludePatchInformation(); 1306 *direct_type_ptr = reinterpret_cast<uintptr_t>(resolved_class); 1307 return true; 1308 } else { 1309 // app -> app class pointers. 1310 // Give up because app does not have an image and class 1311 // isn't created at compile time. TODO: implement this 1312 // if/when each app gets an image. 1313 return false; 1314 } 1315 } 1316} 1317 1318bool CompilerDriver::CanEmbedReferenceTypeInCode(ClassReference* ref, 1319 bool* use_direct_ptr, 1320 uintptr_t* direct_type_ptr) { 1321 CHECK(ref != nullptr); 1322 CHECK(use_direct_ptr != nullptr); 1323 CHECK(direct_type_ptr != nullptr); 1324 1325 ScopedObjectAccess soa(Thread::Current()); 1326 mirror::Class* reference_class = mirror::Reference::GetJavaLangRefReference(); 1327 bool is_initialized = false; 1328 bool unused_finalizable; 1329 // Make sure we have a finished Reference class object before attempting to use it. 1330 if (!CanEmbedTypeInCode(*reference_class->GetDexCache()->GetDexFile(), 1331 reference_class->GetDexTypeIndex(), &is_initialized, 1332 use_direct_ptr, direct_type_ptr, &unused_finalizable) || 1333 !is_initialized) { 1334 return false; 1335 } 1336 ref->first = &reference_class->GetDexFile(); 1337 ref->second = reference_class->GetDexClassDefIndex(); 1338 return true; 1339} 1340 1341uint32_t CompilerDriver::GetReferenceSlowFlagOffset() const { 1342 ScopedObjectAccess soa(Thread::Current()); 1343 mirror::Class* klass = mirror::Reference::GetJavaLangRefReference(); 1344 DCHECK(klass->IsInitialized()); 1345 return klass->GetSlowPathFlagOffset().Uint32Value(); 1346} 1347 1348uint32_t CompilerDriver::GetReferenceDisableFlagOffset() const { 1349 ScopedObjectAccess soa(Thread::Current()); 1350 mirror::Class* klass = mirror::Reference::GetJavaLangRefReference(); 1351 DCHECK(klass->IsInitialized()); 1352 return klass->GetDisableIntrinsicFlagOffset().Uint32Value(); 1353} 1354 1355DexCacheArraysLayout CompilerDriver::GetDexCacheArraysLayout(const DexFile* dex_file) { 1356 return ContainsElement(GetDexFilesForOatFile(), dex_file) 1357 ? DexCacheArraysLayout(GetInstructionSetPointerSize(instruction_set_), dex_file) 1358 : DexCacheArraysLayout(); 1359} 1360 1361void CompilerDriver::ProcessedInstanceField(bool resolved) { 1362 if (!resolved) { 1363 stats_->UnresolvedInstanceField(); 1364 } else { 1365 stats_->ResolvedInstanceField(); 1366 } 1367} 1368 1369void CompilerDriver::ProcessedStaticField(bool resolved, bool local) { 1370 if (!resolved) { 1371 stats_->UnresolvedStaticField(); 1372 } else if (local) { 1373 stats_->ResolvedLocalStaticField(); 1374 } else { 1375 stats_->ResolvedStaticField(); 1376 } 1377} 1378 1379void CompilerDriver::ProcessedInvoke(InvokeType invoke_type, int flags) { 1380 stats_->ProcessedInvoke(invoke_type, flags); 1381} 1382 1383ArtField* CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, 1384 const DexCompilationUnit* mUnit, bool is_put, 1385 const ScopedObjectAccess& soa) { 1386 // Try to resolve the field and compiling method's class. 1387 ArtField* resolved_field; 1388 mirror::Class* referrer_class; 1389 Handle<mirror::DexCache> dex_cache(mUnit->GetDexCache()); 1390 { 1391 StackHandleScope<1> hs(soa.Self()); 1392 Handle<mirror::ClassLoader> class_loader_handle( 1393 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()))); 1394 resolved_field = ResolveField(soa, dex_cache, class_loader_handle, mUnit, field_idx, false); 1395 referrer_class = resolved_field != nullptr 1396 ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader_handle, mUnit) : nullptr; 1397 } 1398 bool can_link = false; 1399 if (resolved_field != nullptr && referrer_class != nullptr) { 1400 std::pair<bool, bool> fast_path = IsFastInstanceField( 1401 dex_cache.Get(), referrer_class, resolved_field, field_idx); 1402 can_link = is_put ? fast_path.second : fast_path.first; 1403 } 1404 ProcessedInstanceField(can_link); 1405 return can_link ? resolved_field : nullptr; 1406} 1407 1408bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, 1409 bool is_put, MemberOffset* field_offset, 1410 bool* is_volatile) { 1411 ScopedObjectAccess soa(Thread::Current()); 1412 ArtField* resolved_field = ComputeInstanceFieldInfo(field_idx, mUnit, is_put, soa); 1413 1414 if (resolved_field == nullptr) { 1415 // Conservative defaults. 1416 *is_volatile = true; 1417 *field_offset = MemberOffset(static_cast<size_t>(-1)); 1418 return false; 1419 } else { 1420 *is_volatile = resolved_field->IsVolatile(); 1421 *field_offset = resolved_field->GetOffset(); 1422 return true; 1423 } 1424} 1425 1426bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, 1427 bool is_put, MemberOffset* field_offset, 1428 uint32_t* storage_index, bool* is_referrers_class, 1429 bool* is_volatile, bool* is_initialized, 1430 Primitive::Type* type) { 1431 ScopedObjectAccess soa(Thread::Current()); 1432 // Try to resolve the field and compiling method's class. 1433 ArtField* resolved_field; 1434 mirror::Class* referrer_class; 1435 Handle<mirror::DexCache> dex_cache(mUnit->GetDexCache()); 1436 { 1437 StackHandleScope<1> hs(soa.Self()); 1438 Handle<mirror::ClassLoader> class_loader_handle( 1439 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()))); 1440 resolved_field = 1441 ResolveField(soa, dex_cache, class_loader_handle, mUnit, field_idx, true); 1442 referrer_class = resolved_field != nullptr 1443 ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader_handle, mUnit) : nullptr; 1444 } 1445 bool result = false; 1446 if (resolved_field != nullptr && referrer_class != nullptr) { 1447 *is_volatile = IsFieldVolatile(resolved_field); 1448 std::pair<bool, bool> fast_path = IsFastStaticField( 1449 dex_cache.Get(), referrer_class, resolved_field, field_idx, storage_index); 1450 result = is_put ? fast_path.second : fast_path.first; 1451 } 1452 if (result) { 1453 *field_offset = GetFieldOffset(resolved_field); 1454 *is_referrers_class = IsStaticFieldInReferrerClass(referrer_class, resolved_field); 1455 // *is_referrers_class == true implies no worrying about class initialization. 1456 *is_initialized = (*is_referrers_class) || 1457 (IsStaticFieldsClassInitialized(referrer_class, resolved_field) && 1458 CanAssumeTypeIsPresentInDexCache(*mUnit->GetDexFile(), *storage_index)); 1459 *type = resolved_field->GetTypeAsPrimitiveType(); 1460 } else { 1461 // Conservative defaults. 1462 *is_volatile = true; 1463 *field_offset = MemberOffset(static_cast<size_t>(-1)); 1464 *storage_index = -1; 1465 *is_referrers_class = false; 1466 *is_initialized = false; 1467 *type = Primitive::kPrimVoid; 1468 } 1469 ProcessedStaticField(result, *is_referrers_class); 1470 return result; 1471} 1472 1473void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type, 1474 bool no_guarantee_of_dex_cache_entry, 1475 const mirror::Class* referrer_class, 1476 ArtMethod* method, 1477 int* stats_flags, 1478 MethodReference* target_method, 1479 uintptr_t* direct_code, 1480 uintptr_t* direct_method) { 1481 // For direct and static methods compute possible direct_code and direct_method values, ie 1482 // an address for the Method* being invoked and an address of the code for that Method*. 1483 // For interface calls compute a value for direct_method that is the interface method being 1484 // invoked, so this can be passed to the out-of-line runtime support code. 1485 *direct_code = 0; 1486 *direct_method = 0; 1487 Runtime* const runtime = Runtime::Current(); 1488 gc::Heap* const heap = runtime->GetHeap(); 1489 auto* cl = runtime->GetClassLinker(); 1490 const auto pointer_size = cl->GetImagePointerSize(); 1491 bool use_dex_cache = GetCompilerOptions().GetCompilePic(); // Off by default 1492 const bool compiling_boot = heap->IsCompilingBoot(); 1493 // TODO This is somewhat hacky. We should refactor all of this invoke codepath. 1494 const bool force_relocations = (compiling_boot || 1495 GetCompilerOptions().GetIncludePatchInformation()); 1496 if (sharp_type != kStatic && sharp_type != kDirect) { 1497 return; 1498 } 1499 // TODO: support patching on all architectures. 1500 use_dex_cache = use_dex_cache || (force_relocations && !support_boot_image_fixup_); 1501 mirror::Class* declaring_class = method->GetDeclaringClass(); 1502 bool method_code_in_boot = declaring_class->GetClassLoader() == nullptr; 1503 if (!use_dex_cache) { 1504 if (!method_code_in_boot) { 1505 use_dex_cache = true; 1506 } else { 1507 bool has_clinit_trampoline = 1508 method->IsStatic() && !declaring_class->IsInitialized(); 1509 if (has_clinit_trampoline && declaring_class != referrer_class) { 1510 // Ensure we run the clinit trampoline unless we are invoking a static method in the same 1511 // class. 1512 use_dex_cache = true; 1513 } 1514 } 1515 } 1516 if (runtime->UseJit()) { 1517 // If we are the JIT, then don't allow a direct call to the interpreter bridge since this will 1518 // never be updated even after we compile the method. 1519 if (cl->IsQuickToInterpreterBridge( 1520 reinterpret_cast<const void*>(compiler_->GetEntryPointOf(method)))) { 1521 use_dex_cache = true; 1522 } 1523 } 1524 if (method_code_in_boot) { 1525 *stats_flags |= kFlagDirectCallToBoot | kFlagDirectMethodToBoot; 1526 } 1527 if (!use_dex_cache && force_relocations) { 1528 bool is_in_image; 1529 if (IsBootImage()) { 1530 is_in_image = IsImageClass(method->GetDeclaringClassDescriptor()); 1531 } else { 1532 is_in_image = instruction_set_ != kX86 && instruction_set_ != kX86_64 && 1533 heap->FindSpaceFromObject(method->GetDeclaringClass(), false)->IsImageSpace() && 1534 !cl->IsQuickToInterpreterBridge( 1535 reinterpret_cast<const void*>(compiler_->GetEntryPointOf(method))); 1536 } 1537 if (!is_in_image) { 1538 // We can only branch directly to Methods that are resolved in the DexCache. 1539 // Otherwise we won't invoke the resolution trampoline. 1540 use_dex_cache = true; 1541 } 1542 } 1543 if (!use_dex_cache && IsBootImage()) { 1544 if (!AreInSameOatFile(&(const_cast<mirror::Class*>(referrer_class)->GetDexFile()), 1545 &declaring_class->GetDexFile())) { 1546 use_dex_cache = true; 1547 } 1548 } 1549 // The method is defined not within this dex file. We need a dex cache slot within the current 1550 // dex file or direct pointers. 1551 bool must_use_direct_pointers = false; 1552 mirror::DexCache* dex_cache = declaring_class->GetDexCache(); 1553 if (target_method->dex_file == dex_cache->GetDexFile() && 1554 !(runtime->UseJit() && dex_cache->GetResolvedMethod( 1555 method->GetDexMethodIndex(), pointer_size) == nullptr)) { 1556 target_method->dex_method_index = method->GetDexMethodIndex(); 1557 } else { 1558 if (no_guarantee_of_dex_cache_entry) { 1559 // See if the method is also declared in this dex cache. 1560 uint32_t dex_method_idx = method->FindDexMethodIndexInOtherDexFile( 1561 *target_method->dex_file, target_method->dex_method_index); 1562 if (dex_method_idx != DexFile::kDexNoIndex) { 1563 target_method->dex_method_index = dex_method_idx; 1564 } else { 1565 if (force_relocations && !use_dex_cache) { 1566 target_method->dex_method_index = method->GetDexMethodIndex(); 1567 target_method->dex_file = dex_cache->GetDexFile(); 1568 } 1569 must_use_direct_pointers = true; 1570 } 1571 } 1572 } 1573 if (use_dex_cache) { 1574 if (must_use_direct_pointers) { 1575 // Fail. Test above showed the only safe dispatch was via the dex cache, however, the direct 1576 // pointers are required as the dex cache lacks an appropriate entry. 1577 VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method); 1578 } else { 1579 *type = sharp_type; 1580 } 1581 } else { 1582 bool method_in_image = false; 1583 const std::vector<gc::space::ImageSpace*> image_spaces = heap->GetBootImageSpaces(); 1584 for (gc::space::ImageSpace* image_space : image_spaces) { 1585 const auto& method_section = image_space->GetImageHeader().GetMethodsSection(); 1586 if (method_section.Contains(reinterpret_cast<uint8_t*>(method) - image_space->Begin())) { 1587 method_in_image = true; 1588 break; 1589 } 1590 } 1591 if (method_in_image || compiling_boot || runtime->UseJit()) { 1592 // We know we must be able to get to the method in the image, so use that pointer. 1593 // In the case where we are the JIT, we can always use direct pointers since we know where 1594 // the method and its code are / will be. We don't sharpen to interpreter bridge since we 1595 // check IsQuickToInterpreterBridge above. 1596 CHECK(!method->IsAbstract()); 1597 *type = sharp_type; 1598 *direct_method = force_relocations ? -1 : reinterpret_cast<uintptr_t>(method); 1599 *direct_code = force_relocations ? -1 : compiler_->GetEntryPointOf(method); 1600 target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile(); 1601 target_method->dex_method_index = method->GetDexMethodIndex(); 1602 } else if (!must_use_direct_pointers) { 1603 // Set the code and rely on the dex cache for the method. 1604 *type = sharp_type; 1605 if (force_relocations) { 1606 *direct_code = -1; 1607 target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile(); 1608 target_method->dex_method_index = method->GetDexMethodIndex(); 1609 } else { 1610 *direct_code = compiler_->GetEntryPointOf(method); 1611 } 1612 } else { 1613 // Direct pointers were required but none were available. 1614 VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method); 1615 } 1616 } 1617} 1618 1619bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc, 1620 bool update_stats, bool enable_devirtualization, 1621 InvokeType* invoke_type, MethodReference* target_method, 1622 int* vtable_idx, uintptr_t* direct_code, 1623 uintptr_t* direct_method) { 1624 InvokeType orig_invoke_type = *invoke_type; 1625 int stats_flags = 0; 1626 ScopedObjectAccess soa(Thread::Current()); 1627 // Try to resolve the method and compiling method's class. 1628 StackHandleScope<2> hs(soa.Self()); 1629 Handle<mirror::DexCache> dex_cache(mUnit->GetDexCache()); 1630 Handle<mirror::ClassLoader> class_loader(hs.NewHandle( 1631 soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()))); 1632 uint32_t method_idx = target_method->dex_method_index; 1633 ArtMethod* resolved_method = ResolveMethod( 1634 soa, dex_cache, class_loader, mUnit, method_idx, orig_invoke_type); 1635 auto h_referrer_class = hs.NewHandle(resolved_method != nullptr ? 1636 ResolveCompilingMethodsClass(soa, dex_cache, class_loader, mUnit) : nullptr); 1637 bool result = false; 1638 if (resolved_method != nullptr) { 1639 *vtable_idx = GetResolvedMethodVTableIndex(resolved_method, orig_invoke_type); 1640 1641 if (enable_devirtualization && mUnit->GetVerifiedMethod() != nullptr) { 1642 const MethodReference* devirt_target = mUnit->GetVerifiedMethod()->GetDevirtTarget(dex_pc); 1643 1644 stats_flags = IsFastInvoke( 1645 soa, dex_cache, class_loader, mUnit, h_referrer_class.Get(), resolved_method, 1646 invoke_type, target_method, devirt_target, direct_code, direct_method); 1647 result = stats_flags != 0; 1648 } else { 1649 // Devirtualization not enabled. Inline IsFastInvoke(), dropping the devirtualization parts. 1650 if (UNLIKELY(h_referrer_class.Get() == nullptr) || 1651 UNLIKELY(!h_referrer_class->CanAccessResolvedMethod(resolved_method->GetDeclaringClass(), 1652 resolved_method, dex_cache.Get(), 1653 target_method->dex_method_index)) || 1654 *invoke_type == kSuper) { 1655 // Slow path. (Without devirtualization, all super calls go slow path as well.) 1656 } else { 1657 // Sharpening failed so generate a regular resolved method dispatch. 1658 stats_flags = kFlagMethodResolved; 1659 GetCodeAndMethodForDirectCall( 1660 invoke_type, *invoke_type, false, h_referrer_class.Get(), resolved_method, &stats_flags, 1661 target_method, direct_code, direct_method); 1662 result = true; 1663 } 1664 } 1665 } 1666 if (!result) { 1667 // Conservative defaults. 1668 *vtable_idx = -1; 1669 *direct_code = 0u; 1670 *direct_method = 0u; 1671 } 1672 if (update_stats) { 1673 ProcessedInvoke(orig_invoke_type, stats_flags); 1674 } 1675 return result; 1676} 1677 1678const VerifiedMethod* CompilerDriver::GetVerifiedMethod(const DexFile* dex_file, 1679 uint32_t method_idx) const { 1680 MethodReference ref(dex_file, method_idx); 1681 return verification_results_->GetVerifiedMethod(ref); 1682} 1683 1684bool CompilerDriver::IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc) { 1685 if (!compiler_options_->IsVerificationEnabled()) { 1686 // If we didn't verify, every cast has to be treated as non-safe. 1687 return false; 1688 } 1689 DCHECK(mUnit->GetVerifiedMethod() != nullptr); 1690 bool result = mUnit->GetVerifiedMethod()->IsSafeCast(dex_pc); 1691 if (result) { 1692 stats_->SafeCast(); 1693 } else { 1694 stats_->NotASafeCast(); 1695 } 1696 return result; 1697} 1698 1699class CompilationVisitor { 1700 public: 1701 virtual ~CompilationVisitor() {} 1702 virtual void Visit(size_t index) = 0; 1703}; 1704 1705class ParallelCompilationManager { 1706 public: 1707 ParallelCompilationManager(ClassLinker* class_linker, 1708 jobject class_loader, 1709 CompilerDriver* compiler, 1710 const DexFile* dex_file, 1711 const std::vector<const DexFile*>& dex_files, 1712 ThreadPool* thread_pool) 1713 : index_(0), 1714 class_linker_(class_linker), 1715 class_loader_(class_loader), 1716 compiler_(compiler), 1717 dex_file_(dex_file), 1718 dex_files_(dex_files), 1719 thread_pool_(thread_pool) {} 1720 1721 ClassLinker* GetClassLinker() const { 1722 CHECK(class_linker_ != nullptr); 1723 return class_linker_; 1724 } 1725 1726 jobject GetClassLoader() const { 1727 return class_loader_; 1728 } 1729 1730 CompilerDriver* GetCompiler() const { 1731 CHECK(compiler_ != nullptr); 1732 return compiler_; 1733 } 1734 1735 const DexFile* GetDexFile() const { 1736 CHECK(dex_file_ != nullptr); 1737 return dex_file_; 1738 } 1739 1740 const std::vector<const DexFile*>& GetDexFiles() const { 1741 return dex_files_; 1742 } 1743 1744 void ForAll(size_t begin, size_t end, CompilationVisitor* visitor, size_t work_units) 1745 REQUIRES(!*Locks::mutator_lock_) { 1746 Thread* self = Thread::Current(); 1747 self->AssertNoPendingException(); 1748 CHECK_GT(work_units, 0U); 1749 1750 index_.StoreRelaxed(begin); 1751 for (size_t i = 0; i < work_units; ++i) { 1752 thread_pool_->AddTask(self, new ForAllClosure(this, end, visitor)); 1753 } 1754 thread_pool_->StartWorkers(self); 1755 1756 // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker 1757 // thread destructor's called below perform join). 1758 CHECK_NE(self->GetState(), kRunnable); 1759 1760 // Wait for all the worker threads to finish. 1761 thread_pool_->Wait(self, true, false); 1762 } 1763 1764 size_t NextIndex() { 1765 return index_.FetchAndAddSequentiallyConsistent(1); 1766 } 1767 1768 private: 1769 class ForAllClosure : public Task { 1770 public: 1771 ForAllClosure(ParallelCompilationManager* manager, size_t end, CompilationVisitor* visitor) 1772 : manager_(manager), 1773 end_(end), 1774 visitor_(visitor) {} 1775 1776 virtual void Run(Thread* self) { 1777 while (true) { 1778 const size_t index = manager_->NextIndex(); 1779 if (UNLIKELY(index >= end_)) { 1780 break; 1781 } 1782 visitor_->Visit(index); 1783 self->AssertNoPendingException(); 1784 } 1785 } 1786 1787 virtual void Finalize() { 1788 delete this; 1789 } 1790 1791 private: 1792 ParallelCompilationManager* const manager_; 1793 const size_t end_; 1794 CompilationVisitor* const visitor_; 1795 }; 1796 1797 AtomicInteger index_; 1798 ClassLinker* const class_linker_; 1799 const jobject class_loader_; 1800 CompilerDriver* const compiler_; 1801 const DexFile* const dex_file_; 1802 const std::vector<const DexFile*>& dex_files_; 1803 ThreadPool* const thread_pool_; 1804 1805 DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager); 1806}; 1807 1808// A fast version of SkipClass above if the class pointer is available 1809// that avoids the expensive FindInClassPath search. 1810static bool SkipClass(jobject class_loader, const DexFile& dex_file, mirror::Class* klass) 1811 SHARED_REQUIRES(Locks::mutator_lock_) { 1812 DCHECK(klass != nullptr); 1813 const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile(); 1814 if (&dex_file != &original_dex_file) { 1815 if (class_loader == nullptr) { 1816 LOG(WARNING) << "Skipping class " << PrettyDescriptor(klass) << " from " 1817 << dex_file.GetLocation() << " previously found in " 1818 << original_dex_file.GetLocation(); 1819 } 1820 return true; 1821 } 1822 return false; 1823} 1824 1825static void CheckAndClearResolveException(Thread* self) 1826 SHARED_REQUIRES(Locks::mutator_lock_) { 1827 CHECK(self->IsExceptionPending()); 1828 mirror::Throwable* exception = self->GetException(); 1829 std::string temp; 1830 const char* descriptor = exception->GetClass()->GetDescriptor(&temp); 1831 const char* expected_exceptions[] = { 1832 "Ljava/lang/IllegalAccessError;", 1833 "Ljava/lang/IncompatibleClassChangeError;", 1834 "Ljava/lang/InstantiationError;", 1835 "Ljava/lang/LinkageError;", 1836 "Ljava/lang/NoClassDefFoundError;", 1837 "Ljava/lang/NoSuchFieldError;", 1838 "Ljava/lang/NoSuchMethodError;" 1839 }; 1840 bool found = false; 1841 for (size_t i = 0; (found == false) && (i < arraysize(expected_exceptions)); ++i) { 1842 if (strcmp(descriptor, expected_exceptions[i]) == 0) { 1843 found = true; 1844 } 1845 } 1846 if (!found) { 1847 LOG(FATAL) << "Unexpected exception " << exception->Dump(); 1848 } 1849 self->ClearException(); 1850} 1851 1852class ResolveClassFieldsAndMethodsVisitor : public CompilationVisitor { 1853 public: 1854 explicit ResolveClassFieldsAndMethodsVisitor(const ParallelCompilationManager* manager) 1855 : manager_(manager) {} 1856 1857 void Visit(size_t class_def_index) OVERRIDE REQUIRES(!Locks::mutator_lock_) { 1858 ATRACE_CALL(); 1859 Thread* const self = Thread::Current(); 1860 jobject jclass_loader = manager_->GetClassLoader(); 1861 const DexFile& dex_file = *manager_->GetDexFile(); 1862 ClassLinker* class_linker = manager_->GetClassLinker(); 1863 1864 // If an instance field is final then we need to have a barrier on the return, static final 1865 // fields are assigned within the lock held for class initialization. Conservatively assume 1866 // constructor barriers are always required. 1867 bool requires_constructor_barrier = true; 1868 1869 // Method and Field are the worst. We can't resolve without either 1870 // context from the code use (to disambiguate virtual vs direct 1871 // method and instance vs static field) or from class 1872 // definitions. While the compiler will resolve what it can as it 1873 // needs it, here we try to resolve fields and methods used in class 1874 // definitions, since many of them many never be referenced by 1875 // generated code. 1876 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1877 ScopedObjectAccess soa(self); 1878 StackHandleScope<2> hs(soa.Self()); 1879 Handle<mirror::ClassLoader> class_loader( 1880 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 1881 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache( 1882 soa.Self(), dex_file, false))); 1883 // Resolve the class. 1884 mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache, 1885 class_loader); 1886 bool resolve_fields_and_methods; 1887 if (klass == nullptr) { 1888 // Class couldn't be resolved, for example, super-class is in a different dex file. Don't 1889 // attempt to resolve methods and fields when there is no declaring class. 1890 CheckAndClearResolveException(soa.Self()); 1891 resolve_fields_and_methods = false; 1892 } else { 1893 // We successfully resolved a class, should we skip it? 1894 if (SkipClass(jclass_loader, dex_file, klass)) { 1895 return; 1896 } 1897 // We want to resolve the methods and fields eagerly. 1898 resolve_fields_and_methods = true; 1899 } 1900 // Note the class_data pointer advances through the headers, 1901 // static fields, instance fields, direct methods, and virtual 1902 // methods. 1903 const uint8_t* class_data = dex_file.GetClassData(class_def); 1904 if (class_data == nullptr) { 1905 // Empty class such as a marker interface. 1906 requires_constructor_barrier = false; 1907 } else { 1908 ClassDataItemIterator it(dex_file, class_data); 1909 while (it.HasNextStaticField()) { 1910 if (resolve_fields_and_methods) { 1911 ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), 1912 dex_cache, class_loader, true); 1913 if (field == nullptr) { 1914 CheckAndClearResolveException(soa.Self()); 1915 } 1916 } 1917 it.Next(); 1918 } 1919 // We require a constructor barrier if there are final instance fields. 1920 requires_constructor_barrier = false; 1921 while (it.HasNextInstanceField()) { 1922 if (it.MemberIsFinal()) { 1923 requires_constructor_barrier = true; 1924 } 1925 if (resolve_fields_and_methods) { 1926 ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), 1927 dex_cache, class_loader, false); 1928 if (field == nullptr) { 1929 CheckAndClearResolveException(soa.Self()); 1930 } 1931 } 1932 it.Next(); 1933 } 1934 if (resolve_fields_and_methods) { 1935 while (it.HasNextDirectMethod()) { 1936 ArtMethod* method = class_linker->ResolveMethod<ClassLinker::kNoICCECheckForCache>( 1937 dex_file, it.GetMemberIndex(), dex_cache, class_loader, nullptr, 1938 it.GetMethodInvokeType(class_def)); 1939 if (method == nullptr) { 1940 CheckAndClearResolveException(soa.Self()); 1941 } 1942 it.Next(); 1943 } 1944 while (it.HasNextVirtualMethod()) { 1945 ArtMethod* method = class_linker->ResolveMethod<ClassLinker::kNoICCECheckForCache>( 1946 dex_file, it.GetMemberIndex(), dex_cache, class_loader, nullptr, 1947 it.GetMethodInvokeType(class_def)); 1948 if (method == nullptr) { 1949 CheckAndClearResolveException(soa.Self()); 1950 } 1951 it.Next(); 1952 } 1953 DCHECK(!it.HasNext()); 1954 } 1955 } 1956 if (requires_constructor_barrier) { 1957 manager_->GetCompiler()->AddRequiresConstructorBarrier(self, &dex_file, class_def_index); 1958 } 1959 } 1960 1961 private: 1962 const ParallelCompilationManager* const manager_; 1963}; 1964 1965class ResolveTypeVisitor : public CompilationVisitor { 1966 public: 1967 explicit ResolveTypeVisitor(const ParallelCompilationManager* manager) : manager_(manager) { 1968 } 1969 virtual void Visit(size_t type_idx) OVERRIDE REQUIRES(!Locks::mutator_lock_) { 1970 // Class derived values are more complicated, they require the linker and loader. 1971 ScopedObjectAccess soa(Thread::Current()); 1972 ClassLinker* class_linker = manager_->GetClassLinker(); 1973 const DexFile& dex_file = *manager_->GetDexFile(); 1974 StackHandleScope<2> hs(soa.Self()); 1975 Handle<mirror::ClassLoader> class_loader( 1976 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(manager_->GetClassLoader()))); 1977 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->RegisterDexFile( 1978 dex_file, 1979 class_linker->GetOrCreateAllocatorForClassLoader(class_loader.Get())))); 1980 mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader); 1981 1982 if (klass == nullptr) { 1983 soa.Self()->AssertPendingException(); 1984 mirror::Throwable* exception = soa.Self()->GetException(); 1985 VLOG(compiler) << "Exception during type resolution: " << exception->Dump(); 1986 if (exception->GetClass()->DescriptorEquals("Ljava/lang/OutOfMemoryError;")) { 1987 // There's little point continuing compilation if the heap is exhausted. 1988 LOG(FATAL) << "Out of memory during type resolution for compilation"; 1989 } 1990 soa.Self()->ClearException(); 1991 } 1992 } 1993 1994 private: 1995 const ParallelCompilationManager* const manager_; 1996}; 1997 1998void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file, 1999 const std::vector<const DexFile*>& dex_files, 2000 ThreadPool* thread_pool, TimingLogger* timings) { 2001 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2002 2003 // TODO: we could resolve strings here, although the string table is largely filled with class 2004 // and method names. 2005 2006 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files, 2007 thread_pool); 2008 if (IsBootImage()) { 2009 // For images we resolve all types, such as array, whereas for applications just those with 2010 // classdefs are resolved by ResolveClassFieldsAndMethods. 2011 TimingLogger::ScopedTiming t("Resolve Types", timings); 2012 ResolveTypeVisitor visitor(&context); 2013 context.ForAll(0, dex_file.NumTypeIds(), &visitor, thread_count_); 2014 } 2015 2016 TimingLogger::ScopedTiming t("Resolve MethodsAndFields", timings); 2017 ResolveClassFieldsAndMethodsVisitor visitor(&context); 2018 context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count_); 2019} 2020 2021void CompilerDriver::SetVerified(jobject class_loader, const std::vector<const DexFile*>& dex_files, 2022 ThreadPool* thread_pool, TimingLogger* timings) { 2023 for (const DexFile* dex_file : dex_files) { 2024 CHECK(dex_file != nullptr); 2025 SetVerifiedDexFile(class_loader, *dex_file, dex_files, thread_pool, timings); 2026 } 2027} 2028 2029void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files, 2030 ThreadPool* thread_pool, TimingLogger* timings) { 2031 for (const DexFile* dex_file : dex_files) { 2032 CHECK(dex_file != nullptr); 2033 VerifyDexFile(class_loader, *dex_file, dex_files, thread_pool, timings); 2034 } 2035} 2036 2037class VerifyClassVisitor : public CompilationVisitor { 2038 public: 2039 explicit VerifyClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {} 2040 2041 virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE { 2042 ATRACE_CALL(); 2043 ScopedObjectAccess soa(Thread::Current()); 2044 const DexFile& dex_file = *manager_->GetDexFile(); 2045 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2046 const char* descriptor = dex_file.GetClassDescriptor(class_def); 2047 ClassLinker* class_linker = manager_->GetClassLinker(); 2048 jobject jclass_loader = manager_->GetClassLoader(); 2049 StackHandleScope<3> hs(soa.Self()); 2050 Handle<mirror::ClassLoader> class_loader( 2051 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 2052 Handle<mirror::Class> klass( 2053 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader))); 2054 if (klass.Get() == nullptr) { 2055 CHECK(soa.Self()->IsExceptionPending()); 2056 soa.Self()->ClearException(); 2057 2058 /* 2059 * At compile time, we can still structurally verify the class even if FindClass fails. 2060 * This is to ensure the class is structurally sound for compilation. An unsound class 2061 * will be rejected by the verifier and later skipped during compilation in the compiler. 2062 */ 2063 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache( 2064 soa.Self(), dex_file, false))); 2065 std::string error_msg; 2066 if (verifier::MethodVerifier::VerifyClass(soa.Self(), 2067 &dex_file, 2068 dex_cache, 2069 class_loader, 2070 &class_def, 2071 Runtime::Current()->GetCompilerCallbacks(), 2072 true /* allow soft failures */, 2073 true /* log hard failures */, 2074 &error_msg) == 2075 verifier::MethodVerifier::kHardFailure) { 2076 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor) 2077 << " because: " << error_msg; 2078 manager_->GetCompiler()->SetHadHardVerifierFailure(); 2079 } 2080 } else if (!SkipClass(jclass_loader, dex_file, klass.Get())) { 2081 CHECK(klass->IsResolved()) << PrettyClass(klass.Get()); 2082 class_linker->VerifyClass(soa.Self(), klass); 2083 2084 if (klass->IsErroneous()) { 2085 // ClassLinker::VerifyClass throws, which isn't useful in the compiler. 2086 CHECK(soa.Self()->IsExceptionPending()); 2087 soa.Self()->ClearException(); 2088 manager_->GetCompiler()->SetHadHardVerifierFailure(); 2089 } 2090 2091 CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous()) 2092 << PrettyDescriptor(klass.Get()) << ": state=" << klass->GetStatus(); 2093 2094 // It is *very* problematic if there are verification errors in the boot classpath. For example, 2095 // we rely on things working OK without verification when the decryption dialog is brought up. 2096 // So abort in a debug build if we find this violated. 2097 DCHECK(!manager_->GetCompiler()->IsBootImage() || klass->IsVerified()) 2098 << "Boot classpath class " << PrettyClass(klass.Get()) << " failed to fully verify."; 2099 } 2100 soa.Self()->AssertNoPendingException(); 2101 } 2102 2103 private: 2104 const ParallelCompilationManager* const manager_; 2105}; 2106 2107void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file, 2108 const std::vector<const DexFile*>& dex_files, 2109 ThreadPool* thread_pool, TimingLogger* timings) { 2110 TimingLogger::ScopedTiming t("Verify Dex File", timings); 2111 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2112 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files, 2113 thread_pool); 2114 VerifyClassVisitor visitor(&context); 2115 context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count_); 2116} 2117 2118class SetVerifiedClassVisitor : public CompilationVisitor { 2119 public: 2120 explicit SetVerifiedClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {} 2121 2122 virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE { 2123 ATRACE_CALL(); 2124 ScopedObjectAccess soa(Thread::Current()); 2125 const DexFile& dex_file = *manager_->GetDexFile(); 2126 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2127 const char* descriptor = dex_file.GetClassDescriptor(class_def); 2128 ClassLinker* class_linker = manager_->GetClassLinker(); 2129 jobject jclass_loader = manager_->GetClassLoader(); 2130 StackHandleScope<3> hs(soa.Self()); 2131 Handle<mirror::ClassLoader> class_loader( 2132 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 2133 Handle<mirror::Class> klass( 2134 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader))); 2135 // Class might have failed resolution. Then don't set it to verified. 2136 if (klass.Get() != nullptr) { 2137 // Only do this if the class is resolved. If even resolution fails, quickening will go very, 2138 // very wrong. 2139 if (klass->IsResolved()) { 2140 if (klass->GetStatus() < mirror::Class::kStatusVerified) { 2141 ObjectLock<mirror::Class> lock(soa.Self(), klass); 2142 // Set class status to verified. 2143 mirror::Class::SetStatus(klass, mirror::Class::kStatusVerified, soa.Self()); 2144 // Mark methods as pre-verified. If we don't do this, the interpreter will run with 2145 // access checks. 2146 klass->SetPreverifiedFlagOnAllMethods( 2147 GetInstructionSetPointerSize(manager_->GetCompiler()->GetInstructionSet())); 2148 klass->SetPreverified(); 2149 } 2150 // Record the final class status if necessary. 2151 ClassReference ref(manager_->GetDexFile(), class_def_index); 2152 manager_->GetCompiler()->RecordClassStatus(ref, klass->GetStatus()); 2153 } 2154 } else { 2155 Thread* self = soa.Self(); 2156 DCHECK(self->IsExceptionPending()); 2157 self->ClearException(); 2158 } 2159 } 2160 2161 private: 2162 const ParallelCompilationManager* const manager_; 2163}; 2164 2165void CompilerDriver::SetVerifiedDexFile(jobject class_loader, const DexFile& dex_file, 2166 const std::vector<const DexFile*>& dex_files, 2167 ThreadPool* thread_pool, TimingLogger* timings) { 2168 TimingLogger::ScopedTiming t("Verify Dex File", timings); 2169 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2170 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files, 2171 thread_pool); 2172 SetVerifiedClassVisitor visitor(&context); 2173 context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count_); 2174} 2175 2176class InitializeClassVisitor : public CompilationVisitor { 2177 public: 2178 explicit InitializeClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {} 2179 2180 virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE { 2181 ATRACE_CALL(); 2182 jobject jclass_loader = manager_->GetClassLoader(); 2183 const DexFile& dex_file = *manager_->GetDexFile(); 2184 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2185 const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_); 2186 const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_); 2187 2188 ScopedObjectAccess soa(Thread::Current()); 2189 StackHandleScope<3> hs(soa.Self()); 2190 Handle<mirror::ClassLoader> class_loader( 2191 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 2192 Handle<mirror::Class> klass( 2193 hs.NewHandle(manager_->GetClassLinker()->FindClass(soa.Self(), descriptor, class_loader))); 2194 2195 if (klass.Get() != nullptr && !SkipClass(jclass_loader, dex_file, klass.Get())) { 2196 // Only try to initialize classes that were successfully verified. 2197 if (klass->IsVerified()) { 2198 // Attempt to initialize the class but bail if we either need to initialize the super-class 2199 // or static fields. 2200 manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, false, false); 2201 if (!klass->IsInitialized()) { 2202 // We don't want non-trivial class initialization occurring on multiple threads due to 2203 // deadlock problems. For example, a parent class is initialized (holding its lock) that 2204 // refers to a sub-class in its static/class initializer causing it to try to acquire the 2205 // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock) 2206 // after first initializing its parents, whose locks are acquired. This leads to a 2207 // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock. 2208 // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather 2209 // than use a special Object for the purpose we use the Class of java.lang.Class. 2210 Handle<mirror::Class> h_klass(hs.NewHandle(klass->GetClass())); 2211 ObjectLock<mirror::Class> lock(soa.Self(), h_klass); 2212 // Attempt to initialize allowing initialization of parent classes but still not static 2213 // fields. 2214 manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, false, true); 2215 if (!klass->IsInitialized()) { 2216 // We need to initialize static fields, we only do this for image classes that aren't 2217 // marked with the $NoPreloadHolder (which implies this should not be initialized early). 2218 bool can_init_static_fields = manager_->GetCompiler()->IsBootImage() && 2219 manager_->GetCompiler()->IsImageClass(descriptor) && 2220 !StringPiece(descriptor).ends_with("$NoPreloadHolder;"); 2221 if (can_init_static_fields) { 2222 VLOG(compiler) << "Initializing: " << descriptor; 2223 // TODO multithreading support. We should ensure the current compilation thread has 2224 // exclusive access to the runtime and the transaction. To achieve this, we could use 2225 // a ReaderWriterMutex but we're holding the mutator lock so we fail mutex sanity 2226 // checks in Thread::AssertThreadSuspensionIsAllowable. 2227 Runtime* const runtime = Runtime::Current(); 2228 Transaction transaction; 2229 2230 // Run the class initializer in transaction mode. 2231 runtime->EnterTransactionMode(&transaction); 2232 const mirror::Class::Status old_status = klass->GetStatus(); 2233 bool success = manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, true, 2234 true); 2235 // TODO we detach transaction from runtime to indicate we quit the transactional 2236 // mode which prevents the GC from visiting objects modified during the transaction. 2237 // Ensure GC is not run so don't access freed objects when aborting transaction. 2238 2239 ScopedAssertNoThreadSuspension ants(soa.Self(), "Transaction end"); 2240 runtime->ExitTransactionMode(); 2241 2242 if (!success) { 2243 CHECK(soa.Self()->IsExceptionPending()); 2244 mirror::Throwable* exception = soa.Self()->GetException(); 2245 VLOG(compiler) << "Initialization of " << descriptor << " aborted because of " 2246 << exception->Dump(); 2247 std::ostream* file_log = manager_->GetCompiler()-> 2248 GetCompilerOptions().GetInitFailureOutput(); 2249 if (file_log != nullptr) { 2250 *file_log << descriptor << "\n"; 2251 *file_log << exception->Dump() << "\n"; 2252 } 2253 soa.Self()->ClearException(); 2254 transaction.Rollback(); 2255 CHECK_EQ(old_status, klass->GetStatus()) << "Previous class status not restored"; 2256 } 2257 } 2258 } 2259 soa.Self()->AssertNoPendingException(); 2260 } 2261 } 2262 // Record the final class status if necessary. 2263 ClassReference ref(manager_->GetDexFile(), class_def_index); 2264 manager_->GetCompiler()->RecordClassStatus(ref, klass->GetStatus()); 2265 } 2266 // Clear any class not found or verification exceptions. 2267 soa.Self()->ClearException(); 2268 } 2269 2270 private: 2271 const ParallelCompilationManager* const manager_; 2272}; 2273 2274void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file, 2275 const std::vector<const DexFile*>& dex_files, 2276 ThreadPool* thread_pool, TimingLogger* timings) { 2277 TimingLogger::ScopedTiming t("InitializeNoClinit", timings); 2278 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2279 ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, dex_files, 2280 thread_pool); 2281 size_t thread_count; 2282 if (IsBootImage()) { 2283 // TODO: remove this when transactional mode supports multithreading. 2284 thread_count = 1U; 2285 } else { 2286 thread_count = thread_count_; 2287 } 2288 InitializeClassVisitor visitor(&context); 2289 context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count); 2290} 2291 2292void CompilerDriver::InitializeClasses(jobject class_loader, 2293 const std::vector<const DexFile*>& dex_files, 2294 ThreadPool* thread_pool, TimingLogger* timings) { 2295 for (size_t i = 0; i != dex_files.size(); ++i) { 2296 const DexFile* dex_file = dex_files[i]; 2297 CHECK(dex_file != nullptr); 2298 InitializeClasses(class_loader, *dex_file, dex_files, thread_pool, timings); 2299 } 2300 if (IsBootImage()) { 2301 // Prune garbage objects created during aborted transactions. 2302 Runtime::Current()->GetHeap()->CollectGarbage(true); 2303 } 2304} 2305 2306void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 2307 ThreadPool* thread_pool, TimingLogger* timings) { 2308 if (kDebugProfileGuidedCompilation) { 2309 LOG(INFO) << "[ProfileGuidedCompilation] " << 2310 ((profile_compilation_info_ == nullptr) 2311 ? "null" 2312 : profile_compilation_info_->DumpInfo(&dex_files)); 2313 } 2314 for (size_t i = 0; i != dex_files.size(); ++i) { 2315 const DexFile* dex_file = dex_files[i]; 2316 CHECK(dex_file != nullptr); 2317 CompileDexFile(class_loader, *dex_file, dex_files, thread_pool, timings); 2318 } 2319 VLOG(compiler) << "Compile: " << GetMemoryUsageString(false); 2320} 2321 2322class CompileClassVisitor : public CompilationVisitor { 2323 public: 2324 explicit CompileClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {} 2325 2326 virtual void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) OVERRIDE { 2327 ATRACE_CALL(); 2328 const DexFile& dex_file = *manager_->GetDexFile(); 2329 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2330 ClassLinker* class_linker = manager_->GetClassLinker(); 2331 jobject jclass_loader = manager_->GetClassLoader(); 2332 ClassReference ref(&dex_file, class_def_index); 2333 // Skip compiling classes with generic verifier failures since they will still fail at runtime 2334 if (manager_->GetCompiler()->verification_results_->IsClassRejected(ref)) { 2335 return; 2336 } 2337 // Use a scoped object access to perform to the quick SkipClass check. 2338 const char* descriptor = dex_file.GetClassDescriptor(class_def); 2339 ScopedObjectAccess soa(Thread::Current()); 2340 StackHandleScope<3> hs(soa.Self()); 2341 Handle<mirror::ClassLoader> class_loader( 2342 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 2343 Handle<mirror::Class> klass( 2344 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader))); 2345 Handle<mirror::DexCache> dex_cache; 2346 if (klass.Get() == nullptr) { 2347 soa.Self()->AssertPendingException(); 2348 soa.Self()->ClearException(); 2349 dex_cache = hs.NewHandle(class_linker->FindDexCache(soa.Self(), dex_file)); 2350 } else if (SkipClass(jclass_loader, dex_file, klass.Get())) { 2351 return; 2352 } else { 2353 dex_cache = hs.NewHandle(klass->GetDexCache()); 2354 } 2355 2356 const uint8_t* class_data = dex_file.GetClassData(class_def); 2357 if (class_data == nullptr) { 2358 // empty class, probably a marker interface 2359 return; 2360 } 2361 2362 // Go to native so that we don't block GC during compilation. 2363 ScopedThreadSuspension sts(soa.Self(), kNative); 2364 2365 CompilerDriver* const driver = manager_->GetCompiler(); 2366 2367 // Can we run DEX-to-DEX compiler on this class ? 2368 optimizer::DexToDexCompilationLevel dex_to_dex_compilation_level = 2369 GetDexToDexCompilationLevel(soa.Self(), *driver, jclass_loader, dex_file, class_def); 2370 2371 ClassDataItemIterator it(dex_file, class_data); 2372 // Skip fields 2373 while (it.HasNextStaticField()) { 2374 it.Next(); 2375 } 2376 while (it.HasNextInstanceField()) { 2377 it.Next(); 2378 } 2379 2380 bool compilation_enabled = driver->IsClassToCompile( 2381 dex_file.StringByTypeIdx(class_def.class_idx_)); 2382 2383 // Compile direct methods 2384 int64_t previous_direct_method_idx = -1; 2385 while (it.HasNextDirectMethod()) { 2386 uint32_t method_idx = it.GetMemberIndex(); 2387 if (method_idx == previous_direct_method_idx) { 2388 // smali can create dex files with two encoded_methods sharing the same method_idx 2389 // http://code.google.com/p/smali/issues/detail?id=119 2390 it.Next(); 2391 continue; 2392 } 2393 previous_direct_method_idx = method_idx; 2394 CompileMethod(soa.Self(), driver, it.GetMethodCodeItem(), it.GetMethodAccessFlags(), 2395 it.GetMethodInvokeType(class_def), class_def_index, 2396 method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level, 2397 compilation_enabled, dex_cache); 2398 it.Next(); 2399 } 2400 // Compile virtual methods 2401 int64_t previous_virtual_method_idx = -1; 2402 while (it.HasNextVirtualMethod()) { 2403 uint32_t method_idx = it.GetMemberIndex(); 2404 if (method_idx == previous_virtual_method_idx) { 2405 // smali can create dex files with two encoded_methods sharing the same method_idx 2406 // http://code.google.com/p/smali/issues/detail?id=119 2407 it.Next(); 2408 continue; 2409 } 2410 previous_virtual_method_idx = method_idx; 2411 CompileMethod(soa.Self(), driver, it.GetMethodCodeItem(), it.GetMethodAccessFlags(), 2412 it.GetMethodInvokeType(class_def), class_def_index, 2413 method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level, 2414 compilation_enabled, dex_cache); 2415 it.Next(); 2416 } 2417 DCHECK(!it.HasNext()); 2418 } 2419 2420 private: 2421 const ParallelCompilationManager* const manager_; 2422}; 2423 2424void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file, 2425 const std::vector<const DexFile*>& dex_files, 2426 ThreadPool* thread_pool, TimingLogger* timings) { 2427 TimingLogger::ScopedTiming t("Compile Dex File", timings); 2428 ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this, 2429 &dex_file, dex_files, thread_pool); 2430 CompileClassVisitor visitor(&context); 2431 context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count_); 2432} 2433 2434void CompilerDriver::AddCompiledMethod(const MethodReference& method_ref, 2435 CompiledMethod* const compiled_method, 2436 size_t non_relative_linker_patch_count) { 2437 DCHECK(GetCompiledMethod(method_ref) == nullptr) 2438 << PrettyMethod(method_ref.dex_method_index, *method_ref.dex_file); 2439 { 2440 MutexLock mu(Thread::Current(), compiled_methods_lock_); 2441 compiled_methods_.Put(method_ref, compiled_method); 2442 non_relative_linker_patch_count_ += non_relative_linker_patch_count; 2443 } 2444 DCHECK(GetCompiledMethod(method_ref) != nullptr) 2445 << PrettyMethod(method_ref.dex_method_index, *method_ref.dex_file); 2446} 2447 2448void CompilerDriver::RemoveCompiledMethod(const MethodReference& method_ref) { 2449 CompiledMethod* compiled_method = nullptr; 2450 { 2451 MutexLock mu(Thread::Current(), compiled_methods_lock_); 2452 auto it = compiled_methods_.find(method_ref); 2453 if (it != compiled_methods_.end()) { 2454 compiled_method = it->second; 2455 compiled_methods_.erase(it); 2456 } 2457 } 2458 if (compiled_method != nullptr) { 2459 CompiledMethod::ReleaseSwapAllocatedCompiledMethod(this, compiled_method); 2460 } 2461} 2462 2463CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const { 2464 MutexLock mu(Thread::Current(), compiled_classes_lock_); 2465 ClassTable::const_iterator it = compiled_classes_.find(ref); 2466 if (it == compiled_classes_.end()) { 2467 return nullptr; 2468 } 2469 CHECK(it->second != nullptr); 2470 return it->second; 2471} 2472 2473void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) { 2474 MutexLock mu(Thread::Current(), compiled_classes_lock_); 2475 auto it = compiled_classes_.find(ref); 2476 if (it == compiled_classes_.end() || it->second->GetStatus() != status) { 2477 // An entry doesn't exist or the status is lower than the new status. 2478 if (it != compiled_classes_.end()) { 2479 CHECK_GT(status, it->second->GetStatus()); 2480 delete it->second; 2481 } 2482 switch (status) { 2483 case mirror::Class::kStatusNotReady: 2484 case mirror::Class::kStatusError: 2485 case mirror::Class::kStatusRetryVerificationAtRuntime: 2486 case mirror::Class::kStatusVerified: 2487 case mirror::Class::kStatusInitialized: 2488 break; // Expected states. 2489 default: 2490 LOG(FATAL) << "Unexpected class status for class " 2491 << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second))) 2492 << " of " << status; 2493 } 2494 CompiledClass* compiled_class = new CompiledClass(status); 2495 compiled_classes_.Overwrite(ref, compiled_class); 2496 } 2497} 2498 2499CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const { 2500 MutexLock mu(Thread::Current(), compiled_methods_lock_); 2501 MethodTable::const_iterator it = compiled_methods_.find(ref); 2502 if (it == compiled_methods_.end()) { 2503 return nullptr; 2504 } 2505 CHECK(it->second != nullptr); 2506 return it->second; 2507} 2508 2509bool CompilerDriver::IsMethodVerifiedWithoutFailures(uint32_t method_idx, 2510 uint16_t class_def_idx, 2511 const DexFile& dex_file) const { 2512 const VerifiedMethod* verified_method = GetVerifiedMethod(&dex_file, method_idx); 2513 if (verified_method != nullptr) { 2514 return !verified_method->HasVerificationFailures(); 2515 } 2516 2517 // If we can't find verification metadata, check if this is a system class (we trust that system 2518 // classes have their methods verified). If it's not, be conservative and assume the method 2519 // has not been verified successfully. 2520 2521 // TODO: When compiling the boot image it should be safe to assume that everything is verified, 2522 // even if methods are not found in the verification cache. 2523 const char* descriptor = dex_file.GetClassDescriptor(dex_file.GetClassDef(class_def_idx)); 2524 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2525 Thread* self = Thread::Current(); 2526 ScopedObjectAccess soa(self); 2527 bool is_system_class = class_linker->FindSystemClass(self, descriptor) != nullptr; 2528 if (!is_system_class) { 2529 self->ClearException(); 2530 } 2531 return is_system_class; 2532} 2533 2534size_t CompilerDriver::GetNonRelativeLinkerPatchCount() const { 2535 MutexLock mu(Thread::Current(), compiled_methods_lock_); 2536 return non_relative_linker_patch_count_; 2537} 2538 2539void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, 2540 uint16_t class_def_index) { 2541 WriterMutexLock mu(self, freezing_constructor_lock_); 2542 freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index)); 2543} 2544 2545bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, 2546 uint16_t class_def_index) const { 2547 ReaderMutexLock mu(self, freezing_constructor_lock_); 2548 return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0; 2549} 2550 2551std::string CompilerDriver::GetMemoryUsageString(bool extended) const { 2552 std::ostringstream oss; 2553 Runtime* const runtime = Runtime::Current(); 2554 const ArenaPool* arena_pool = runtime->GetArenaPool(); 2555 gc::Heap* const heap = runtime->GetHeap(); 2556 oss << "arena alloc=" << PrettySize(arena_pool->GetBytesAllocated()); 2557 oss << " java alloc=" << PrettySize(heap->GetBytesAllocated()); 2558#if defined(__BIONIC__) || defined(__GLIBC__) 2559 struct mallinfo info = mallinfo(); 2560 const size_t allocated_space = static_cast<size_t>(info.uordblks); 2561 const size_t free_space = static_cast<size_t>(info.fordblks); 2562 oss << " native alloc=" << PrettySize(allocated_space) << " free=" 2563 << PrettySize(free_space); 2564#endif 2565 compiled_method_storage_.DumpMemoryUsage(oss, extended); 2566 return oss.str(); 2567} 2568 2569bool CompilerDriver::IsStringTypeIndex(uint16_t type_index, const DexFile* dex_file) { 2570 const char* type = dex_file->GetTypeDescriptor(dex_file->GetTypeId(type_index)); 2571 return strcmp(type, "Ljava/lang/String;") == 0; 2572} 2573 2574bool CompilerDriver::IsStringInit(uint32_t method_index, const DexFile* dex_file, int32_t* offset) { 2575 DexFileMethodInliner* inliner = GetMethodInlinerMap()->GetMethodInliner(dex_file); 2576 size_t pointer_size = InstructionSetPointerSize(GetInstructionSet()); 2577 *offset = inliner->GetOffsetForStringInit(method_index, pointer_size); 2578 return inliner->IsStringInitMethodIndex(method_index); 2579} 2580 2581bool CompilerDriver::MayInlineInternal(const DexFile* inlined_from, 2582 const DexFile* inlined_into) const { 2583 // We're not allowed to inline across dex files if we're the no-inline-from dex file. 2584 if (inlined_from != inlined_into && 2585 compiler_options_->GetNoInlineFromDexFile() == inlined_from) { 2586 return false; 2587 } 2588 2589 return true; 2590} 2591 2592} // namespace art 2593