compiler_driver.cc revision df013175d1aa04641e5c6175f8c786e547d31654
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 "dex_compilation_unit.h" 29#include "dex_file-inl.h" 30#include "dex/verified_methods_data.h" 31#include "jni_internal.h" 32#include "object_utils.h" 33#include "runtime.h" 34#include "gc/accounting/card_table-inl.h" 35#include "gc/accounting/heap_bitmap.h" 36#include "gc/space/space.h" 37#include "mirror/art_field-inl.h" 38#include "mirror/art_method-inl.h" 39#include "mirror/class_loader.h" 40#include "mirror/class-inl.h" 41#include "mirror/dex_cache-inl.h" 42#include "mirror/object-inl.h" 43#include "mirror/object_array-inl.h" 44#include "mirror/throwable.h" 45#include "scoped_thread_state_change.h" 46#include "ScopedLocalRef.h" 47#include "thread.h" 48#include "thread_pool.h" 49#include "trampolines/trampoline_compiler.h" 50#include "verifier/method_verifier.h" 51 52#if defined(ART_USE_PORTABLE_COMPILER) 53#include "elf_writer_mclinker.h" 54#else 55#include "elf_writer_quick.h" 56#endif 57 58namespace art { 59 60static double Percentage(size_t x, size_t y) { 61 return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y)); 62} 63 64static void DumpStat(size_t x, size_t y, const char* str) { 65 if (x == 0 && y == 0) { 66 return; 67 } 68 LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases"; 69} 70 71class AOTCompilationStats { 72 public: 73 AOTCompilationStats() 74 : stats_lock_("AOT compilation statistics lock"), 75 types_in_dex_cache_(0), types_not_in_dex_cache_(0), 76 strings_in_dex_cache_(0), strings_not_in_dex_cache_(0), 77 resolved_types_(0), unresolved_types_(0), 78 resolved_instance_fields_(0), unresolved_instance_fields_(0), 79 resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0), 80 type_based_devirtualization_(0), 81 safe_casts_(0), not_safe_casts_(0) { 82 for (size_t i = 0; i <= kMaxInvokeType; i++) { 83 resolved_methods_[i] = 0; 84 unresolved_methods_[i] = 0; 85 virtual_made_direct_[i] = 0; 86 direct_calls_to_boot_[i] = 0; 87 direct_methods_to_boot_[i] = 0; 88 } 89 } 90 91 void Dump() { 92 DumpStat(types_in_dex_cache_, types_not_in_dex_cache_, "types known to be in dex cache"); 93 DumpStat(strings_in_dex_cache_, strings_not_in_dex_cache_, "strings known to be in dex cache"); 94 DumpStat(resolved_types_, unresolved_types_, "types resolved"); 95 DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved"); 96 DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_, 97 "static fields resolved"); 98 DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_, 99 "static fields local to a class"); 100 DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information"); 101 // Note, the code below subtracts the stat value so that when added to the stat value we have 102 // 100% of samples. TODO: clean this up. 103 DumpStat(type_based_devirtualization_, 104 resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] + 105 resolved_methods_[kInterface] + unresolved_methods_[kInterface] - 106 type_based_devirtualization_, 107 "virtual/interface calls made direct based on type information"); 108 109 for (size_t i = 0; i <= kMaxInvokeType; i++) { 110 std::ostringstream oss; 111 oss << static_cast<InvokeType>(i) << " methods were AOT resolved"; 112 DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str()); 113 if (virtual_made_direct_[i] > 0) { 114 std::ostringstream oss2; 115 oss2 << static_cast<InvokeType>(i) << " methods made direct"; 116 DumpStat(virtual_made_direct_[i], 117 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i], 118 oss2.str().c_str()); 119 } 120 if (direct_calls_to_boot_[i] > 0) { 121 std::ostringstream oss2; 122 oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot"; 123 DumpStat(direct_calls_to_boot_[i], 124 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i], 125 oss2.str().c_str()); 126 } 127 if (direct_methods_to_boot_[i] > 0) { 128 std::ostringstream oss2; 129 oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot"; 130 DumpStat(direct_methods_to_boot_[i], 131 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i], 132 oss2.str().c_str()); 133 } 134 } 135 } 136 137// Allow lossy statistics in non-debug builds. 138#ifndef NDEBUG 139#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_) 140#else 141#define STATS_LOCK() 142#endif 143 144 void TypeInDexCache() { 145 STATS_LOCK(); 146 types_in_dex_cache_++; 147 } 148 149 void TypeNotInDexCache() { 150 STATS_LOCK(); 151 types_not_in_dex_cache_++; 152 } 153 154 void StringInDexCache() { 155 STATS_LOCK(); 156 strings_in_dex_cache_++; 157 } 158 159 void StringNotInDexCache() { 160 STATS_LOCK(); 161 strings_not_in_dex_cache_++; 162 } 163 164 void TypeDoesntNeedAccessCheck() { 165 STATS_LOCK(); 166 resolved_types_++; 167 } 168 169 void TypeNeedsAccessCheck() { 170 STATS_LOCK(); 171 unresolved_types_++; 172 } 173 174 void ResolvedInstanceField() { 175 STATS_LOCK(); 176 resolved_instance_fields_++; 177 } 178 179 void UnresolvedInstanceField() { 180 STATS_LOCK(); 181 unresolved_instance_fields_++; 182 } 183 184 void ResolvedLocalStaticField() { 185 STATS_LOCK(); 186 resolved_local_static_fields_++; 187 } 188 189 void ResolvedStaticField() { 190 STATS_LOCK(); 191 resolved_static_fields_++; 192 } 193 194 void UnresolvedStaticField() { 195 STATS_LOCK(); 196 unresolved_static_fields_++; 197 } 198 199 // Indicate that type information from the verifier led to devirtualization. 200 void PreciseTypeDevirtualization() { 201 STATS_LOCK(); 202 type_based_devirtualization_++; 203 } 204 205 // Indicate that a method of the given type was resolved at compile time. 206 void ResolvedMethod(InvokeType type) { 207 DCHECK_LE(type, kMaxInvokeType); 208 STATS_LOCK(); 209 resolved_methods_[type]++; 210 } 211 212 // Indicate that a method of the given type was unresolved at compile time as it was in an 213 // unknown dex file. 214 void UnresolvedMethod(InvokeType type) { 215 DCHECK_LE(type, kMaxInvokeType); 216 STATS_LOCK(); 217 unresolved_methods_[type]++; 218 } 219 220 // Indicate that a type of virtual method dispatch has been converted into a direct method 221 // dispatch. 222 void VirtualMadeDirect(InvokeType type) { 223 DCHECK(type == kVirtual || type == kInterface || type == kSuper); 224 STATS_LOCK(); 225 virtual_made_direct_[type]++; 226 } 227 228 // Indicate that a method of the given type was able to call directly into boot. 229 void DirectCallsToBoot(InvokeType type) { 230 DCHECK_LE(type, kMaxInvokeType); 231 STATS_LOCK(); 232 direct_calls_to_boot_[type]++; 233 } 234 235 // Indicate that a method of the given type was able to be resolved directly from boot. 236 void DirectMethodsToBoot(InvokeType type) { 237 DCHECK_LE(type, kMaxInvokeType); 238 STATS_LOCK(); 239 direct_methods_to_boot_[type]++; 240 } 241 242 // A check-cast could be eliminated due to verifier type analysis. 243 void SafeCast() { 244 STATS_LOCK(); 245 safe_casts_++; 246 } 247 248 // A check-cast couldn't be eliminated due to verifier type analysis. 249 void NotASafeCast() { 250 STATS_LOCK(); 251 not_safe_casts_++; 252 } 253 254 private: 255 Mutex stats_lock_; 256 257 size_t types_in_dex_cache_; 258 size_t types_not_in_dex_cache_; 259 260 size_t strings_in_dex_cache_; 261 size_t strings_not_in_dex_cache_; 262 263 size_t resolved_types_; 264 size_t unresolved_types_; 265 266 size_t resolved_instance_fields_; 267 size_t unresolved_instance_fields_; 268 269 size_t resolved_local_static_fields_; 270 size_t resolved_static_fields_; 271 size_t unresolved_static_fields_; 272 // Type based devirtualization for invoke interface and virtual. 273 size_t type_based_devirtualization_; 274 275 size_t resolved_methods_[kMaxInvokeType + 1]; 276 size_t unresolved_methods_[kMaxInvokeType + 1]; 277 size_t virtual_made_direct_[kMaxInvokeType + 1]; 278 size_t direct_calls_to_boot_[kMaxInvokeType + 1]; 279 size_t direct_methods_to_boot_[kMaxInvokeType + 1]; 280 281 size_t safe_casts_; 282 size_t not_safe_casts_; 283 284 DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats); 285}; 286 287extern "C" void ArtInitCompilerContext(art::CompilerDriver& driver); 288extern "C" void ArtInitQuickCompilerContext(art::CompilerDriver& driver); 289 290extern "C" void ArtUnInitCompilerContext(art::CompilerDriver& driver); 291extern "C" void ArtUnInitQuickCompilerContext(art::CompilerDriver& driver); 292 293extern "C" art::CompiledMethod* ArtCompileMethod(art::CompilerDriver& driver, 294 const art::DexFile::CodeItem* code_item, 295 uint32_t access_flags, 296 art::InvokeType invoke_type, 297 uint16_t class_def_idx, 298 uint32_t method_idx, 299 jobject class_loader, 300 const art::DexFile& dex_file); 301extern "C" art::CompiledMethod* ArtQuickCompileMethod(art::CompilerDriver& compiler, 302 const art::DexFile::CodeItem* code_item, 303 uint32_t access_flags, 304 art::InvokeType invoke_type, 305 uint16_t class_def_idx, 306 uint32_t method_idx, 307 jobject class_loader, 308 const art::DexFile& dex_file); 309 310extern "C" art::CompiledMethod* ArtCompileDEX(art::CompilerDriver& compiler, 311 const art::DexFile::CodeItem* code_item, 312 uint32_t access_flags, 313 art::InvokeType invoke_type, 314 uint16_t class_def_idx, 315 uint32_t method_idx, 316 jobject class_loader, 317 const art::DexFile& dex_file); 318#ifdef ART_SEA_IR_MODE 319extern "C" art::CompiledMethod* SeaIrCompileMethod(art::CompilerDriver& compiler, 320 const art::DexFile::CodeItem* code_item, 321 uint32_t access_flags, 322 art::InvokeType invoke_type, 323 uint16_t class_def_idx, 324 uint32_t method_idx, 325 jobject class_loader, 326 const art::DexFile& dex_file); 327#endif 328extern "C" art::CompiledMethod* ArtLLVMJniCompileMethod(art::CompilerDriver& driver, 329 uint32_t access_flags, uint32_t method_idx, 330 const art::DexFile& dex_file); 331 332extern "C" art::CompiledMethod* ArtQuickJniCompileMethod(art::CompilerDriver& compiler, 333 uint32_t access_flags, uint32_t method_idx, 334 const art::DexFile& dex_file); 335 336extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver, 337 std::string const& filename); 338 339CompilerDriver::CompilerDriver(VerifiedMethodsData* verified_methods_data, 340 DexFileToMethodInlinerMap* method_inliner_map, 341 CompilerBackend compiler_backend, InstructionSet instruction_set, 342 InstructionSetFeatures instruction_set_features, 343 bool image, DescriptorSet* image_classes, size_t thread_count, 344 bool dump_stats, bool dump_passes, CumulativeLogger* timer) 345 : verified_methods_data_(verified_methods_data), 346 method_inliner_map_(method_inliner_map), 347 compiler_backend_(compiler_backend), 348 instruction_set_(instruction_set), 349 instruction_set_features_(instruction_set_features), 350 freezing_constructor_lock_("freezing constructor lock"), 351 compiled_classes_lock_("compiled classes lock"), 352 compiled_methods_lock_("compiled method lock"), 353 image_(image), 354 image_classes_(image_classes), 355 thread_count_(thread_count), 356 start_ns_(0), 357 stats_(new AOTCompilationStats), 358 dump_stats_(dump_stats), 359 dump_passes_(dump_passes), 360 timings_logger_(timer), 361 compiler_library_(NULL), 362 compiler_(NULL), 363 compiler_context_(NULL), 364 jni_compiler_(NULL), 365 compiler_enable_auto_elf_loading_(NULL), 366 compiler_get_method_code_addr_(NULL), 367 support_boot_image_fixup_(instruction_set == kThumb2), 368 dedupe_code_("dedupe code"), 369 dedupe_mapping_table_("dedupe mapping table"), 370 dedupe_vmap_table_("dedupe vmap table"), 371 dedupe_gc_map_("dedupe gc map") { 372 373 CHECK_PTHREAD_CALL(pthread_key_create, (&tls_key_, NULL), "compiler tls key"); 374 375 // TODO: more work needed to combine initializations and allow per-method backend selection 376 typedef void (*InitCompilerContextFn)(CompilerDriver&); 377 InitCompilerContextFn init_compiler_context; 378 if (compiler_backend_ == kPortable) { 379 // Initialize compiler_context_ 380 init_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtInitCompilerContext); 381 compiler_ = reinterpret_cast<CompilerFn>(ArtCompileMethod); 382 } else { 383 init_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtInitQuickCompilerContext); 384 compiler_ = reinterpret_cast<CompilerFn>(ArtQuickCompileMethod); 385 } 386 387 dex_to_dex_compiler_ = reinterpret_cast<DexToDexCompilerFn>(ArtCompileDEX); 388 389#ifdef ART_SEA_IR_MODE 390 sea_ir_compiler_ = NULL; 391 if (Runtime::Current()->IsSeaIRMode()) { 392 sea_ir_compiler_ = reinterpret_cast<CompilerFn>(SeaIrCompileMethod); 393 } 394#endif 395 396 init_compiler_context(*this); 397 398 if (compiler_backend_ == kPortable) { 399 jni_compiler_ = reinterpret_cast<JniCompilerFn>(ArtLLVMJniCompileMethod); 400 } else { 401 jni_compiler_ = reinterpret_cast<JniCompilerFn>(ArtQuickJniCompileMethod); 402 } 403 404 CHECK(!Runtime::Current()->IsStarted()); 405 if (!image_) { 406 CHECK(image_classes_.get() == NULL); 407 } 408} 409 410std::vector<uint8_t>* CompilerDriver::DeduplicateCode(const std::vector<uint8_t>& code) { 411 return dedupe_code_.Add(Thread::Current(), code); 412} 413 414std::vector<uint8_t>* CompilerDriver::DeduplicateMappingTable(const std::vector<uint8_t>& code) { 415 return dedupe_mapping_table_.Add(Thread::Current(), code); 416} 417 418std::vector<uint8_t>* CompilerDriver::DeduplicateVMapTable(const std::vector<uint8_t>& code) { 419 return dedupe_vmap_table_.Add(Thread::Current(), code); 420} 421 422std::vector<uint8_t>* CompilerDriver::DeduplicateGCMap(const std::vector<uint8_t>& code) { 423 return dedupe_gc_map_.Add(Thread::Current(), code); 424} 425 426CompilerDriver::~CompilerDriver() { 427 Thread* self = Thread::Current(); 428 { 429 MutexLock mu(self, compiled_classes_lock_); 430 STLDeleteValues(&compiled_classes_); 431 } 432 { 433 MutexLock mu(self, compiled_methods_lock_); 434 STLDeleteValues(&compiled_methods_); 435 } 436 { 437 MutexLock mu(self, compiled_methods_lock_); 438 STLDeleteElements(&code_to_patch_); 439 } 440 { 441 MutexLock mu(self, compiled_methods_lock_); 442 STLDeleteElements(&methods_to_patch_); 443 } 444 CHECK_PTHREAD_CALL(pthread_key_delete, (tls_key_), "delete tls key"); 445 typedef void (*UninitCompilerContextFn)(CompilerDriver&); 446 UninitCompilerContextFn uninit_compiler_context; 447 // Uninitialize compiler_context_ 448 // TODO: rework to combine initialization/uninitialization 449 if (compiler_backend_ == kPortable) { 450 uninit_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtUnInitCompilerContext); 451 } else { 452 uninit_compiler_context = reinterpret_cast<void (*)(CompilerDriver&)>(ArtUnInitQuickCompilerContext); 453 } 454 uninit_compiler_context(*this); 455} 456 457CompilerTls* CompilerDriver::GetTls() { 458 // Lazily create thread-local storage 459 CompilerTls* res = static_cast<CompilerTls*>(pthread_getspecific(tls_key_)); 460 if (res == NULL) { 461 res = new CompilerTls(); 462 CHECK_PTHREAD_CALL(pthread_setspecific, (tls_key_, res), "compiler tls"); 463 } 464 return res; 465} 466 467const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToInterpreterBridge() const { 468 return CreateTrampoline(instruction_set_, kInterpreterAbi, 469 INTERPRETER_ENTRYPOINT_OFFSET(pInterpreterToInterpreterBridge)); 470} 471 472const std::vector<uint8_t>* CompilerDriver::CreateInterpreterToCompiledCodeBridge() const { 473 return CreateTrampoline(instruction_set_, kInterpreterAbi, 474 INTERPRETER_ENTRYPOINT_OFFSET(pInterpreterToCompiledCodeBridge)); 475} 476 477const std::vector<uint8_t>* CompilerDriver::CreateJniDlsymLookup() const { 478 return CreateTrampoline(instruction_set_, kJniAbi, JNI_ENTRYPOINT_OFFSET(pDlsymLookup)); 479} 480 481const std::vector<uint8_t>* CompilerDriver::CreatePortableImtConflictTrampoline() const { 482 return CreateTrampoline(instruction_set_, kPortableAbi, 483 PORTABLE_ENTRYPOINT_OFFSET(pPortableImtConflictTrampoline)); 484} 485 486const std::vector<uint8_t>* CompilerDriver::CreatePortableResolutionTrampoline() const { 487 return CreateTrampoline(instruction_set_, kPortableAbi, 488 PORTABLE_ENTRYPOINT_OFFSET(pPortableResolutionTrampoline)); 489} 490 491const std::vector<uint8_t>* CompilerDriver::CreatePortableToInterpreterBridge() const { 492 return CreateTrampoline(instruction_set_, kPortableAbi, 493 PORTABLE_ENTRYPOINT_OFFSET(pPortableToInterpreterBridge)); 494} 495 496const std::vector<uint8_t>* CompilerDriver::CreateQuickImtConflictTrampoline() const { 497 return CreateTrampoline(instruction_set_, kQuickAbi, 498 QUICK_ENTRYPOINT_OFFSET(pQuickImtConflictTrampoline)); 499} 500 501const std::vector<uint8_t>* CompilerDriver::CreateQuickResolutionTrampoline() const { 502 return CreateTrampoline(instruction_set_, kQuickAbi, 503 QUICK_ENTRYPOINT_OFFSET(pQuickResolutionTrampoline)); 504} 505 506const std::vector<uint8_t>* CompilerDriver::CreateQuickToInterpreterBridge() const { 507 return CreateTrampoline(instruction_set_, kQuickAbi, 508 QUICK_ENTRYPOINT_OFFSET(pQuickToInterpreterBridge)); 509} 510 511void CompilerDriver::CompileAll(jobject class_loader, 512 const std::vector<const DexFile*>& dex_files, 513 TimingLogger& timings) { 514 DCHECK(!Runtime::Current()->IsStarted()); 515 UniquePtr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", thread_count_ - 1)); 516 PreCompile(class_loader, dex_files, *thread_pool.get(), timings); 517 Compile(class_loader, dex_files, *thread_pool.get(), timings); 518 if (dump_stats_) { 519 stats_->Dump(); 520 } 521} 522 523static DexToDexCompilationLevel GetDexToDexCompilationlevel( 524 SirtRef<mirror::ClassLoader>& class_loader, const DexFile& dex_file, 525 const DexFile::ClassDef& class_def) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 526 const char* descriptor = dex_file.GetClassDescriptor(class_def); 527 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 528 mirror::Class* klass = class_linker->FindClass(descriptor, class_loader); 529 if (klass == NULL) { 530 Thread* self = Thread::Current(); 531 CHECK(self->IsExceptionPending()); 532 self->ClearException(); 533 return kDontDexToDexCompile; 534 } 535 // The verifier can only run on "quick" instructions at runtime (see usage of 536 // FindAccessedFieldAtDexPc and FindInvokedMethodAtDexPc in ThrowNullPointerExceptionFromDexPC 537 // function). Since image classes can be verified again while compiling an application, 538 // we must prevent the DEX-to-DEX compiler from introducing them. 539 // TODO: find a way to enable "quick" instructions for image classes and remove this check. 540 bool compiling_image_classes = class_loader.get() == nullptr; 541 if (compiling_image_classes) { 542 return kRequired; 543 } else if (klass->IsVerified()) { 544 // Class is verified so we can enable DEX-to-DEX compilation for performance. 545 return kOptimize; 546 } else if (klass->IsCompileTimeVerified()) { 547 // Class verification has soft-failed. Anyway, ensure at least correctness. 548 DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime); 549 return kRequired; 550 } else { 551 // Class verification has failed: do not run DEX-to-DEX compilation. 552 return kDontDexToDexCompile; 553 } 554} 555 556void CompilerDriver::CompileOne(const mirror::ArtMethod* method, TimingLogger& timings) { 557 DCHECK(!Runtime::Current()->IsStarted()); 558 Thread* self = Thread::Current(); 559 jobject jclass_loader; 560 const DexFile* dex_file; 561 uint16_t class_def_idx; 562 { 563 ScopedObjectAccessUnchecked soa(self); 564 ScopedLocalRef<jobject> 565 local_class_loader(soa.Env(), 566 soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader())); 567 jclass_loader = soa.Env()->NewGlobalRef(local_class_loader.get()); 568 // Find the dex_file 569 MethodHelper mh(method); 570 dex_file = &mh.GetDexFile(); 571 class_def_idx = mh.GetClassDefIndex(); 572 } 573 self->TransitionFromRunnableToSuspended(kNative); 574 575 std::vector<const DexFile*> dex_files; 576 dex_files.push_back(dex_file); 577 578 UniquePtr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", 0U)); 579 PreCompile(jclass_loader, dex_files, *thread_pool.get(), timings); 580 581 uint32_t method_idx = method->GetDexMethodIndex(); 582 const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset()); 583 // Can we run DEX-to-DEX compiler on this class ? 584 DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile; 585 { 586 ScopedObjectAccess soa(Thread::Current()); 587 const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_idx); 588 SirtRef<mirror::ClassLoader> class_loader(soa.Self(), 589 soa.Decode<mirror::ClassLoader*>(jclass_loader)); 590 dex_to_dex_compilation_level = GetDexToDexCompilationlevel(class_loader, *dex_file, class_def); 591 } 592 CompileMethod(code_item, method->GetAccessFlags(), method->GetInvokeType(), 593 class_def_idx, method_idx, jclass_loader, *dex_file, dex_to_dex_compilation_level); 594 595 self->GetJniEnv()->DeleteGlobalRef(jclass_loader); 596 597 self->TransitionFromSuspendedToRunnable(); 598} 599 600void CompilerDriver::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files, 601 ThreadPool& thread_pool, TimingLogger& timings) { 602 for (size_t i = 0; i != dex_files.size(); ++i) { 603 const DexFile* dex_file = dex_files[i]; 604 CHECK(dex_file != NULL); 605 ResolveDexFile(class_loader, *dex_file, thread_pool, timings); 606 } 607} 608 609void CompilerDriver::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 610 ThreadPool& thread_pool, TimingLogger& timings) { 611 LoadImageClasses(timings); 612 613 Resolve(class_loader, dex_files, thread_pool, timings); 614 615 Verify(class_loader, dex_files, thread_pool, timings); 616 617 InitializeClasses(class_loader, dex_files, thread_pool, timings); 618 619 UpdateImageClasses(timings); 620} 621 622bool CompilerDriver::IsImageClass(const char* descriptor) const { 623 if (!IsImage()) { 624 return true; 625 } else { 626 return image_classes_->find(descriptor) != image_classes_->end(); 627 } 628} 629 630static void ResolveExceptionsForMethod(MethodHelper* mh, 631 std::set<std::pair<uint16_t, const DexFile*> >& exceptions_to_resolve) 632 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 633 const DexFile::CodeItem* code_item = mh->GetCodeItem(); 634 if (code_item == NULL) { 635 return; // native or abstract method 636 } 637 if (code_item->tries_size_ == 0) { 638 return; // nothing to process 639 } 640 const byte* encoded_catch_handler_list = DexFile::GetCatchHandlerData(*code_item, 0); 641 size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list); 642 for (size_t i = 0; i < num_encoded_catch_handlers; i++) { 643 int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list); 644 bool has_catch_all = false; 645 if (encoded_catch_handler_size <= 0) { 646 encoded_catch_handler_size = -encoded_catch_handler_size; 647 has_catch_all = true; 648 } 649 for (int32_t j = 0; j < encoded_catch_handler_size; j++) { 650 uint16_t encoded_catch_handler_handlers_type_idx = 651 DecodeUnsignedLeb128(&encoded_catch_handler_list); 652 // Add to set of types to resolve if not already in the dex cache resolved types 653 if (!mh->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) { 654 exceptions_to_resolve.insert( 655 std::pair<uint16_t, const DexFile*>(encoded_catch_handler_handlers_type_idx, 656 &mh->GetDexFile())); 657 } 658 // ignore address associated with catch handler 659 DecodeUnsignedLeb128(&encoded_catch_handler_list); 660 } 661 if (has_catch_all) { 662 // ignore catch all address 663 DecodeUnsignedLeb128(&encoded_catch_handler_list); 664 } 665 } 666} 667 668static bool ResolveCatchBlockExceptionsClassVisitor(mirror::Class* c, void* arg) 669 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 670 std::set<std::pair<uint16_t, const DexFile*> >* exceptions_to_resolve = 671 reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg); 672 MethodHelper mh; 673 for (size_t i = 0; i < c->NumVirtualMethods(); ++i) { 674 mirror::ArtMethod* m = c->GetVirtualMethod(i); 675 mh.ChangeMethod(m); 676 ResolveExceptionsForMethod(&mh, *exceptions_to_resolve); 677 } 678 for (size_t i = 0; i < c->NumDirectMethods(); ++i) { 679 mirror::ArtMethod* m = c->GetDirectMethod(i); 680 mh.ChangeMethod(m); 681 ResolveExceptionsForMethod(&mh, *exceptions_to_resolve); 682 } 683 return true; 684} 685 686static bool RecordImageClassesVisitor(mirror::Class* klass, void* arg) 687 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 688 CompilerDriver::DescriptorSet* image_classes = 689 reinterpret_cast<CompilerDriver::DescriptorSet*>(arg); 690 image_classes->insert(ClassHelper(klass).GetDescriptor()); 691 return true; 692} 693 694// Make a list of descriptors for classes to include in the image 695void CompilerDriver::LoadImageClasses(TimingLogger& timings) 696 LOCKS_EXCLUDED(Locks::mutator_lock_) { 697 if (!IsImage()) { 698 return; 699 } 700 701 timings.NewSplit("LoadImageClasses"); 702 // Make a first class to load all classes explicitly listed in the file 703 Thread* self = Thread::Current(); 704 ScopedObjectAccess soa(self); 705 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 706 for (auto it = image_classes_->begin(), end = image_classes_->end(); it != end;) { 707 const std::string& descriptor(*it); 708 SirtRef<mirror::Class> klass(self, class_linker->FindSystemClass(descriptor.c_str())); 709 if (klass.get() == NULL) { 710 VLOG(compiler) << "Failed to find class " << descriptor; 711 image_classes_->erase(it++); 712 self->ClearException(); 713 } else { 714 ++it; 715 } 716 } 717 718 // Resolve exception classes referenced by the loaded classes. The catch logic assumes 719 // exceptions are resolved by the verifier when there is a catch block in an interested method. 720 // Do this here so that exception classes appear to have been specified image classes. 721 std::set<std::pair<uint16_t, const DexFile*> > unresolved_exception_types; 722 SirtRef<mirror::Class> java_lang_Throwable(self, 723 class_linker->FindSystemClass("Ljava/lang/Throwable;")); 724 do { 725 unresolved_exception_types.clear(); 726 class_linker->VisitClasses(ResolveCatchBlockExceptionsClassVisitor, 727 &unresolved_exception_types); 728 for (const std::pair<uint16_t, const DexFile*>& exception_type : unresolved_exception_types) { 729 uint16_t exception_type_idx = exception_type.first; 730 const DexFile* dex_file = exception_type.second; 731 SirtRef<mirror::DexCache> dex_cache(self, class_linker->FindDexCache(*dex_file)); 732 SirtRef<mirror::ClassLoader> class_loader(self, nullptr); 733 SirtRef<mirror::Class> klass(self, class_linker->ResolveType(*dex_file, exception_type_idx, 734 dex_cache, class_loader)); 735 if (klass.get() == NULL) { 736 const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx); 737 const char* descriptor = dex_file->GetTypeDescriptor(type_id); 738 LOG(FATAL) << "Failed to resolve class " << descriptor; 739 } 740 DCHECK(java_lang_Throwable->IsAssignableFrom(klass.get())); 741 } 742 // Resolving exceptions may load classes that reference more exceptions, iterate until no 743 // more are found 744 } while (!unresolved_exception_types.empty()); 745 746 // We walk the roots looking for classes so that we'll pick up the 747 // above classes plus any classes them depend on such super 748 // classes, interfaces, and the required ClassLinker roots. 749 class_linker->VisitClasses(RecordImageClassesVisitor, image_classes_.get()); 750 751 CHECK_NE(image_classes_->size(), 0U); 752} 753 754static void MaybeAddToImageClasses(mirror::Class* klass, CompilerDriver::DescriptorSet* image_classes) 755 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 756 while (!klass->IsObjectClass()) { 757 ClassHelper kh(klass); 758 const char* descriptor = kh.GetDescriptor(); 759 std::pair<CompilerDriver::DescriptorSet::iterator, bool> result = 760 image_classes->insert(descriptor); 761 if (result.second) { 762 VLOG(compiler) << "Adding " << descriptor << " to image classes"; 763 } else { 764 return; 765 } 766 for (size_t i = 0; i < kh.NumDirectInterfaces(); ++i) { 767 MaybeAddToImageClasses(kh.GetDirectInterface(i), image_classes); 768 } 769 if (klass->IsArrayClass()) { 770 MaybeAddToImageClasses(klass->GetComponentType(), image_classes); 771 } 772 klass = klass->GetSuperClass(); 773 } 774} 775 776void CompilerDriver::FindClinitImageClassesCallback(mirror::Object* object, void* arg) { 777 DCHECK(object != NULL); 778 DCHECK(arg != NULL); 779 CompilerDriver* compiler_driver = reinterpret_cast<CompilerDriver*>(arg); 780 MaybeAddToImageClasses(object->GetClass(), compiler_driver->image_classes_.get()); 781} 782 783void CompilerDriver::UpdateImageClasses(TimingLogger& timings) { 784 if (IsImage()) { 785 timings.NewSplit("UpdateImageClasses"); 786 787 // Update image_classes_ with classes for objects created by <clinit> methods. 788 Thread* self = Thread::Current(); 789 const char* old_cause = self->StartAssertNoThreadSuspension("ImageWriter"); 790 gc::Heap* heap = Runtime::Current()->GetHeap(); 791 // TODO: Image spaces only? 792 ScopedObjectAccess soa(Thread::Current()); 793 WriterMutexLock mu(self, *Locks::heap_bitmap_lock_); 794 heap->VisitObjects(FindClinitImageClassesCallback, this); 795 self->EndAssertNoThreadSuspension(old_cause); 796 } 797} 798 799bool CompilerDriver::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file, uint32_t type_idx) { 800 if (IsImage() && 801 IsImageClass(dex_file.StringDataByIdx(dex_file.GetTypeId(type_idx).descriptor_idx_))) { 802 if (kIsDebugBuild) { 803 ScopedObjectAccess soa(Thread::Current()); 804 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file); 805 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 806 CHECK(resolved_class != NULL); 807 } 808 stats_->TypeInDexCache(); 809 return true; 810 } else { 811 stats_->TypeNotInDexCache(); 812 return false; 813 } 814} 815 816bool CompilerDriver::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file, 817 uint32_t string_idx) { 818 // See also Compiler::ResolveDexFile 819 820 bool result = false; 821 if (IsImage()) { 822 // We resolve all const-string strings when building for the image. 823 ScopedObjectAccess soa(Thread::Current()); 824 SirtRef<mirror::DexCache> dex_cache(soa.Self(), Runtime::Current()->GetClassLinker()->FindDexCache(dex_file)); 825 Runtime::Current()->GetClassLinker()->ResolveString(dex_file, string_idx, dex_cache); 826 result = true; 827 } 828 if (result) { 829 stats_->StringInDexCache(); 830 } else { 831 stats_->StringNotInDexCache(); 832 } 833 return result; 834} 835 836bool CompilerDriver::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file, 837 uint32_t type_idx, 838 bool* type_known_final, bool* type_known_abstract, 839 bool* equals_referrers_class) { 840 if (type_known_final != NULL) { 841 *type_known_final = false; 842 } 843 if (type_known_abstract != NULL) { 844 *type_known_abstract = false; 845 } 846 if (equals_referrers_class != NULL) { 847 *equals_referrers_class = false; 848 } 849 ScopedObjectAccess soa(Thread::Current()); 850 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file); 851 // Get type from dex cache assuming it was populated by the verifier 852 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 853 if (resolved_class == NULL) { 854 stats_->TypeNeedsAccessCheck(); 855 return false; // Unknown class needs access checks. 856 } 857 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx); 858 if (equals_referrers_class != NULL) { 859 *equals_referrers_class = (method_id.class_idx_ == type_idx); 860 } 861 mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_); 862 if (referrer_class == NULL) { 863 stats_->TypeNeedsAccessCheck(); 864 return false; // Incomplete referrer knowledge needs access check. 865 } 866 // Perform access check, will return true if access is ok or false if we're going to have to 867 // check this at runtime (for example for class loaders). 868 bool result = referrer_class->CanAccess(resolved_class); 869 if (result) { 870 stats_->TypeDoesntNeedAccessCheck(); 871 if (type_known_final != NULL) { 872 *type_known_final = resolved_class->IsFinal() && !resolved_class->IsArrayClass(); 873 } 874 if (type_known_abstract != NULL) { 875 *type_known_abstract = resolved_class->IsAbstract() && !resolved_class->IsArrayClass(); 876 } 877 } else { 878 stats_->TypeNeedsAccessCheck(); 879 } 880 return result; 881} 882 883bool CompilerDriver::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx, 884 const DexFile& dex_file, 885 uint32_t type_idx) { 886 ScopedObjectAccess soa(Thread::Current()); 887 mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file); 888 // Get type from dex cache assuming it was populated by the verifier. 889 mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx); 890 if (resolved_class == NULL) { 891 stats_->TypeNeedsAccessCheck(); 892 return false; // Unknown class needs access checks. 893 } 894 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx); 895 mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_); 896 if (referrer_class == NULL) { 897 stats_->TypeNeedsAccessCheck(); 898 return false; // Incomplete referrer knowledge needs access check. 899 } 900 // Perform access and instantiable checks, will return true if access is ok or false if we're 901 // going to have to check this at runtime (for example for class loaders). 902 bool result = referrer_class->CanAccess(resolved_class) && resolved_class->IsInstantiable(); 903 if (result) { 904 stats_->TypeDoesntNeedAccessCheck(); 905 } else { 906 stats_->TypeNeedsAccessCheck(); 907 } 908 return result; 909} 910 911static mirror::Class* ComputeCompilingMethodsClass(ScopedObjectAccess& soa, 912 SirtRef<mirror::DexCache>& dex_cache, 913 const DexCompilationUnit* mUnit) 914 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 915 // The passed dex_cache is a hint, sanity check before asking the class linker that will take a 916 // lock. 917 if (dex_cache->GetDexFile() != mUnit->GetDexFile()) { 918 dex_cache.reset(mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile())); 919 } 920 SirtRef<mirror::ClassLoader> 921 class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader())); 922 const DexFile::MethodId& referrer_method_id = 923 mUnit->GetDexFile()->GetMethodId(mUnit->GetDexMethodIndex()); 924 return mUnit->GetClassLinker()->ResolveType(*mUnit->GetDexFile(), referrer_method_id.class_idx_, 925 dex_cache, class_loader); 926} 927 928static mirror::ArtField* ComputeFieldReferencedFromCompilingMethod( 929 ScopedObjectAccess& soa, const DexCompilationUnit* mUnit, uint32_t field_idx) 930 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 931 SirtRef<mirror::DexCache> dex_cache(soa.Self(), mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile())); 932 SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader())); 933 return mUnit->GetClassLinker()->ResolveField(*mUnit->GetDexFile(), field_idx, dex_cache, 934 class_loader, false); 935} 936 937static mirror::ArtMethod* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa, 938 const DexCompilationUnit* mUnit, 939 uint32_t method_idx, 940 InvokeType type) 941 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 942 SirtRef<mirror::DexCache> dex_cache(soa.Self(), mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile())); 943 SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader())); 944 return mUnit->GetClassLinker()->ResolveMethod(*mUnit->GetDexFile(), method_idx, dex_cache, 945 class_loader, NULL, type); 946} 947 948bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, 949 bool is_put, int* field_offset, bool* is_volatile) { 950 ScopedObjectAccess soa(Thread::Current()); 951 // Conservative defaults. 952 *field_offset = -1; 953 *is_volatile = true; 954 // Try to resolve field and ignore if an Incompatible Class Change Error (ie is static). 955 mirror::ArtField* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx); 956 if (resolved_field != NULL && !resolved_field->IsStatic()) { 957 SirtRef<mirror::DexCache> dex_cache(soa.Self(), 958 resolved_field->GetDeclaringClass()->GetDexCache()); 959 mirror::Class* referrer_class = 960 ComputeCompilingMethodsClass(soa, dex_cache, mUnit); 961 if (referrer_class != NULL) { 962 mirror::Class* fields_class = resolved_field->GetDeclaringClass(); 963 bool access_ok = referrer_class->CanAccess(fields_class) && 964 referrer_class->CanAccessMember(fields_class, 965 resolved_field->GetAccessFlags()); 966 if (!access_ok) { 967 // The referring class can't access the resolved field, this may occur as a result of a 968 // protected field being made public by a sub-class. Resort to the dex file to determine 969 // the correct class for the access check. 970 const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile(); 971 mirror::Class* dex_fields_class = mUnit->GetClassLinker()->ResolveType(dex_file, 972 dex_file.GetFieldId(field_idx).class_idx_, 973 referrer_class); 974 access_ok = referrer_class->CanAccess(dex_fields_class) && 975 referrer_class->CanAccessMember(dex_fields_class, 976 resolved_field->GetAccessFlags()); 977 } 978 bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal() && 979 fields_class != referrer_class; 980 if (access_ok && !is_write_to_final_from_wrong_class) { 981 *field_offset = resolved_field->GetOffset().Int32Value(); 982 *is_volatile = resolved_field->IsVolatile(); 983 stats_->ResolvedInstanceField(); 984 return true; // Fast path. 985 } 986 } 987 } 988 // Clean up any exception left by field/type resolution 989 if (soa.Self()->IsExceptionPending()) { 990 soa.Self()->ClearException(); 991 } 992 stats_->UnresolvedInstanceField(); 993 return false; // Incomplete knowledge needs slow path. 994} 995 996bool CompilerDriver::ComputeStaticFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit, 997 bool is_put, int* field_offset, int* storage_index, 998 bool* is_referrers_class, bool* is_volatile, 999 bool* is_initialized) { 1000 ScopedObjectAccess soa(Thread::Current()); 1001 // Conservative defaults. 1002 *field_offset = -1; 1003 *storage_index = -1; 1004 *is_referrers_class = false; 1005 *is_volatile = true; 1006 *is_initialized = false; 1007 // Try to resolve field and ignore if an Incompatible Class Change Error (ie isn't static). 1008 mirror::ArtField* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx); 1009 if (resolved_field != NULL && resolved_field->IsStatic()) { 1010 SirtRef<mirror::DexCache> dex_cache(soa.Self(), resolved_field->GetDeclaringClass()->GetDexCache()); 1011 mirror::Class* referrer_class = 1012 ComputeCompilingMethodsClass(soa, dex_cache, mUnit); 1013 if (referrer_class != NULL) { 1014 mirror::Class* fields_class = resolved_field->GetDeclaringClass(); 1015 if (fields_class == referrer_class) { 1016 *is_referrers_class = true; // implies no worrying about class initialization 1017 *is_initialized = true; 1018 *field_offset = resolved_field->GetOffset().Int32Value(); 1019 *is_volatile = resolved_field->IsVolatile(); 1020 stats_->ResolvedLocalStaticField(); 1021 return true; // fast path 1022 } else { 1023 bool access_ok = referrer_class->CanAccess(fields_class) && 1024 referrer_class->CanAccessMember(fields_class, 1025 resolved_field->GetAccessFlags()); 1026 if (!access_ok) { 1027 // The referring class can't access the resolved field, this may occur as a result of a 1028 // protected field being made public by a sub-class. Resort to the dex file to determine 1029 // the correct class for the access check. Don't change the field's class as that is 1030 // used to identify the SSB. 1031 const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile(); 1032 mirror::Class* dex_fields_class = 1033 mUnit->GetClassLinker()->ResolveType(dex_file, 1034 dex_file.GetFieldId(field_idx).class_idx_, 1035 referrer_class); 1036 access_ok = referrer_class->CanAccess(dex_fields_class) && 1037 referrer_class->CanAccessMember(dex_fields_class, 1038 resolved_field->GetAccessFlags()); 1039 } 1040 bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal(); 1041 if (access_ok && !is_write_to_final_from_wrong_class) { 1042 // We have the resolved field, we must make it into a index for the referrer 1043 // in its static storage (which may fail if it doesn't have a slot for it) 1044 // TODO: for images we can elide the static storage base null check 1045 // if we know there's a non-null entry in the image 1046 mirror::DexCache* dex_cache = mUnit->GetClassLinker()->FindDexCache(*mUnit->GetDexFile()); 1047 if (fields_class->GetDexCache() == dex_cache) { 1048 // common case where the dex cache of both the referrer and the field are the same, 1049 // no need to search the dex file 1050 *storage_index = fields_class->GetDexTypeIndex(); 1051 *field_offset = resolved_field->GetOffset().Int32Value(); 1052 *is_volatile = resolved_field->IsVolatile(); 1053 *is_initialized = fields_class->IsInitialized() && 1054 CanAssumeTypeIsPresentInDexCache(*mUnit->GetDexFile(), *storage_index); 1055 stats_->ResolvedStaticField(); 1056 return true; 1057 } 1058 // Search dex file for localized ssb index, may fail if field's class is a parent 1059 // of the class mentioned in the dex file and there is no dex cache entry. 1060 const DexFile::StringId* string_id = 1061 mUnit->GetDexFile()->FindStringId(FieldHelper(resolved_field).GetDeclaringClassDescriptor()); 1062 if (string_id != NULL) { 1063 const DexFile::TypeId* type_id = 1064 mUnit->GetDexFile()->FindTypeId(mUnit->GetDexFile()->GetIndexForStringId(*string_id)); 1065 if (type_id != NULL) { 1066 // medium path, needs check of static storage base being initialized 1067 *storage_index = mUnit->GetDexFile()->GetIndexForTypeId(*type_id); 1068 *field_offset = resolved_field->GetOffset().Int32Value(); 1069 *is_volatile = resolved_field->IsVolatile(); 1070 *is_initialized = fields_class->IsInitialized() && 1071 CanAssumeTypeIsPresentInDexCache(*mUnit->GetDexFile(), *storage_index); 1072 stats_->ResolvedStaticField(); 1073 return true; 1074 } 1075 } 1076 } 1077 } 1078 } 1079 } 1080 // Clean up any exception left by field/type resolution 1081 if (soa.Self()->IsExceptionPending()) { 1082 soa.Self()->ClearException(); 1083 } 1084 stats_->UnresolvedStaticField(); 1085 return false; // Incomplete knowledge needs slow path. 1086} 1087 1088void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType sharp_type, 1089 bool no_guarantee_of_dex_cache_entry, 1090 mirror::Class* referrer_class, 1091 mirror::ArtMethod* method, 1092 bool update_stats, 1093 MethodReference* target_method, 1094 uintptr_t* direct_code, 1095 uintptr_t* direct_method) { 1096 // For direct and static methods compute possible direct_code and direct_method values, ie 1097 // an address for the Method* being invoked and an address of the code for that Method*. 1098 // For interface calls compute a value for direct_method that is the interface method being 1099 // invoked, so this can be passed to the out-of-line runtime support code. 1100 *direct_code = 0; 1101 *direct_method = 0; 1102 bool use_dex_cache = false; 1103 const bool compiling_boot = Runtime::Current()->GetHeap()->IsCompilingBoot(); 1104 if (compiler_backend_ == kPortable) { 1105 if (sharp_type != kStatic && sharp_type != kDirect) { 1106 return; 1107 } 1108 use_dex_cache = true; 1109 } else { 1110 if (sharp_type != kStatic && sharp_type != kDirect) { 1111 return; 1112 } 1113 // TODO: support patching on all architectures. 1114 use_dex_cache = compiling_boot && !support_boot_image_fixup_; 1115 } 1116 bool method_code_in_boot = (method->GetDeclaringClass()->GetClassLoader() == nullptr); 1117 if (!use_dex_cache) { 1118 if (!method_code_in_boot) { 1119 use_dex_cache = true; 1120 } else { 1121 bool has_clinit_trampoline = 1122 method->IsStatic() && !method->GetDeclaringClass()->IsInitialized(); 1123 if (has_clinit_trampoline && (method->GetDeclaringClass() != referrer_class)) { 1124 // Ensure we run the clinit trampoline unless we are invoking a static method in the same 1125 // class. 1126 use_dex_cache = true; 1127 } 1128 } 1129 } 1130 if (update_stats && method_code_in_boot) { 1131 stats_->DirectCallsToBoot(*type); 1132 stats_->DirectMethodsToBoot(*type); 1133 } 1134 if (!use_dex_cache && compiling_boot) { 1135 MethodHelper mh(method); 1136 if (!IsImageClass(mh.GetDeclaringClassDescriptor())) { 1137 // We can only branch directly to Methods that are resolved in the DexCache. 1138 // Otherwise we won't invoke the resolution trampoline. 1139 use_dex_cache = true; 1140 } 1141 } 1142 // The method is defined not within this dex file. We need a dex cache slot within the current 1143 // dex file or direct pointers. 1144 bool must_use_direct_pointers = false; 1145 if (target_method->dex_file == method->GetDeclaringClass()->GetDexCache()->GetDexFile()) { 1146 target_method->dex_method_index = method->GetDexMethodIndex(); 1147 } else { 1148 // TODO: support patching from one dex file to another in the boot image. 1149 use_dex_cache = use_dex_cache || compiling_boot; 1150 if (no_guarantee_of_dex_cache_entry) { 1151 // See if the method is also declared in this dex cache. 1152 uint32_t dex_method_idx = MethodHelper(method).FindDexMethodIndexInOtherDexFile( 1153 *referrer_class->GetDexCache()->GetDexFile()); 1154 if (dex_method_idx != DexFile::kDexNoIndex) { 1155 target_method->dex_method_index = dex_method_idx; 1156 } else { 1157 must_use_direct_pointers = true; 1158 } 1159 } 1160 } 1161 if (use_dex_cache) { 1162 if (must_use_direct_pointers) { 1163 // Fail. Test above showed the only safe dispatch was via the dex cache, however, the direct 1164 // pointers are required as the dex cache lacks an appropriate entry. 1165 VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method); 1166 } else { 1167 *type = sharp_type; 1168 } 1169 } else { 1170 if (compiling_boot) { 1171 *type = sharp_type; 1172 *direct_method = -1; 1173 *direct_code = -1; 1174 } else { 1175 bool method_in_image = 1176 Runtime::Current()->GetHeap()->FindSpaceFromObject(method, false)->IsImageSpace(); 1177 if (method_in_image) { 1178 CHECK(!method->IsAbstract()); 1179 *type = sharp_type; 1180 *direct_method = reinterpret_cast<uintptr_t>(method); 1181 *direct_code = reinterpret_cast<uintptr_t>(method->GetEntryPointFromCompiledCode()); 1182 target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile(); 1183 target_method->dex_method_index = method->GetDexMethodIndex(); 1184 } else if (!must_use_direct_pointers) { 1185 // Set the code and rely on the dex cache for the method. 1186 *type = sharp_type; 1187 *direct_code = reinterpret_cast<uintptr_t>(method->GetEntryPointFromCompiledCode()); 1188 } else { 1189 // Direct pointers were required but none were available. 1190 VLOG(compiler) << "Dex cache devirtualization failed for: " << PrettyMethod(method); 1191 } 1192 } 1193 } 1194} 1195 1196bool CompilerDriver::ComputeInvokeInfo(const DexCompilationUnit* mUnit, const uint32_t dex_pc, 1197 bool update_stats, bool enable_devirtualization, 1198 InvokeType* invoke_type, MethodReference* target_method, 1199 int* vtable_idx, uintptr_t* direct_code, 1200 uintptr_t* direct_method) { 1201 ScopedObjectAccess soa(Thread::Current()); 1202 *vtable_idx = -1; 1203 *direct_code = 0; 1204 *direct_method = 0; 1205 mirror::ArtMethod* resolved_method = 1206 ComputeMethodReferencedFromCompilingMethod(soa, mUnit, target_method->dex_method_index, 1207 *invoke_type); 1208 if (resolved_method != NULL) { 1209 if (*invoke_type == kVirtual || *invoke_type == kSuper) { 1210 *vtable_idx = resolved_method->GetMethodIndex(); 1211 } else if (*invoke_type == kInterface) { 1212 *vtable_idx = resolved_method->GetDexMethodIndex(); 1213 } 1214 // Don't try to fast-path if we don't understand the caller's class or this appears to be an 1215 // Incompatible Class Change Error. 1216 SirtRef<mirror::DexCache> dex_cache(soa.Self(), resolved_method->GetDeclaringClass()->GetDexCache()); 1217 mirror::Class* referrer_class = 1218 ComputeCompilingMethodsClass(soa, dex_cache, mUnit); 1219 bool icce = resolved_method->CheckIncompatibleClassChange(*invoke_type); 1220 if (referrer_class != NULL && !icce) { 1221 mirror::Class* methods_class = resolved_method->GetDeclaringClass(); 1222 if (!referrer_class->CanAccess(methods_class) || 1223 !referrer_class->CanAccessMember(methods_class, 1224 resolved_method->GetAccessFlags())) { 1225 // The referring class can't access the resolved method, this may occur as a result of a 1226 // protected method being made public by implementing an interface that re-declares the 1227 // method public. Resort to the dex file to determine the correct class for the access 1228 // check. 1229 uint16_t class_idx = 1230 target_method->dex_file->GetMethodId(target_method->dex_method_index).class_idx_; 1231 methods_class = mUnit->GetClassLinker()->ResolveType(*target_method->dex_file, 1232 class_idx, referrer_class); 1233 } 1234 if (referrer_class->CanAccess(methods_class) && 1235 referrer_class->CanAccessMember(methods_class, resolved_method->GetAccessFlags())) { 1236 const bool enableFinalBasedSharpening = enable_devirtualization; 1237 // Sharpen a virtual call into a direct call when the target is known not to have been 1238 // overridden (ie is final). 1239 bool can_sharpen_virtual_based_on_type = 1240 (*invoke_type == kVirtual) && (resolved_method->IsFinal() || methods_class->IsFinal()); 1241 // For invoke-super, ensure the vtable index will be correct to dispatch in the vtable of 1242 // the super class. 1243 bool can_sharpen_super_based_on_type = (*invoke_type == kSuper) && 1244 (referrer_class != methods_class) && referrer_class->IsSubClass(methods_class) && 1245 resolved_method->GetMethodIndex() < methods_class->GetVTable()->GetLength() && 1246 (methods_class->GetVTable()->Get(resolved_method->GetMethodIndex()) == resolved_method); 1247 1248 if (enableFinalBasedSharpening && (can_sharpen_virtual_based_on_type || 1249 can_sharpen_super_based_on_type)) { 1250 // Sharpen a virtual call into a direct call. The method_idx is into referrer's 1251 // dex cache, check that this resolved method is where we expect it. 1252 CHECK(referrer_class->GetDexCache()->GetResolvedMethod(target_method->dex_method_index) == 1253 resolved_method) << PrettyMethod(resolved_method); 1254 InvokeType orig_invoke_type = *invoke_type; 1255 GetCodeAndMethodForDirectCall(invoke_type, kDirect, false, referrer_class, resolved_method, 1256 update_stats, target_method, direct_code, direct_method); 1257 if (update_stats && (*invoke_type == kDirect)) { 1258 stats_->ResolvedMethod(orig_invoke_type); 1259 stats_->VirtualMadeDirect(orig_invoke_type); 1260 } 1261 DCHECK_NE(*invoke_type, kSuper) << PrettyMethod(resolved_method); 1262 return true; 1263 } 1264 const bool enableVerifierBasedSharpening = enable_devirtualization; 1265 if (enableVerifierBasedSharpening && (*invoke_type == kVirtual || 1266 *invoke_type == kInterface)) { 1267 // Did the verifier record a more precise invoke target based on its type information? 1268 const MethodReference caller_method(mUnit->GetDexFile(), mUnit->GetDexMethodIndex()); 1269 const MethodReference* devirt_map_target = 1270 verified_methods_data_->GetDevirtMap(caller_method, dex_pc); 1271 if (devirt_map_target != NULL) { 1272 SirtRef<mirror::DexCache> target_dex_cache(soa.Self(), mUnit->GetClassLinker()->FindDexCache(*devirt_map_target->dex_file)); 1273 SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader())); 1274 mirror::ArtMethod* called_method = 1275 mUnit->GetClassLinker()->ResolveMethod(*devirt_map_target->dex_file, 1276 devirt_map_target->dex_method_index, 1277 target_dex_cache, class_loader, NULL, 1278 kVirtual); 1279 CHECK(called_method != NULL); 1280 CHECK(!called_method->IsAbstract()); 1281 InvokeType orig_invoke_type = *invoke_type; 1282 GetCodeAndMethodForDirectCall(invoke_type, kDirect, true, referrer_class, called_method, 1283 update_stats, target_method, direct_code, direct_method); 1284 if (update_stats && (*invoke_type == kDirect)) { 1285 stats_->ResolvedMethod(orig_invoke_type); 1286 stats_->VirtualMadeDirect(orig_invoke_type); 1287 stats_->PreciseTypeDevirtualization(); 1288 } 1289 DCHECK_NE(*invoke_type, kSuper); 1290 return true; 1291 } 1292 } 1293 if (*invoke_type == kSuper) { 1294 // Unsharpened super calls are suspicious so go slow-path. 1295 } else { 1296 // Sharpening failed so generate a regular resolved method dispatch. 1297 if (update_stats) { 1298 stats_->ResolvedMethod(*invoke_type); 1299 } 1300 GetCodeAndMethodForDirectCall(invoke_type, *invoke_type, false, referrer_class, resolved_method, 1301 update_stats, target_method, direct_code, direct_method); 1302 return true; 1303 } 1304 } 1305 } 1306 } 1307 // Clean up any exception left by method/invoke_type resolution 1308 if (soa.Self()->IsExceptionPending()) { 1309 soa.Self()->ClearException(); 1310 } 1311 if (update_stats) { 1312 stats_->UnresolvedMethod(*invoke_type); 1313 } 1314 return false; // Incomplete knowledge needs slow path. 1315} 1316 1317bool CompilerDriver::IsSafeCast(const MethodReference& mr, uint32_t dex_pc) { 1318 bool result = verified_methods_data_->IsSafeCast(mr, dex_pc); 1319 if (result) { 1320 stats_->SafeCast(); 1321 } else { 1322 stats_->NotASafeCast(); 1323 } 1324 return result; 1325} 1326 1327 1328void CompilerDriver::AddCodePatch(const DexFile* dex_file, 1329 uint16_t referrer_class_def_idx, 1330 uint32_t referrer_method_idx, 1331 InvokeType referrer_invoke_type, 1332 uint32_t target_method_idx, 1333 InvokeType target_invoke_type, 1334 size_t literal_offset) { 1335 MutexLock mu(Thread::Current(), compiled_methods_lock_); 1336 code_to_patch_.push_back(new PatchInformation(dex_file, 1337 referrer_class_def_idx, 1338 referrer_method_idx, 1339 referrer_invoke_type, 1340 target_method_idx, 1341 target_invoke_type, 1342 literal_offset)); 1343} 1344void CompilerDriver::AddMethodPatch(const DexFile* dex_file, 1345 uint16_t referrer_class_def_idx, 1346 uint32_t referrer_method_idx, 1347 InvokeType referrer_invoke_type, 1348 uint32_t target_method_idx, 1349 InvokeType target_invoke_type, 1350 size_t literal_offset) { 1351 MutexLock mu(Thread::Current(), compiled_methods_lock_); 1352 methods_to_patch_.push_back(new PatchInformation(dex_file, 1353 referrer_class_def_idx, 1354 referrer_method_idx, 1355 referrer_invoke_type, 1356 target_method_idx, 1357 target_invoke_type, 1358 literal_offset)); 1359} 1360 1361class ParallelCompilationManager { 1362 public: 1363 typedef void Callback(const ParallelCompilationManager* manager, size_t index); 1364 1365 ParallelCompilationManager(ClassLinker* class_linker, 1366 jobject class_loader, 1367 CompilerDriver* compiler, 1368 const DexFile* dex_file, 1369 ThreadPool& thread_pool) 1370 : index_(0), 1371 class_linker_(class_linker), 1372 class_loader_(class_loader), 1373 compiler_(compiler), 1374 dex_file_(dex_file), 1375 thread_pool_(&thread_pool) {} 1376 1377 ClassLinker* GetClassLinker() const { 1378 CHECK(class_linker_ != NULL); 1379 return class_linker_; 1380 } 1381 1382 jobject GetClassLoader() const { 1383 return class_loader_; 1384 } 1385 1386 CompilerDriver* GetCompiler() const { 1387 CHECK(compiler_ != NULL); 1388 return compiler_; 1389 } 1390 1391 const DexFile* GetDexFile() const { 1392 CHECK(dex_file_ != NULL); 1393 return dex_file_; 1394 } 1395 1396 void ForAll(size_t begin, size_t end, Callback callback, size_t work_units) { 1397 Thread* self = Thread::Current(); 1398 self->AssertNoPendingException(); 1399 CHECK_GT(work_units, 0U); 1400 1401 index_ = begin; 1402 for (size_t i = 0; i < work_units; ++i) { 1403 thread_pool_->AddTask(self, new ForAllClosure(this, end, callback)); 1404 } 1405 thread_pool_->StartWorkers(self); 1406 1407 // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker 1408 // thread destructor's called below perform join). 1409 CHECK_NE(self->GetState(), kRunnable); 1410 1411 // Wait for all the worker threads to finish. 1412 thread_pool_->Wait(self, true, false); 1413 } 1414 1415 size_t NextIndex() { 1416 return index_.FetchAndAdd(1); 1417 } 1418 1419 private: 1420 class ForAllClosure : public Task { 1421 public: 1422 ForAllClosure(ParallelCompilationManager* manager, size_t end, Callback* callback) 1423 : manager_(manager), 1424 end_(end), 1425 callback_(callback) {} 1426 1427 virtual void Run(Thread* self) { 1428 while (true) { 1429 const size_t index = manager_->NextIndex(); 1430 if (UNLIKELY(index >= end_)) { 1431 break; 1432 } 1433 callback_(manager_, index); 1434 self->AssertNoPendingException(); 1435 } 1436 } 1437 1438 virtual void Finalize() { 1439 delete this; 1440 } 1441 1442 private: 1443 ParallelCompilationManager* const manager_; 1444 const size_t end_; 1445 Callback* const callback_; 1446 }; 1447 1448 AtomicInteger index_; 1449 ClassLinker* const class_linker_; 1450 const jobject class_loader_; 1451 CompilerDriver* const compiler_; 1452 const DexFile* const dex_file_; 1453 ThreadPool* const thread_pool_; 1454 1455 DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager); 1456}; 1457 1458// Return true if the class should be skipped during compilation. 1459// 1460// The first case where we skip is for redundant class definitions in 1461// the boot classpath. We skip all but the first definition in that case. 1462// 1463// The second case where we skip is when an app bundles classes found 1464// in the boot classpath. Since at runtime we will select the class from 1465// the boot classpath, we ignore the one from the app. 1466static bool SkipClass(ClassLinker* class_linker, jobject class_loader, const DexFile& dex_file, 1467 const DexFile::ClassDef& class_def) { 1468 const char* descriptor = dex_file.GetClassDescriptor(class_def); 1469 if (class_loader == NULL) { 1470 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_linker->GetBootClassPath()); 1471 CHECK(pair.second != NULL); 1472 if (pair.first != &dex_file) { 1473 LOG(WARNING) << "Skipping class " << descriptor << " from " << dex_file.GetLocation() 1474 << " previously found in " << pair.first->GetLocation(); 1475 return true; 1476 } 1477 return false; 1478 } 1479 return class_linker->IsInBootClassPath(descriptor); 1480} 1481 1482// A fast version of SkipClass above if the class pointer is available 1483// that avoids the expensive FindInClassPath search. 1484static bool SkipClass(jobject class_loader, const DexFile& dex_file, mirror::Class* klass) 1485 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 1486 DCHECK(klass != NULL); 1487 const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile(); 1488 if (&dex_file != &original_dex_file) { 1489 if (class_loader == NULL) { 1490 LOG(WARNING) << "Skipping class " << PrettyDescriptor(klass) << " from " 1491 << dex_file.GetLocation() << " previously found in " 1492 << original_dex_file.GetLocation(); 1493 } 1494 return true; 1495 } 1496 return false; 1497} 1498 1499static void ResolveClassFieldsAndMethods(const ParallelCompilationManager* manager, 1500 size_t class_def_index) 1501 LOCKS_EXCLUDED(Locks::mutator_lock_) { 1502 ATRACE_CALL(); 1503 Thread* self = Thread::Current(); 1504 jobject jclass_loader = manager->GetClassLoader(); 1505 const DexFile& dex_file = *manager->GetDexFile(); 1506 ClassLinker* class_linker = manager->GetClassLinker(); 1507 1508 // If an instance field is final then we need to have a barrier on the return, static final 1509 // fields are assigned within the lock held for class initialization. Conservatively assume 1510 // constructor barriers are always required. 1511 bool requires_constructor_barrier = true; 1512 1513 // Method and Field are the worst. We can't resolve without either 1514 // context from the code use (to disambiguate virtual vs direct 1515 // method and instance vs static field) or from class 1516 // definitions. While the compiler will resolve what it can as it 1517 // needs it, here we try to resolve fields and methods used in class 1518 // definitions, since many of them many never be referenced by 1519 // generated code. 1520 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1521 if (!SkipClass(class_linker, jclass_loader, dex_file, class_def)) { 1522 ScopedObjectAccess soa(self); 1523 SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(jclass_loader)); 1524 SirtRef<mirror::DexCache> dex_cache(soa.Self(), class_linker->FindDexCache(dex_file)); 1525 // Resolve the class. 1526 mirror::Class* klass = class_linker->ResolveType(dex_file, class_def.class_idx_, dex_cache, 1527 class_loader); 1528 bool resolve_fields_and_methods; 1529 if (klass == NULL) { 1530 // Class couldn't be resolved, for example, super-class is in a different dex file. Don't 1531 // attempt to resolve methods and fields when there is no declaring class. 1532 CHECK(soa.Self()->IsExceptionPending()); 1533 soa.Self()->ClearException(); 1534 resolve_fields_and_methods = false; 1535 } else { 1536 resolve_fields_and_methods = manager->GetCompiler()->IsImage(); 1537 } 1538 // Note the class_data pointer advances through the headers, 1539 // static fields, instance fields, direct methods, and virtual 1540 // methods. 1541 const byte* class_data = dex_file.GetClassData(class_def); 1542 if (class_data == NULL) { 1543 // Empty class such as a marker interface. 1544 requires_constructor_barrier = false; 1545 } else { 1546 ClassDataItemIterator it(dex_file, class_data); 1547 while (it.HasNextStaticField()) { 1548 if (resolve_fields_and_methods) { 1549 mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), 1550 dex_cache, class_loader, true); 1551 if (field == NULL) { 1552 CHECK(soa.Self()->IsExceptionPending()); 1553 soa.Self()->ClearException(); 1554 } 1555 } 1556 it.Next(); 1557 } 1558 // We require a constructor barrier if there are final instance fields. 1559 requires_constructor_barrier = false; 1560 while (it.HasNextInstanceField()) { 1561 if ((it.GetMemberAccessFlags() & kAccFinal) != 0) { 1562 requires_constructor_barrier = true; 1563 } 1564 if (resolve_fields_and_methods) { 1565 mirror::ArtField* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), 1566 dex_cache, class_loader, false); 1567 if (field == NULL) { 1568 CHECK(soa.Self()->IsExceptionPending()); 1569 soa.Self()->ClearException(); 1570 } 1571 } 1572 it.Next(); 1573 } 1574 if (resolve_fields_and_methods) { 1575 while (it.HasNextDirectMethod()) { 1576 mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), 1577 dex_cache, class_loader, NULL, 1578 it.GetMethodInvokeType(class_def)); 1579 if (method == NULL) { 1580 CHECK(soa.Self()->IsExceptionPending()); 1581 soa.Self()->ClearException(); 1582 } 1583 it.Next(); 1584 } 1585 while (it.HasNextVirtualMethod()) { 1586 mirror::ArtMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), 1587 dex_cache, class_loader, NULL, 1588 it.GetMethodInvokeType(class_def)); 1589 if (method == NULL) { 1590 CHECK(soa.Self()->IsExceptionPending()); 1591 soa.Self()->ClearException(); 1592 } 1593 it.Next(); 1594 } 1595 DCHECK(!it.HasNext()); 1596 } 1597 } 1598 } 1599 if (requires_constructor_barrier) { 1600 manager->GetCompiler()->AddRequiresConstructorBarrier(self, &dex_file, class_def_index); 1601 } 1602} 1603 1604static void ResolveType(const ParallelCompilationManager* manager, size_t type_idx) 1605 LOCKS_EXCLUDED(Locks::mutator_lock_) { 1606 // Class derived values are more complicated, they require the linker and loader. 1607 ScopedObjectAccess soa(Thread::Current()); 1608 ClassLinker* class_linker = manager->GetClassLinker(); 1609 const DexFile& dex_file = *manager->GetDexFile(); 1610 SirtRef<mirror::DexCache> dex_cache(soa.Self(), class_linker->FindDexCache(dex_file)); 1611 SirtRef<mirror::ClassLoader> class_loader( 1612 soa.Self(), soa.Decode<mirror::ClassLoader*>(manager->GetClassLoader())); 1613 mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader); 1614 1615 if (klass == NULL) { 1616 CHECK(soa.Self()->IsExceptionPending()); 1617 mirror::Throwable* exception = soa.Self()->GetException(NULL); 1618 VLOG(compiler) << "Exception during type resolution: " << exception->Dump(); 1619 if (strcmp("Ljava/lang/OutOfMemoryError;", 1620 ClassHelper(exception->GetClass()).GetDescriptor()) == 0) { 1621 // There's little point continuing compilation if the heap is exhausted. 1622 LOG(FATAL) << "Out of memory during type resolution for compilation"; 1623 } 1624 soa.Self()->ClearException(); 1625 } 1626} 1627 1628void CompilerDriver::ResolveDexFile(jobject class_loader, const DexFile& dex_file, 1629 ThreadPool& thread_pool, TimingLogger& timings) { 1630 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1631 1632 // TODO: we could resolve strings here, although the string table is largely filled with class 1633 // and method names. 1634 1635 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool); 1636 if (IsImage()) { 1637 // For images we resolve all types, such as array, whereas for applications just those with 1638 // classdefs are resolved by ResolveClassFieldsAndMethods. 1639 timings.NewSplit("Resolve Types"); 1640 context.ForAll(0, dex_file.NumTypeIds(), ResolveType, thread_count_); 1641 } 1642 1643 timings.NewSplit("Resolve MethodsAndFields"); 1644 context.ForAll(0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_); 1645} 1646 1647void CompilerDriver::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files, 1648 ThreadPool& thread_pool, TimingLogger& timings) { 1649 for (size_t i = 0; i != dex_files.size(); ++i) { 1650 const DexFile* dex_file = dex_files[i]; 1651 CHECK(dex_file != NULL); 1652 VerifyDexFile(class_loader, *dex_file, thread_pool, timings); 1653 } 1654} 1655 1656static void VerifyClass(const ParallelCompilationManager* manager, size_t class_def_index) 1657 LOCKS_EXCLUDED(Locks::mutator_lock_) { 1658 ATRACE_CALL(); 1659 ScopedObjectAccess soa(Thread::Current()); 1660 const DexFile& dex_file = *manager->GetDexFile(); 1661 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 1662 const char* descriptor = dex_file.GetClassDescriptor(class_def); 1663 ClassLinker* class_linker = manager->GetClassLinker(); 1664 jobject jclass_loader = manager->GetClassLoader(); 1665 SirtRef<mirror::ClassLoader> class_loader( 1666 soa.Self(), soa.Decode<mirror::ClassLoader*>(jclass_loader)); 1667 SirtRef<mirror::Class> klass(soa.Self(), class_linker->FindClass(descriptor, class_loader)); 1668 if (klass.get() == nullptr) { 1669 CHECK(soa.Self()->IsExceptionPending()); 1670 soa.Self()->ClearException(); 1671 1672 /* 1673 * At compile time, we can still structurally verify the class even if FindClass fails. 1674 * This is to ensure the class is structurally sound for compilation. An unsound class 1675 * will be rejected by the verifier and later skipped during compilation in the compiler. 1676 */ 1677 SirtRef<mirror::DexCache> dex_cache(soa.Self(), class_linker->FindDexCache(dex_file)); 1678 std::string error_msg; 1679 if (verifier::MethodVerifier::VerifyClass(&dex_file, dex_cache, class_loader, &class_def, true, 1680 &error_msg) == 1681 verifier::MethodVerifier::kHardFailure) { 1682 LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor) 1683 << " because: " << error_msg; 1684 } 1685 } else if (!SkipClass(jclass_loader, dex_file, klass.get())) { 1686 CHECK(klass->IsResolved()) << PrettyClass(klass.get()); 1687 class_linker->VerifyClass(klass); 1688 1689 if (klass->IsErroneous()) { 1690 // ClassLinker::VerifyClass throws, which isn't useful in the compiler. 1691 CHECK(soa.Self()->IsExceptionPending()); 1692 soa.Self()->ClearException(); 1693 } 1694 1695 CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous()) 1696 << PrettyDescriptor(klass.get()) << ": state=" << klass->GetStatus(); 1697 } 1698 soa.Self()->AssertNoPendingException(); 1699} 1700 1701void CompilerDriver::VerifyDexFile(jobject class_loader, const DexFile& dex_file, 1702 ThreadPool& thread_pool, TimingLogger& timings) { 1703 timings.NewSplit("Verify Dex File"); 1704 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1705 ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, thread_pool); 1706 context.ForAll(0, dex_file.NumClassDefs(), VerifyClass, thread_count_); 1707} 1708 1709static const char* class_initializer_black_list[] = { 1710 "Landroid/app/ActivityThread;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1711 "Landroid/bluetooth/BluetoothAudioGateway;", // Calls android.bluetooth.BluetoothAudioGateway.classInitNative(). 1712 "Landroid/bluetooth/HeadsetBase;", // Calls android.bluetooth.HeadsetBase.classInitNative(). 1713 "Landroid/content/res/CompatibilityInfo;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int. 1714 "Landroid/content/res/CompatibilityInfo$1;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int. 1715 "Landroid/content/UriMatcher;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1716 "Landroid/database/CursorWindow;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int. 1717 "Landroid/database/sqlite/SQLiteConnection;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1718 "Landroid/database/sqlite/SQLiteConnection$Operation;", // Requires SimpleDateFormat -> java.util.Locale. 1719 "Landroid/database/sqlite/SQLiteDatabaseConfiguration;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1720 "Landroid/database/sqlite/SQLiteDebug;", // Calls android.util.Log.isLoggable. 1721 "Landroid/database/sqlite/SQLiteOpenHelper;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex. 1722 "Landroid/database/sqlite/SQLiteQueryBuilder;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1723 "Landroid/drm/DrmManagerClient;", // Calls System.loadLibrary. 1724 "Landroid/graphics/drawable/AnimatedRotateDrawable;", // Sub-class of Drawable. 1725 "Landroid/graphics/drawable/AnimationDrawable;", // Sub-class of Drawable. 1726 "Landroid/graphics/drawable/BitmapDrawable;", // Sub-class of Drawable. 1727 "Landroid/graphics/drawable/ClipDrawable;", // Sub-class of Drawable. 1728 "Landroid/graphics/drawable/ColorDrawable;", // Sub-class of Drawable. 1729 "Landroid/graphics/drawable/Drawable;", // Requires android.graphics.Rect. 1730 "Landroid/graphics/drawable/DrawableContainer;", // Sub-class of Drawable. 1731 "Landroid/graphics/drawable/GradientDrawable;", // Sub-class of Drawable. 1732 "Landroid/graphics/drawable/LayerDrawable;", // Sub-class of Drawable. 1733 "Landroid/graphics/drawable/NinePatchDrawable;", // Sub-class of Drawable. 1734 "Landroid/graphics/drawable/RotateDrawable;", // Sub-class of Drawable. 1735 "Landroid/graphics/drawable/ScaleDrawable;", // Sub-class of Drawable. 1736 "Landroid/graphics/drawable/ShapeDrawable;", // Sub-class of Drawable. 1737 "Landroid/graphics/drawable/StateListDrawable;", // Sub-class of Drawable. 1738 "Landroid/graphics/drawable/TransitionDrawable;", // Sub-class of Drawable. 1739 "Landroid/graphics/Matrix;", // Calls android.graphics.Matrix.native_create. 1740 "Landroid/graphics/Matrix$1;", // Requires Matrix. 1741 "Landroid/graphics/PixelFormat;", // Calls android.graphics.PixelFormat.nativeClassInit(). 1742 "Landroid/graphics/Rect;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1743 "Landroid/graphics/SurfaceTexture;", // Calls android.graphics.SurfaceTexture.nativeClassInit(). 1744 "Landroid/graphics/Typeface;", // Calls android.graphics.Typeface.nativeCreate. 1745 "Landroid/inputmethodservice/ExtractEditText;", // Requires android.widget.TextView. 1746 "Landroid/media/AmrInputStream;", // Calls OsConstants.initConstants. 1747 "Landroid/media/CamcorderProfile;", // Calls OsConstants.initConstants. 1748 "Landroid/media/CameraProfile;", // Calls System.loadLibrary. 1749 "Landroid/media/DecoderCapabilities;", // Calls System.loadLibrary. 1750 "Landroid/media/EncoderCapabilities;", // Calls OsConstants.initConstants. 1751 "Landroid/media/ExifInterface;", // Calls OsConstants.initConstants. 1752 "Landroid/media/MediaCodec;", // Calls OsConstants.initConstants. 1753 "Landroid/media/MediaCodecList;", // Calls OsConstants.initConstants. 1754 "Landroid/media/MediaCrypto;", // Calls OsConstants.initConstants. 1755 "Landroid/media/MediaDrm;", // Calls OsConstants.initConstants. 1756 "Landroid/media/MediaExtractor;", // Calls OsConstants.initConstants. 1757 "Landroid/media/MediaFile;", // Requires DecoderCapabilities. 1758 "Landroid/media/MediaMetadataRetriever;", // Calls OsConstants.initConstants. 1759 "Landroid/media/MediaMuxer;", // Calls OsConstants.initConstants. 1760 "Landroid/media/MediaPlayer;", // Calls System.loadLibrary. 1761 "Landroid/media/MediaRecorder;", // Calls System.loadLibrary. 1762 "Landroid/media/MediaScanner;", // Calls System.loadLibrary. 1763 "Landroid/media/ResampleInputStream;", // Calls OsConstants.initConstants. 1764 "Landroid/media/SoundPool;", // Calls OsConstants.initConstants. 1765 "Landroid/media/videoeditor/MediaArtistNativeHelper;", // Calls OsConstants.initConstants. 1766 "Landroid/media/videoeditor/VideoEditorProfile;", // Calls OsConstants.initConstants. 1767 "Landroid/mtp/MtpDatabase;", // Calls OsConstants.initConstants. 1768 "Landroid/mtp/MtpDevice;", // Calls OsConstants.initConstants. 1769 "Landroid/mtp/MtpServer;", // Calls OsConstants.initConstants. 1770 "Landroid/net/NetworkInfo;", // Calls java.util.EnumMap.<init> -> java.lang.Enum.getSharedConstants -> System.identityHashCode. 1771 "Landroid/net/Proxy;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1772 "Landroid/net/SSLCertificateSocketFactory;", // Requires javax.net.ssl.HttpsURLConnection. 1773 "Landroid/net/Uri$AbstractHierarchicalUri;", // Requires Uri. 1774 "Landroid/net/Uri$HierarchicalUri;", // Requires Uri. 1775 "Landroid/net/Uri$OpaqueUri;", // Requires Uri. 1776 "Landroid/net/Uri$StringUri;", // Requires Uri. 1777 "Landroid/net/Uri;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex. 1778 "Landroid/net/WebAddress;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1779 "Landroid/net/wifi/WifiNative;", // Calls new LocalLog -> new Time -> TimeZone -> Pattern.compile. 1780 "Landroid/nfc/NdefRecord;", // Calls String.getBytes -> java.nio.charset.Charset. 1781 "Landroid/opengl/EGL14;", // Calls android.opengl.EGL14._nativeClassInit. 1782 "Landroid/opengl/GLES10;", // Calls android.opengl.GLES10._nativeClassInit. 1783 "Landroid/opengl/GLES10Ext;", // Calls android.opengl.GLES10Ext._nativeClassInit. 1784 "Landroid/opengl/GLES11;", // Requires GLES10. 1785 "Landroid/opengl/GLES11Ext;", // Calls android.opengl.GLES11Ext._nativeClassInit. 1786 "Landroid/opengl/GLES20;", // Calls android.opengl.GLES20._nativeClassInit. 1787 "Landroid/opengl/GLUtils;", // Calls android.opengl.GLUtils.nativeClassInit. 1788 "Landroid/os/Build;", // Calls -..-> android.os.SystemProperties.native_get. 1789 "Landroid/os/Build$VERSION;", // Requires Build. 1790 "Landroid/os/Bundle;", // Calls android.os.Parcel.obtain -..> Parcel.nativeCreate. 1791 "Landroid/os/Debug;", // Requires android.os.Environment. 1792 "Landroid/os/Environment;", // Calls System.getenv. 1793 "Landroid/os/FileUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1794 "Landroid/os/StrictMode;", // Calls android.util.Log.isLoggable. 1795 "Landroid/os/StrictMode$VmPolicy;", // Requires StrictMode. 1796 "Landroid/os/Trace;", // Calls android.os.Trace.nativeGetEnabledTags. 1797 "Landroid/os/UEventObserver;", // Calls Class.getSimpleName -> Class.isAnonymousClass -> Class.getDex. 1798 "Landroid/provider/ContactsContract;", // Calls OsConstants.initConstants. 1799 "Landroid/provider/Settings$Global;", // Calls OsConstants.initConstants. 1800 "Landroid/provider/Settings$Secure;", // Requires android.net.Uri. 1801 "Landroid/provider/Settings$System;", // Requires android.net.Uri. 1802 "Landroid/renderscript/RenderScript;", // Calls System.loadLibrary. 1803 "Landroid/server/BluetoothService;", // Calls android.server.BluetoothService.classInitNative. 1804 "Landroid/server/BluetoothEventLoop;", // Calls android.server.BluetoothEventLoop.classInitNative. 1805 "Landroid/telephony/PhoneNumberUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1806 "Landroid/telephony/TelephonyManager;", // Calls OsConstants.initConstants. 1807 "Landroid/text/AutoText;", // Requires android.util.DisplayMetrics -..-> android.os.SystemProperties.native_get_int. 1808 "Landroid/text/Layout;", // Calls com.android.internal.util.ArrayUtils.emptyArray -> System.identityHashCode. 1809 "Landroid/text/BoringLayout;", // Requires Layout. 1810 "Landroid/text/DynamicLayout;", // Requires Layout. 1811 "Landroid/text/Html$HtmlParser;", // Calls -..-> String.toLowerCase -> java.util.Locale. 1812 "Landroid/text/StaticLayout;", // Requires Layout. 1813 "Landroid/text/TextUtils;", // Requires android.util.DisplayMetrics. 1814 "Landroid/util/DisplayMetrics;", // Calls SystemProperties.native_get_int. 1815 "Landroid/util/Patterns;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1816 "Landroid/view/Choreographer;", // Calls SystemProperties.native_get_boolean. 1817 "Landroid/util/Patterns;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1818 "Landroid/view/GLES20Canvas;", // Calls GLES20Canvas.nIsAvailable(). 1819 "Landroid/view/GLES20RecordingCanvas;", // Requires android.view.GLES20Canvas. 1820 "Landroid/view/GestureDetector;", // Calls android.view.GLES20Canvas.nIsAvailable. 1821 "Landroid/view/HardwareRenderer$Gl20Renderer;", // Requires SystemProperties.native_get. 1822 "Landroid/view/HardwareRenderer$GlRenderer;", // Requires SystemProperties.native_get. 1823 "Landroid/view/InputEventConsistencyVerifier;", // Requires android.os.Build. 1824 "Landroid/view/Surface;", // Requires SystemProperties.native_get. 1825 "Landroid/view/SurfaceControl;", // Calls OsConstants.initConstants. 1826 "Landroid/view/animation/AlphaAnimation;", // Requires Animation. 1827 "Landroid/view/animation/Animation;", // Calls SystemProperties.native_get_boolean. 1828 "Landroid/view/animation/AnimationSet;", // Calls OsConstants.initConstants. 1829 "Landroid/view/textservice/SpellCheckerSubtype;", // Calls Class.getDex(). 1830 "Landroid/webkit/JniUtil;", // Calls System.loadLibrary. 1831 "Landroid/webkit/PluginManager;", // // Calls OsConstants.initConstants. 1832 "Landroid/webkit/WebViewCore;", // Calls System.loadLibrary. 1833 "Landroid/webkit/WebViewFactory;", // Calls -..-> android.os.SystemProperties.native_get. 1834 "Landroid/webkit/WebViewFactory$Preloader;", // Calls to Class.forName. 1835 "Landroid/webkit/WebViewInputDispatcher;", // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1836 "Landroid/webkit/URLUtil;", // Calls Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1837 "Landroid/widget/AutoCompleteTextView;", // Requires TextView. 1838 "Landroid/widget/Button;", // Requires TextView. 1839 "Landroid/widget/CheckBox;", // Requires TextView. 1840 "Landroid/widget/CheckedTextView;", // Requires TextView. 1841 "Landroid/widget/CompoundButton;", // Requires TextView. 1842 "Landroid/widget/EditText;", // Requires TextView. 1843 "Landroid/widget/NumberPicker;", // Requires java.util.Locale. 1844 "Landroid/widget/ScrollBarDrawable;", // Sub-class of Drawable. 1845 "Landroid/widget/SearchView$SearchAutoComplete;", // Requires TextView. 1846 "Landroid/widget/Switch;", // Requires TextView. 1847 "Landroid/widget/TextView;", // Calls Paint.<init> -> Paint.native_init. 1848 "Lcom/android/i18n/phonenumbers/AsYouTypeFormatter;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1849 "Lcom/android/i18n/phonenumbers/MetadataManager;", // Calls OsConstants.initConstants. 1850 "Lcom/android/i18n/phonenumbers/PhoneNumberMatcher;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1851 "Lcom/android/i18n/phonenumbers/PhoneNumberUtil;", // Requires java.util.logging.LogManager. 1852 "Lcom/android/i18n/phonenumbers/geocoding/AreaCodeMap;", // Calls OsConstants.initConstants. 1853 "Lcom/android/i18n/phonenumbers/geocoding/PhoneNumberOfflineGeocoder;", // Calls OsConstants.initConstants. 1854 "Lcom/android/internal/os/SamplingProfilerIntegration;", // Calls SystemProperties.native_get_int. 1855 "Lcom/android/internal/policy/impl/PhoneWindow;", // Calls android.os.Binder.init. 1856 "Lcom/android/internal/view/menu/ActionMenuItemView;", // Requires TextView. 1857 "Lcom/android/internal/widget/DialogTitle;", // Requires TextView. 1858 "Lcom/android/org/bouncycastle/asn1/StreamUtil;", // Calls Runtime.getRuntime().maxMemory(). 1859 "Lcom/android/org/bouncycastle/asn1/pkcs/MacData;", // Calls native ... -> java.math.NativeBN.BN_new(). 1860 "Lcom/android/org/bouncycastle/asn1/pkcs/RSASSAPSSparams;", // Calls native ... -> java.math.NativeBN.BN_new(). 1861 "Lcom/android/org/bouncycastle/asn1/cms/SignedData;", // Calls native ... -> java.math.NativeBN.BN_new(). 1862 "Lcom/android/org/bouncycastle/asn1/x509/GeneralSubtree;", // Calls native ... -> java.math.NativeBN.BN_new(). 1863 "Lcom/android/org/bouncycastle/asn1/x9/X9ECParameters;", // Calls native ... -> java.math.NativeBN.BN_new(). 1864 "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$MD5;", // Requires com.android.org.conscrypt.NativeCrypto. 1865 "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA1;", // Requires com.android.org.conscrypt.NativeCrypto. 1866 "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA256;", // Requires com.android.org.conscrypt.NativeCrypto. 1867 "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA384;", // Requires com.android.org.conscrypt.NativeCrypto. 1868 "Lcom/android/org/bouncycastle/crypto/digests/OpenSSLDigest$SHA512;", // Requires com.android.org.conscrypt.NativeCrypto. 1869 "Lcom/android/org/bouncycastle/crypto/engines/RSABlindedEngine;", // Calls native ... -> java.math.NativeBN.BN_new(). 1870 "Lcom/android/org/bouncycastle/crypto/generators/DHKeyGeneratorHelper;", // Calls native ... -> java.math.NativeBN.BN_new(). 1871 "Lcom/android/org/bouncycastle/crypto/generators/DHParametersGenerator;", // Calls native ... -> java.math.NativeBN.BN_new(). 1872 "Lcom/android/org/bouncycastle/crypto/generators/DHParametersHelper;", // Calls System.getenv -> OsConstants.initConstants. 1873 "Lcom/android/org/bouncycastle/crypto/generators/DSAKeyPairGenerator;", // Calls native ... -> java.math.NativeBN.BN_new(). 1874 "Lcom/android/org/bouncycastle/crypto/generators/DSAParametersGenerator;", // Calls native ... -> java.math.NativeBN.BN_new(). 1875 "Lcom/android/org/bouncycastle/crypto/generators/RSAKeyPairGenerator;", // Calls native ... -> java.math.NativeBN.BN_new(). 1876 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dh/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants. 1877 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/dsa/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants. 1878 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$EC;", // Calls OsConstants.initConstants. 1879 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDH;", // Calls OsConstants.initConstants. 1880 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDHC;", // Calls OsConstants.initConstants. 1881 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECDSA;", // Calls OsConstants.initConstants. 1882 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi$ECMQV;", // Calls OsConstants.initConstants. 1883 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/ec/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants. 1884 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateCrtKey;", // Calls native ... -> java.math.NativeBN.BN_new(). 1885 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/BCRSAPrivateKey;", // Calls native ... -> java.math.NativeBN.BN_new(). 1886 "Lcom/android/org/bouncycastle/jcajce/provider/asymmetric/rsa/KeyPairGeneratorSpi;", // Calls OsConstants.initConstants. 1887 "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi$BCPKCS12KeyStore;", // Calls Thread.currentThread. 1888 "Lcom/android/org/bouncycastle/jcajce/provider/keystore/pkcs12/PKCS12KeyStoreSpi;", // Calls Thread.currentThread. 1889 "Lcom/android/org/bouncycastle/jce/PKCS10CertificationRequest;", // Calls native ... -> java.math.NativeBN.BN_new(). 1890 "Lcom/android/org/bouncycastle/jce/provider/CertBlacklist;", // Calls System.getenv -> OsConstants.initConstants. 1891 "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateCrtKey;", // Calls native ... -> java.math.NativeBN.BN_new(). 1892 "Lcom/android/org/bouncycastle/jce/provider/JCERSAPrivateKey;", // Calls native ... -> java.math.NativeBN.BN_new(). 1893 "Lcom/android/org/bouncycastle/jce/provider/PKIXCertPathValidatorSpi;", // Calls System.getenv -> OsConstants.initConstants. 1894 "Lcom/android/org/bouncycastle/math/ec/ECConstants;", // Calls native ... -> java.math.NativeBN.BN_new(). 1895 "Lcom/android/org/bouncycastle/math/ec/Tnaf;", // Calls native ... -> java.math.NativeBN.BN_new(). 1896 "Lcom/android/org/bouncycastle/util/BigIntegers;", // Calls native ... -> java.math.NativeBN.BN_new(). 1897 "Lcom/android/org/bouncycastle/x509/X509Util;", // Calls native ... -> java.math.NativeBN.BN_new(). 1898 "Lcom/android/org/conscrypt/CipherSuite;", // Calls OsConstants.initConstants. 1899 "Lcom/android/org/conscrypt/FileClientSessionCache$CacheFile;", // Calls OsConstants.initConstants. 1900 "Lcom/android/org/conscrypt/HandshakeIODataStream;", // Calls OsConstants.initConstants. 1901 "Lcom/android/org/conscrypt/Logger;", // Calls OsConstants.initConstants. 1902 "Lcom/android/org/conscrypt/NativeCrypto;", // Calls native NativeCrypto.clinit(). 1903 "Lcom/android/org/conscrypt/OpenSSLECKeyPairGenerator;", // Calls OsConstants.initConstants. 1904 "Lcom/android/org/conscrypt/OpenSSLEngine;", // Requires com.android.org.conscrypt.NativeCrypto. 1905 "Lcom/android/org/conscrypt/OpenSSLMac$HmacMD5;", // Calls native NativeCrypto.clinit(). 1906 "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA1;", // Calls native NativeCrypto.clinit(). 1907 "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA256;", // Calls native NativeCrypto.clinit(). 1908 "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA384;", // Calls native NativeCrypto.clinit(). 1909 "Lcom/android/org/conscrypt/OpenSSLMac$HmacSHA512;", // Calls native NativeCrypto.clinit(). 1910 "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$MD5;", // Requires com.android.org.conscrypt.NativeCrypto. 1911 "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA1;", // Requires com.android.org.conscrypt.NativeCrypto. 1912 "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA256;", // Requires com.android.org.conscrypt.NativeCrypto. 1913 "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA384;", // Requires com.android.org.conscrypt.NativeCrypto. 1914 "Lcom/android/org/conscrypt/OpenSSLMessageDigestJDK$SHA512;", // Requires com.android.org.conscrypt.NativeCrypto. 1915 "Lcom/android/org/conscrypt/OpenSSLX509CertPath;", // Calls OsConstants.initConstants. 1916 "Lcom/android/org/conscrypt/OpenSSLX509CertificateFactory;", // Calls OsConstants.initConstants. 1917 "Lcom/android/org/conscrypt/PRF;", // Calls OsConstants.initConstants. 1918 "Lcom/android/org/conscrypt/SSLSessionImpl;", // Calls OsConstants.initConstants. 1919 "Lcom/android/org/conscrypt/TrustedCertificateStore;", // Calls System.getenv -> OsConstants.initConstants. 1920 "Lcom/android/okhttp/ConnectionPool;", // Calls OsConstants.initConstants. 1921 "Lcom/android/okhttp/OkHttpClient;", // Calls OsConstants.initConstants. 1922 "Lcom/android/okhttp/internal/DiskLruCache;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1923 "Lcom/android/okhttp/internal/Util;", // Calls OsConstants.initConstants. 1924 "Lcom/android/okhttp/internal/http/HttpsURLConnectionImpl;", // Calls VMClassLoader.getBootClassPathSize. 1925 "Lcom/android/okhttp/internal/spdy/SpdyConnection;", // Calls OsConstants.initConstants. 1926 "Lcom/android/okhttp/internal/spdy/SpdyReader;", // Calls OsConstants.initConstants. 1927 "Lcom/android/okhttp/internal/tls/OkHostnameVerifier;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 1928 "Lcom/google/android/gles_jni/EGLContextImpl;", // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit. 1929 "Lcom/google/android/gles_jni/EGLImpl;", // Calls com.google.android.gles_jni.EGLImpl._nativeClassInit. 1930 "Lcom/google/android/gles_jni/GLImpl;", // Calls com.google.android.gles_jni.GLImpl._nativeClassInit. 1931 "Lgov/nist/core/GenericObject;", // Calls OsConstants.initConstants. 1932 "Lgov/nist/core/Host;", // Calls OsConstants.initConstants. 1933 "Lgov/nist/core/HostPort;", // Calls OsConstants.initConstants. 1934 "Lgov/nist/core/NameValue;", // Calls OsConstants.initConstants. 1935 "Lgov/nist/core/net/DefaultNetworkLayer;", // Calls OsConstants.initConstants. 1936 "Lgov/nist/javax/sip/Utils;", // Calls OsConstants.initConstants. 1937 "Lgov/nist/javax/sip/address/AddressImpl;", // Calls OsConstants.initConstants. 1938 "Lgov/nist/javax/sip/address/Authority;", // Calls OsConstants.initConstants. 1939 "Lgov/nist/javax/sip/address/GenericURI;", // Calls OsConstants.initConstants. 1940 "Lgov/nist/javax/sip/address/NetObject;", // Calls OsConstants.initConstants. 1941 "Lgov/nist/javax/sip/address/SipUri;", // Calls OsConstants.initConstants. 1942 "Lgov/nist/javax/sip/address/TelephoneNumber;", // Calls OsConstants.initConstants. 1943 "Lgov/nist/javax/sip/address/UserInfo;", // Calls OsConstants.initConstants. 1944 "Lgov/nist/javax/sip/header/Accept;", // Calls OsConstants.initConstants. 1945 "Lgov/nist/javax/sip/header/AcceptEncoding;", // Calls OsConstants.initConstants. 1946 "Lgov/nist/javax/sip/header/AcceptLanguage;", // Calls OsConstants.initConstants. 1947 "Lgov/nist/javax/sip/header/AddressParametersHeader;", // Calls OsConstants.initConstants. 1948 "Lgov/nist/javax/sip/header/AlertInfoList;", // Calls OsConstants.initConstants. 1949 "Lgov/nist/javax/sip/header/AllowEvents;", // Calls OsConstants.initConstants. 1950 "Lgov/nist/javax/sip/header/AllowEventsList;", // Calls OsConstants.initConstants. 1951 "Lgov/nist/javax/sip/header/AuthenticationInfo;", // Calls OsConstants.initConstants. 1952 "Lgov/nist/javax/sip/header/Authorization;", // Calls OsConstants.initConstants. 1953 "Lgov/nist/javax/sip/header/CSeq;", // Calls OsConstants.initConstants. 1954 "Lgov/nist/javax/sip/header/CallIdentifier;", // Calls OsConstants.initConstants. 1955 "Lgov/nist/javax/sip/header/Challenge;", // Calls OsConstants.initConstants. 1956 "Lgov/nist/javax/sip/header/ContactList;", // Calls OsConstants.initConstants. 1957 "Lgov/nist/javax/sip/header/ContentEncoding;", // Calls OsConstants.initConstants. 1958 "Lgov/nist/javax/sip/header/ContentEncodingList;", // Calls OsConstants.initConstants. 1959 "Lgov/nist/javax/sip/header/ContentLanguageList;", // Calls OsConstants.initConstants. 1960 "Lgov/nist/javax/sip/header/ContentType;", // Calls OsConstants.initConstants. 1961 "Lgov/nist/javax/sip/header/Credentials;", // Calls OsConstants.initConstants. 1962 "Lgov/nist/javax/sip/header/ErrorInfoList;", // Calls OsConstants.initConstants. 1963 "Lgov/nist/javax/sip/header/Expires;", // Calls OsConstants.initConstants. 1964 "Lgov/nist/javax/sip/header/From;", // Calls OsConstants.initConstants. 1965 "Lgov/nist/javax/sip/header/MimeVersion;", // Calls OsConstants.initConstants. 1966 "Lgov/nist/javax/sip/header/NameMap;", // Calls OsConstants.initConstants. 1967 "Lgov/nist/javax/sip/header/Priority;", // Calls OsConstants.initConstants. 1968 "Lgov/nist/javax/sip/header/Protocol;", // Calls OsConstants.initConstants. 1969 "Lgov/nist/javax/sip/header/ProxyAuthenticate;", // Calls OsConstants.initConstants. 1970 "Lgov/nist/javax/sip/header/ProxyAuthenticateList;", // Calls OsConstants.initConstants. 1971 "Lgov/nist/javax/sip/header/ProxyAuthorizationList;", // Calls OsConstants.initConstants. 1972 "Lgov/nist/javax/sip/header/ProxyRequire;", // Calls OsConstants.initConstants. 1973 "Lgov/nist/javax/sip/header/ProxyRequireList;", // Calls OsConstants.initConstants. 1974 "Lgov/nist/javax/sip/header/RSeq;", // Calls OsConstants.initConstants. 1975 "Lgov/nist/javax/sip/header/RecordRoute;", // Calls OsConstants.initConstants. 1976 "Lgov/nist/javax/sip/header/ReferTo;", // Calls OsConstants.initConstants. 1977 "Lgov/nist/javax/sip/header/RequestLine;", // Calls OsConstants.initConstants. 1978 "Lgov/nist/javax/sip/header/Require;", // Calls OsConstants.initConstants. 1979 "Lgov/nist/javax/sip/header/RetryAfter;", // Calls OsConstants.initConstants. 1980 "Lgov/nist/javax/sip/header/SIPETag;", // Calls OsConstants.initConstants. 1981 "Lgov/nist/javax/sip/header/SIPHeader;", // Calls OsConstants.initConstants. 1982 "Lgov/nist/javax/sip/header/SIPHeaderNamesCache;", // Calls OsConstants.initConstants. 1983 "Lgov/nist/javax/sip/header/StatusLine;", // Calls OsConstants.initConstants. 1984 "Lgov/nist/javax/sip/header/SubscriptionState;", // Calls OsConstants.initConstants. 1985 "Lgov/nist/javax/sip/header/TimeStamp;", // Calls OsConstants.initConstants. 1986 "Lgov/nist/javax/sip/header/UserAgent;", // Calls OsConstants.initConstants. 1987 "Lgov/nist/javax/sip/header/Unsupported;", // Calls OsConstants.initConstants. 1988 "Lgov/nist/javax/sip/header/Warning;", // Calls OsConstants.initConstants. 1989 "Lgov/nist/javax/sip/header/ViaList;", // Calls OsConstants.initConstants. 1990 "Lgov/nist/javax/sip/header/extensions/Join;", // Calls OsConstants.initConstants. 1991 "Lgov/nist/javax/sip/header/extensions/References;", // Calls OsConstants.initConstants. 1992 "Lgov/nist/javax/sip/header/extensions/Replaces;", // Calls OsConstants.initConstants. 1993 "Lgov/nist/javax/sip/header/ims/PAccessNetworkInfo;", // Calls OsConstants.initConstants. 1994 "Lgov/nist/javax/sip/header/ims/PAssertedIdentity;", // Calls OsConstants.initConstants. 1995 "Lgov/nist/javax/sip/header/ims/PAssertedIdentityList;", // Calls OsConstants.initConstants. 1996 "Lgov/nist/javax/sip/header/ims/PAssociatedURI;", // Calls OsConstants.initConstants. 1997 "Lgov/nist/javax/sip/header/ims/PCalledPartyID;", // Calls OsConstants.initConstants. 1998 "Lgov/nist/javax/sip/header/ims/PChargingVector;", // Calls OsConstants.initConstants. 1999 "Lgov/nist/javax/sip/header/ims/PPreferredIdentity;", // Calls OsConstants.initConstants. 2000 "Lgov/nist/javax/sip/header/ims/PVisitedNetworkIDList;", // Calls OsConstants.initConstants. 2001 "Lgov/nist/javax/sip/header/ims/PathList;", // Calls OsConstants.initConstants. 2002 "Lgov/nist/javax/sip/header/ims/SecurityAgree;", // Calls OsConstants.initConstants. 2003 "Lgov/nist/javax/sip/header/ims/SecurityClient;", // Calls OsConstants.initConstants. 2004 "Lgov/nist/javax/sip/header/ims/ServiceRoute;", // Calls OsConstants.initConstants. 2005 "Ljava/io/Console;", // Has FileDescriptor(s). 2006 "Ljava/io/File;", // Calls to Random.<init> -> System.currentTimeMillis -> OsConstants.initConstants. 2007 "Ljava/io/FileDescriptor;", // Requires libcore.io.OsConstants. 2008 "Ljava/io/ObjectInputStream;", // Requires java.lang.ClassLoader$SystemClassLoader. 2009 "Ljava/io/ObjectStreamClass;", // Calls to Class.forName -> java.io.FileDescriptor. 2010 "Ljava/io/ObjectStreamConstants;", // Instance of non-image class SerializablePermission. 2011 "Ljava/lang/ClassLoader$SystemClassLoader;", // Calls System.getProperty -> OsConstants.initConstants. 2012 "Ljava/lang/HexStringParser;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 2013 "Ljava/lang/ProcessManager;", // Calls Thread.currentThread. 2014 "Ljava/lang/Runtime;", // Calls System.getProperty -> OsConstants.initConstants. 2015 "Ljava/lang/System;", // Calls OsConstants.initConstants. 2016 "Ljava/math/BigDecimal;", // Calls native ... -> java.math.NativeBN.BN_new(). 2017 "Ljava/math/BigInteger;", // Calls native ... -> java.math.NativeBN.BN_new(). 2018 "Ljava/math/Primality;", // Calls native ... -> java.math.NativeBN.BN_new(). 2019 "Ljava/math/Multiplication;", // Calls native ... -> java.math.NativeBN.BN_new(). 2020 "Ljava/net/InetAddress;", // Requires libcore.io.OsConstants. 2021 "Ljava/net/Inet4Address;", // Sub-class of InetAddress. 2022 "Ljava/net/Inet6Address;", // Sub-class of InetAddress. 2023 "Ljava/net/InetUnixAddress;", // Sub-class of InetAddress. 2024 "Ljava/net/NetworkInterface;", // Calls to Random.<init> -> System.currentTimeMillis -> OsConstants.initConstants. 2025 "Ljava/nio/charset/Charset;", // Calls Charset.getDefaultCharset -> System.getProperty -> OsConstants.initConstants. 2026 "Ljava/nio/charset/CharsetICU;", // Sub-class of Charset. 2027 "Ljava/nio/charset/Charsets;", // Calls Charset.forName. 2028 "Ljava/nio/charset/StandardCharsets;", // Calls OsConstants.initConstants. 2029 "Ljava/security/AlgorithmParameterGenerator;", // Calls OsConstants.initConstants. 2030 "Ljava/security/KeyPairGenerator$KeyPairGeneratorImpl;", // Calls OsConstants.initConstants. 2031 "Ljava/security/KeyPairGenerator;", // Calls OsConstants.initConstants. 2032 "Ljava/security/Security;", // Tries to do disk IO for "security.properties". 2033 "Ljava/security/spec/RSAKeyGenParameterSpec;", // java.math.NativeBN.BN_new() 2034 "Ljava/sql/Date;", // Calls OsConstants.initConstants. 2035 "Ljava/sql/DriverManager;", // Calls OsConstants.initConstants. 2036 "Ljava/sql/Time;", // Calls OsConstants.initConstants. 2037 "Ljava/sql/Timestamp;", // Calls OsConstants.initConstants. 2038 "Ljava/util/Date;", // Calls Date.<init> -> System.currentTimeMillis -> OsConstants.initConstants. 2039 "Ljava/util/ListResourceBundle;", // Calls OsConstants.initConstants. 2040 "Ljava/util/Locale;", // Calls System.getProperty -> OsConstants.initConstants. 2041 "Ljava/util/PropertyResourceBundle;", // Calls OsConstants.initConstants. 2042 "Ljava/util/ResourceBundle;", // Calls OsConstants.initConstants. 2043 "Ljava/util/ResourceBundle$MissingBundle;", // Calls OsConstants.initConstants. 2044 "Ljava/util/Scanner;", // regex.Pattern.compileImpl. 2045 "Ljava/util/SimpleTimeZone;", // Sub-class of TimeZone. 2046 "Ljava/util/TimeZone;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 2047 "Ljava/util/concurrent/ConcurrentHashMap;", // Calls Runtime.getRuntime().availableProcessors(). 2048 "Ljava/util/concurrent/ConcurrentHashMap$Segment;", // Calls Runtime.getRuntime().availableProcessors(). 2049 "Ljava/util/concurrent/ConcurrentSkipListMap;", // Calls Random() -> OsConstants.initConstants. 2050 "Ljava/util/concurrent/Exchanger;", // Calls Runtime.getRuntime().availableProcessors(). 2051 "Ljava/util/concurrent/ForkJoinPool;", // Makes a thread pool ..-> calls OsConstants.initConstants. 2052 "Ljava/util/concurrent/LinkedTransferQueue;", // Calls Runtime.getRuntime().availableProcessors(). 2053 "Ljava/util/concurrent/Phaser;", // Calls Runtime.getRuntime().availableProcessors(). 2054 "Ljava/util/concurrent/ScheduledThreadPoolExecutor;", // Calls AtomicLong.VMSupportsCS8() 2055 "Ljava/util/concurrent/SynchronousQueue;", // Calls Runtime.getRuntime().availableProcessors(). 2056 "Ljava/util/concurrent/atomic/AtomicLong;", // Calls AtomicLong.VMSupportsCS8() 2057 "Ljava/util/logging/LogManager;", // Calls System.getProperty -> OsConstants.initConstants. 2058 "Ljava/util/prefs/AbstractPreferences;", // Calls OsConstants.initConstants. 2059 "Ljava/util/prefs/FilePreferencesImpl;", // Calls OsConstants.initConstants. 2060 "Ljava/util/prefs/FilePreferencesFactoryImpl;", // Calls OsConstants.initConstants. 2061 "Ljava/util/prefs/Preferences;", // Calls OsConstants.initConstants. 2062 "Ljavax/crypto/KeyAgreement;", // Calls OsConstants.initConstants. 2063 "Ljavax/crypto/KeyGenerator;", // Calls OsConstants.initConstants. 2064 "Ljavax/security/cert/X509Certificate;", // Calls VMClassLoader.getBootClassPathSize. 2065 "Ljavax/security/cert/X509Certificate$1;", // Calls VMClassLoader.getBootClassPathSize. 2066 "Ljavax/microedition/khronos/egl/EGL10;", // Requires EGLContext. 2067 "Ljavax/microedition/khronos/egl/EGLContext;", // Requires com.google.android.gles_jni.EGLImpl. 2068 "Ljavax/xml/datatype/DatatypeConstants;", // Calls OsConstants.initConstants. 2069 "Ljavax/xml/datatype/FactoryFinder;", // Calls OsConstants.initConstants. 2070 "Ljavax/xml/namespace/QName;", // Calls OsConstants.initConstants. 2071 "Ljavax/xml/validation/SchemaFactoryFinder;", // Calls OsConstants.initConstants. 2072 "Ljavax/xml/xpath/XPathConstants;", // Calls OsConstants.initConstants. 2073 "Ljavax/xml/xpath/XPathFactoryFinder;", // Calls OsConstants.initConstants. 2074 "Llibcore/icu/LocaleData;", // Requires java.util.Locale. 2075 "Llibcore/icu/TimeZoneNames;", // Requires java.util.TimeZone. 2076 "Llibcore/io/IoUtils;", // Calls Random.<init> -> System.currentTimeMillis -> FileDescriptor -> OsConstants.initConstants. 2077 "Llibcore/io/OsConstants;", // Platform specific. 2078 "Llibcore/net/MimeUtils;", // Calls libcore.net.MimeUtils.getContentTypesPropertiesStream -> System.getProperty. 2079 "Llibcore/reflect/Types;", // Calls OsConstants.initConstants. 2080 "Llibcore/util/ZoneInfo;", // Sub-class of TimeZone. 2081 "Llibcore/util/ZoneInfoDB;", // Calls System.getenv -> OsConstants.initConstants. 2082 "Lorg/apache/commons/logging/LogFactory;", // Calls System.getProperty. 2083 "Lorg/apache/commons/logging/impl/LogFactoryImpl;", // Calls OsConstants.initConstants. 2084 "Lorg/apache/harmony/security/fortress/Services;", // Calls ClassLoader.getSystemClassLoader -> System.getProperty. 2085 "Lorg/apache/harmony/security/provider/cert/X509CertFactoryImpl;", // Requires java.nio.charsets.Charsets. 2086 "Lorg/apache/harmony/security/provider/crypto/RandomBitsSupplier;", // Requires java.io.File. 2087 "Lorg/apache/harmony/security/utils/AlgNameMapper;", // Requires java.util.Locale. 2088 "Lorg/apache/harmony/security/pkcs10/CertificationRequest;", // Calls Thread.currentThread. 2089 "Lorg/apache/harmony/security/pkcs10/CertificationRequestInfo;", // Calls Thread.currentThread. 2090 "Lorg/apache/harmony/security/pkcs7/AuthenticatedAttributes;", // Calls Thread.currentThread. 2091 "Lorg/apache/harmony/security/pkcs7/SignedData;", // Calls Thread.currentThread. 2092 "Lorg/apache/harmony/security/pkcs7/SignerInfo;", // Calls Thread.currentThread. 2093 "Lorg/apache/harmony/security/pkcs8/PrivateKeyInfo;", // Calls Thread.currentThread. 2094 "Lorg/apache/harmony/security/provider/crypto/SHA1PRNG_SecureRandomImpl;", // Calls OsConstants.initConstants. 2095 "Lorg/apache/harmony/security/x501/AttributeTypeAndValue;", // Calls IntegralToString.convertInt -> Thread.currentThread. 2096 "Lorg/apache/harmony/security/x501/DirectoryString;", // Requires BigInteger. 2097 "Lorg/apache/harmony/security/x501/Name;", // Requires org.apache.harmony.security.x501.AttributeTypeAndValue. 2098 "Lorg/apache/harmony/security/x509/AccessDescription;", // Calls Thread.currentThread. 2099 "Lorg/apache/harmony/security/x509/AuthorityKeyIdentifier;", // Calls Thread.currentThread. 2100 "Lorg/apache/harmony/security/x509/CRLDistributionPoints;", // Calls Thread.currentThread. 2101 "Lorg/apache/harmony/security/x509/Certificate;", // Requires org.apache.harmony.security.x509.TBSCertificate. 2102 "Lorg/apache/harmony/security/x509/CertificateIssuer;", // Calls Thread.currentThread. 2103 "Lorg/apache/harmony/security/x509/CertificateList;", // Calls Thread.currentThread. 2104 "Lorg/apache/harmony/security/x509/DistributionPoint;", // Calls Thread.currentThread. 2105 "Lorg/apache/harmony/security/x509/DistributionPointName;", // Calls Thread.currentThread. 2106 "Lorg/apache/harmony/security/x509/EDIPartyName;", // Calls native ... -> java.math.NativeBN.BN_new(). 2107 "Lorg/apache/harmony/security/x509/GeneralName;", // Requires org.apache.harmony.security.x501.Name. 2108 "Lorg/apache/harmony/security/x509/GeneralNames;", // Requires GeneralName. 2109 "Lorg/apache/harmony/security/x509/GeneralSubtree;", // Calls Thread.currentThread. 2110 "Lorg/apache/harmony/security/x509/GeneralSubtrees;", // Calls Thread.currentThread. 2111 "Lorg/apache/harmony/security/x509/InfoAccessSyntax;", // Calls Thread.currentThread. 2112 "Lorg/apache/harmony/security/x509/IssuingDistributionPoint;", // Calls Thread.currentThread. 2113 "Lorg/apache/harmony/security/x509/NameConstraints;", // Calls Thread.currentThread. 2114 "Lorg/apache/harmony/security/x509/TBSCertList$RevokedCertificate;", // Calls NativeBN.BN_new(). 2115 "Lorg/apache/harmony/security/x509/TBSCertList;", // Calls Thread.currentThread. 2116 "Lorg/apache/harmony/security/x509/TBSCertificate;", // Requires org.apache.harmony.security.x501.Name. 2117 "Lorg/apache/harmony/security/x509/Time;", // Calls native ... -> java.math.NativeBN.BN_new(). 2118 "Lorg/apache/harmony/security/x509/Validity;", // Requires x509.Time. 2119 "Lorg/apache/harmony/security/x509/tsp/TSTInfo;", // Calls Thread.currentThread. 2120 "Lorg/apache/harmony/xml/ExpatParser;", // Calls native ExpatParser.staticInitialize. 2121 "Lorg/apache/harmony/xml/ExpatParser$EntityParser;", // Calls ExpatParser.staticInitialize. 2122 "Lorg/apache/http/conn/params/ConnRouteParams;", // Requires java.util.Locale. 2123 "Lorg/apache/http/conn/ssl/SSLSocketFactory;", // Calls java.security.Security.getProperty. 2124 "Lorg/apache/http/conn/util/InetAddressUtils;", // Calls regex.Pattern.compile -..-> regex.Pattern.compileImpl. 2125}; 2126 2127static void InitializeClass(const ParallelCompilationManager* manager, size_t class_def_index) 2128 LOCKS_EXCLUDED(Locks::mutator_lock_) { 2129 ATRACE_CALL(); 2130 jobject jclass_loader = manager->GetClassLoader(); 2131 const DexFile& dex_file = *manager->GetDexFile(); 2132 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2133 const DexFile::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_); 2134 const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_); 2135 2136 ScopedObjectAccess soa(Thread::Current()); 2137 SirtRef<mirror::ClassLoader> class_loader(soa.Self(), 2138 soa.Decode<mirror::ClassLoader*>(jclass_loader)); 2139 SirtRef<mirror::Class> klass(soa.Self(), 2140 manager->GetClassLinker()->FindClass(descriptor, class_loader)); 2141 2142 if (klass.get() != nullptr && !SkipClass(jclass_loader, dex_file, klass.get())) { 2143 // Only try to initialize classes that were successfully verified. 2144 if (klass->IsVerified()) { 2145 // Attempt to initialize the class but bail if we either need to initialize the super-class 2146 // or static fields. 2147 manager->GetClassLinker()->EnsureInitialized(klass, false, false); 2148 if (!klass->IsInitialized()) { 2149 // We don't want non-trivial class initialization occurring on multiple threads due to 2150 // deadlock problems. For example, a parent class is initialized (holding its lock) that 2151 // refers to a sub-class in its static/class initializer causing it to try to acquire the 2152 // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock) 2153 // after first initializing its parents, whose locks are acquired. This leads to a 2154 // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock. 2155 // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather 2156 // than use a special Object for the purpose we use the Class of java.lang.Class. 2157 SirtRef<mirror::Class> sirt_klass(soa.Self(), klass->GetClass()); 2158 ObjectLock<mirror::Class> lock(soa.Self(), &sirt_klass); 2159 // Attempt to initialize allowing initialization of parent classes but still not static 2160 // fields. 2161 manager->GetClassLinker()->EnsureInitialized(klass, false, true); 2162 if (!klass->IsInitialized()) { 2163 // We need to initialize static fields, we only do this for image classes that aren't 2164 // black listed or marked with the $NoPreloadHolder. 2165 bool can_init_static_fields = manager->GetCompiler()->IsImage() && 2166 manager->GetCompiler()->IsImageClass(descriptor); 2167 if (can_init_static_fields) { 2168 // NoPreloadHolder inner class implies this should not be initialized early. 2169 bool is_black_listed = StringPiece(descriptor).ends_with("$NoPreloadHolder;"); 2170 if (!is_black_listed) { 2171 for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) { 2172 if (strcmp(descriptor, class_initializer_black_list[i]) == 0) { 2173 is_black_listed = true; 2174 break; 2175 } 2176 } 2177 } 2178 if (!is_black_listed) { 2179 VLOG(compiler) << "Initializing: " << descriptor; 2180 if (strcmp("Ljava/lang/Void;", descriptor) == 0) { 2181 // Hand initialize j.l.Void to avoid Dex file operations in un-started runtime. 2182 ObjectLock<mirror::Class> lock(soa.Self(), &klass); 2183 mirror::ObjectArray<mirror::ArtField>* fields = klass->GetSFields(); 2184 CHECK_EQ(fields->GetLength(), 1); 2185 fields->Get(0)->SetObj(klass.get(), 2186 manager->GetClassLinker()->FindPrimitiveClass('V')); 2187 klass->SetStatus(mirror::Class::kStatusInitialized, soa.Self()); 2188 } else { 2189 manager->GetClassLinker()->EnsureInitialized(klass, true, true); 2190 } 2191 } 2192 } 2193 } 2194 soa.Self()->AssertNoPendingException(); 2195 } 2196 } 2197 // Record the final class status if necessary. 2198 ClassReference ref(manager->GetDexFile(), class_def_index); 2199 manager->GetCompiler()->RecordClassStatus(ref, klass->GetStatus()); 2200 } 2201 // Clear any class not found or verification exceptions. 2202 soa.Self()->ClearException(); 2203} 2204 2205void CompilerDriver::InitializeClasses(jobject jni_class_loader, const DexFile& dex_file, 2206 ThreadPool& thread_pool, TimingLogger& timings) { 2207 timings.NewSplit("InitializeNoClinit"); 2208#ifndef NDEBUG 2209 // Sanity check blacklist descriptors. 2210 if (IsImage()) { 2211 for (size_t i = 0; i < arraysize(class_initializer_black_list); ++i) { 2212 const char* descriptor = class_initializer_black_list[i]; 2213 CHECK(IsValidDescriptor(descriptor)) << descriptor; 2214 } 2215 } 2216#endif 2217 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 2218 ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, thread_pool); 2219 context.ForAll(0, dex_file.NumClassDefs(), InitializeClass, thread_count_); 2220} 2221 2222void CompilerDriver::InitializeClasses(jobject class_loader, 2223 const std::vector<const DexFile*>& dex_files, 2224 ThreadPool& thread_pool, TimingLogger& timings) { 2225 for (size_t i = 0; i != dex_files.size(); ++i) { 2226 const DexFile* dex_file = dex_files[i]; 2227 CHECK(dex_file != NULL); 2228 InitializeClasses(class_loader, *dex_file, thread_pool, timings); 2229 } 2230} 2231 2232void CompilerDriver::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files, 2233 ThreadPool& thread_pool, TimingLogger& timings) { 2234 for (size_t i = 0; i != dex_files.size(); ++i) { 2235 const DexFile* dex_file = dex_files[i]; 2236 CHECK(dex_file != NULL); 2237 CompileDexFile(class_loader, *dex_file, thread_pool, timings); 2238 } 2239} 2240 2241void CompilerDriver::CompileClass(const ParallelCompilationManager* manager, size_t class_def_index) { 2242 ATRACE_CALL(); 2243 jobject jclass_loader = manager->GetClassLoader(); 2244 const DexFile& dex_file = *manager->GetDexFile(); 2245 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index); 2246 ClassLinker* class_linker = manager->GetClassLinker(); 2247 if (SkipClass(class_linker, jclass_loader, dex_file, class_def)) { 2248 return; 2249 } 2250 ClassReference ref(&dex_file, class_def_index); 2251 // Skip compiling classes with generic verifier failures since they will still fail at runtime 2252 if (manager->GetCompiler()->verified_methods_data_->IsClassRejected(ref)) { 2253 return; 2254 } 2255 const byte* class_data = dex_file.GetClassData(class_def); 2256 if (class_data == NULL) { 2257 // empty class, probably a marker interface 2258 return; 2259 } 2260 2261 // Can we run DEX-to-DEX compiler on this class ? 2262 DexToDexCompilationLevel dex_to_dex_compilation_level = kDontDexToDexCompile; 2263 { 2264 ScopedObjectAccess soa(Thread::Current()); 2265 SirtRef<mirror::ClassLoader> class_loader(soa.Self(), 2266 soa.Decode<mirror::ClassLoader*>(jclass_loader)); 2267 dex_to_dex_compilation_level = GetDexToDexCompilationlevel(class_loader, dex_file, class_def); 2268 } 2269 ClassDataItemIterator it(dex_file, class_data); 2270 // Skip fields 2271 while (it.HasNextStaticField()) { 2272 it.Next(); 2273 } 2274 while (it.HasNextInstanceField()) { 2275 it.Next(); 2276 } 2277 CompilerDriver* driver = manager->GetCompiler(); 2278 // Compile direct methods 2279 int64_t previous_direct_method_idx = -1; 2280 while (it.HasNextDirectMethod()) { 2281 uint32_t method_idx = it.GetMemberIndex(); 2282 if (method_idx == previous_direct_method_idx) { 2283 // smali can create dex files with two encoded_methods sharing the same method_idx 2284 // http://code.google.com/p/smali/issues/detail?id=119 2285 it.Next(); 2286 continue; 2287 } 2288 previous_direct_method_idx = method_idx; 2289 driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(), 2290 it.GetMethodInvokeType(class_def), class_def_index, 2291 method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level); 2292 it.Next(); 2293 } 2294 // Compile virtual methods 2295 int64_t previous_virtual_method_idx = -1; 2296 while (it.HasNextVirtualMethod()) { 2297 uint32_t method_idx = it.GetMemberIndex(); 2298 if (method_idx == previous_virtual_method_idx) { 2299 // smali can create dex files with two encoded_methods sharing the same method_idx 2300 // http://code.google.com/p/smali/issues/detail?id=119 2301 it.Next(); 2302 continue; 2303 } 2304 previous_virtual_method_idx = method_idx; 2305 driver->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(), 2306 it.GetMethodInvokeType(class_def), class_def_index, 2307 method_idx, jclass_loader, dex_file, dex_to_dex_compilation_level); 2308 it.Next(); 2309 } 2310 DCHECK(!it.HasNext()); 2311} 2312 2313void CompilerDriver::CompileDexFile(jobject class_loader, const DexFile& dex_file, 2314 ThreadPool& thread_pool, TimingLogger& timings) { 2315 timings.NewSplit("Compile Dex File"); 2316 ParallelCompilationManager context(Runtime::Current()->GetClassLinker(), class_loader, this, 2317 &dex_file, thread_pool); 2318 context.ForAll(0, dex_file.NumClassDefs(), CompilerDriver::CompileClass, thread_count_); 2319} 2320 2321void CompilerDriver::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, 2322 InvokeType invoke_type, uint16_t class_def_idx, 2323 uint32_t method_idx, jobject class_loader, 2324 const DexFile& dex_file, 2325 DexToDexCompilationLevel dex_to_dex_compilation_level) { 2326 CompiledMethod* compiled_method = NULL; 2327 uint64_t start_ns = NanoTime(); 2328 2329 if ((access_flags & kAccNative) != 0) { 2330 compiled_method = (*jni_compiler_)(*this, access_flags, method_idx, dex_file); 2331 CHECK(compiled_method != NULL); 2332 } else if ((access_flags & kAccAbstract) != 0) { 2333 } else { 2334 MethodReference method_ref(&dex_file, method_idx); 2335 bool compile = VerifiedMethodsData::IsCandidateForCompilation(method_ref, access_flags); 2336 2337 if (compile) { 2338 CompilerFn compiler = compiler_; 2339#ifdef ART_SEA_IR_MODE 2340 bool use_sea = Runtime::Current()->IsSeaIRMode(); 2341 use_sea = use_sea && 2342 (std::string::npos != PrettyMethod(method_idx, dex_file).find("fibonacci")); 2343 if (use_sea) { 2344 compiler = sea_ir_compiler_; 2345 LOG(INFO) << "Using SEA IR to compile..." << std::endl; 2346 } 2347#endif 2348 // NOTE: if compiler declines to compile this method, it will return NULL. 2349 compiled_method = (*compiler)(*this, code_item, access_flags, invoke_type, class_def_idx, 2350 method_idx, class_loader, dex_file); 2351 } else if (dex_to_dex_compilation_level != kDontDexToDexCompile) { 2352 // TODO: add a mode to disable DEX-to-DEX compilation ? 2353 (*dex_to_dex_compiler_)(*this, code_item, access_flags, 2354 invoke_type, class_def_idx, 2355 method_idx, class_loader, dex_file, 2356 dex_to_dex_compilation_level); 2357 } 2358 } 2359 uint64_t duration_ns = NanoTime() - start_ns; 2360#ifdef ART_USE_PORTABLE_COMPILER 2361 const uint64_t kWarnMilliSeconds = 1000; 2362#else 2363 const uint64_t kWarnMilliSeconds = 100; 2364#endif 2365 if (duration_ns > MsToNs(kWarnMilliSeconds)) { 2366 LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file) 2367 << " took " << PrettyDuration(duration_ns); 2368 } 2369 2370 Thread* self = Thread::Current(); 2371 if (compiled_method != NULL) { 2372 MethodReference ref(&dex_file, method_idx); 2373 DCHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file); 2374 { 2375 MutexLock mu(self, compiled_methods_lock_); 2376 compiled_methods_.Put(ref, compiled_method); 2377 } 2378 DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file); 2379 } 2380 2381 if (self->IsExceptionPending()) { 2382 ScopedObjectAccess soa(self); 2383 LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n" 2384 << self->GetException(NULL)->Dump(); 2385 } 2386} 2387 2388CompiledClass* CompilerDriver::GetCompiledClass(ClassReference ref) const { 2389 MutexLock mu(Thread::Current(), compiled_classes_lock_); 2390 ClassTable::const_iterator it = compiled_classes_.find(ref); 2391 if (it == compiled_classes_.end()) { 2392 return NULL; 2393 } 2394 CHECK(it->second != NULL); 2395 return it->second; 2396} 2397 2398void CompilerDriver::RecordClassStatus(ClassReference ref, mirror::Class::Status status) { 2399 MutexLock mu(Thread::Current(), compiled_classes_lock_); 2400 auto it = compiled_classes_.find(ref); 2401 if (it == compiled_classes_.end() || it->second->GetStatus() != status) { 2402 // An entry doesn't exist or the status is lower than the new status. 2403 if (it != compiled_classes_.end()) { 2404 CHECK_GT(status, it->second->GetStatus()); 2405 delete it->second; 2406 } 2407 switch (status) { 2408 case mirror::Class::kStatusNotReady: 2409 case mirror::Class::kStatusError: 2410 case mirror::Class::kStatusRetryVerificationAtRuntime: 2411 case mirror::Class::kStatusVerified: 2412 case mirror::Class::kStatusInitialized: 2413 break; // Expected states. 2414 default: 2415 LOG(FATAL) << "Unexpected class status for class " 2416 << PrettyDescriptor(ref.first->GetClassDescriptor(ref.first->GetClassDef(ref.second))) 2417 << " of " << status; 2418 } 2419 CompiledClass* compiled_class = new CompiledClass(status); 2420 compiled_classes_.Overwrite(ref, compiled_class); 2421 } 2422} 2423 2424CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const { 2425 MutexLock mu(Thread::Current(), compiled_methods_lock_); 2426 MethodTable::const_iterator it = compiled_methods_.find(ref); 2427 if (it == compiled_methods_.end()) { 2428 return NULL; 2429 } 2430 CHECK(it->second != NULL); 2431 return it->second; 2432} 2433 2434void CompilerDriver::SetBitcodeFileName(std::string const& filename) { 2435 typedef void (*SetBitcodeFileNameFn)(CompilerDriver&, std::string const&); 2436 2437 SetBitcodeFileNameFn set_bitcode_file_name = 2438 reinterpret_cast<SetBitcodeFileNameFn>(compilerLLVMSetBitcodeFileName); 2439 2440 set_bitcode_file_name(*this, filename); 2441} 2442 2443 2444void CompilerDriver::AddRequiresConstructorBarrier(Thread* self, const DexFile* dex_file, 2445 uint16_t class_def_index) { 2446 WriterMutexLock mu(self, freezing_constructor_lock_); 2447 freezing_constructor_classes_.insert(ClassReference(dex_file, class_def_index)); 2448} 2449 2450bool CompilerDriver::RequiresConstructorBarrier(Thread* self, const DexFile* dex_file, 2451 uint16_t class_def_index) { 2452 ReaderMutexLock mu(self, freezing_constructor_lock_); 2453 return freezing_constructor_classes_.count(ClassReference(dex_file, class_def_index)) != 0; 2454} 2455 2456bool CompilerDriver::WriteElf(const std::string& android_root, 2457 bool is_host, 2458 const std::vector<const art::DexFile*>& dex_files, 2459 OatWriter& oat_writer, 2460 art::File* file) 2461 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 2462#if defined(ART_USE_PORTABLE_COMPILER) 2463 return art::ElfWriterMclinker::Create(file, oat_writer, dex_files, android_root, is_host, *this); 2464#else 2465 return art::ElfWriterQuick::Create(file, oat_writer, dex_files, android_root, is_host, *this); 2466#endif 2467} 2468void CompilerDriver::InstructionSetToLLVMTarget(InstructionSet instruction_set, 2469 std::string& target_triple, 2470 std::string& target_cpu, 2471 std::string& target_attr) { 2472 switch (instruction_set) { 2473 case kThumb2: 2474 target_triple = "thumb-none-linux-gnueabi"; 2475 target_cpu = "cortex-a9"; 2476 target_attr = "+thumb2,+neon,+neonfp,+vfp3,+db"; 2477 break; 2478 2479 case kArm: 2480 target_triple = "armv7-none-linux-gnueabi"; 2481 // TODO: Fix for Nexus S. 2482 target_cpu = "cortex-a9"; 2483 // TODO: Fix for Xoom. 2484 target_attr = "+v7,+neon,+neonfp,+vfp3,+db"; 2485 break; 2486 2487 case kX86: 2488 target_triple = "i386-pc-linux-gnu"; 2489 target_attr = ""; 2490 break; 2491 2492 case kMips: 2493 target_triple = "mipsel-unknown-linux"; 2494 target_attr = "mips32r2"; 2495 break; 2496 2497 default: 2498 LOG(FATAL) << "Unknown instruction set: " << instruction_set; 2499 } 2500 } 2501} // namespace art 2502