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