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