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