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