compiler_driver.cc revision 643b5df2b065ccf5bb19a183573da691e9d0311f
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 <vector> 23#include <unistd.h> 24 25#include "base/stl_util.h" 26#include "base/timing_logger.h" 27#include "class_linker.h" 28#include "compiled_class.h" 29#include "compiler.h" 30#include "compiler_driver-inl.h" 31#include "dex_compilation_unit.h" 32#include "dex_file-inl.h" 33#include "dex/verification_results.h" 34#include "dex/verified_method.h" 35#include "dex/quick/dex_file_method_inliner.h" 36#include "driver/compiler_options.h" 37#include "jni_internal.h" 38#include "object_lock.h" 39#include "profiler.h" 40#include "runtime.h" 41#include "gc/accounting/card_table-inl.h" 42#include "gc/accounting/heap_bitmap.h" 43#include "gc/space/space.h" 44#include "mirror/art_field-inl.h" 45#include "mirror/art_method-inl.h" 46#include "mirror/class_loader.h" 47#include "mirror/class-inl.h" 48#include "mirror/dex_cache-inl.h" 49#include "mirror/object-inl.h" 50#include "mirror/object_array-inl.h" 51#include "mirror/throwable.h" 52#include "scoped_thread_state_change.h" 53#include "ScopedLocalRef.h" 54#include "handle_scope-inl.h" 55#include "thread.h" 56#include "thread_pool.h" 57#include "trampolines/trampoline_compiler.h" 58#include "transaction.h" 59#include "verifier/method_verifier.h" 60#include "verifier/method_verifier-inl.h" 61 62namespace art { 63 64static constexpr bool kTimeCompileMethod = !kIsDebugBuild; 65 66static double Percentage(size_t x, size_t y) { 67 return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y)); 68} 69 70static void DumpStat(size_t x, size_t y, const char* str) { 71 if (x == 0 && y == 0) { 72 return; 73 } 74 LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases"; 75} 76 77class CompilerDriver::AOTCompilationStats { 78 public: 79 AOTCompilationStats() 80 : stats_lock_("AOT compilation statistics lock"), 81 types_in_dex_cache_(0), types_not_in_dex_cache_(0), 82 strings_in_dex_cache_(0), strings_not_in_dex_cache_(0), 83 resolved_types_(0), unresolved_types_(0), 84 resolved_instance_fields_(0), unresolved_instance_fields_(0), 85 resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0), 86 type_based_devirtualization_(0), 87 safe_casts_(0), not_safe_casts_(0) { 88 for (size_t i = 0; i <= kMaxInvokeType; i++) { 89 resolved_methods_[i] = 0; 90 unresolved_methods_[i] = 0; 91 virtual_made_direct_[i] = 0; 92 direct_calls_to_boot_[i] = 0; 93 direct_methods_to_boot_[i] = 0; 94 } 95 } 96 97 void Dump() { 98 DumpStat(types_in_dex_cache_, types_not_in_dex_cache_, "types known to be in dex cache"); 99 DumpStat(strings_in_dex_cache_, strings_not_in_dex_cache_, "strings known to be in dex cache"); 100 DumpStat(resolved_types_, unresolved_types_, "types resolved"); 101 DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved"); 102 DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_, 103 "static fields resolved"); 104 DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_, 105 "static fields local to a class"); 106 DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information"); 107 // Note, the code below subtracts the stat value so that when added to the stat value we have 108 // 100% of samples. TODO: clean this up. 109 DumpStat(type_based_devirtualization_, 110 resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] + 111 resolved_methods_[kInterface] + unresolved_methods_[kInterface] - 112 type_based_devirtualization_, 113 "virtual/interface calls made direct based on type information"); 114 115 for (size_t i = 0; i <= kMaxInvokeType; i++) { 116 std::ostringstream oss; 117 oss << static_cast<InvokeType>(i) << " methods were AOT resolved"; 118 DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str()); 119 if (virtual_made_direct_[i] > 0) { 120 std::ostringstream oss2; 121 oss2 << static_cast<InvokeType>(i) << " methods made direct"; 122 DumpStat(virtual_made_direct_[i], 123 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i], 124 oss2.str().c_str()); 125 } 126 if (direct_calls_to_boot_[i] > 0) { 127 std::ostringstream oss2; 128 oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot"; 129 DumpStat(direct_calls_to_boot_[i], 130 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i], 131 oss2.str().c_str()); 132 } 133 if (direct_methods_to_boot_[i] > 0) { 134 std::ostringstream oss2; 135 oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot"; 136 DumpStat(direct_methods_to_boot_[i], 137 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i], 138 oss2.str().c_str()); 139 } 140 } 141 } 142 143// Allow lossy statistics in non-debug builds. 144#ifndef NDEBUG 145#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_) 146#else 147#define STATS_LOCK() 148#endif 149 150 void TypeInDexCache() { 151 STATS_LOCK(); 152 types_in_dex_cache_++; 153 } 154 155 void TypeNotInDexCache() { 156 STATS_LOCK(); 157 types_not_in_dex_cache_++; 158 } 159 160 void StringInDexCache() { 161 STATS_LOCK(); 162 strings_in_dex_cache_++; 163 } 164 165 void StringNotInDexCache() { 166 STATS_LOCK(); 167 strings_not_in_dex_cache_++; 168 } 169 170 void TypeDoesntNeedAccessCheck() { 171 STATS_LOCK(); 172 resolved_types_++; 173 } 174 175 void TypeNeedsAccessCheck() { 176 STATS_LOCK(); 177 unresolved_types_++; 178 } 179 180 void ResolvedInstanceField() { 181 STATS_LOCK(); 182 resolved_instance_fields_++; 183 } 184 185 void UnresolvedInstanceField() { 186 STATS_LOCK(); 187 unresolved_instance_fields_++; 188 } 189 190 void ResolvedLocalStaticField() { 191 STATS_LOCK(); 192 resolved_local_static_fields_++; 193 } 194 195 void ResolvedStaticField() { 196 STATS_LOCK(); 197 resolved_static_fields_++; 198 } 199 200 void UnresolvedStaticField() { 201 STATS_LOCK(); 202 unresolved_static_fields_++; 203 } 204 205 // Indicate that type information from the verifier led to devirtualization. 206 void PreciseTypeDevirtualization() { 207 STATS_LOCK(); 208 type_based_devirtualization_++; 209 } 210 211 // Indicate that a method of the given type was resolved at compile time. 212 void ResolvedMethod(InvokeType type) { 213 DCHECK_LE(type, kMaxInvokeType); 214 STATS_LOCK(); 215 resolved_methods_[type]++; 216 } 217 218 // Indicate that a method of the given type was unresolved at compile time as it was in an 219 // unknown dex file. 220 void UnresolvedMethod(InvokeType type) { 221 DCHECK_LE(type, kMaxInvokeType); 222 STATS_LOCK(); 223 unresolved_methods_[type]++; 224 } 225 226 // Indicate that a type of virtual method dispatch has been converted into a direct method 227 // dispatch. 228 void VirtualMadeDirect(InvokeType type) { 229 DCHECK(type == kVirtual || type == kInterface || type == kSuper); 230 STATS_LOCK(); 231 virtual_made_direct_[type]++; 232 } 233 234 // Indicate that a method of the given type was able to call directly into boot. 235 void DirectCallsToBoot(InvokeType type) { 236 DCHECK_LE(type, kMaxInvokeType); 237 STATS_LOCK(); 238 direct_calls_to_boot_[type]++; 239 } 240 241 // Indicate that a method of the given type was able to be resolved directly from boot. 242 void DirectMethodsToBoot(InvokeType type) { 243 DCHECK_LE(type, kMaxInvokeType); 244 STATS_LOCK(); 245 direct_methods_to_boot_[type]++; 246 } 247 248 void ProcessedInvoke(InvokeType type, int flags) { 249 STATS_LOCK(); 250 if (flags == 0) { 251 unresolved_methods_[type]++; 252 } else { 253 DCHECK_NE((flags & kFlagMethodResolved), 0); 254 resolved_methods_[type]++; 255 if ((flags & kFlagVirtualMadeDirect) != 0) { 256 virtual_made_direct_[type]++; 257 if ((flags & kFlagPreciseTypeDevirtualization) != 0) { 258 type_based_devirtualization_++; 259 } 260 } else { 261 DCHECK_EQ((flags & kFlagPreciseTypeDevirtualization), 0); 262 } 263 if ((flags & kFlagDirectCallToBoot) != 0) { 264 direct_calls_to_boot_[type]++; 265 } 266 if ((flags & kFlagDirectMethodToBoot) != 0) { 267 direct_methods_to_boot_[type]++; 268 } 269 } 270 } 271 272 // A check-cast could be eliminated due to verifier type analysis. 273 void SafeCast() { 274 STATS_LOCK(); 275 safe_casts_++; 276 } 277 278 // A check-cast couldn't be eliminated due to verifier type analysis. 279 void NotASafeCast() { 280 STATS_LOCK(); 281 not_safe_casts_++; 282 } 283 284 private: 285 Mutex stats_lock_; 286 287 size_t types_in_dex_cache_; 288 size_t types_not_in_dex_cache_; 289 290 size_t strings_in_dex_cache_; 291 size_t strings_not_in_dex_cache_; 292 293 size_t resolved_types_; 294 size_t unresolved_types_; 295 296 size_t resolved_instance_fields_; 297 size_t unresolved_instance_fields_; 298 299 size_t resolved_local_static_fields_; 300 size_t resolved_static_fields_; 301 size_t unresolved_static_fields_; 302 // Type based devirtualization for invoke interface and virtual. 303 size_t type_based_devirtualization_; 304 305 size_t resolved_methods_[kMaxInvokeType + 1]; 306 size_t unresolved_methods_[kMaxInvokeType + 1]; 307 size_t virtual_made_direct_[kMaxInvokeType + 1]; 308 size_t direct_calls_to_boot_[kMaxInvokeType + 1]; 309 size_t direct_methods_to_boot_[kMaxInvokeType + 1]; 310 311 size_t safe_casts_; 312 size_t not_safe_casts_; 313 314 DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats); 315}; 316 317 318extern "C" art::CompiledMethod* ArtCompileDEX(art::CompilerDriver& compiler, 319 const art::DexFile::CodeItem* code_item, 320 uint32_t access_flags, 321 art::InvokeType invoke_type, 322 uint16_t class_def_idx, 323 uint32_t method_idx, 324 jobject class_loader, 325 const art::DexFile& dex_file); 326 327CompilerDriver::CompilerDriver(const CompilerOptions* compiler_options, 328 VerificationResults* verification_results, 329 DexFileToMethodInlinerMap* method_inliner_map, 330 Compiler::Kind compiler_kind, 331 InstructionSet instruction_set, 332 InstructionSetFeatures instruction_set_features, 333 bool image, std::set<std::string>* image_classes, size_t thread_count, 334 bool dump_stats, bool dump_passes, CumulativeLogger* timer, 335 std::string profile_file) 336 : profile_present_(false), compiler_options_(compiler_options), 337 verification_results_(verification_results), 338 method_inliner_map_(method_inliner_map), 339 compiler_(Compiler::Create(this, compiler_kind)), 340 instruction_set_(instruction_set), 341 instruction_set_features_(instruction_set_features), 342 freezing_constructor_lock_("freezing constructor lock"), 343 compiled_classes_lock_("compiled classes lock"), 344 compiled_methods_lock_("compiled method lock"), 345 image_(image), 346 image_classes_(image_classes), 347 thread_count_(thread_count), 348 start_ns_(0), 349 stats_(new AOTCompilationStats), 350 dump_stats_(dump_stats), 351 dump_passes_(dump_passes), 352 timings_logger_(timer), 353 compiler_library_(nullptr), 354 compiler_context_(nullptr), 355 compiler_enable_auto_elf_loading_(nullptr), 356 compiler_get_method_code_addr_(nullptr), 357 support_boot_image_fixup_(instruction_set != kMips), 358 cfi_info_(nullptr), 359 dedupe_code_("dedupe code"), 360 dedupe_mapping_table_("dedupe mapping table"), 361 dedupe_vmap_table_("dedupe vmap table"), 362 dedupe_gc_map_("dedupe gc map"), 363 dedupe_cfi_info_("dedupe cfi info") { 364 DCHECK(compiler_options_ != nullptr); 365 DCHECK(verification_results_ != nullptr); 366 DCHECK(method_inliner_map_ != nullptr); 367 368 CHECK_PTHREAD_CALL(pthread_key_create, (&tls_key_, nullptr), "compiler tls key"); 369 370 dex_to_dex_compiler_ = reinterpret_cast<DexToDexCompilerFn>(ArtCompileDEX); 371 372 compiler_->Init(); 373 374 CHECK(!Runtime::Current()->IsStarted()); 375 if (image_) { 376 CHECK(image_classes_.get() != nullptr); 377 } else { 378 CHECK(image_classes_.get() == nullptr); 379 } 380 381 // Are we generating CFI information? 382 if (compiler_options->GetGenerateGDBInformation()) { 383 cfi_info_.reset(compiler_->GetCallFrameInformationInitialization(*this)); 384 } 385 386 // Read the profile file if one is provided. 387 if (!profile_file.empty()) { 388 profile_present_ = profile_file_.LoadFile(profile_file); 389 if (profile_present_) { 390 LOG(INFO) << "Using profile data form file " << profile_file; 391 } else { 392 LOG(INFO) << "Failed to load profile file " << profile_file; 393 } 394 } 395} 396 397std::vector<uint8_t>* CompilerDriver::DeduplicateCode(const std::vector<uint8_t>& code) { 398 return dedupe_code_.Add(Thread::Current(), code); 399} 400 401std::vector<uint8_t>* CompilerDriver::DeduplicateMappingTable(const std::vector<uint8_t>& code) { 402 return dedupe_mapping_table_.Add(Thread::Current(), code); 403} 404 405std::vector<uint8_t>* CompilerDriver::DeduplicateVMapTable(const std::vector<uint8_t>& code) { 406 return dedupe_vmap_table_.Add(Thread::Current(), code); 407} 408 409std::vector<uint8_t>* CompilerDriver::DeduplicateGCMap(const std::vector<uint8_t>& code) { 410 return dedupe_gc_map_.Add(Thread::Current(), code); 411} 412 413std::vector<uint8_t>* CompilerDriver::DeduplicateCFIInfo(const std::vector<uint8_t>* cfi_info) { 414 if (cfi_info == nullptr) { 415 return nullptr; 416 } 417 return dedupe_cfi_info_.Add(Thread::Current(), *cfi_info); 418} 419 420CompilerDriver::~CompilerDriver() { 421 Thread* self = Thread::Current(); 422 { 423 MutexLock mu(self, compiled_classes_lock_); 424 STLDeleteValues(&compiled_classes_); 425 } 426 { 427 MutexLock mu(self, compiled_methods_lock_); 428 STLDeleteValues(&compiled_methods_); 429 } 430 { 431 MutexLock mu(self, compiled_methods_lock_); 432 STLDeleteElements(&code_to_patch_); 433 } 434 { 435 MutexLock mu(self, compiled_methods_lock_); 436 STLDeleteElements(&methods_to_patch_); 437 } 438 { 439 MutexLock mu(self, compiled_methods_lock_); 440 STLDeleteElements(&classes_to_patch_); 441 } 442 CHECK_PTHREAD_CALL(pthread_key_delete, (tls_key_), "delete tls key"); 443 compiler_->UnInit(); 444} 445 446CompilerTls* CompilerDriver::GetTls() { 447 // Lazily create thread-local storage 448 CompilerTls* res = static_cast<CompilerTls*>(pthread_getspecific(tls_key_)); 449 if (res == nullptr) { 450 res = new CompilerTls(); 451 CHECK_PTHREAD_CALL(pthread_setspecific, (tls_key_, res), "compiler tls"); 452 } 453 return res; 454} 455 456#define CREATE_TRAMPOLINE(type, abi, offset) \ 457 if (Is64BitInstructionSet(instruction_set_)) { \ 458 return CreateTrampoline64(instruction_set_, abi, \ 459 type ## _ENTRYPOINT_OFFSET(8, offset)); \ 460 } else { \ 461 return CreateTrampoline32(instruction_set_, abi, \ 462 type ## _ENTRYPOINT_OFFSET(4, offset)); \ 463 } 464 465const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToInterpreterBridge() const { 466 CREATE_TRAMPOLINE(INTERPRETER, kInterpreterAbi, pInterpreterToInterpreterBridge) 467} 468 469const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToCompiledCodeBridge() const { 470 CREATE_TRAMPOLINE(INTERPRETER, kInterpreterAbi, pInterpreterToCompiledCodeBridge) 471} 472 473const std::vector<uint8_t>* CompilerDriver::CreateJniDlsymLookup() const { 474 CREATE_TRAMPOLINE(JNI, kJniAbi, pDlsymLookup) 475} 476 477const std::vector<uint8_t>* CompilerDriver::CreatePortableImtConflictTrampoline() const { 478 CREATE_TRAMPOLINE(PORTABLE, kPortableAbi, pPortableImtConflictTrampoline) 479} 480 481const std::vector<uint8_t>* CompilerDriver::CreatePortableResolutionTrampoline() const { 482 CREATE_TRAMPOLINE(PORTABLE, kPortableAbi, pPortableResolutionTrampoline) 483} 484 485const std::vector<uint8_t>* CompilerDriver::CreatePortableToInterpreterBridge() const { 486 CREATE_TRAMPOLINE(PORTABLE, kPortableAbi, pPortableToInterpreterBridge) 487} 488 489const std::vector<uint8_t>* CompilerDriver::CreateQuickGenericJniTrampoline() const { 490 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickGenericJniTrampoline) 491} 492 493const std::vector<uint8_t>* CompilerDriver::CreateQuickImtConflictTrampoline() const { 494 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickImtConflictTrampoline) 495} 496 497const std::vector<uint8_t>* CompilerDriver::CreateQuickResolutionTrampoline() const { 498 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickResolutionTrampoline) 499} 500 501const std::vector<uint8_t>* CompilerDriver::CreateQuickToInterpreterBridge() const { 502 CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickToInterpreterBridge) 503} 504#undef CREATE_TRAMPOLINE 505 506void CompilerDriver::CompileAll(jobject class_loader, 507 const std::vector<const DexFile*>& dex_files, 508 TimingLogger* timings) { 509 DCHECK(!Runtime::Current()->IsStarted()); 510 std::unique_ptr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", thread_count_ - 1)); 511 PreCompile(class_loader, dex_files, thread_pool.get(), timings); 512 Compile(class_loader, dex_files, thread_pool.get(), timings); 513 if (dump_stats_) { 514 stats_->Dump(); 515 } 516} 517 518static DexToDexCompilationLevel GetDexToDexCompilationlevel( 519 Thread* self, Handle<mirror::ClassLoader> class_loader, const DexFile& dex_file, 520 const DexFile::ClassDef& class_def) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 521 const char* descriptor = dex_file.GetClassDescriptor(class_def); 522 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 523 mirror::Class* klass = class_linker->FindClass(self, descriptor, class_loader); 524 if (klass == nullptr) { 525 CHECK(self->IsExceptionPending()); 526 self->ClearException(); 527 return kDontDexToDexCompile; 528 } 529 // DexToDex at the kOptimize level may introduce quickened opcodes, which replace symbolic 530 // references with actual offsets. We cannot re-verify such instructions. 531 // 532 // We store the verification information in the class status in the oat file, which the linker 533 // can validate (checksums) and use to skip load-time verification. It is thus safe to 534 // optimize when a class has been fully verified before. 535 if (klass->IsVerified()) { 536 // Class is verified so we can enable DEX-to-DEX compilation for performance. 537 return kOptimize; 538 } else if (klass->IsCompileTimeVerified()) { 539 // Class verification has soft-failed. Anyway, ensure at least correctness. 540 DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime); 541 return kRequired; 542 } else { 543 // Class verification has failed: do not run DEX-to-DEX compilation. 544 return kDontDexToDexCompile; 545 } 546} 547 548void CompilerDriver::CompileOne(mirror::ArtMethod* method, TimingLogger* timings) { 549 DCHECK(!Runtime::Current()->IsStarted()); 550 Thread* self = Thread::Current(); 551 jobject jclass_loader; 552 const DexFile* dex_file; 553 uint16_t class_def_idx; 554 uint32_t method_idx = method->GetDexMethodIndex(); 555 uint32_t access_flags = method->GetAccessFlags(); 556 InvokeType invoke_type = method->GetInvokeType(); 557 { 558 ScopedObjectAccessUnchecked soa(self); 559 ScopedLocalRef<jobject> 560 local_class_loader(soa.Env(), 561 soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader())); 562 jclass_loader = soa.Env()->NewGlobalRef(local_class_loader.get()); 563 // Find the dex_file 564 dex_file = method->GetDexFile(); 565 class_def_idx = method->GetClassDefIndex(); 566 } 567 const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset()); 568 self->TransitionFromRunnableToSuspended(kNative); 569 570 std::vector<const DexFile*> dex_files; 571 dex_files.push_back(dex_file); 572 573 std::unique_ptr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", 0U)); 574 PreCompile(jclass_loader, dex_files, thread_pool.get(), timings); 575 576 // Can we run DEX-to-DEX compiler on this class ? 577 DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile; 578 { 579 ScopedObjectAccess soa(Thread::Current()); 580 const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_idx); 581 StackHandleScope<1> hs(soa.Self()); 582 Handle<mirror::ClassLoader> class_loader( 583 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 584 dex_to_dex_compilation_level = GetDexToDexCompilationlevel(self, class_loader, *dex_file, 585 class_def); 586 } 587 CompileMethod(code_item, access_flags, invoke_type, class_def_idx, method_idx, jclass_loader, 588 *dex_file, dex_to_dex_compilation_level); 589 590 self->GetJniEnv()->DeleteGlobalRef(jclass_loader); 591 592 self->TransitionFromSuspendedToRunnable(); 593} 594 595void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files, 596 ThreadPool* thread_pool, TimingLogger* timings) { 597 for (size_t i = 0; i != dex_files.size(); ++i) { 598 const DexFile* dex_file = dex_files[i]; 599 CHECK(dex_file != nullptr); 600 ResolveDexFile(class_loader, *dex_file, dex_files, thread_pool, timings); 601 } 602} 603 604void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 605 ThreadPool* thread_pool, TimingLogger* timings) { 606 LoadImageClasses(timings); 607 608 Resolve(class_loader, dex_files, thread_pool, timings); 609 610 if (!compiler_options_->IsVerificationEnabled()) { 611 LOG(INFO) << "Verify none mode specified, skipping verification."; 612 SetVerified(class_loader, dex_files, thread_pool, timings); 613 return; 614 } 615 616 Verify(class_loader, dex_files, thread_pool, timings); 617 618 InitializeClasses(class_loader, dex_files, thread_pool, timings); 619 620 UpdateImageClasses(timings); 621} 622 623bool CompilerDriver::IsImageClass(const char* descriptor) const { 624 if (!IsImage()) { 625 return true; 626 } else { 627 return image_classes_->find(descriptor) != image_classes_->end(); 628 } 629} 630 631static void ResolveExceptionsForMethod(MethodHelper* mh, 632 std::set<std::pair<uint16_t, const DexFile*>>& exceptions_to_resolve) 633 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 634 const DexFile::CodeItem* code_item = mh->GetMethod()->GetCodeItem(); 635 if (code_item == nullptr) { 636 return; // native or abstract method 637 } 638 if (code_item->tries_size_ == 0) { 639 return; // nothing to process 640 } 641 const byte* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0); 642 size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list); 643 for (size_t i = 0; i < num_encoded_catch_handlers; i++) { 644 int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list); 645 bool has_catch_all = false; 646 if (encoded_catch_handler_size <= 0) { 647 encoded_catch_handler_size = -encoded_catch_handler_size; 648 has_catch_all = true; 649 } 650 for (int32_t j = 0; j < encoded_catch_handler_size; j++) { 651 uint16_t encoded_catch_handler_handlers_type_idx = 652 DecodeUnsignedLeb128(&encoded_catch_handler_list); 653 // Add to set of types to resolve if not already in the dex cache resolved types 654 if (!mh->GetMethod()->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) { 655 exceptions_to_resolve.insert( 656 std::pair<uint16_t, const DexFile*>(encoded_catch_handler_handlers_type_idx, 657 mh->GetMethod()->GetDexFile())); 658 } 659 // ignore address associated with catch handler 660 DecodeUnsignedLeb128(&encoded_catch_handler_list); 661 } 662 if (has_catch_all) { 663 // ignore catch all address 664 DecodeUnsignedLeb128(&encoded_catch_handler_list); 665 } 666 } 667} 668 669static bool ResolveCatchBlockExceptionsClassVisitor(mirror::Class* c, void* arg) 670 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 671 std::set<std::pair<uint16_t, const DexFile*>>* exceptions_to_resolve = 672 reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*>>*>(arg); 673 StackHandleScope<1> hs(Thread::Current()); 674 MethodHelper mh(hs.NewHandle<mirror::ArtMethod>(nullptr)); 675 for (size_t i = 0; i < c->NumVirtualMethods(); ++i) { 676 mh.ChangeMethod(c->GetVirtualMethod(i)); 677 ResolveExceptionsForMethod(&mh, *exceptions_to_resolve); 678 } 679 for (size_t i = 0; i < c->NumDirectMethods(); ++i) { 680 mh.ChangeMethod(c->GetDirectMethod(i)); 681 ResolveExceptionsForMethod(&mh, *exceptions_to_resolve); 682 } 683 return true; 684} 685 686static bool RecordImageClassesVisitor(mirror::Class* klass, void* arg) 687 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 688 std::set<std::string>* image_classes = reinterpret_cast<std::set<std::string>*>(arg); 689 std::string temp; 690 image_classes->insert(klass->GetDescriptor(&temp)); 691 return true; 692} 693 694// Make a list of descriptors for classes to include in the image 695void CompilerDriver::LoadImageClasses(TimingLogger* timings) 696 LOCKS_EXCLUDED(Locks::mutator_lock_) { 697 CHECK(timings != nullptr); 698 if (!IsImage()) { 699 return; 700 } 701 702 TimingLogger::ScopedTiming t("LoadImageClasses", timings); 703 // Make a first class to load all classes explicitly listed in the file 704 Thread* self = Thread::Current(); 705 ScopedObjectAccess soa(self); 706 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 707 CHECK(image_classes_.get() != nullptr); 708 for (auto it = image_classes_->begin(), end = image_classes_->end(); it != end;) { 709 const std::string& descriptor(*it); 710 StackHandleScope<1> hs(self); 711 Handle<mirror::Class> klass( 712 hs.NewHandle(class_linker->FindSystemClass(self, descriptor.c_str()))); 713 if (klass.Get() == nullptr) { 714 VLOG(compiler) << "Failed to find class " << descriptor; 715 image_classes_->erase(it++); 716 self->ClearException(); 717 } else { 718 ++it; 719 } 720 } 721 722 // Resolve exception classes referenced by the loaded classes. The catch logic assumes 723 // exceptions are resolved by the verifier when there is a catch block in an interested method. 724 // Do this here so that exception classes appear to have been specified image classes. 725 std::set<std::pair<uint16_t, const DexFile*>> unresolved_exception_types; 726 StackHandleScope<1> hs(self); 727 Handle<mirror::Class> java_lang_Throwable( 728 hs.NewHandle(class_linker->FindSystemClass(self, "Ljava/lang/Throwable;"))); 729 do { 730 unresolved_exception_types.clear(); 731 class_linker->VisitClasses(ResolveCatchBlockExceptionsClassVisitor, 732 &unresolved_exception_types); 733 for (const std::pair<uint16_t, const DexFile*>& exception_type : unresolved_exception_types) { 734 uint16_t exception_type_idx = exception_type.first; 735 const DexFile* dex_file = exception_type.second; 736 StackHandleScope<2> hs(self); 737 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(*dex_file))); 738 Handle<mirror::Class> klass(hs.NewHandle( 739 class_linker->ResolveType(*dex_file, exception_type_idx, dex_cache, 740 NullHandle<mirror::ClassLoader>()))); 741 if (klass.Get() == nullptr) { 742 const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx); 743 const char* descriptor = dex_file->GetTypeDescriptor(type_id); 744 LOG(FATAL) << "Failed to resolve class " << descriptor; 745 } 746 DCHECK(java_lang_Throwable->IsAssignableFrom(klass.Get())); 747 } 748 // Resolving exceptions may load classes that reference more exceptions, iterate until no 749 // more are found 750 } while (!unresolved_exception_types.empty()); 751 752 // We walk the roots looking for classes so that we'll pick up the 753 // above classes plus any classes them depend on such super 754 // classes, interfaces, and the required ClassLinker roots. 755 class_linker->VisitClasses(RecordImageClassesVisitor, image_classes_.get()); 756 757 CHECK_NE(image_classes_->size(), 0U); 758} 759 760static void MaybeAddToImageClasses(Handle<mirror::Class> c, std::set<std::string>* image_classes) 761 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 762 Thread* self = Thread::Current(); 763 StackHandleScope<1> hs(self); 764 // Make a copy of the handle so that we don't clobber it doing Assign. 765 Handle<mirror::Class> klass(hs.NewHandle(c.Get())); 766 std::string temp; 767 while (!klass->IsObjectClass()) { 768 const char* descriptor = klass->GetDescriptor(&temp); 769 std::pair<std::set<std::string>::iterator, bool> result = image_classes->insert(descriptor); 770 if (!result.second) { // Previously inserted. 771 break; 772 } 773 VLOG(compiler) << "Adding " << descriptor << " to image classes"; 774 for (size_t i = 0; i < klass->NumDirectInterfaces(); ++i) { 775 StackHandleScope<1> hs(self); 776 MaybeAddToImageClasses(hs.NewHandle(mirror::Class::GetDirectInterface(self, klass, i)), 777 image_classes); 778 } 779 if (klass->IsArrayClass()) { 780 StackHandleScope<1> hs(self); 781 MaybeAddToImageClasses(hs.NewHandle(klass->GetComponentType()), image_classes); 782 } 783 klass.Assign(klass->GetSuperClass()); 784 } 785} 786 787void CompilerDriver::FindClinitImageClassesCallback(mirror::Object* object, void* arg) { 788 DCHECK(object != nullptr); 789 DCHECK(arg != nullptr); 790 CompilerDriver* compiler_driver = reinterpret_cast<CompilerDriver*>(arg); 791 StackHandleScope<1> hs(Thread::Current()); 792 MaybeAddToImageClasses(hs.NewHandle(object->GetClass()), compiler_driver->image_classes_.get()); 793} 794 795void CompilerDriver::UpdateImageClasses(TimingLogger* timings) { 796 if (IsImage()) { 797 TimingLogger::ScopedTiming t("UpdateImageClasses", timings); 798 // Update image_classes_ with classes for objects created by <clinit> methods. 799 Thread* self = Thread::Current(); 800 const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter"); 801 gc::Heap* heap = Runtime::Current()->GetHeap(); 802 // TODO: Image spaces only? 803 ScopedObjectAccess soa(Thread::Current()); 804 WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); 805 heap->VisitObjects(FindClinitImageClassesCallback, this); 806 self->EndAssertNoThreadSuspension(old_cause); 807 } 808} 809 810bool CompilerDriver::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx) { 811 if (IsImage() && 812 IsImageClass(dex_file.StringDataByIdx(dex_file.GetTypeId(type_idx).descriptor_idx_))) { 813 { 814 ScopedObjectAccess soa(Thread::Current()); 815 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file); 816 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 817 if (resolved_class == nullptr) { 818 // Erroneous class. 819 stats_->TypeNotInDexCache(); 820 return false; 821 } 822 } 823 stats_->TypeInDexCache(); 824 return true; 825 } else { 826 stats_->TypeNotInDexCache(); 827 return false; 828 } 829} 830 831bool CompilerDriver::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, 832 uint32_t string_idx) { 833 // See also Compiler::ResolveDexFile 834 835 bool result = false; 836 if (IsImage()) { 837 // We resolve all const-string strings when building for the image. 838 ScopedObjectAccess soa(Thread::Current()); 839 StackHandleScope<1> hs(soa.Self()); 840 Handle<mirror::DexCache> dex_cache( 841 hs.NewHandle(Runtime::Current()->GetClassLinker()->FindDexCache(dex_file))); 842 Runtime::Current()->GetClassLinker()->ResolveString(dex_file, string_idx, dex_cache); 843 result = true; 844 } 845 if (result) { 846 stats_->StringInDexCache(); 847 } else { 848 stats_->StringNotInDexCache(); 849 } 850 return result; 851} 852 853bool CompilerDriver::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, 854 uint32_t type_idx, 855 bool* type_known_final, bool* type_known_abstract, 856 bool* equals_referrers_class) { 857 if (type_known_final != nullptr) { 858 *type_known_final = false; 859 } 860 if (type_known_abstract != nullptr) { 861 *type_known_abstract = false; 862 } 863 if (equals_referrers_class != nullptr) { 864 *equals_referrers_class = false; 865 } 866 ScopedObjectAccess soa(Thread::Current()); 867 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file); 868 // Get type from dex cache assuming it was populated by the verifier 869 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 870 if (resolved_class == nullptr) { 871 stats_->TypeNeedsAccessCheck(); 872 return false; // Unknown class needs access checks. 873 } 874 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx); 875 if (equals_referrers_class != nullptr) { 876 *equals_referrers_class = (method_id.class_idx_ == type_idx); 877 } 878 mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_); 879 if (referrer_class == nullptr) { 880 stats_->TypeNeedsAccessCheck(); 881 return false; // Incomplete referrer knowledge needs access check. 882 } 883 // Perform access check, will return true if access is ok or false if we're going to have to 884 // check this at runtime (for example for class loaders). 885 bool result = referrer_class->CanAccess(resolved_class); 886 if (result) { 887 stats_->TypeDoesntNeedAccessCheck(); 888 if (type_known_final != nullptr) { 889 *type_known_final = resolved_class->IsFinal() && !resolved_class->IsArrayClass(); 890 } 891 if (type_known_abstract != nullptr) { 892 *type_known_abstract = resolved_class->IsAbstract() && !resolved_class->IsArrayClass(); 893 } 894 } else { 895 stats_->TypeNeedsAccessCheck(); 896 } 897 return result; 898} 899 900bool CompilerDriver::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, 901 const DexFile& dex_file, 902 uint32_t type_idx) { 903 ScopedObjectAccess soa(Thread::Current()); 904 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file); 905 // Get type from dex cache assuming it was populated by the verifier. 906 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 907 if (resolved_class == nullptr) { 908 stats_->TypeNeedsAccessCheck(); 909 return false; // Unknown class needs access checks. 910 } 911 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx); 912 mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_); 913 if (referrer_class == nullptr) { 914 stats_->TypeNeedsAccessCheck(); 915 return false; // Incomplete referrer knowledge needs access check. 916 } 917 // Perform access and instantiable checks, will return true if access is ok or false if we're 918 // going to have to check this at runtime (for example for class loaders). 919 bool result = referrer_class->CanAccess(resolved_class) && resolved_class->IsInstantiable(); 920 if (result) { 921 stats_->TypeDoesntNeedAccessCheck(); 922 } else { 923 stats_->TypeNeedsAccessCheck(); 924 } 925 return result; 926} 927 928bool CompilerDriver::CanEmbedTypeInCode(const DexFile& dex_file, uint32_t type_idx, 929 bool* is_type_initialized, bool* use_direct_type_ptr, 930 uintptr_t* direct_type_ptr, bool* out_is_finalizable) { 931 ScopedObjectAccess soa(Thread::Current()); 932 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file); 933 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 934 if (resolved_class == nullptr) { 935 return false; 936 } 937 if (GetCompilerOptions().GetCompilePic()) { 938 // Do not allow a direct class pointer to be used when compiling for position-independent 939 return false; 940 } 941 *out_is_finalizable = resolved_class->IsFinalizable(); 942 const bool compiling_boot = Runtime::Current()->GetHeap()->IsCompilingBoot(); 943 const bool support_boot_image_fixup = GetSupportBootImageFixup(); 944 if (compiling_boot) { 945 // boot -> boot class pointers. 946 // True if the class is in the image at boot compiling time. 947 const bool is_image_class = IsImage() && IsImageClass( 948 dex_file.StringDataByIdx(dex_file.GetTypeId(type_idx).descriptor_idx_)); 949 // True if pc relative load works. 950 if (is_image_class && support_boot_image_fixup) { 951 *is_type_initialized = resolved_class->IsInitialized(); 952 *use_direct_type_ptr = false; 953 *direct_type_ptr = 0; 954 return true; 955 } else { 956 return false; 957 } 958 } else { 959 // True if the class is in the image at app compiling time. 960 const bool class_in_image = 961 Runtime::Current()->GetHeap()->FindSpaceFromObject(resolved_class, false)->IsImageSpace(); 962 if (class_in_image && support_boot_image_fixup) { 963 // boot -> app class pointers. 964 *is_type_initialized = resolved_class->IsInitialized(); 965 // TODO This is somewhat hacky. We should refactor all of this invoke codepath. 966 *use_direct_type_ptr = !GetCompilerOptions().GetIncludePatchInformation(); 967 *direct_type_ptr = reinterpret_cast<uintptr_t>(resolved_class); 968 return true; 969 } else { 970 // app -> app class pointers. 971 // Give up because app does not have an image and class 972 // isn't created at compile time. TODO: implement this 973 // if/when each app gets an image. 974 return false; 975 } 976 } 977} 978 979void CompilerDriver::ProcessedInstanceField(bool resolved) { 980 if (!resolved) { 981 stats_->UnresolvedInstanceField(); 982 } else { 983 stats_->ResolvedInstanceField(); 984 } 985} 986 987void CompilerDriver::ProcessedStaticField(bool resolved, bool local) { 988 if (!resolved) { 989 stats_->UnresolvedStaticField(); 990 } else if (local) { 991 stats_->ResolvedLocalStaticField(); 992 } else { 993 stats_->ResolvedStaticField(); 994 } 995} 996 997void CompilerDriver::ProcessedInvoke(InvokeType invoke_type, int flags) { 998 stats_->ProcessedInvoke(invoke_type, flags); 999} 1000 1001mirror::ArtField* CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, 1002 const DexCompilationUnit* mUnit, 1003 bool is_put, 1004 const ScopedObjectAccess& soa) { 1005 // Try to resolve the field and compiling method's class. 1006 mirror::ArtField* resolved_field; 1007 mirror::Class* referrer_class; 1008 mirror::DexCache* dex_cache; 1009 { 1010 StackHandleScope<3> hs(soa.Self()); 1011 Handle<mirror::DexCache> dex_cache_handle( 1012 hs.NewHandle(mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()))); 1013 Handle<mirror::ClassLoader> class_loader_handle( 1014 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()))); 1015 Handle<mirror::ArtField> resolved_field_handle(hs.NewHandle( 1016 ResolveField(soa, dex_cache_handle, class_loader_handle, mUnit, field_idx, false))); 1017 referrer_class = (resolved_field_handle.Get() != nullptr) 1018 ? ResolveCompilingMethodsClass(soa, dex_cache_handle, class_loader_handle, mUnit) : nullptr; 1019 resolved_field = resolved_field_handle.Get(); 1020 dex_cache = dex_cache_handle.Get(); 1021 } 1022 bool can_link = false; 1023 if (resolved_field != nullptr && referrer_class != nullptr) { 1024 std::pair<bool, bool> fast_path = IsFastInstanceField( 1025 dex_cache, referrer_class, resolved_field, field_idx); 1026 can_link = is_put ? fast_path.second : fast_path.first; 1027 } 1028 ProcessedInstanceField(can_link); 1029 return can_link ? resolved_field : nullptr; 1030} 1031 1032bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, 1033 bool is_put, MemberOffset* field_offset, 1034 bool* is_volatile) { 1035 ScopedObjectAccess soa(Thread::Current()); 1036 StackHandleScope<1> hs(soa.Self()); 1037 Handle<mirror::ArtField> resolved_field = 1038 hs.NewHandle(ComputeInstanceFieldInfo(field_idx, mUnit, is_put, soa)); 1039 1040 if (resolved_field.Get() == nullptr) { 1041 // Conservative defaults. 1042 *is_volatile = true; 1043 *field_offset = MemberOffset(static_cast<size_t>(-1)); 1044 return false; 1045 } else { 1046 *is_volatile = resolved_field->IsVolatile(); 1047 *field_offset = resolved_field->GetOffset(); 1048 return true; 1049 } 1050} 1051 1052bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, 1053 bool is_put, MemberOffset* field_offset, 1054 uint32_t* storage_index, bool* is_referrers_class, 1055 bool* is_volatile, bool* is_initialized) { 1056 ScopedObjectAccess soa(Thread::Current()); 1057 // Try to resolve the field and compiling method's class. 1058 mirror::ArtField* resolved_field; 1059 mirror::Class* referrer_class; 1060 mirror::DexCache* dex_cache; 1061 { 1062 StackHandleScope<3> hs(soa.Self()); 1063 Handle<mirror::DexCache> dex_cache_handle( 1064 hs.NewHandle(mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()))); 1065 Handle<mirror::ClassLoader> class_loader_handle( 1066 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()))); 1067 Handle<mirror::ArtField> resolved_field_handle(hs.NewHandle( 1068 ResolveField(soa, dex_cache_handle, class_loader_handle, mUnit, field_idx, true))); 1069 referrer_class = (resolved_field_handle.Get() != nullptr) 1070 ? ResolveCompilingMethodsClass(soa, dex_cache_handle, class_loader_handle, mUnit) : nullptr; 1071 resolved_field = resolved_field_handle.Get(); 1072 dex_cache = dex_cache_handle.Get(); 1073 } 1074 bool result = false; 1075 if (resolved_field != nullptr && referrer_class != nullptr) { 1076 *is_volatile = IsFieldVolatile(resolved_field); 1077 std::pair<bool, bool> fast_path = IsFastStaticField( 1078 dex_cache, referrer_class, resolved_field, field_idx, field_offset, 1079 storage_index, is_referrers_class, is_initialized); 1080 result = is_put ? fast_path.second : fast_path.first; 1081 } 1082 if (!result) { 1083 // Conservative defaults. 1084 *is_volatile = true; 1085 *field_offset = MemberOffset(static_cast<size_t>(-1)); 1086 *storage_index = -1; 1087 *is_referrers_class = false; 1088 *is_initialized = false; 1089 } 1090 ProcessedStaticField(result, *is_referrers_class); 1091 return result; 1092} 1093 1094void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type, 1095 bool no_guarantee_of_dex_cache_entry, 1096 const mirror::Class* referrer_class, 1097 mirror::ArtMethod* method, 1098 int* stats_flags, 1099 MethodReference* target_method, 1100 uintptr_t* direct_code, 1101 uintptr_t* direct_method) { 1102 // For direct and static methods compute possible direct_code and direct_method values, ie 1103 // an address for the Method* being invoked and an address of the code for that Method*. 1104 // For interface calls compute a value for direct_method that is the interface method being 1105 // invoked, so this can be passed to the out-of-line runtime support code. 1106 *direct_code = 0; 1107 *direct_method = 0; 1108 bool use_dex_cache = GetCompilerOptions().GetCompilePic(); // Off by default 1109 const bool compiling_boot = Runtime::Current()->GetHeap()->IsCompilingBoot(); 1110 // TODO This is somewhat hacky. We should refactor all of this invoke codepath. 1111 const bool force_relocations = (compiling_boot || 1112 GetCompilerOptions().GetIncludePatchInformation()); 1113 if (compiler_->IsPortable()) { 1114 if (sharp_type != kStatic && sharp_type != kDirect) { 1115 return; 1116 } 1117 use_dex_cache = true; 1118 } else { 1119 if (sharp_type != kStatic && sharp_type != kDirect) { 1120 return; 1121 } 1122 // TODO: support patching on all architectures. 1123 use_dex_cache = use_dex_cache || (force_relocations && !support_boot_image_fixup_); 1124 } 1125 bool method_code_in_boot = (method->GetDeclaringClass()->GetClassLoader() == nullptr); 1126 if (!use_dex_cache) { 1127 if (!method_code_in_boot) { 1128 use_dex_cache = true; 1129 } else { 1130 bool has_clinit_trampoline = 1131 method->IsStatic() && !method->GetDeclaringClass()->IsInitialized(); 1132 if (has_clinit_trampoline && (method->GetDeclaringClass() != referrer_class)) { 1133 // Ensure we run the clinit trampoline unless we are invoking a static method in the same 1134 // class. 1135 use_dex_cache = true; 1136 } 1137 } 1138 } 1139 if (method_code_in_boot) { 1140 *stats_flags |= kFlagDirectCallToBoot | kFlagDirectMethodToBoot; 1141 } 1142 if (!use_dex_cache && force_relocations) { 1143 if (!IsImage() || !IsImageClass(method->GetDeclaringClassDescriptor())) { 1144 // We can only branch directly to Methods that are resolved in the DexCache. 1145 // Otherwise we won't invoke the resolution trampoline. 1146 use_dex_cache = true; 1147 } 1148 } 1149 // The method is defined not within this dex file. We need a dex cache slot within the current 1150 // dex file or direct pointers. 1151 bool must_use_direct_pointers = false; 1152 if (target_method->dex_file == method->GetDeclaringClass()->GetDexCache()->GetDexFile()) { 1153 target_method->dex_method_index = method->GetDexMethodIndex(); 1154 } else { 1155 if (no_guarantee_of_dex_cache_entry) { 1156 StackHandleScope<1> hs(Thread::Current()); 1157 MethodHelper mh(hs.NewHandle(method)); 1158 // See if the method is also declared in this dex cache. 1159 uint32_t dex_method_idx = mh.FindDexMethodIndexInOtherDexFile( 1160 *target_method->dex_file, target_method->dex_method_index); 1161 if (dex_method_idx != DexFile::kDexNoIndex) { 1162 target_method->dex_method_index = dex_method_idx; 1163 } else { 1164 if (force_relocations && !use_dex_cache) { 1165 target_method->dex_method_index = method->GetDexMethodIndex(); 1166 target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile(); 1167 } 1168 must_use_direct_pointers = true; 1169 } 1170 } 1171 } 1172 if (use_dex_cache) { 1173 if (must_use_direct_pointers) { 1174 // Fail. Test above showed the only safe dispatch was via the dex cache, however, the direct 1175 // pointers are required as the dex cache lacks an appropriate entry. 1176 VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method); 1177 } else { 1178 *type = sharp_type; 1179 } 1180 } else { 1181 bool method_in_image = 1182 Runtime::Current()->GetHeap()->FindSpaceFromObject(method, false)->IsImageSpace(); 1183 if (method_in_image || compiling_boot) { 1184 // We know we must be able to get to the method in the image, so use that pointer. 1185 CHECK(!method->IsAbstract()); 1186 *type = sharp_type; 1187 *direct_method = force_relocations ? -1 : reinterpret_cast<uintptr_t>(method); 1188 *direct_code = force_relocations ? -1 : compiler_->GetEntryPointOf(method); 1189 target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile(); 1190 target_method->dex_method_index = method->GetDexMethodIndex(); 1191 } else if (!must_use_direct_pointers) { 1192 // Set the code and rely on the dex cache for the method. 1193 *type = sharp_type; 1194 if (force_relocations) { 1195 *direct_code = -1; 1196 target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile(); 1197 target_method->dex_method_index = method->GetDexMethodIndex(); 1198 } else { 1199 *direct_code = compiler_->GetEntryPointOf(method); 1200 } 1201 } else { 1202 // Direct pointers were required but none were available. 1203 VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method); 1204 } 1205 } 1206} 1207 1208bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc, 1209 bool update_stats, bool enable_devirtualization, 1210 InvokeType* invoke_type, MethodReference* target_method, 1211 int* vtable_idx, uintptr_t* direct_code, 1212 uintptr_t* direct_method) { 1213 InvokeType orig_invoke_type = *invoke_type; 1214 int stats_flags = 0; 1215 ScopedObjectAccess soa(Thread::Current()); 1216 // Try to resolve the method and compiling method's class. 1217 mirror::ArtMethod* resolved_method; 1218 mirror::Class* referrer_class; 1219 StackHandleScope<3> hs(soa.Self()); 1220 Handle<mirror::DexCache> dex_cache( 1221 hs.NewHandle(mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()))); 1222 Handle<mirror::ClassLoader> class_loader(hs.NewHandle( 1223 soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()))); 1224 { 1225 uint32_t method_idx = target_method->dex_method_index; 1226 Handle<mirror::ArtMethod> resolved_method_handle(hs.NewHandle( 1227 ResolveMethod(soa, dex_cache, class_loader, mUnit, method_idx, orig_invoke_type))); 1228 referrer_class = (resolved_method_handle.Get() != nullptr) 1229 ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader, mUnit) : nullptr; 1230 resolved_method = resolved_method_handle.Get(); 1231 } 1232 bool result = false; 1233 if (resolved_method != nullptr) { 1234 *vtable_idx = GetResolvedMethodVTableIndex(resolved_method, orig_invoke_type); 1235 1236 if (enable_devirtualization) { 1237 DCHECK(mUnit->GetVerifiedMethod() != nullptr); 1238 const MethodReference* devirt_target = mUnit->GetVerifiedMethod()->GetDevirtTarget(dex_pc); 1239 1240 stats_flags = IsFastInvoke( 1241 soa, dex_cache, class_loader, mUnit, referrer_class, resolved_method, 1242 invoke_type, target_method, devirt_target, direct_code, direct_method); 1243 result = stats_flags != 0; 1244 } else { 1245 // Devirtualization not enabled. Inline IsFastInvoke(), dropping the devirtualization parts. 1246 if (UNLIKELY(referrer_class == nullptr) || 1247 UNLIKELY(!referrer_class->CanAccessResolvedMethod(resolved_method->GetDeclaringClass(), 1248 resolved_method, dex_cache.Get(), 1249 target_method->dex_method_index)) || 1250 *invoke_type == kSuper) { 1251 // Slow path. (Without devirtualization, all super calls go slow path as well.) 1252 } else { 1253 // Sharpening failed so generate a regular resolved method dispatch. 1254 stats_flags = kFlagMethodResolved; 1255 GetCodeAndMethodForDirectCall(invoke_type, *invoke_type, false, referrer_class, resolved_method, 1256 &stats_flags, target_method, direct_code, direct_method); 1257 result = true; 1258 } 1259 } 1260 } 1261 if (!result) { 1262 // Conservative defaults. 1263 *vtable_idx = -1; 1264 *direct_code = 0u; 1265 *direct_method = 0u; 1266 } 1267 if (update_stats) { 1268 ProcessedInvoke(orig_invoke_type, stats_flags); 1269 } 1270 return result; 1271} 1272 1273const VerifiedMethod* CompilerDriver::GetVerifiedMethod(const DexFile* dex_file, 1274 uint32_t method_idx) const { 1275 MethodReference ref(dex_file, method_idx); 1276 return verification_results_->GetVerifiedMethod(ref); 1277} 1278 1279bool CompilerDriver::IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc) { 1280 if (!compiler_options_->IsVerificationEnabled()) { 1281 // If we didn't verify, every cast has to be treated as non-safe. 1282 return false; 1283 } 1284 DCHECK(mUnit->GetVerifiedMethod() != nullptr); 1285 bool result = mUnit->GetVerifiedMethod()->IsSafeCast(dex_pc); 1286 if (result) { 1287 stats_->SafeCast(); 1288 } else { 1289 stats_->NotASafeCast(); 1290 } 1291 return result; 1292} 1293 1294void CompilerDriver::AddCodePatch(const DexFile* dex_file, 1295 uint16_t referrer_class_def_idx, 1296 uint32_t referrer_method_idx, 1297 InvokeType referrer_invoke_type, 1298 uint32_t target_method_idx, 1299 const DexFile* target_dex_file, 1300 InvokeType target_invoke_type, 1301 size_t literal_offset) { 1302 MutexLock mu(Thread::Current(), compiled_methods_lock_); 1303 code_to_patch_.push_back(new CallPatchInformation(dex_file, 1304 referrer_class_def_idx, 1305 referrer_method_idx, 1306 referrer_invoke_type, 1307 target_method_idx, 1308 target_dex_file, 1309 target_invoke_type, 1310 literal_offset)); 1311} 1312void CompilerDriver::AddRelativeCodePatch(const DexFile* dex_file, 1313 uint16_t referrer_class_def_idx, 1314 uint32_t referrer_method_idx, 1315 InvokeType referrer_invoke_type, 1316 uint32_t target_method_idx, 1317 const DexFile* target_dex_file, 1318 InvokeType target_invoke_type, 1319 size_t literal_offset, 1320 int32_t pc_relative_offset) { 1321 MutexLock mu(Thread::Current(), compiled_methods_lock_); 1322 code_to_patch_.push_back(new RelativeCallPatchInformation(dex_file, 1323 referrer_class_def_idx, 1324 referrer_method_idx, 1325 referrer_invoke_type, 1326 target_method_idx, 1327 target_dex_file, 1328 target_invoke_type, 1329 literal_offset, 1330 pc_relative_offset)); 1331} 1332void CompilerDriver::AddMethodPatch(const DexFile* dex_file, 1333 uint16_t referrer_class_def_idx, 1334 uint32_t referrer_method_idx, 1335 InvokeType referrer_invoke_type, 1336 uint32_t target_method_idx, 1337 const DexFile* target_dex_file, 1338 InvokeType target_invoke_type, 1339 size_t literal_offset) { 1340 MutexLock mu(Thread::Current(), compiled_methods_lock_); 1341 methods_to_patch_.push_back(new CallPatchInformation(dex_file, 1342 referrer_class_def_idx, 1343 referrer_method_idx, 1344 referrer_invoke_type, 1345 target_method_idx, 1346 target_dex_file, 1347 target_invoke_type, 1348 literal_offset)); 1349} 1350void CompilerDriver::AddClassPatch(const DexFile* dex_file, 1351 uint16_t referrer_class_def_idx, 1352 uint32_t referrer_method_idx, 1353 uint32_t target_type_idx, 1354 size_t literal_offset) { 1355 MutexLock mu(Thread::Current(), compiled_methods_lock_); 1356 classes_to_patch_.push_back(new TypePatchInformation(dex_file, 1357 referrer_class_def_idx, 1358 referrer_method_idx, 1359 target_type_idx, 1360 literal_offset)); 1361} 1362 1363class ParallelCompilationManager { 1364 public: 1365 typedef void Callback(const ParallelCompilationManager* manager, size_t index); 1366 1367 ParallelCompilationManager(ClassLinker* class_linker, 1368 jobject class_loader, 1369 CompilerDriver* compiler, 1370 const DexFile* dex_file, 1371 const std::vector<const DexFile*>& dex_files, 1372 ThreadPool* thread_pool) 1373 : index_(0), 1374 class_linker_(class_linker), 1375 class_loader_(class_loader), 1376 compiler_(compiler), 1377 dex_file_(dex_file), 1378 dex_files_(dex_files), 1379 thread_pool_(thread_pool) {} 1380 1381 ClassLinker* GetClassLinker() const { 1382 CHECK(class_linker_ != nullptr); 1383 return class_linker_; 1384 } 1385 1386 jobject GetClassLoader() const { 1387 return class_loader_; 1388 } 1389 1390 CompilerDriver* GetCompiler() const { 1391 CHECK(compiler_ != nullptr); 1392 return compiler_; 1393 } 1394 1395 const DexFile* GetDexFile() const { 1396 CHECK(dex_file_ != nullptr); 1397 return dex_file_; 1398 } 1399 1400 const std::vector<const DexFile*>& GetDexFiles() const { 1401 return dex_files_; 1402 } 1403 1404 void ForAll(size_t begin, size_t end, Callback callback, size_t work_units) { 1405 Thread* self = Thread::Current(); 1406 self->AssertNoPendingException(); 1407 CHECK_GT(work_units, 0U); 1408 1409 index_.StoreRelaxed(begin); 1410 for (size_t i = 0; i < work_units; ++i) { 1411 thread_pool_->AddTask(self, new ForAllClosure(this, end, callback)); 1412 } 1413 thread_pool_->StartWorkers(self); 1414 1415 // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker 1416 // thread destructor's called below perform join). 1417 CHECK_NE(self->GetState(), kRunnable); 1418 1419 // Wait for all the worker threads to finish. 1420 thread_pool_->Wait(self, true, false); 1421 } 1422 1423 size_t NextIndex() { 1424 return index_.FetchAndAddSequentiallyConsistent(1); 1425 } 1426 1427 private: 1428 class ForAllClosure : public Task { 1429 public: 1430 ForAllClosure(ParallelCompilationManager* manager, size_t end, Callback* callback) 1431 : manager_(manager), 1432 end_(end), 1433 callback_(callback) {} 1434 1435 virtual void Run(Thread* self) { 1436 while (true) { 1437 const size_t index = manager_->NextIndex(); 1438 if (UNLIKELY(index >= end_)) { 1439 break; 1440 } 1441 callback_(manager_, index); 1442 self->AssertNoPendingException(); 1443 } 1444 } 1445 1446 virtual void Finalize() { 1447 delete this; 1448 } 1449 1450 private: 1451 ParallelCompilationManager* const manager_; 1452 const size_t end_; 1453 Callback* const callback_; 1454 }; 1455 1456 AtomicInteger index_; 1457 ClassLinker* const class_linker_; 1458 const jobject class_loader_; 1459 CompilerDriver* const compiler_; 1460 const DexFile* const dex_file_; 1461 const std::vector<const DexFile*>& dex_files_; 1462 ThreadPool* const thread_pool_; 1463 1464 DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager); 1465}; 1466 1467// A fast version of SkipClass above if the class pointer is available 1468// that avoids the expensive FindInClassPath search. 1469static bool SkipClass(jobject class_loader, const DexFile& dex_file, mirror::Class* klass) 1470 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 1471 DCHECK(klass != nullptr); 1472 const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile(); 1473 if (&dex_file != &original_dex_file) { 1474 if (class_loader == nullptr) { 1475 LOG(WARNING) << "Skipping class " << PrettyDescriptor(klass) << " from " 1476 << dex_file.GetLocation() << " previously found in " 1477 << original_dex_file.GetLocation(); 1478 } 1479 return true; 1480 } 1481 return false; 1482} 1483 1484static void CheckAndClearResolveException(Thread* self) 1485 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 1486 CHECK(self->IsExceptionPending()); 1487 mirror::Throwable* exception = self->GetException(nullptr); 1488 std::string temp; 1489 const char* descriptor = exception->GetClass()->GetDescriptor(&temp); 1490 const char* expected_exceptions[] = { 1491 "Ljava/lang/IllegalAccessError;", 1492 "Ljava/lang/IncompatibleClassChangeError;", 1493 "Ljava/lang/InstantiationError;", 1494 "Ljava/lang/LinkageError;", 1495 "Ljava/lang/NoClassDefFoundError;", 1496 "Ljava/lang/NoSuchFieldError;", 1497 "Ljava/lang/NoSuchMethodError;" 1498 }; 1499 bool found = false; 1500 for (size_t i = 0; (found == false) && (i < arraysize(expected_exceptions)); ++i) { 1501 if (strcmp(descriptor, expected_exceptions[i]) == 0) { 1502 found = true; 1503 } 1504 } 1505 if (!found) { 1506 LOG(FATAL) << "Unexpected exception " << exception->Dump(); 1507 } 1508 self->ClearException(); 1509} 1510 1511static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager, 1512 size_t class_def_index) 1513 LOCKS_EXCLUDED(Locks::mutator_lock_) { 1514 ATRACE_CALL(); 1515 Thread* self = Thread::Current(); 1516 jobject jclass_loader = manager->GetClassLoader(); 1517 const DexFile& dex_file = *manager->GetDexFile(); 1518 ClassLinker* class_linker = manager->GetClassLinker(); 1519 1520 // If an instance field is final then we need to have a barrier on the return, static final 1521 // fields are assigned within the lock held for class initialization. Conservatively assume 1522 // constructor barriers are always required. 1523 bool requires_constructor_barrier = true; 1524 1525 // Method and Field are the worst. We can't resolve without either 1526 // context from the code use (to disambiguate virtual vs direct 1527 // method and instance vs static field) or from class 1528 // definitions. While the compiler will resolve what it can as it 1529 // needs it, here we try to resolve fields and methods used in class 1530 // definitions, since many of them many never be referenced by 1531 // generated code. 1532 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1533 ScopedObjectAccess soa(self); 1534 StackHandleScope<2> hs(soa.Self()); 1535 Handle<mirror::ClassLoader> class_loader( 1536 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 1537 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(dex_file))); 1538 // Resolve the class. 1539 mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache, 1540 class_loader); 1541 bool resolve_fields_and_methods; 1542 if (klass == nullptr) { 1543 // Class couldn't be resolved, for example, super-class is in a different dex file. Don't 1544 // attempt to resolve methods and fields when there is no declaring class. 1545 CheckAndClearResolveException(soa.Self()); 1546 resolve_fields_and_methods = false; 1547 } else { 1548 // We successfully resolved a class, should we skip it? 1549 if (SkipClass(jclass_loader, dex_file, klass)) { 1550 return; 1551 } 1552 // We want to resolve the methods and fields eagerly. 1553 resolve_fields_and_methods = true; 1554 } 1555 // Note the class_data pointer advances through the headers, 1556 // static fields, instance fields, direct methods, and virtual 1557 // methods. 1558 const byte* class_data = dex_file.GetClassData(class_def); 1559 if (class_data == nullptr) { 1560 // Empty class such as a marker interface. 1561 requires_constructor_barrier = false; 1562 } else { 1563 ClassDataItemIterator it(dex_file, class_data); 1564 while (it.HasNextStaticField()) { 1565 if (resolve_fields_and_methods) { 1566 mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), 1567 dex_cache, class_loader, true); 1568 if (field == nullptr) { 1569 CheckAndClearResolveException(soa.Self()); 1570 } 1571 } 1572 it.Next(); 1573 } 1574 // We require a constructor barrier if there are final instance fields. 1575 requires_constructor_barrier = false; 1576 while (it.HasNextInstanceField()) { 1577 if (it.MemberIsFinal()) { 1578 requires_constructor_barrier = true; 1579 } 1580 if (resolve_fields_and_methods) { 1581 mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), 1582 dex_cache, class_loader, false); 1583 if (field == nullptr) { 1584 CheckAndClearResolveException(soa.Self()); 1585 } 1586 } 1587 it.Next(); 1588 } 1589 if (resolve_fields_and_methods) { 1590 while (it.HasNextDirectMethod()) { 1591 mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), 1592 dex_cache, class_loader, 1593 NullHandle<mirror::ArtMethod>(), 1594 it.GetMethodInvokeType(class_def)); 1595 if (method == nullptr) { 1596 CheckAndClearResolveException(soa.Self()); 1597 } 1598 it.Next(); 1599 } 1600 while (it.HasNextVirtualMethod()) { 1601 mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), 1602 dex_cache, class_loader, 1603 NullHandle<mirror::ArtMethod>(), 1604 it.GetMethodInvokeType(class_def)); 1605 if (method == nullptr) { 1606 CheckAndClearResolveException(soa.Self()); 1607 } 1608 it.Next(); 1609 } 1610 DCHECK(!it.HasNext()); 1611 } 1612 } 1613 if (requires_constructor_barrier) { 1614 manager->GetCompiler()->AddRequiresConstructorBarrier(self, &dex_file, class_def_index); 1615 } 1616} 1617 1618static void ResolveType(const ParallelCompilationManager* manager, size_t type_idx) 1619 LOCKS_EXCLUDED(Locks::mutator_lock_) { 1620 // Class derived values are more complicated, they require the linker and loader. 1621 ScopedObjectAccess soa(Thread::Current()); 1622 ClassLinker* class_linker = manager->GetClassLinker(); 1623 const DexFile& dex_file = *manager->GetDexFile(); 1624 StackHandleScope<2> hs(soa.Self()); 1625 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(dex_file))); 1626 Handle<mirror::ClassLoader> class_loader( 1627 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader()))); 1628 mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader); 1629 1630 if (klass == nullptr) { 1631 CHECK(soa.Self()->IsExceptionPending()); 1632 mirror::Throwable* exception = soa.Self()->GetException(nullptr); 1633 VLOG(compiler) << "Exception during type resolution: " << exception->Dump(); 1634 if (exception->GetClass()->DescriptorEquals("Ljava/lang/OutOfMemoryError;")) { 1635 // There's little point continuing compilation if the heap is exhausted. 1636 LOG(FATAL) << "Out of memory during type resolution for compilation"; 1637 } 1638 soa.Self()->ClearException(); 1639 } 1640} 1641 1642void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file, 1643 const std::vector<const DexFile*>& dex_files, 1644 ThreadPool* thread_pool, TimingLogger* timings) { 1645 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1646 1647 // TODO: we could resolve strings here, although the string table is largely filled with class 1648 // and method names. 1649 1650 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files, 1651 thread_pool); 1652 if (IsImage()) { 1653 // For images we resolve all types, such as array, whereas for applications just those with 1654 // classdefs are resolved by ResolveClassFieldsAndMethods. 1655 TimingLogger::ScopedTiming t("Resolve Types", timings); 1656 context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_); 1657 } 1658 1659 TimingLogger::ScopedTiming t("Resolve MethodsAndFields", timings); 1660 context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_); 1661} 1662 1663void CompilerDriver::SetVerified(jobject class_loader, const std::vector<const DexFile*>& dex_files, 1664 ThreadPool* thread_pool, TimingLogger* timings) { 1665 for (size_t i = 0; i != dex_files.size(); ++i) { 1666 const DexFile* dex_file = dex_files[i]; 1667 CHECK(dex_file != nullptr); 1668 SetVerifiedDexFile(class_loader, *dex_file, dex_files, thread_pool, timings); 1669 } 1670} 1671 1672void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files, 1673 ThreadPool* thread_pool, TimingLogger* timings) { 1674 for (size_t i = 0; i != dex_files.size(); ++i) { 1675 const DexFile* dex_file = dex_files[i]; 1676 CHECK(dex_file != nullptr); 1677 VerifyDexFile(class_loader, *dex_file, dex_files, thread_pool, timings); 1678 } 1679} 1680 1681static void VerifyClass(const ParallelCompilationManager* manager, size_t class_def_index) 1682 LOCKS_EXCLUDED(Locks::mutator_lock_) { 1683 ATRACE_CALL(); 1684 ScopedObjectAccess soa(Thread::Current()); 1685 const DexFile& dex_file = *manager->GetDexFile(); 1686 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1687 const char* descriptor = dex_file.GetClassDescriptor(class_def); 1688 ClassLinker* class_linker = manager->GetClassLinker(); 1689 jobject jclass_loader = manager->GetClassLoader(); 1690 StackHandleScope<3> hs(soa.Self()); 1691 Handle<mirror::ClassLoader> class_loader( 1692 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 1693 Handle<mirror::Class> klass( 1694 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader))); 1695 if (klass.Get() == nullptr) { 1696 CHECK(soa.Self()->IsExceptionPending()); 1697 soa.Self()->ClearException(); 1698 1699 /* 1700 * At compile time, we can still structurally verify the class even if FindClass fails. 1701 * This is to ensure the class is structurally sound for compilation. An unsound class 1702 * will be rejected by the verifier and later skipped during compilation in the compiler. 1703 */ 1704 Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(dex_file))); 1705 std::string error_msg; 1706 if (verifier::MethodVerifier::VerifyClass(&dex_file, dex_cache, class_loader, &class_def, true, 1707 &error_msg) == 1708 verifier::MethodVerifier::kHardFailure) { 1709 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor) 1710 << " because: " << error_msg; 1711 } 1712 } else if (!SkipClass(jclass_loader, dex_file, klass.Get())) { 1713 CHECK(klass->IsResolved()) << PrettyClass(klass.Get()); 1714 class_linker->VerifyClass(klass); 1715 1716 if (klass->IsErroneous()) { 1717 // ClassLinker::VerifyClass throws, which isn't useful in the compiler. 1718 CHECK(soa.Self()->IsExceptionPending()); 1719 soa.Self()->ClearException(); 1720 } 1721 1722 CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous()) 1723 << PrettyDescriptor(klass.Get()) << ": state=" << klass->GetStatus(); 1724 } 1725 soa.Self()->AssertNoPendingException(); 1726} 1727 1728void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file, 1729 const std::vector<const DexFile*>& dex_files, 1730 ThreadPool* thread_pool, TimingLogger* timings) { 1731 TimingLogger::ScopedTiming t("Verify Dex File", timings); 1732 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1733 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files, 1734 thread_pool); 1735 context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_); 1736} 1737 1738static void SetVerifiedClass(const ParallelCompilationManager* manager, size_t class_def_index) 1739 LOCKS_EXCLUDED(Locks::mutator_lock_) { 1740 ATRACE_CALL(); 1741 ScopedObjectAccess soa(Thread::Current()); 1742 const DexFile& dex_file = *manager->GetDexFile(); 1743 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1744 const char* descriptor = dex_file.GetClassDescriptor(class_def); 1745 ClassLinker* class_linker = manager->GetClassLinker(); 1746 jobject jclass_loader = manager->GetClassLoader(); 1747 StackHandleScope<3> hs(soa.Self()); 1748 Handle<mirror::ClassLoader> class_loader( 1749 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 1750 Handle<mirror::Class> klass( 1751 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader))); 1752 // Class might have failed resolution. Then don't set it to verified. 1753 if (klass.Get() != nullptr) { 1754 // Only do this if the class is resolved. If even resolution fails, quickening will go very, 1755 // very wrong. 1756 if (klass->IsResolved()) { 1757 if (klass->GetStatus() < mirror::Class::kStatusVerified) { 1758 ObjectLock<mirror::Class> lock(soa.Self(), klass); 1759 klass->SetStatus(mirror::Class::kStatusVerified, soa.Self()); 1760 } 1761 // Record the final class status if necessary. 1762 ClassReference ref(manager->GetDexFile(), class_def_index); 1763 manager->GetCompiler()->RecordClassStatus(ref, klass->GetStatus()); 1764 } 1765 } else { 1766 Thread* self = soa.Self(); 1767 DCHECK(self->IsExceptionPending()); 1768 self->ClearException(); 1769 } 1770} 1771 1772void CompilerDriver::SetVerifiedDexFile(jobject class_loader, const DexFile& dex_file, 1773 const std::vector<const DexFile*>& dex_files, 1774 ThreadPool* thread_pool, TimingLogger* timings) { 1775 TimingLogger::ScopedTiming t("Verify Dex File", timings); 1776 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1777 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files, 1778 thread_pool); 1779 context.ForAll(0, dex_file.NumClassDefs(), SetVerifiedClass, thread_count_); 1780} 1781 1782static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index) 1783 LOCKS_EXCLUDED(Locks::mutator_lock_) { 1784 ATRACE_CALL(); 1785 jobject jclass_loader = manager->GetClassLoader(); 1786 const DexFile& dex_file = *manager->GetDexFile(); 1787 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1788 const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_); 1789 const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_); 1790 1791 ScopedObjectAccess soa(Thread::Current()); 1792 StackHandleScope<3> hs(soa.Self()); 1793 Handle<mirror::ClassLoader> class_loader( 1794 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 1795 Handle<mirror::Class> klass( 1796 hs.NewHandle(manager->GetClassLinker()->FindClass(soa.Self(), descriptor, class_loader))); 1797 1798 if (klass.Get() != nullptr && !SkipClass(jclass_loader, dex_file, klass.Get())) { 1799 // Only try to initialize classes that were successfully verified. 1800 if (klass->IsVerified()) { 1801 // Attempt to initialize the class but bail if we either need to initialize the super-class 1802 // or static fields. 1803 manager->GetClassLinker()->EnsureInitialized(klass, false, false); 1804 if (!klass->IsInitialized()) { 1805 // We don't want non-trivial class initialization occurring on multiple threads due to 1806 // deadlock problems. For example, a parent class is initialized (holding its lock) that 1807 // refers to a sub-class in its static/class initializer causing it to try to acquire the 1808 // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock) 1809 // after first initializing its parents, whose locks are acquired. This leads to a 1810 // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock. 1811 // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather 1812 // than use a special Object for the purpose we use the Class of java.lang.Class. 1813 Handle<mirror::Class> h_klass(hs.NewHandle(klass->GetClass())); 1814 ObjectLock<mirror::Class> lock(soa.Self(), h_klass); 1815 // Attempt to initialize allowing initialization of parent classes but still not static 1816 // fields. 1817 manager->GetClassLinker()->EnsureInitialized(klass, false, true); 1818 if (!klass->IsInitialized()) { 1819 // We need to initialize static fields, we only do this for image classes that aren't 1820 // marked with the $NoPreloadHolder (which implies this should not be initialized early). 1821 bool can_init_static_fields = manager->GetCompiler()->IsImage() && 1822 manager->GetCompiler()->IsImageClass(descriptor) && 1823 !StringPiece(descriptor).ends_with("$NoPreloadHolder;"); 1824 if (can_init_static_fields) { 1825 VLOG(compiler) << "Initializing: " << descriptor; 1826 // TODO multithreading support. We should ensure the current compilation thread has 1827 // exclusive access to the runtime and the transaction. To achieve this, we could use 1828 // a ReaderWriterMutex but we're holding the mutator lock so we fail mutex sanity 1829 // checks in Thread::AssertThreadSuspensionIsAllowable. 1830 Runtime* const runtime = Runtime::Current(); 1831 Transaction transaction; 1832 1833 // Run the class initializer in transaction mode. 1834 runtime->EnterTransactionMode(&transaction); 1835 const mirror::Class::Status old_status = klass->GetStatus(); 1836 bool success = manager->GetClassLinker()->EnsureInitialized(klass, true, true); 1837 // TODO we detach transaction from runtime to indicate we quit the transactional 1838 // mode which prevents the GC from visiting objects modified during the transaction. 1839 // Ensure GC is not run so don't access freed objects when aborting transaction. 1840 const char* old_casue = soa.Self()->StartAssertNoThreadSuspension("Transaction end"); 1841 runtime->ExitTransactionMode(); 1842 1843 if (!success) { 1844 CHECK(soa.Self()->IsExceptionPending()); 1845 ThrowLocation throw_location; 1846 mirror::Throwable* exception = soa.Self()->GetException(&throw_location); 1847 VLOG(compiler) << "Initialization of " << descriptor << " aborted because of " 1848 << exception->Dump(); 1849 soa.Self()->ClearException(); 1850 transaction.Abort(); 1851 CHECK_EQ(old_status, klass->GetStatus()) << "Previous class status not restored"; 1852 } 1853 soa.Self()->EndAssertNoThreadSuspension(old_casue); 1854 } 1855 } 1856 soa.Self()->AssertNoPendingException(); 1857 } 1858 } 1859 // Record the final class status if necessary. 1860 ClassReference ref(manager->GetDexFile(), class_def_index); 1861 manager->GetCompiler()->RecordClassStatus(ref, klass->GetStatus()); 1862 } 1863 // Clear any class not found or verification exceptions. 1864 soa.Self()->ClearException(); 1865} 1866 1867void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file, 1868 const std::vector<const DexFile*>& dex_files, 1869 ThreadPool* thread_pool, TimingLogger* timings) { 1870 TimingLogger::ScopedTiming t("InitializeNoClinit", timings); 1871 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1872 ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, dex_files, 1873 thread_pool); 1874 size_t thread_count; 1875 if (IsImage()) { 1876 // TODO: remove this when transactional mode supports multithreading. 1877 thread_count = 1U; 1878 } else { 1879 thread_count = thread_count_; 1880 } 1881 context.ForAll(0, dex_file.NumClassDefs(), InitializeClass, thread_count); 1882} 1883 1884void CompilerDriver::InitializeClasses(jobject class_loader, 1885 const std::vector<const DexFile*>& dex_files, 1886 ThreadPool* thread_pool, TimingLogger* timings) { 1887 for (size_t i = 0; i != dex_files.size(); ++i) { 1888 const DexFile* dex_file = dex_files[i]; 1889 CHECK(dex_file != nullptr); 1890 InitializeClasses(class_loader, *dex_file, dex_files, thread_pool, timings); 1891 } 1892 if (IsImage()) { 1893 // Prune garbage objects created during aborted transactions. 1894 Runtime::Current()->GetHeap()->CollectGarbage(true); 1895 } 1896} 1897 1898void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 1899 ThreadPool* thread_pool, TimingLogger* timings) { 1900 for (size_t i = 0; i != dex_files.size(); ++i) { 1901 const DexFile* dex_file = dex_files[i]; 1902 CHECK(dex_file != nullptr); 1903 CompileDexFile(class_loader, *dex_file, dex_files, thread_pool, timings); 1904 } 1905} 1906 1907void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, size_t class_def_index) { 1908 ATRACE_CALL(); 1909 const DexFile& dex_file = *manager->GetDexFile(); 1910 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1911 ClassLinker* class_linker = manager->GetClassLinker(); 1912 jobject jclass_loader = manager->GetClassLoader(); 1913 { 1914 // Use a scoped object access to perform to the quick SkipClass check. 1915 const char* descriptor = dex_file.GetClassDescriptor(class_def); 1916 ScopedObjectAccess soa(Thread::Current()); 1917 StackHandleScope<3> hs(soa.Self()); 1918 Handle<mirror::ClassLoader> class_loader( 1919 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 1920 Handle<mirror::Class> klass( 1921 hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader))); 1922 if (klass.Get() == nullptr) { 1923 CHECK(soa.Self()->IsExceptionPending()); 1924 soa.Self()->ClearException(); 1925 } else if (SkipClass(jclass_loader, dex_file, klass.Get())) { 1926 return; 1927 } 1928 } 1929 ClassReference ref(&dex_file, class_def_index); 1930 // Skip compiling classes with generic verifier failures since they will still fail at runtime 1931 if (manager->GetCompiler()->verification_results_->IsClassRejected(ref)) { 1932 return; 1933 } 1934 const byte* class_data = dex_file.GetClassData(class_def); 1935 if (class_data == nullptr) { 1936 // empty class, probably a marker interface 1937 return; 1938 } 1939 1940 // Can we run DEX-to-DEX compiler on this class ? 1941 DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile; 1942 { 1943 ScopedObjectAccess soa(Thread::Current()); 1944 StackHandleScope<1> hs(soa.Self()); 1945 Handle<mirror::ClassLoader> class_loader( 1946 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader))); 1947 dex_to_dex_compilation_level = GetDexToDexCompilationlevel(soa.Self(), class_loader, dex_file, 1948 class_def); 1949 } 1950 ClassDataItemIterator it(dex_file, class_data); 1951 // Skip fields 1952 while (it.HasNextStaticField()) { 1953 it.Next(); 1954 } 1955 while (it.HasNextInstanceField()) { 1956 it.Next(); 1957 } 1958 CompilerDriver* driver = manager->GetCompiler(); 1959 // Compile direct methods 1960 int64_t previous_direct_method_idx = -1; 1961 while (it.HasNextDirectMethod()) { 1962 uint32_t method_idx = it.GetMemberIndex(); 1963 if (method_idx == previous_direct_method_idx) { 1964 // smali can create dex files with two encoded_methods sharing the same method_idx 1965 // http://code.google.com/p/smali/issues/detail?id=119 1966 it.Next(); 1967 continue; 1968 } 1969 previous_direct_method_idx = method_idx; 1970 driver->CompileMethod(it.GetMethodCodeItem(), it.GetMethodAccessFlags(), 1971 it.GetMethodInvokeType(class_def), class_def_index, 1972 method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level); 1973 it.Next(); 1974 } 1975 // Compile virtual methods 1976 int64_t previous_virtual_method_idx = -1; 1977 while (it.HasNextVirtualMethod()) { 1978 uint32_t method_idx = it.GetMemberIndex(); 1979 if (method_idx == previous_virtual_method_idx) { 1980 // smali can create dex files with two encoded_methods sharing the same method_idx 1981 // http://code.google.com/p/smali/issues/detail?id=119 1982 it.Next(); 1983 continue; 1984 } 1985 previous_virtual_method_idx = method_idx; 1986 driver->CompileMethod(it.GetMethodCodeItem(), it.GetMethodAccessFlags(), 1987 it.GetMethodInvokeType(class_def), class_def_index, 1988 method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level); 1989 it.Next(); 1990 } 1991 DCHECK(!it.HasNext()); 1992} 1993 1994void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file, 1995 const std::vector<const DexFile*>& dex_files, 1996 ThreadPool* thread_pool, TimingLogger* timings) { 1997 TimingLogger::ScopedTiming t("Compile Dex File", timings); 1998 ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this, 1999 &dex_file, dex_files, thread_pool); 2000 context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_); 2001} 2002 2003void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, 2004 InvokeType invoke_type, uint16_t class_def_idx, 2005 uint32_t method_idx, jobject class_loader, 2006 const DexFile& dex_file, 2007 DexToDexCompilationLevel dex_to_dex_compilation_level) { 2008 CompiledMethod* compiled_method = nullptr; 2009 uint64_t start_ns = kTimeCompileMethod ? NanoTime() : 0; 2010 2011 if ((access_flags & kAccNative) != 0) { 2012 // Are we interpreting only and have support for generic JNI down calls? 2013 if (!compiler_options_->IsCompilationEnabled() && 2014 (instruction_set_ == kX86_64 || instruction_set_ == kArm64)) { 2015 // Leaving this empty will trigger the generic JNI version 2016 } else { 2017 compiled_method = compiler_->JniCompile(access_flags, method_idx, dex_file); 2018 CHECK(compiled_method != nullptr); 2019 } 2020 } else if ((access_flags & kAccAbstract) != 0) { 2021 } else { 2022 MethodReference method_ref(&dex_file, method_idx); 2023 bool compile = verification_results_->IsCandidateForCompilation(method_ref, access_flags); 2024 if (compile) { 2025 // NOTE: if compiler declines to compile this method, it will return nullptr. 2026 compiled_method = compiler_->Compile(code_item, access_flags, invoke_type, class_def_idx, 2027 method_idx, class_loader, dex_file); 2028 } 2029 if (compiled_method == nullptr && dex_to_dex_compilation_level != kDontDexToDexCompile) { 2030 // TODO: add a command-line option to disable DEX-to-DEX compilation ? 2031 (*dex_to_dex_compiler_)(*this, code_item, access_flags, 2032 invoke_type, class_def_idx, 2033 method_idx, class_loader, dex_file, 2034 dex_to_dex_compilation_level); 2035 } 2036 } 2037 if (kTimeCompileMethod) { 2038 uint64_t duration_ns = NanoTime() - start_ns; 2039 if (duration_ns > MsToNs(compiler_->GetMaximumCompilationTimeBeforeWarning())) { 2040 LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file) 2041 << " took " << PrettyDuration(duration_ns); 2042 } 2043 } 2044 2045 Thread* self = Thread::Current(); 2046 if (compiled_method != nullptr) { 2047 MethodReference ref(&dex_file, method_idx); 2048 DCHECK(GetCompiledMethod(ref) == nullptr) << PrettyMethod(method_idx, dex_file); 2049 { 2050 MutexLock mu(self, compiled_methods_lock_); 2051 compiled_methods_.Put(ref, compiled_method); 2052 } 2053 DCHECK(GetCompiledMethod(ref) != nullptr) << PrettyMethod(method_idx, dex_file); 2054 } 2055 2056 if (self->IsExceptionPending()) { 2057 ScopedObjectAccess soa(self); 2058 LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n" 2059 << self->GetException(nullptr)->Dump(); 2060 } 2061} 2062 2063CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const { 2064 MutexLock mu(Thread::Current(), compiled_classes_lock_); 2065 ClassTable::const_iterator it = compiled_classes_.find(ref); 2066 if (it == compiled_classes_.end()) { 2067 return nullptr; 2068 } 2069 CHECK(it->second != nullptr); 2070 return it->second; 2071} 2072 2073void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) { 2074 MutexLock mu(Thread::Current(), compiled_classes_lock_); 2075 auto it = compiled_classes_.find(ref); 2076 if (it == compiled_classes_.end() || it->second->GetStatus() != status) { 2077 // An entry doesn't exist or the status is lower than the new status. 2078 if (it != compiled_classes_.end()) { 2079 CHECK_GT(status, it->second->GetStatus()); 2080 delete it->second; 2081 } 2082 switch (status) { 2083 case mirror::Class::kStatusNotReady: 2084 case mirror::Class::kStatusError: 2085 case mirror::Class::kStatusRetryVerificationAtRuntime: 2086 case mirror::Class::kStatusVerified: 2087 case mirror::Class::kStatusInitialized: 2088 break; // Expected states. 2089 default: 2090 LOG(FATAL) << "Unexpected class status for class " 2091 << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second))) 2092 << " of " << status; 2093 } 2094 CompiledClass* compiled_class = new CompiledClass(status); 2095 compiled_classes_.Overwrite(ref, compiled_class); 2096 } 2097} 2098 2099CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const { 2100 MutexLock mu(Thread::Current(), compiled_methods_lock_); 2101 MethodTable::const_iterator it = compiled_methods_.find(ref); 2102 if (it == compiled_methods_.end()) { 2103 return nullptr; 2104 } 2105 CHECK(it->second != nullptr); 2106 return it->second; 2107} 2108 2109void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, 2110 uint16_t class_def_index) { 2111 WriterMutexLock mu(self, freezing_constructor_lock_); 2112 freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index)); 2113} 2114 2115bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, 2116 uint16_t class_def_index) { 2117 ReaderMutexLock mu(self, freezing_constructor_lock_); 2118 return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0; 2119} 2120 2121bool CompilerDriver::WriteElf(const std::string& android_root, 2122 bool is_host, 2123 const std::vector<const art::DexFile*>& dex_files, 2124 OatWriter* oat_writer, 2125 art::File* file) 2126 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 2127 return compiler_->WriteElf(file, oat_writer, dex_files, android_root, is_host); 2128} 2129void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set, 2130 std::string* target_triple, 2131 std::string* target_cpu, 2132 std::string* target_attr) { 2133 switch (instruction_set) { 2134 case kThumb2: 2135 *target_triple = "thumb-none-linux-gnueabi"; 2136 *target_cpu = "cortex-a9"; 2137 *target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db"; 2138 break; 2139 2140 case kArm: 2141 *target_triple = "armv7-none-linux-gnueabi"; 2142 // TODO: Fix for Nexus S. 2143 *target_cpu = "cortex-a9"; 2144 // TODO: Fix for Xoom. 2145 *target_attr = "+v7,+neon,+neonfp,+vfp3,+db"; 2146 break; 2147 2148 case kX86: 2149 *target_triple = "i386-pc-linux-gnu"; 2150 *target_attr = ""; 2151 break; 2152 2153 case kX86_64: 2154 *target_triple = "x86_64-pc-linux-gnu"; 2155 *target_attr = ""; 2156 break; 2157 2158 case kMips: 2159 *target_triple = "mipsel-unknown-linux"; 2160 *target_attr = "mips32r2"; 2161 break; 2162 2163 default: 2164 LOG(FATAL) << "Unknown instruction set: " << instruction_set; 2165 } 2166 } 2167 2168bool CompilerDriver::SkipCompilation(const std::string& method_name) { 2169 if (!profile_present_) { 2170 return false; 2171 } 2172 // First find the method in the profile file. 2173 ProfileFile::ProfileData data; 2174 if (!profile_file_.GetProfileData(&data, method_name)) { 2175 // Not in profile, no information can be determined. 2176 if (kIsDebugBuild) { 2177 VLOG(compiler) << "not compiling " << method_name << " because it's not in the profile"; 2178 } 2179 return true; 2180 } 2181 2182 // Methods that comprise top_k_threshold % of the total samples will be compiled. 2183 // Compare against the start of the topK percentage bucket just in case the threshold 2184 // falls inside a bucket. 2185 bool compile = data.GetTopKUsedPercentage() - data.GetUsedPercent() 2186 <= compiler_options_->GetTopKProfileThreshold(); 2187 if (kIsDebugBuild) { 2188 if (compile) { 2189 LOG(INFO) << "compiling method " << method_name << " because its usage is part of top " 2190 << data.GetTopKUsedPercentage() << "% with a percent of " << data.GetUsedPercent() << "%" 2191 << " (topKThreshold=" << compiler_options_->GetTopKProfileThreshold() << ")"; 2192 } else { 2193 VLOG(compiler) << "not compiling method " << method_name 2194 << " because it's not part of leading " << compiler_options_->GetTopKProfileThreshold() 2195 << "% samples)"; 2196 } 2197 } 2198 return !compile; 2199} 2200} // namespace art 2201