summaryrefslogtreecommitdiff
path: root/compiler/driver/compiler_driver.cc
diff options
context:
space:
mode:
author Vladimir Marko <vmarko@google.com> 2019-03-04 12:53:20 +0000
committer Vladimir Marko <vmarko@google.com> 2019-03-11 06:59:41 +0000
commit327497e303903f300b01f77f2259fd5b61238ee3 (patch)
tree3f714d2d2ee7d9b6c0ecf71a10c157d4952e5758 /compiler/driver/compiler_driver.cc
parentef764ad3e6d7f07ea9e32642dc3e163bb4eb44fb (diff)
Move CompilerDriver to dex2oat/.
Also DexToDexCompiler, QuickCompilerCallbacks and tests. aosp_taimen-userdebug: - before: lib64/libart-compiler.so: 3112344 lib/libart-compiler.so: 2312908 bin/dex2oat: 563176 - after: lib64/libart-compiler.so: 2986720 (-123KiB) lib/libart-compiler.so: 2219852 (-91KiB) bin/dex2oat: 635832 (+71KiB) Test: m test-art-host-gtest Test: testrunner.py --host --optimizing --jit Change-Id: I36e63b83dff1d5c731d05de27d3663cfc81de6ad
Diffstat (limited to 'compiler/driver/compiler_driver.cc')
-rw-r--r--compiler/driver/compiler_driver.cc2789
1 files changed, 0 insertions, 2789 deletions
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
deleted file mode 100644
index 3be5627c13..0000000000
--- a/compiler/driver/compiler_driver.cc
+++ /dev/null
@@ -1,2789 +0,0 @@
-/*
- * Copyright (C) 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "compiler_driver.h"
-
-#include <unistd.h>
-
-#ifndef __APPLE__
-#include <malloc.h> // For mallinfo
-#endif
-
-#include <string_view>
-#include <unordered_set>
-#include <vector>
-
-#include "android-base/logging.h"
-#include "android-base/strings.h"
-
-#include "art_field-inl.h"
-#include "art_method-inl.h"
-#include "base/arena_allocator.h"
-#include "base/array_ref.h"
-#include "base/bit_vector.h"
-#include "base/enums.h"
-#include "base/logging.h" // For VLOG
-#include "base/stl_util.h"
-#include "base/string_view_cpp20.h"
-#include "base/systrace.h"
-#include "base/time_utils.h"
-#include "base/timing_logger.h"
-#include "class_linker-inl.h"
-#include "compiled_method-inl.h"
-#include "compiler.h"
-#include "compiler_callbacks.h"
-#include "compiler_driver-inl.h"
-#include "dex/class_accessor-inl.h"
-#include "dex/descriptors_names.h"
-#include "dex/dex_file-inl.h"
-#include "dex/dex_file_annotations.h"
-#include "dex/dex_instruction-inl.h"
-#include "dex/dex_to_dex_compiler.h"
-#include "dex/verification_results.h"
-#include "dex/verified_method.h"
-#include "dex_compilation_unit.h"
-#include "driver/compiler_options.h"
-#include "gc/accounting/card_table-inl.h"
-#include "gc/accounting/heap_bitmap.h"
-#include "gc/space/image_space.h"
-#include "gc/space/space.h"
-#include "handle_scope-inl.h"
-#include "intrinsics_enum.h"
-#include "jni/jni_internal.h"
-#include "linker/linker_patch.h"
-#include "mirror/class-inl.h"
-#include "mirror/class_loader.h"
-#include "mirror/dex_cache-inl.h"
-#include "mirror/object-inl.h"
-#include "mirror/object-refvisitor-inl.h"
-#include "mirror/object_array-inl.h"
-#include "mirror/throwable.h"
-#include "object_lock.h"
-#include "profile/profile_compilation_info.h"
-#include "runtime.h"
-#include "runtime_intrinsics.h"
-#include "scoped_thread_state_change-inl.h"
-#include "thread.h"
-#include "thread_list.h"
-#include "thread_pool.h"
-#include "trampolines/trampoline_compiler.h"
-#include "transaction.h"
-#include "utils/atomic_dex_ref_map-inl.h"
-#include "utils/dex_cache_arrays_layout-inl.h"
-#include "utils/swap_space.h"
-#include "vdex_file.h"
-#include "verifier/method_verifier-inl.h"
-#include "verifier/method_verifier.h"
-#include "verifier/verifier_deps.h"
-#include "verifier/verifier_enums.h"
-
-namespace art {
-
-static constexpr bool kTimeCompileMethod = !kIsDebugBuild;
-
-// Print additional info during profile guided compilation.
-static constexpr bool kDebugProfileGuidedCompilation = false;
-
-// Max encoded fields allowed for initializing app image. Hardcode the number for now
-// because 5000 should be large enough.
-static constexpr uint32_t kMaxEncodedFields = 5000;
-
-static double Percentage(size_t x, size_t y) {
- return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y));
-}
-
-static void DumpStat(size_t x, size_t y, const char* str) {
- if (x == 0 && y == 0) {
- return;
- }
- LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
-}
-
-class CompilerDriver::AOTCompilationStats {
- public:
- AOTCompilationStats()
- : stats_lock_("AOT compilation statistics lock") {}
-
- void Dump() {
- DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved");
- DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_,
- "static fields resolved");
- DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_,
- "static fields local to a class");
- DumpStat(safe_casts_, not_safe_casts_, "check-casts removed based on type information");
- // Note, the code below subtracts the stat value so that when added to the stat value we have
- // 100% of samples. TODO: clean this up.
- DumpStat(type_based_devirtualization_,
- resolved_methods_[kVirtual] + unresolved_methods_[kVirtual] +
- resolved_methods_[kInterface] + unresolved_methods_[kInterface] -
- type_based_devirtualization_,
- "virtual/interface calls made direct based on type information");
-
- const size_t total = std::accumulate(
- class_status_count_,
- class_status_count_ + static_cast<size_t>(ClassStatus::kLast) + 1,
- 0u);
- for (size_t i = 0; i <= static_cast<size_t>(ClassStatus::kLast); ++i) {
- std::ostringstream oss;
- oss << "classes with status " << static_cast<ClassStatus>(i);
- DumpStat(class_status_count_[i], total - class_status_count_[i], oss.str().c_str());
- }
-
- for (size_t i = 0; i <= kMaxInvokeType; i++) {
- std::ostringstream oss;
- oss << static_cast<InvokeType>(i) << " methods were AOT resolved";
- DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str());
- if (virtual_made_direct_[i] > 0) {
- std::ostringstream oss2;
- oss2 << static_cast<InvokeType>(i) << " methods made direct";
- DumpStat(virtual_made_direct_[i],
- resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i],
- oss2.str().c_str());
- }
- if (direct_calls_to_boot_[i] > 0) {
- std::ostringstream oss2;
- oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot";
- DumpStat(direct_calls_to_boot_[i],
- resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i],
- oss2.str().c_str());
- }
- if (direct_methods_to_boot_[i] > 0) {
- std::ostringstream oss2;
- oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot";
- DumpStat(direct_methods_to_boot_[i],
- resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i],
- oss2.str().c_str());
- }
- }
- }
-
-// Allow lossy statistics in non-debug builds.
-#ifndef NDEBUG
-#define STATS_LOCK() MutexLock mu(Thread::Current(), stats_lock_)
-#else
-#define STATS_LOCK()
-#endif
-
- void ResolvedInstanceField() REQUIRES(!stats_lock_) {
- STATS_LOCK();
- resolved_instance_fields_++;
- }
-
- void UnresolvedInstanceField() REQUIRES(!stats_lock_) {
- STATS_LOCK();
- unresolved_instance_fields_++;
- }
-
- void ResolvedLocalStaticField() REQUIRES(!stats_lock_) {
- STATS_LOCK();
- resolved_local_static_fields_++;
- }
-
- void ResolvedStaticField() REQUIRES(!stats_lock_) {
- STATS_LOCK();
- resolved_static_fields_++;
- }
-
- void UnresolvedStaticField() REQUIRES(!stats_lock_) {
- STATS_LOCK();
- unresolved_static_fields_++;
- }
-
- // Indicate that type information from the verifier led to devirtualization.
- void PreciseTypeDevirtualization() REQUIRES(!stats_lock_) {
- STATS_LOCK();
- type_based_devirtualization_++;
- }
-
- // A check-cast could be eliminated due to verifier type analysis.
- void SafeCast() REQUIRES(!stats_lock_) {
- STATS_LOCK();
- safe_casts_++;
- }
-
- // A check-cast couldn't be eliminated due to verifier type analysis.
- void NotASafeCast() REQUIRES(!stats_lock_) {
- STATS_LOCK();
- not_safe_casts_++;
- }
-
- // Register a class status.
- void AddClassStatus(ClassStatus status) REQUIRES(!stats_lock_) {
- STATS_LOCK();
- ++class_status_count_[static_cast<size_t>(status)];
- }
-
- private:
- Mutex stats_lock_;
-
- size_t resolved_instance_fields_ = 0u;
- size_t unresolved_instance_fields_ = 0u;
-
- size_t resolved_local_static_fields_ = 0u;
- size_t resolved_static_fields_ = 0u;
- size_t unresolved_static_fields_ = 0u;
- // Type based devirtualization for invoke interface and virtual.
- size_t type_based_devirtualization_ = 0u;
-
- size_t resolved_methods_[kMaxInvokeType + 1] = {};
- size_t unresolved_methods_[kMaxInvokeType + 1] = {};
- size_t virtual_made_direct_[kMaxInvokeType + 1] = {};
- size_t direct_calls_to_boot_[kMaxInvokeType + 1] = {};
- size_t direct_methods_to_boot_[kMaxInvokeType + 1] = {};
-
- size_t safe_casts_ = 0u;
- size_t not_safe_casts_ = 0u;
-
- size_t class_status_count_[static_cast<size_t>(ClassStatus::kLast) + 1] = {};
-
- DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats);
-};
-
-CompilerDriver::CompilerDriver(
- const CompilerOptions* compiler_options,
- Compiler::Kind compiler_kind,
- size_t thread_count,
- int swap_fd)
- : compiler_options_(compiler_options),
- compiler_(),
- compiler_kind_(compiler_kind),
- number_of_soft_verifier_failures_(0),
- had_hard_verifier_failure_(false),
- parallel_thread_count_(thread_count),
- stats_(new AOTCompilationStats),
- compiled_method_storage_(swap_fd),
- max_arena_alloc_(0),
- dex_to_dex_compiler_(this) {
- DCHECK(compiler_options_ != nullptr);
-
- compiled_method_storage_.SetDedupeEnabled(compiler_options_->DeduplicateCode());
- compiler_.reset(Compiler::Create(*compiler_options, &compiled_method_storage_, compiler_kind));
-}
-
-CompilerDriver::~CompilerDriver() {
- compiled_methods_.Visit([this](const DexFileReference& ref ATTRIBUTE_UNUSED,
- CompiledMethod* method) {
- if (method != nullptr) {
- CompiledMethod::ReleaseSwapAllocatedCompiledMethod(GetCompiledMethodStorage(), method);
- }
- });
-}
-
-
-#define CREATE_TRAMPOLINE(type, abi, offset) \
- if (Is64BitInstructionSet(GetCompilerOptions().GetInstructionSet())) { \
- return CreateTrampoline64(GetCompilerOptions().GetInstructionSet(), \
- abi, \
- type ## _ENTRYPOINT_OFFSET(PointerSize::k64, offset)); \
- } else { \
- return CreateTrampoline32(GetCompilerOptions().GetInstructionSet(), \
- abi, \
- type ## _ENTRYPOINT_OFFSET(PointerSize::k32, offset)); \
- }
-
-std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateJniDlsymLookup() const {
- CREATE_TRAMPOLINE(JNI, kJniAbi, pDlsymLookup)
-}
-
-std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickGenericJniTrampoline()
- const {
- CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickGenericJniTrampoline)
-}
-
-std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickImtConflictTrampoline()
- const {
- CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickImtConflictTrampoline)
-}
-
-std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickResolutionTrampoline()
- const {
- CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickResolutionTrampoline)
-}
-
-std::unique_ptr<const std::vector<uint8_t>> CompilerDriver::CreateQuickToInterpreterBridge()
- const {
- CREATE_TRAMPOLINE(QUICK, kQuickAbi, pQuickToInterpreterBridge)
-}
-#undef CREATE_TRAMPOLINE
-
-void CompilerDriver::CompileAll(jobject class_loader,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings) {
- DCHECK(!Runtime::Current()->IsStarted());
-
- CheckThreadPools();
-
- if (GetCompilerOptions().IsBootImage()) {
- // We don't need to setup the intrinsics for non boot image compilation, as
- // those compilations will pick up a boot image that have the ArtMethod already
- // set with the intrinsics flag.
- InitializeIntrinsics();
- }
- // Compile:
- // 1) Compile all classes and methods enabled for compilation. May fall back to dex-to-dex
- // compilation.
- if (GetCompilerOptions().IsAnyCompilationEnabled()) {
- Compile(class_loader, dex_files, timings);
- }
- if (GetCompilerOptions().GetDumpStats()) {
- stats_->Dump();
- }
-}
-
-static optimizer::DexToDexCompiler::CompilationLevel GetDexToDexCompilationLevel(
- Thread* self, const CompilerDriver& driver, Handle<mirror::ClassLoader> class_loader,
- const DexFile& dex_file, const dex::ClassDef& class_def)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- // When the dex file is uncompressed in the APK, we do not generate a copy in the .vdex
- // file. As a result, dex2oat will map the dex file read-only, and we only need to check
- // that to know if we can do quickening.
- if (dex_file.GetContainer() != nullptr && dex_file.GetContainer()->IsReadOnly()) {
- return optimizer::DexToDexCompiler::CompilationLevel::kDontDexToDexCompile;
- }
- auto* const runtime = Runtime::Current();
- DCHECK(driver.GetCompilerOptions().IsQuickeningCompilationEnabled());
- const char* descriptor = dex_file.GetClassDescriptor(class_def);
- ClassLinker* class_linker = runtime->GetClassLinker();
- ObjPtr<mirror::Class> klass = class_linker->FindClass(self, descriptor, class_loader);
- if (klass == nullptr) {
- CHECK(self->IsExceptionPending());
- self->ClearException();
- return optimizer::DexToDexCompiler::CompilationLevel::kDontDexToDexCompile;
- }
- // DexToDex at the kOptimize level may introduce quickened opcodes, which replace symbolic
- // references with actual offsets. We cannot re-verify such instructions.
- //
- // We store the verification information in the class status in the oat file, which the linker
- // can validate (checksums) and use to skip load-time verification. It is thus safe to
- // optimize when a class has been fully verified before.
- optimizer::DexToDexCompiler::CompilationLevel max_level =
- optimizer::DexToDexCompiler::CompilationLevel::kOptimize;
- if (driver.GetCompilerOptions().GetDebuggable()) {
- // We are debuggable so definitions of classes might be changed. We don't want to do any
- // optimizations that could break that.
- max_level = optimizer::DexToDexCompiler::CompilationLevel::kDontDexToDexCompile;
- }
- if (klass->IsVerified()) {
- // Class is verified so we can enable DEX-to-DEX compilation for performance.
- return max_level;
- } else {
- // Class verification has failed: do not run DEX-to-DEX optimizations.
- return optimizer::DexToDexCompiler::CompilationLevel::kDontDexToDexCompile;
- }
-}
-
-static optimizer::DexToDexCompiler::CompilationLevel GetDexToDexCompilationLevel(
- Thread* self,
- const CompilerDriver& driver,
- jobject jclass_loader,
- const DexFile& dex_file,
- const dex::ClassDef& class_def) {
- ScopedObjectAccess soa(self);
- StackHandleScope<1> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
- return GetDexToDexCompilationLevel(self, driver, class_loader, dex_file, class_def);
-}
-
-// Does the runtime for the InstructionSet provide an implementation returned by
-// GetQuickGenericJniStub allowing down calls that aren't compiled using a JNI compiler?
-static bool InstructionSetHasGenericJniStub(InstructionSet isa) {
- switch (isa) {
- case InstructionSet::kArm:
- case InstructionSet::kArm64:
- case InstructionSet::kThumb2:
- case InstructionSet::kMips:
- case InstructionSet::kMips64:
- case InstructionSet::kX86:
- case InstructionSet::kX86_64: return true;
- default: return false;
- }
-}
-
-template <typename CompileFn>
-static void CompileMethodHarness(
- Thread* self,
- CompilerDriver* driver,
- const dex::CodeItem* code_item,
- uint32_t access_flags,
- InvokeType invoke_type,
- uint16_t class_def_idx,
- uint32_t method_idx,
- Handle<mirror::ClassLoader> class_loader,
- const DexFile& dex_file,
- optimizer::DexToDexCompiler::CompilationLevel dex_to_dex_compilation_level,
- Handle<mirror::DexCache> dex_cache,
- CompileFn compile_fn) {
- DCHECK(driver != nullptr);
- CompiledMethod* compiled_method;
- uint64_t start_ns = kTimeCompileMethod ? NanoTime() : 0;
- MethodReference method_ref(&dex_file, method_idx);
-
- compiled_method = compile_fn(self,
- driver,
- code_item,
- access_flags,
- invoke_type,
- class_def_idx,
- method_idx,
- class_loader,
- dex_file,
- dex_to_dex_compilation_level,
- dex_cache);
-
- if (kTimeCompileMethod) {
- uint64_t duration_ns = NanoTime() - start_ns;
- if (duration_ns > MsToNs(driver->GetCompiler()->GetMaximumCompilationTimeBeforeWarning())) {
- LOG(WARNING) << "Compilation of " << dex_file.PrettyMethod(method_idx)
- << " took " << PrettyDuration(duration_ns);
- }
- }
-
- if (compiled_method != nullptr) {
- driver->AddCompiledMethod(method_ref, compiled_method);
- }
-
- if (self->IsExceptionPending()) {
- ScopedObjectAccess soa(self);
- LOG(FATAL) << "Unexpected exception compiling: " << dex_file.PrettyMethod(method_idx) << "\n"
- << self->GetException()->Dump();
- }
-}
-
-static void CompileMethodDex2Dex(
- Thread* self,
- CompilerDriver* driver,
- const dex::CodeItem* code_item,
- uint32_t access_flags,
- InvokeType invoke_type,
- uint16_t class_def_idx,
- uint32_t method_idx,
- Handle<mirror::ClassLoader> class_loader,
- const DexFile& dex_file,
- optimizer::DexToDexCompiler::CompilationLevel dex_to_dex_compilation_level,
- Handle<mirror::DexCache> dex_cache) {
- auto dex_2_dex_fn = [](Thread* self ATTRIBUTE_UNUSED,
- CompilerDriver* driver,
- const dex::CodeItem* code_item,
- uint32_t access_flags,
- InvokeType invoke_type,
- uint16_t class_def_idx,
- uint32_t method_idx,
- Handle<mirror::ClassLoader> class_loader,
- const DexFile& dex_file,
- optimizer::DexToDexCompiler::CompilationLevel dex_to_dex_compilation_level,
- Handle<mirror::DexCache> dex_cache ATTRIBUTE_UNUSED) -> CompiledMethod* {
- DCHECK(driver != nullptr);
- MethodReference method_ref(&dex_file, method_idx);
-
- optimizer::DexToDexCompiler* const compiler = &driver->GetDexToDexCompiler();
-
- if (compiler->ShouldCompileMethod(method_ref)) {
- const VerificationResults* results = driver->GetCompilerOptions().GetVerificationResults();
- DCHECK(results != nullptr);
- const VerifiedMethod* verified_method = results->GetVerifiedMethod(method_ref);
- // Do not optimize if a VerifiedMethod is missing. SafeCast elision,
- // for example, relies on it.
- return compiler->CompileMethod(
- code_item,
- access_flags,
- invoke_type,
- class_def_idx,
- method_idx,
- class_loader,
- dex_file,
- (verified_method != nullptr)
- ? dex_to_dex_compilation_level
- : optimizer::DexToDexCompiler::CompilationLevel::kDontDexToDexCompile);
- }
- return nullptr;
- };
- CompileMethodHarness(self,
- driver,
- code_item,
- access_flags,
- invoke_type,
- class_def_idx,
- method_idx,
- class_loader,
- dex_file,
- dex_to_dex_compilation_level,
- dex_cache,
- dex_2_dex_fn);
-}
-
-static void CompileMethodQuick(
- Thread* self,
- CompilerDriver* driver,
- const dex::CodeItem* code_item,
- uint32_t access_flags,
- InvokeType invoke_type,
- uint16_t class_def_idx,
- uint32_t method_idx,
- Handle<mirror::ClassLoader> class_loader,
- const DexFile& dex_file,
- optimizer::DexToDexCompiler::CompilationLevel dex_to_dex_compilation_level,
- Handle<mirror::DexCache> dex_cache) {
- auto quick_fn = [](
- Thread* self,
- CompilerDriver* driver,
- const dex::CodeItem* code_item,
- uint32_t access_flags,
- InvokeType invoke_type,
- uint16_t class_def_idx,
- uint32_t method_idx,
- Handle<mirror::ClassLoader> class_loader,
- const DexFile& dex_file,
- optimizer::DexToDexCompiler::CompilationLevel dex_to_dex_compilation_level,
- Handle<mirror::DexCache> dex_cache) {
- DCHECK(driver != nullptr);
- CompiledMethod* compiled_method = nullptr;
- MethodReference method_ref(&dex_file, method_idx);
-
- if ((access_flags & kAccNative) != 0) {
- // Are we extracting only and have support for generic JNI down calls?
- if (!driver->GetCompilerOptions().IsJniCompilationEnabled() &&
- InstructionSetHasGenericJniStub(driver->GetCompilerOptions().GetInstructionSet())) {
- // Leaving this empty will trigger the generic JNI version
- } else {
- // Query any JNI optimization annotations such as @FastNative or @CriticalNative.
- access_flags |= annotations::GetNativeMethodAnnotationAccessFlags(
- dex_file, dex_file.GetClassDef(class_def_idx), method_idx);
-
- compiled_method = driver->GetCompiler()->JniCompile(
- access_flags, method_idx, dex_file, dex_cache);
- CHECK(compiled_method != nullptr);
- }
- } else if ((access_flags & kAccAbstract) != 0) {
- // Abstract methods don't have code.
- } else {
- const VerificationResults* results = driver->GetCompilerOptions().GetVerificationResults();
- DCHECK(results != nullptr);
- const VerifiedMethod* verified_method = results->GetVerifiedMethod(method_ref);
- bool compile =
- // Basic checks, e.g., not <clinit>.
- results->IsCandidateForCompilation(method_ref, access_flags) &&
- // Did not fail to create VerifiedMethod metadata.
- verified_method != nullptr &&
- // Do not have failures that should punt to the interpreter.
- !verified_method->HasRuntimeThrow() &&
- (verified_method->GetEncounteredVerificationFailures() &
- (verifier::VERIFY_ERROR_FORCE_INTERPRETER | verifier::VERIFY_ERROR_LOCKING)) == 0 &&
- // Is eligable for compilation by methods-to-compile filter.
- driver->ShouldCompileBasedOnProfile(method_ref);
-
- if (compile) {
- // NOTE: if compiler declines to compile this method, it will return null.
- compiled_method = driver->GetCompiler()->Compile(code_item,
- access_flags,
- invoke_type,
- class_def_idx,
- method_idx,
- class_loader,
- dex_file,
- dex_cache);
- ProfileMethodsCheck check_type =
- driver->GetCompilerOptions().CheckProfiledMethodsCompiled();
- if (UNLIKELY(check_type != ProfileMethodsCheck::kNone)) {
- bool violation = driver->ShouldCompileBasedOnProfile(method_ref) &&
- (compiled_method == nullptr);
- if (violation) {
- std::ostringstream oss;
- oss << "Failed to compile "
- << method_ref.dex_file->PrettyMethod(method_ref.index)
- << "[" << method_ref.dex_file->GetLocation() << "]"
- << " as expected by profile";
- switch (check_type) {
- case ProfileMethodsCheck::kNone:
- break;
- case ProfileMethodsCheck::kLog:
- LOG(ERROR) << oss.str();
- break;
- case ProfileMethodsCheck::kAbort:
- LOG(FATAL_WITHOUT_ABORT) << oss.str();
- _exit(1);
- }
- }
- }
- }
- if (compiled_method == nullptr &&
- dex_to_dex_compilation_level !=
- optimizer::DexToDexCompiler::CompilationLevel::kDontDexToDexCompile) {
- DCHECK(!Runtime::Current()->UseJitCompilation());
- // TODO: add a command-line option to disable DEX-to-DEX compilation ?
- driver->GetDexToDexCompiler().MarkForCompilation(self, method_ref);
- }
- }
- return compiled_method;
- };
- CompileMethodHarness(self,
- driver,
- code_item,
- access_flags,
- invoke_type,
- class_def_idx,
- method_idx,
- class_loader,
- dex_file,
- dex_to_dex_compilation_level,
- dex_cache,
- quick_fn);
-}
-
-void CompilerDriver::Resolve(jobject class_loader,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings) {
- // Resolution allocates classes and needs to run single-threaded to be deterministic.
- bool force_determinism = GetCompilerOptions().IsForceDeterminism();
- ThreadPool* resolve_thread_pool = force_determinism
- ? single_thread_pool_.get()
- : parallel_thread_pool_.get();
- size_t resolve_thread_count = force_determinism ? 1U : parallel_thread_count_;
-
- for (size_t i = 0; i != dex_files.size(); ++i) {
- const DexFile* dex_file = dex_files[i];
- CHECK(dex_file != nullptr);
- ResolveDexFile(class_loader,
- *dex_file,
- dex_files,
- resolve_thread_pool,
- resolve_thread_count,
- timings);
- }
-}
-
-void CompilerDriver::ResolveConstStrings(const std::vector<const DexFile*>& dex_files,
- bool only_startup_strings,
- TimingLogger* timings) {
- ScopedObjectAccess soa(Thread::Current());
- StackHandleScope<1> hs(soa.Self());
- ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
- MutableHandle<mirror::DexCache> dex_cache(hs.NewHandle<mirror::DexCache>(nullptr));
- size_t num_instructions = 0u;
-
- for (const DexFile* dex_file : dex_files) {
- dex_cache.Assign(class_linker->FindDexCache(soa.Self(), *dex_file));
- if (only_startup_strings) {
- // When resolving startup strings, create the preresolved strings array.
- dex_cache->AddPreResolvedStringsArray();
- }
- TimingLogger::ScopedTiming t("Resolve const-string Strings", timings);
-
- // TODO: Implement a profile-based filter for the boot image. See b/76145463.
- for (ClassAccessor accessor : dex_file->GetClasses()) {
- const ProfileCompilationInfo* profile_compilation_info =
- GetCompilerOptions().GetProfileCompilationInfo();
-
- const bool is_startup_class =
- profile_compilation_info != nullptr &&
- profile_compilation_info->ContainsClass(*dex_file, accessor.GetClassIdx());
-
- for (const ClassAccessor::Method& method : accessor.GetMethods()) {
- const bool is_clinit = (method.GetAccessFlags() & kAccConstructor) != 0 &&
- (method.GetAccessFlags() & kAccStatic) != 0;
- const bool is_startup_clinit = is_startup_class && is_clinit;
-
- if (only_startup_strings &&
- profile_compilation_info != nullptr &&
- (!profile_compilation_info->GetMethodHotness(method.GetReference()).IsStartup() &&
- !is_startup_clinit)) {
- continue;
- }
-
- // Resolve const-strings in the code. Done to have deterministic allocation behavior. Right
- // now this is single-threaded for simplicity.
- // TODO: Collect the relevant string indices in parallel, then allocate them sequentially
- // in a stable order.
- for (const DexInstructionPcPair& inst : method.GetInstructions()) {
- switch (inst->Opcode()) {
- case Instruction::CONST_STRING:
- case Instruction::CONST_STRING_JUMBO: {
- dex::StringIndex string_index((inst->Opcode() == Instruction::CONST_STRING)
- ? inst->VRegB_21c()
- : inst->VRegB_31c());
- ObjPtr<mirror::String> string = class_linker->ResolveString(string_index, dex_cache);
- CHECK(string != nullptr) << "Could not allocate a string when forcing determinism";
- if (only_startup_strings) {
- dex_cache->GetPreResolvedStrings()[string_index.index_] =
- GcRoot<mirror::String>(string);
- }
- ++num_instructions;
- break;
- }
-
- default:
- break;
- }
- }
- }
- }
- }
- VLOG(compiler) << "Resolved " << num_instructions << " const string instructions";
-}
-
-// Initialize type check bit strings for check-cast and instance-of in the code. Done to have
-// deterministic allocation behavior. Right now this is single-threaded for simplicity.
-// TODO: Collect the relevant type indices in parallel, then process them sequentially in a
-// stable order.
-
-static void InitializeTypeCheckBitstrings(CompilerDriver* driver,
- ClassLinker* class_linker,
- Handle<mirror::DexCache> dex_cache,
- const DexFile& dex_file,
- const ClassAccessor::Method& method)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- for (const DexInstructionPcPair& inst : method.GetInstructions()) {
- switch (inst->Opcode()) {
- case Instruction::CHECK_CAST:
- case Instruction::INSTANCE_OF: {
- dex::TypeIndex type_index(
- (inst->Opcode() == Instruction::CHECK_CAST) ? inst->VRegB_21c() : inst->VRegC_22c());
- const char* descriptor = dex_file.StringByTypeIdx(type_index);
- // We currently do not use the bitstring type check for array or final (including
- // primitive) classes. We may reconsider this in future if it's deemed to be beneficial.
- // And we cannot use it for classes outside the boot image as we do not know the runtime
- // value of their bitstring when compiling (it may not even get assigned at runtime).
- if (descriptor[0] == 'L' && driver->GetCompilerOptions().IsImageClass(descriptor)) {
- ObjPtr<mirror::Class> klass =
- class_linker->LookupResolvedType(type_index,
- dex_cache.Get(),
- /* class_loader= */ nullptr);
- CHECK(klass != nullptr) << descriptor << " should have been previously resolved.";
- // Now assign the bitstring if the class is not final. Keep this in sync with sharpening.
- if (!klass->IsFinal()) {
- MutexLock subtype_check_lock(Thread::Current(), *Locks::subtype_check_lock_);
- SubtypeCheck<ObjPtr<mirror::Class>>::EnsureAssigned(klass);
- }
- }
- break;
- }
-
- default:
- break;
- }
- }
-}
-
-static void InitializeTypeCheckBitstrings(CompilerDriver* driver,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings) {
- ScopedObjectAccess soa(Thread::Current());
- StackHandleScope<1> hs(soa.Self());
- ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
- MutableHandle<mirror::DexCache> dex_cache(hs.NewHandle<mirror::DexCache>(nullptr));
-
- for (const DexFile* dex_file : dex_files) {
- dex_cache.Assign(class_linker->FindDexCache(soa.Self(), *dex_file));
- TimingLogger::ScopedTiming t("Initialize type check bitstrings", timings);
-
- for (ClassAccessor accessor : dex_file->GetClasses()) {
- // Direct and virtual methods.
- for (const ClassAccessor::Method& method : accessor.GetMethods()) {
- InitializeTypeCheckBitstrings(driver, class_linker, dex_cache, *dex_file, method);
- }
- }
- }
-}
-
-inline void CompilerDriver::CheckThreadPools() {
- DCHECK(parallel_thread_pool_ != nullptr);
- DCHECK(single_thread_pool_ != nullptr);
-}
-
-static void EnsureVerifiedOrVerifyAtRuntime(jobject jclass_loader,
- const std::vector<const DexFile*>& dex_files) {
- ScopedObjectAccess soa(Thread::Current());
- StackHandleScope<2> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
- MutableHandle<mirror::Class> cls(hs.NewHandle<mirror::Class>(nullptr));
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-
- for (const DexFile* dex_file : dex_files) {
- for (ClassAccessor accessor : dex_file->GetClasses()) {
- cls.Assign(class_linker->FindClass(soa.Self(), accessor.GetDescriptor(), class_loader));
- if (cls == nullptr) {
- soa.Self()->ClearException();
- } else if (&cls->GetDexFile() == dex_file) {
- DCHECK(cls->IsErroneous() || cls->IsVerified() || cls->ShouldVerifyAtRuntime())
- << cls->PrettyClass()
- << " " << cls->GetStatus();
- }
- }
- }
-}
-
-void CompilerDriver::PreCompile(jobject class_loader,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings,
- /*inout*/ HashSet<std::string>* image_classes,
- /*out*/ VerificationResults* verification_results) {
- CheckThreadPools();
-
- VLOG(compiler) << "Before precompile " << GetMemoryUsageString(false);
-
- compiled_classes_.AddDexFiles(GetCompilerOptions().GetDexFilesForOatFile());
- dex_to_dex_compiler_.SetDexFiles(GetCompilerOptions().GetDexFilesForOatFile());
-
- // Precompile:
- // 1) Load image classes.
- // 2) Resolve all classes.
- // 3) For deterministic boot image, resolve strings for const-string instructions.
- // 4) Attempt to verify all classes.
- // 5) Attempt to initialize image classes, and trivially initialized classes.
- // 6) Update the set of image classes.
- // 7) For deterministic boot image, initialize bitstrings for type checking.
-
- LoadImageClasses(timings, image_classes);
- VLOG(compiler) << "LoadImageClasses: " << GetMemoryUsageString(false);
-
- if (compiler_options_->IsAnyCompilationEnabled()) {
- // Avoid adding the dex files in the case where we aren't going to add compiled methods.
- // This reduces RAM usage for this case.
- for (const DexFile* dex_file : dex_files) {
- // Can be already inserted. This happens for gtests.
- if (!compiled_methods_.HaveDexFile(dex_file)) {
- compiled_methods_.AddDexFile(dex_file);
- }
- }
- // Resolve eagerly to prepare for compilation.
- Resolve(class_loader, dex_files, timings);
- VLOG(compiler) << "Resolve: " << GetMemoryUsageString(false);
- }
-
- if (compiler_options_->AssumeClassesAreVerified()) {
- VLOG(compiler) << "Verify none mode specified, skipping verification.";
- SetVerified(class_loader, dex_files, timings);
- }
-
- if (!compiler_options_->IsVerificationEnabled()) {
- return;
- }
-
- if (GetCompilerOptions().IsForceDeterminism() && GetCompilerOptions().IsBootImage()) {
- // Resolve strings from const-string. Do this now to have a deterministic image.
- ResolveConstStrings(dex_files, /*only_startup_strings=*/ false, timings);
- VLOG(compiler) << "Resolve const-strings: " << GetMemoryUsageString(false);
- } else if (GetCompilerOptions().ResolveStartupConstStrings()) {
- ResolveConstStrings(dex_files, /*only_startup_strings=*/ true, timings);
- }
-
- Verify(class_loader, dex_files, timings, verification_results);
- VLOG(compiler) << "Verify: " << GetMemoryUsageString(false);
-
- if (had_hard_verifier_failure_ && GetCompilerOptions().AbortOnHardVerifierFailure()) {
- // Avoid dumping threads. Even if we shut down the thread pools, there will still be three
- // instances of this thread's stack.
- LOG(FATAL_WITHOUT_ABORT) << "Had a hard failure verifying all classes, and was asked to abort "
- << "in such situations. Please check the log.";
- _exit(1);
- } else if (number_of_soft_verifier_failures_ > 0 &&
- GetCompilerOptions().AbortOnSoftVerifierFailure()) {
- LOG(FATAL_WITHOUT_ABORT) << "Had " << number_of_soft_verifier_failures_ << " soft failure(s) "
- << "verifying all classes, and was asked to abort in such situations. "
- << "Please check the log.";
- _exit(1);
- }
-
- if (compiler_options_->IsAnyCompilationEnabled()) {
- if (kIsDebugBuild) {
- EnsureVerifiedOrVerifyAtRuntime(class_loader, dex_files);
- }
- InitializeClasses(class_loader, dex_files, timings);
- VLOG(compiler) << "InitializeClasses: " << GetMemoryUsageString(false);
- }
-
- UpdateImageClasses(timings, image_classes);
- VLOG(compiler) << "UpdateImageClasses: " << GetMemoryUsageString(false);
-
- if (kBitstringSubtypeCheckEnabled &&
- GetCompilerOptions().IsForceDeterminism() && GetCompilerOptions().IsBootImage()) {
- // Initialize type check bit string used by check-cast and instanceof.
- // Do this now to have a deterministic image.
- // Note: This is done after UpdateImageClasses() at it relies on the image classes to be final.
- InitializeTypeCheckBitstrings(this, dex_files, timings);
- }
-}
-
-bool CompilerDriver::ShouldCompileBasedOnProfile(const MethodReference& method_ref) const {
- // Profile compilation info may be null if no profile is passed.
- if (!CompilerFilter::DependsOnProfile(compiler_options_->GetCompilerFilter())) {
- // Use the compiler filter instead of the presence of profile_compilation_info_ since
- // we may want to have full speed compilation along with profile based layout optimizations.
- return true;
- }
- // If we are using a profile filter but do not have a profile compilation info, compile nothing.
- const ProfileCompilationInfo* profile_compilation_info =
- GetCompilerOptions().GetProfileCompilationInfo();
- if (profile_compilation_info == nullptr) {
- return false;
- }
- // Compile only hot methods, it is the profile saver's job to decide what startup methods to mark
- // as hot.
- bool result = profile_compilation_info->GetMethodHotness(method_ref).IsHot();
-
- if (kDebugProfileGuidedCompilation) {
- LOG(INFO) << "[ProfileGuidedCompilation] "
- << (result ? "Compiled" : "Skipped") << " method:" << method_ref.PrettyMethod(true);
- }
- return result;
-}
-
-class ResolveCatchBlockExceptionsClassVisitor : public ClassVisitor {
- public:
- ResolveCatchBlockExceptionsClassVisitor() : classes_() {}
-
- bool operator()(ObjPtr<mirror::Class> c) override REQUIRES_SHARED(Locks::mutator_lock_) {
- classes_.push_back(c);
- return true;
- }
-
- void FindExceptionTypesToResolve(
- std::set<std::pair<dex::TypeIndex, const DexFile*>>* exceptions_to_resolve)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- const auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
- for (ObjPtr<mirror::Class> klass : classes_) {
- for (ArtMethod& method : klass->GetMethods(pointer_size)) {
- FindExceptionTypesToResolveForMethod(&method, exceptions_to_resolve);
- }
- }
- }
-
- private:
- void FindExceptionTypesToResolveForMethod(
- ArtMethod* method,
- std::set<std::pair<dex::TypeIndex, const DexFile*>>* exceptions_to_resolve)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- if (method->GetCodeItem() == nullptr) {
- return; // native or abstract method
- }
- CodeItemDataAccessor accessor(method->DexInstructionData());
- if (accessor.TriesSize() == 0) {
- return; // nothing to process
- }
- const uint8_t* encoded_catch_handler_list = accessor.GetCatchHandlerData();
- size_t num_encoded_catch_handlers = DecodeUnsignedLeb128(&encoded_catch_handler_list);
- for (size_t i = 0; i < num_encoded_catch_handlers; i++) {
- int32_t encoded_catch_handler_size = DecodeSignedLeb128(&encoded_catch_handler_list);
- bool has_catch_all = false;
- if (encoded_catch_handler_size <= 0) {
- encoded_catch_handler_size = -encoded_catch_handler_size;
- has_catch_all = true;
- }
- for (int32_t j = 0; j < encoded_catch_handler_size; j++) {
- dex::TypeIndex encoded_catch_handler_handlers_type_idx =
- dex::TypeIndex(DecodeUnsignedLeb128(&encoded_catch_handler_list));
- // Add to set of types to resolve if not already in the dex cache resolved types
- if (!method->IsResolvedTypeIdx(encoded_catch_handler_handlers_type_idx)) {
- exceptions_to_resolve->emplace(encoded_catch_handler_handlers_type_idx,
- method->GetDexFile());
- }
- // ignore address associated with catch handler
- DecodeUnsignedLeb128(&encoded_catch_handler_list);
- }
- if (has_catch_all) {
- // ignore catch all address
- DecodeUnsignedLeb128(&encoded_catch_handler_list);
- }
- }
- }
-
- std::vector<ObjPtr<mirror::Class>> classes_;
-};
-
-class RecordImageClassesVisitor : public ClassVisitor {
- public:
- explicit RecordImageClassesVisitor(HashSet<std::string>* image_classes)
- : image_classes_(image_classes) {}
-
- bool operator()(ObjPtr<mirror::Class> klass) override REQUIRES_SHARED(Locks::mutator_lock_) {
- std::string temp;
- image_classes_->insert(klass->GetDescriptor(&temp));
- return true;
- }
-
- private:
- HashSet<std::string>* const image_classes_;
-};
-
-// Make a list of descriptors for classes to include in the image
-void CompilerDriver::LoadImageClasses(TimingLogger* timings,
- /*inout*/ HashSet<std::string>* image_classes) {
- CHECK(timings != nullptr);
- if (!GetCompilerOptions().IsBootImage()) {
- return;
- }
-
- TimingLogger::ScopedTiming t("LoadImageClasses", timings);
- // Make a first class to load all classes explicitly listed in the file
- Thread* self = Thread::Current();
- ScopedObjectAccess soa(self);
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- CHECK(image_classes != nullptr);
- for (auto it = image_classes->begin(), end = image_classes->end(); it != end;) {
- const std::string& descriptor(*it);
- StackHandleScope<1> hs(self);
- Handle<mirror::Class> klass(
- hs.NewHandle(class_linker->FindSystemClass(self, descriptor.c_str())));
- if (klass == nullptr) {
- VLOG(compiler) << "Failed to find class " << descriptor;
- it = image_classes->erase(it);
- self->ClearException();
- } else {
- ++it;
- }
- }
-
- // Resolve exception classes referenced by the loaded classes. The catch logic assumes
- // exceptions are resolved by the verifier when there is a catch block in an interested method.
- // Do this here so that exception classes appear to have been specified image classes.
- std::set<std::pair<dex::TypeIndex, const DexFile*>> unresolved_exception_types;
- StackHandleScope<1> hs(self);
- Handle<mirror::Class> java_lang_Throwable(
- hs.NewHandle(class_linker->FindSystemClass(self, "Ljava/lang/Throwable;")));
- do {
- unresolved_exception_types.clear();
- {
- // Thread suspension is not allowed while ResolveCatchBlockExceptionsClassVisitor
- // is using a std::vector<ObjPtr<mirror::Class>>.
- ScopedAssertNoThreadSuspension ants(__FUNCTION__);
- ResolveCatchBlockExceptionsClassVisitor visitor;
- class_linker->VisitClasses(&visitor);
- visitor.FindExceptionTypesToResolve(&unresolved_exception_types);
- }
- for (const auto& exception_type : unresolved_exception_types) {
- dex::TypeIndex exception_type_idx = exception_type.first;
- const DexFile* dex_file = exception_type.second;
- StackHandleScope<1> hs2(self);
- Handle<mirror::DexCache> dex_cache(hs2.NewHandle(class_linker->RegisterDexFile(*dex_file,
- nullptr)));
- ObjPtr<mirror::Class> klass =
- (dex_cache != nullptr)
- ? class_linker->ResolveType(exception_type_idx,
- dex_cache,
- ScopedNullHandle<mirror::ClassLoader>())
- : nullptr;
- if (klass == nullptr) {
- const dex::TypeId& type_id = dex_file->GetTypeId(exception_type_idx);
- const char* descriptor = dex_file->GetTypeDescriptor(type_id);
- LOG(FATAL) << "Failed to resolve class " << descriptor;
- }
- DCHECK(java_lang_Throwable->IsAssignableFrom(klass));
- }
- // Resolving exceptions may load classes that reference more exceptions, iterate until no
- // more are found
- } while (!unresolved_exception_types.empty());
-
- // We walk the roots looking for classes so that we'll pick up the
- // above classes plus any classes them depend on such super
- // classes, interfaces, and the required ClassLinker roots.
- RecordImageClassesVisitor visitor(image_classes);
- class_linker->VisitClasses(&visitor);
-
- CHECK(!image_classes->empty());
-}
-
-static void MaybeAddToImageClasses(Thread* self,
- ObjPtr<mirror::Class> klass,
- HashSet<std::string>* image_classes)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- DCHECK_EQ(self, Thread::Current());
- StackHandleScope<1> hs(self);
- std::string temp;
- const PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
- while (!klass->IsObjectClass()) {
- const char* descriptor = klass->GetDescriptor(&temp);
- if (image_classes->find(std::string_view(descriptor)) != image_classes->end()) {
- break; // Previously inserted.
- }
- image_classes->insert(descriptor);
- VLOG(compiler) << "Adding " << descriptor << " to image classes";
- for (size_t i = 0, num_interfaces = klass->NumDirectInterfaces(); i != num_interfaces; ++i) {
- ObjPtr<mirror::Class> interface = mirror::Class::GetDirectInterface(self, klass, i);
- DCHECK(interface != nullptr);
- MaybeAddToImageClasses(self, interface, image_classes);
- }
- for (auto& m : klass->GetVirtualMethods(pointer_size)) {
- MaybeAddToImageClasses(self, m.GetDeclaringClass(), image_classes);
- }
- if (klass->IsArrayClass()) {
- MaybeAddToImageClasses(self, klass->GetComponentType(), image_classes);
- }
- klass = klass->GetSuperClass();
- }
-}
-
-// Keeps all the data for the update together. Also doubles as the reference visitor.
-// Note: we can use object pointers because we suspend all threads.
-class ClinitImageUpdate {
- public:
- static ClinitImageUpdate* Create(VariableSizedHandleScope& hs,
- HashSet<std::string>* image_class_descriptors,
- Thread* self,
- ClassLinker* linker) {
- std::unique_ptr<ClinitImageUpdate> res(new ClinitImageUpdate(hs,
- image_class_descriptors,
- self,
- linker));
- return res.release();
- }
-
- ~ClinitImageUpdate() {
- // Allow others to suspend again.
- self_->EndAssertNoThreadSuspension(old_cause_);
- }
-
- // Visitor for VisitReferences.
- void operator()(ObjPtr<mirror::Object> object,
- MemberOffset field_offset,
- bool is_static ATTRIBUTE_UNUSED) const
- REQUIRES_SHARED(Locks::mutator_lock_) {
- mirror::Object* ref = object->GetFieldObject<mirror::Object>(field_offset);
- if (ref != nullptr) {
- VisitClinitClassesObject(ref);
- }
- }
-
- // java.lang.ref.Reference visitor for VisitReferences.
- void operator()(ObjPtr<mirror::Class> klass ATTRIBUTE_UNUSED,
- ObjPtr<mirror::Reference> ref ATTRIBUTE_UNUSED) const {}
-
- // Ignore class native roots.
- void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED)
- const {}
- void VisitRoot(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) const {}
-
- void Walk() REQUIRES_SHARED(Locks::mutator_lock_) {
- // Use the initial classes as roots for a search.
- for (Handle<mirror::Class> klass_root : image_classes_) {
- VisitClinitClassesObject(klass_root.Get());
- }
- Thread* self = Thread::Current();
- ScopedAssertNoThreadSuspension ants(__FUNCTION__);
- for (Handle<mirror::Class> h_klass : to_insert_) {
- MaybeAddToImageClasses(self, h_klass.Get(), image_class_descriptors_);
- }
- }
-
- private:
- class FindImageClassesVisitor : public ClassVisitor {
- public:
- explicit FindImageClassesVisitor(VariableSizedHandleScope& hs,
- ClinitImageUpdate* data)
- : data_(data),
- hs_(hs) {}
-
- bool operator()(ObjPtr<mirror::Class> klass) override REQUIRES_SHARED(Locks::mutator_lock_) {
- std::string temp;
- std::string_view name(klass->GetDescriptor(&temp));
- auto it = data_->image_class_descriptors_->find(name);
- if (it != data_->image_class_descriptors_->end()) {
- if (LIKELY(klass->IsResolved())) {
- data_->image_classes_.push_back(hs_.NewHandle(klass));
- } else {
- DCHECK(klass->IsErroneousUnresolved());
- VLOG(compiler) << "Removing unresolved class from image classes: " << name;
- data_->image_class_descriptors_->erase(it);
- }
- } else {
- // Check whether it is initialized and has a clinit. They must be kept, too.
- if (klass->IsInitialized() && klass->FindClassInitializer(
- Runtime::Current()->GetClassLinker()->GetImagePointerSize()) != nullptr) {
- data_->image_classes_.push_back(hs_.NewHandle(klass));
- }
- }
- return true;
- }
-
- private:
- ClinitImageUpdate* const data_;
- VariableSizedHandleScope& hs_;
- };
-
- ClinitImageUpdate(VariableSizedHandleScope& hs,
- HashSet<std::string>* image_class_descriptors,
- Thread* self,
- ClassLinker* linker) REQUIRES_SHARED(Locks::mutator_lock_)
- : hs_(hs),
- image_class_descriptors_(image_class_descriptors),
- self_(self) {
- CHECK(linker != nullptr);
- CHECK(image_class_descriptors != nullptr);
-
- // Make sure nobody interferes with us.
- old_cause_ = self->StartAssertNoThreadSuspension("Boot image closure");
-
- // Find all the already-marked classes.
- WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
- FindImageClassesVisitor visitor(hs_, this);
- linker->VisitClasses(&visitor);
- }
-
- void VisitClinitClassesObject(mirror::Object* object) const
- REQUIRES_SHARED(Locks::mutator_lock_) {
- DCHECK(object != nullptr);
- if (marked_objects_.find(object) != marked_objects_.end()) {
- // Already processed.
- return;
- }
-
- // Mark it.
- marked_objects_.insert(object);
-
- if (object->IsClass()) {
- // Add to the TODO list since MaybeAddToImageClasses may cause thread suspension. Thread
- // suspensionb is not safe to do in VisitObjects or VisitReferences.
- to_insert_.push_back(hs_.NewHandle(object->AsClass()));
- } else {
- // Else visit the object's class.
- VisitClinitClassesObject(object->GetClass());
- }
-
- // If it is not a DexCache, visit all references.
- if (!object->IsDexCache()) {
- object->VisitReferences(*this, *this);
- }
- }
-
- VariableSizedHandleScope& hs_;
- mutable std::vector<Handle<mirror::Class>> to_insert_;
- mutable std::unordered_set<mirror::Object*> marked_objects_;
- HashSet<std::string>* const image_class_descriptors_;
- std::vector<Handle<mirror::Class>> image_classes_;
- Thread* const self_;
- const char* old_cause_;
-
- DISALLOW_COPY_AND_ASSIGN(ClinitImageUpdate);
-};
-
-void CompilerDriver::UpdateImageClasses(TimingLogger* timings,
- /*inout*/ HashSet<std::string>* image_classes) {
- if (GetCompilerOptions().IsBootImage()) {
- TimingLogger::ScopedTiming t("UpdateImageClasses", timings);
-
- Runtime* runtime = Runtime::Current();
-
- // Suspend all threads.
- ScopedSuspendAll ssa(__FUNCTION__);
-
- VariableSizedHandleScope hs(Thread::Current());
- std::string error_msg;
- std::unique_ptr<ClinitImageUpdate> update(ClinitImageUpdate::Create(hs,
- image_classes,
- Thread::Current(),
- runtime->GetClassLinker()));
-
- // Do the marking.
- update->Walk();
- }
-}
-
-void CompilerDriver::ProcessedInstanceField(bool resolved) {
- if (!resolved) {
- stats_->UnresolvedInstanceField();
- } else {
- stats_->ResolvedInstanceField();
- }
-}
-
-void CompilerDriver::ProcessedStaticField(bool resolved, bool local) {
- if (!resolved) {
- stats_->UnresolvedStaticField();
- } else if (local) {
- stats_->ResolvedLocalStaticField();
- } else {
- stats_->ResolvedStaticField();
- }
-}
-
-ArtField* CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx,
- const DexCompilationUnit* mUnit,
- bool is_put,
- const ScopedObjectAccess& soa) {
- // Try to resolve the field and compiling method's class.
- ArtField* resolved_field;
- ObjPtr<mirror::Class> referrer_class;
- Handle<mirror::DexCache> dex_cache(mUnit->GetDexCache());
- {
- Handle<mirror::ClassLoader> class_loader = mUnit->GetClassLoader();
- resolved_field = ResolveField(soa, dex_cache, class_loader, field_idx, /* is_static= */ false);
- referrer_class = resolved_field != nullptr
- ? ResolveCompilingMethodsClass(soa, dex_cache, class_loader, mUnit) : nullptr;
- }
- bool can_link = false;
- if (resolved_field != nullptr && referrer_class != nullptr) {
- std::pair<bool, bool> fast_path = IsFastInstanceField(
- dex_cache.Get(), referrer_class, resolved_field, field_idx);
- can_link = is_put ? fast_path.second : fast_path.first;
- }
- ProcessedInstanceField(can_link);
- return can_link ? resolved_field : nullptr;
-}
-
-bool CompilerDriver::ComputeInstanceFieldInfo(uint32_t field_idx, const DexCompilationUnit* mUnit,
- bool is_put, MemberOffset* field_offset,
- bool* is_volatile) {
- ScopedObjectAccess soa(Thread::Current());
- ArtField* resolved_field = ComputeInstanceFieldInfo(field_idx, mUnit, is_put, soa);
-
- if (resolved_field == nullptr) {
- // Conservative defaults.
- *is_volatile = true;
- *field_offset = MemberOffset(static_cast<size_t>(-1));
- return false;
- } else {
- *is_volatile = resolved_field->IsVolatile();
- *field_offset = resolved_field->GetOffset();
- return true;
- }
-}
-
-bool CompilerDriver::IsSafeCast(const DexCompilationUnit* mUnit, uint32_t dex_pc) {
- if (!compiler_options_->IsVerificationEnabled()) {
- // If we didn't verify, every cast has to be treated as non-safe.
- return false;
- }
- DCHECK(mUnit->GetVerifiedMethod() != nullptr);
- bool result = mUnit->GetVerifiedMethod()->IsSafeCast(dex_pc);
- if (result) {
- stats_->SafeCast();
- } else {
- stats_->NotASafeCast();
- }
- return result;
-}
-
-class CompilationVisitor {
- public:
- virtual ~CompilationVisitor() {}
- virtual void Visit(size_t index) = 0;
-};
-
-class ParallelCompilationManager {
- public:
- ParallelCompilationManager(ClassLinker* class_linker,
- jobject class_loader,
- CompilerDriver* compiler,
- const DexFile* dex_file,
- const std::vector<const DexFile*>& dex_files,
- ThreadPool* thread_pool)
- : index_(0),
- class_linker_(class_linker),
- class_loader_(class_loader),
- compiler_(compiler),
- dex_file_(dex_file),
- dex_files_(dex_files),
- thread_pool_(thread_pool) {}
-
- ClassLinker* GetClassLinker() const {
- CHECK(class_linker_ != nullptr);
- return class_linker_;
- }
-
- jobject GetClassLoader() const {
- return class_loader_;
- }
-
- CompilerDriver* GetCompiler() const {
- CHECK(compiler_ != nullptr);
- return compiler_;
- }
-
- const DexFile* GetDexFile() const {
- CHECK(dex_file_ != nullptr);
- return dex_file_;
- }
-
- const std::vector<const DexFile*>& GetDexFiles() const {
- return dex_files_;
- }
-
- void ForAll(size_t begin, size_t end, CompilationVisitor* visitor, size_t work_units)
- REQUIRES(!*Locks::mutator_lock_) {
- ForAllLambda(begin, end, [visitor](size_t index) { visitor->Visit(index); }, work_units);
- }
-
- template <typename Fn>
- void ForAllLambda(size_t begin, size_t end, Fn fn, size_t work_units)
- REQUIRES(!*Locks::mutator_lock_) {
- Thread* self = Thread::Current();
- self->AssertNoPendingException();
- CHECK_GT(work_units, 0U);
-
- index_.store(begin, std::memory_order_relaxed);
- for (size_t i = 0; i < work_units; ++i) {
- thread_pool_->AddTask(self, new ForAllClosureLambda<Fn>(this, end, fn));
- }
- thread_pool_->StartWorkers(self);
-
- // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
- // thread destructor's called below perform join).
- CHECK_NE(self->GetState(), kRunnable);
-
- // Wait for all the worker threads to finish.
- thread_pool_->Wait(self, true, false);
-
- // And stop the workers accepting jobs.
- thread_pool_->StopWorkers(self);
- }
-
- size_t NextIndex() {
- return index_.fetch_add(1, std::memory_order_seq_cst);
- }
-
- private:
- template <typename Fn>
- class ForAllClosureLambda : public Task {
- public:
- ForAllClosureLambda(ParallelCompilationManager* manager, size_t end, Fn fn)
- : manager_(manager),
- end_(end),
- fn_(fn) {}
-
- void Run(Thread* self) override {
- while (true) {
- const size_t index = manager_->NextIndex();
- if (UNLIKELY(index >= end_)) {
- break;
- }
- fn_(index);
- self->AssertNoPendingException();
- }
- }
-
- void Finalize() override {
- delete this;
- }
-
- private:
- ParallelCompilationManager* const manager_;
- const size_t end_;
- Fn fn_;
- };
-
- AtomicInteger index_;
- ClassLinker* const class_linker_;
- const jobject class_loader_;
- CompilerDriver* const compiler_;
- const DexFile* const dex_file_;
- const std::vector<const DexFile*>& dex_files_;
- ThreadPool* const thread_pool_;
-
- DISALLOW_COPY_AND_ASSIGN(ParallelCompilationManager);
-};
-
-// A fast version of SkipClass above if the class pointer is available
-// that avoids the expensive FindInClassPath search.
-static bool SkipClass(jobject class_loader, const DexFile& dex_file, ObjPtr<mirror::Class> klass)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- DCHECK(klass != nullptr);
- const DexFile& original_dex_file = *klass->GetDexCache()->GetDexFile();
- if (&dex_file != &original_dex_file) {
- if (class_loader == nullptr) {
- LOG(WARNING) << "Skipping class " << klass->PrettyDescriptor() << " from "
- << dex_file.GetLocation() << " previously found in "
- << original_dex_file.GetLocation();
- }
- return true;
- }
- return false;
-}
-
-static void CheckAndClearResolveException(Thread* self)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- CHECK(self->IsExceptionPending());
- mirror::Throwable* exception = self->GetException();
- std::string temp;
- const char* descriptor = exception->GetClass()->GetDescriptor(&temp);
- const char* expected_exceptions[] = {
- "Ljava/lang/IllegalAccessError;",
- "Ljava/lang/IncompatibleClassChangeError;",
- "Ljava/lang/InstantiationError;",
- "Ljava/lang/LinkageError;",
- "Ljava/lang/NoClassDefFoundError;",
- "Ljava/lang/NoSuchFieldError;",
- "Ljava/lang/NoSuchMethodError;"
- };
- bool found = false;
- for (size_t i = 0; (found == false) && (i < arraysize(expected_exceptions)); ++i) {
- if (strcmp(descriptor, expected_exceptions[i]) == 0) {
- found = true;
- }
- }
- if (!found) {
- LOG(FATAL) << "Unexpected exception " << exception->Dump();
- }
- self->ClearException();
-}
-
-class ResolveClassFieldsAndMethodsVisitor : public CompilationVisitor {
- public:
- explicit ResolveClassFieldsAndMethodsVisitor(const ParallelCompilationManager* manager)
- : manager_(manager) {}
-
- void Visit(size_t class_def_index) override REQUIRES(!Locks::mutator_lock_) {
- ScopedTrace trace(__FUNCTION__);
- Thread* const self = Thread::Current();
- jobject jclass_loader = manager_->GetClassLoader();
- const DexFile& dex_file = *manager_->GetDexFile();
- ClassLinker* class_linker = manager_->GetClassLinker();
-
- // Method and Field are the worst. We can't resolve without either
- // context from the code use (to disambiguate virtual vs direct
- // method and instance vs static field) or from class
- // definitions. While the compiler will resolve what it can as it
- // needs it, here we try to resolve fields and methods used in class
- // definitions, since many of them many never be referenced by
- // generated code.
- const dex::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
- ScopedObjectAccess soa(self);
- StackHandleScope<2> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
- Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(
- soa.Self(), dex_file)));
- // Resolve the class.
- ObjPtr<mirror::Class> klass =
- class_linker->ResolveType(class_def.class_idx_, dex_cache, class_loader);
- bool resolve_fields_and_methods;
- if (klass == nullptr) {
- // Class couldn't be resolved, for example, super-class is in a different dex file. Don't
- // attempt to resolve methods and fields when there is no declaring class.
- CheckAndClearResolveException(soa.Self());
- resolve_fields_and_methods = false;
- } else {
- // We successfully resolved a class, should we skip it?
- if (SkipClass(jclass_loader, dex_file, klass)) {
- return;
- }
- // We want to resolve the methods and fields eagerly.
- resolve_fields_and_methods = true;
- }
-
- if (resolve_fields_and_methods) {
- ClassAccessor accessor(dex_file, class_def_index);
- // Optionally resolve fields and methods and figure out if we need a constructor barrier.
- auto method_visitor = [&](const ClassAccessor::Method& method)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- ArtMethod* resolved = class_linker->ResolveMethod<ClassLinker::ResolveMode::kNoChecks>(
- method.GetIndex(),
- dex_cache,
- class_loader,
- /*referrer=*/ nullptr,
- method.GetInvokeType(class_def.access_flags_));
- if (resolved == nullptr) {
- CheckAndClearResolveException(soa.Self());
- }
- };
- accessor.VisitFieldsAndMethods(
- // static fields
- [&](ClassAccessor::Field& field) REQUIRES_SHARED(Locks::mutator_lock_) {
- ArtField* resolved = class_linker->ResolveField(
- field.GetIndex(), dex_cache, class_loader, /*is_static=*/ true);
- if (resolved == nullptr) {
- CheckAndClearResolveException(soa.Self());
- }
- },
- // instance fields
- [&](ClassAccessor::Field& field) REQUIRES_SHARED(Locks::mutator_lock_) {
- ArtField* resolved = class_linker->ResolveField(
- field.GetIndex(), dex_cache, class_loader, /*is_static=*/ false);
- if (resolved == nullptr) {
- CheckAndClearResolveException(soa.Self());
- }
- },
- /*direct_method_visitor=*/ method_visitor,
- /*virtual_method_visitor=*/ method_visitor);
- }
- }
-
- private:
- const ParallelCompilationManager* const manager_;
-};
-
-class ResolveTypeVisitor : public CompilationVisitor {
- public:
- explicit ResolveTypeVisitor(const ParallelCompilationManager* manager) : manager_(manager) {
- }
- void Visit(size_t type_idx) override REQUIRES(!Locks::mutator_lock_) {
- // Class derived values are more complicated, they require the linker and loader.
- ScopedObjectAccess soa(Thread::Current());
- ClassLinker* class_linker = manager_->GetClassLinker();
- const DexFile& dex_file = *manager_->GetDexFile();
- StackHandleScope<2> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader>(manager_->GetClassLoader())));
- Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->RegisterDexFile(
- dex_file,
- class_loader.Get())));
- ObjPtr<mirror::Class> klass = (dex_cache != nullptr)
- ? class_linker->ResolveType(dex::TypeIndex(type_idx), dex_cache, class_loader)
- : nullptr;
-
- if (klass == nullptr) {
- soa.Self()->AssertPendingException();
- mirror::Throwable* exception = soa.Self()->GetException();
- VLOG(compiler) << "Exception during type resolution: " << exception->Dump();
- if (exception->GetClass()->DescriptorEquals("Ljava/lang/OutOfMemoryError;")) {
- // There's little point continuing compilation if the heap is exhausted.
- LOG(FATAL) << "Out of memory during type resolution for compilation";
- }
- soa.Self()->ClearException();
- }
- }
-
- private:
- const ParallelCompilationManager* const manager_;
-};
-
-void CompilerDriver::ResolveDexFile(jobject class_loader,
- const DexFile& dex_file,
- const std::vector<const DexFile*>& dex_files,
- ThreadPool* thread_pool,
- size_t thread_count,
- TimingLogger* timings) {
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-
- // TODO: we could resolve strings here, although the string table is largely filled with class
- // and method names.
-
- ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files,
- thread_pool);
- if (GetCompilerOptions().IsBootImage()) {
- // For images we resolve all types, such as array, whereas for applications just those with
- // classdefs are resolved by ResolveClassFieldsAndMethods.
- TimingLogger::ScopedTiming t("Resolve Types", timings);
- ResolveTypeVisitor visitor(&context);
- context.ForAll(0, dex_file.NumTypeIds(), &visitor, thread_count);
- }
-
- TimingLogger::ScopedTiming t("Resolve MethodsAndFields", timings);
- ResolveClassFieldsAndMethodsVisitor visitor(&context);
- context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count);
-}
-
-void CompilerDriver::SetVerified(jobject class_loader,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings) {
- // This can be run in parallel.
- for (const DexFile* dex_file : dex_files) {
- CHECK(dex_file != nullptr);
- SetVerifiedDexFile(class_loader,
- *dex_file,
- dex_files,
- parallel_thread_pool_.get(),
- parallel_thread_count_,
- timings);
- }
-}
-
-static void LoadAndUpdateStatus(const ClassAccessor& accessor,
- ClassStatus status,
- Handle<mirror::ClassLoader> class_loader,
- Thread* self)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- StackHandleScope<1> hs(self);
- const char* descriptor = accessor.GetDescriptor();
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Handle<mirror::Class> cls(hs.NewHandle<mirror::Class>(
- class_linker->FindClass(self, descriptor, class_loader)));
- if (cls != nullptr) {
- // Check that the class is resolved with the current dex file. We might get
- // a boot image class, or a class in a different dex file for multidex, and
- // we should not update the status in that case.
- if (&cls->GetDexFile() == &accessor.GetDexFile()) {
- ObjectLock<mirror::Class> lock(self, cls);
- mirror::Class::SetStatus(cls, status, self);
- if (status >= ClassStatus::kVerified) {
- cls->SetVerificationAttempted();
- }
- }
- } else {
- DCHECK(self->IsExceptionPending());
- self->ClearException();
- }
-}
-
-bool CompilerDriver::FastVerify(jobject jclass_loader,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings,
- /*out*/ VerificationResults* verification_results) {
- verifier::VerifierDeps* verifier_deps =
- Runtime::Current()->GetCompilerCallbacks()->GetVerifierDeps();
- // If there exist VerifierDeps that aren't the ones we just created to output, use them to verify.
- if (verifier_deps == nullptr || verifier_deps->OutputOnly()) {
- return false;
- }
- TimingLogger::ScopedTiming t("Fast Verify", timings);
-
- ScopedObjectAccess soa(Thread::Current());
- StackHandleScope<2> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
- std::string error_msg;
-
- if (!verifier_deps->ValidateDependencies(
- soa.Self(),
- class_loader,
- // This returns classpath dex files in no particular order but VerifierDeps
- // does not care about the order.
- classpath_classes_.GetDexFiles(),
- &error_msg)) {
- LOG(WARNING) << "Fast verification failed: " << error_msg;
- return false;
- }
-
- bool compiler_only_verifies = !GetCompilerOptions().IsAnyCompilationEnabled();
-
- // We successfully validated the dependencies, now update class status
- // of verified classes. Note that the dependencies also record which classes
- // could not be fully verified; we could try again, but that would hurt verification
- // time. So instead we assume these classes still need to be verified at
- // runtime.
- for (const DexFile* dex_file : dex_files) {
- // Fetch the list of verified classes.
- const std::vector<bool>& verified_classes = verifier_deps->GetVerifiedClasses(*dex_file);
- DCHECK_EQ(verified_classes.size(), dex_file->NumClassDefs());
- for (ClassAccessor accessor : dex_file->GetClasses()) {
- if (verified_classes[accessor.GetClassDefIndex()]) {
- if (compiler_only_verifies) {
- // Just update the compiled_classes_ map. The compiler doesn't need to resolve
- // the type.
- ClassReference ref(dex_file, accessor.GetClassDefIndex());
- const ClassStatus existing = ClassStatus::kNotReady;
- ClassStateTable::InsertResult result =
- compiled_classes_.Insert(ref, existing, ClassStatus::kVerified);
- CHECK_EQ(result, ClassStateTable::kInsertResultSuccess) << ref.dex_file->GetLocation();
- } else {
- // Update the class status, so later compilation stages know they don't need to verify
- // the class.
- LoadAndUpdateStatus(accessor, ClassStatus::kVerified, class_loader, soa.Self());
- // Create `VerifiedMethod`s for each methods, the compiler expects one for
- // quickening or compiling.
- // Note that this means:
- // - We're only going to compile methods that did verify.
- // - Quickening will not do checkcast ellision.
- // TODO(ngeoffray): Reconsider this once we refactor compiler filters.
- for (const ClassAccessor::Method& method : accessor.GetMethods()) {
- verification_results->CreateVerifiedMethodFor(method.GetReference());
- }
- }
- } else if (!compiler_only_verifies) {
- // Make sure later compilation stages know they should not try to verify
- // this class again.
- LoadAndUpdateStatus(accessor,
- ClassStatus::kRetryVerificationAtRuntime,
- class_loader,
- soa.Self());
- }
- }
- }
- return true;
-}
-
-void CompilerDriver::Verify(jobject jclass_loader,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings,
- /*out*/ VerificationResults* verification_results) {
- if (FastVerify(jclass_loader, dex_files, timings, verification_results)) {
- return;
- }
-
- // If there is no existing `verifier_deps` (because of non-existing vdex), or
- // the existing `verifier_deps` is not valid anymore, create a new one for
- // non boot image compilation. The verifier will need it to record the new dependencies.
- // Then dex2oat can update the vdex file with these new dependencies.
- if (!GetCompilerOptions().IsBootImage()) {
- // Dex2oat creates the verifier deps.
- // Create the main VerifierDeps, and set it to this thread.
- verifier::VerifierDeps* verifier_deps =
- Runtime::Current()->GetCompilerCallbacks()->GetVerifierDeps();
- CHECK(verifier_deps != nullptr);
- Thread::Current()->SetVerifierDeps(verifier_deps);
- // Create per-thread VerifierDeps to avoid contention on the main one.
- // We will merge them after verification.
- for (ThreadPoolWorker* worker : parallel_thread_pool_->GetWorkers()) {
- worker->GetThread()->SetVerifierDeps(
- new verifier::VerifierDeps(GetCompilerOptions().GetDexFilesForOatFile()));
- }
- }
-
- // Verification updates VerifierDeps and needs to run single-threaded to be deterministic.
- bool force_determinism = GetCompilerOptions().IsForceDeterminism();
- ThreadPool* verify_thread_pool =
- force_determinism ? single_thread_pool_.get() : parallel_thread_pool_.get();
- size_t verify_thread_count = force_determinism ? 1U : parallel_thread_count_;
- for (const DexFile* dex_file : dex_files) {
- CHECK(dex_file != nullptr);
- VerifyDexFile(jclass_loader,
- *dex_file,
- dex_files,
- verify_thread_pool,
- verify_thread_count,
- timings);
- }
-
- if (!GetCompilerOptions().IsBootImage()) {
- // Merge all VerifierDeps into the main one.
- verifier::VerifierDeps* verifier_deps = Thread::Current()->GetVerifierDeps();
- for (ThreadPoolWorker* worker : parallel_thread_pool_->GetWorkers()) {
- std::unique_ptr<verifier::VerifierDeps> thread_deps(worker->GetThread()->GetVerifierDeps());
- worker->GetThread()->SetVerifierDeps(nullptr); // We just took ownership.
- verifier_deps->MergeWith(std::move(thread_deps),
- GetCompilerOptions().GetDexFilesForOatFile());
- }
- Thread::Current()->SetVerifierDeps(nullptr);
- }
-}
-
-class VerifyClassVisitor : public CompilationVisitor {
- public:
- VerifyClassVisitor(const ParallelCompilationManager* manager, verifier::HardFailLogMode log_level)
- : manager_(manager),
- log_level_(log_level),
- sdk_version_(Runtime::Current()->GetTargetSdkVersion()) {}
-
- void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) override {
- ScopedTrace trace(__FUNCTION__);
- ScopedObjectAccess soa(Thread::Current());
- const DexFile& dex_file = *manager_->GetDexFile();
- const dex::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
- const char* descriptor = dex_file.GetClassDescriptor(class_def);
- ClassLinker* class_linker = manager_->GetClassLinker();
- jobject jclass_loader = manager_->GetClassLoader();
- StackHandleScope<3> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
- Handle<mirror::Class> klass(
- hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader)));
- verifier::FailureKind failure_kind;
- if (klass == nullptr) {
- CHECK(soa.Self()->IsExceptionPending());
- soa.Self()->ClearException();
-
- /*
- * At compile time, we can still structurally verify the class even if FindClass fails.
- * This is to ensure the class is structurally sound for compilation. An unsound class
- * will be rejected by the verifier and later skipped during compilation in the compiler.
- */
- Handle<mirror::DexCache> dex_cache(hs.NewHandle(class_linker->FindDexCache(
- soa.Self(), dex_file)));
- std::string error_msg;
- failure_kind =
- verifier::MethodVerifier::VerifyClass(soa.Self(),
- &dex_file,
- dex_cache,
- class_loader,
- class_def,
- Runtime::Current()->GetCompilerCallbacks(),
- true /* allow soft failures */,
- log_level_,
- sdk_version_,
- &error_msg);
- if (failure_kind == verifier::FailureKind::kHardFailure) {
- LOG(ERROR) << "Verification failed on class " << PrettyDescriptor(descriptor)
- << " because: " << error_msg;
- manager_->GetCompiler()->SetHadHardVerifierFailure();
- } else if (failure_kind == verifier::FailureKind::kSoftFailure) {
- manager_->GetCompiler()->AddSoftVerifierFailure();
- } else {
- // Force a soft failure for the VerifierDeps. This is a sanity measure, as
- // the vdex file already records that the class hasn't been resolved. It avoids
- // trying to do future verification optimizations when processing the vdex file.
- DCHECK(failure_kind == verifier::FailureKind::kNoFailure) << failure_kind;
- failure_kind = verifier::FailureKind::kSoftFailure;
- }
- } else if (&klass->GetDexFile() != &dex_file) {
- // Skip a duplicate class (as the resolved class is from another, earlier dex file).
- // Record the information that we skipped this class in the vdex.
- // If the class resolved to a dex file not covered by the vdex, e.g. boot class path,
- // it is considered external, dependencies on it will be recorded and the vdex will
- // remain usable regardless of whether the class remains redefined or not (in the
- // latter case, this class will be verify-at-runtime).
- // On the other hand, if the class resolved to a dex file covered by the vdex, i.e.
- // a different dex file within the same APK, this class will always be eclipsed by it.
- // Recording that it was redefined is not necessary but will save class resolution
- // time during fast-verify.
- verifier::VerifierDeps::MaybeRecordClassRedefinition(dex_file, class_def);
- return; // Do not update state.
- } else if (!SkipClass(jclass_loader, dex_file, klass.Get())) {
- CHECK(klass->IsResolved()) << klass->PrettyClass();
- failure_kind = class_linker->VerifyClass(soa.Self(), klass, log_level_);
-
- if (klass->IsErroneous()) {
- // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
- CHECK(soa.Self()->IsExceptionPending());
- soa.Self()->ClearException();
- manager_->GetCompiler()->SetHadHardVerifierFailure();
- } else if (failure_kind == verifier::FailureKind::kSoftFailure) {
- manager_->GetCompiler()->AddSoftVerifierFailure();
- }
-
- CHECK(klass->ShouldVerifyAtRuntime() || klass->IsVerified() || klass->IsErroneous())
- << klass->PrettyDescriptor() << ": state=" << klass->GetStatus();
-
- // Class has a meaningful status for the compiler now, record it.
- ClassReference ref(manager_->GetDexFile(), class_def_index);
- manager_->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
-
- // It is *very* problematic if there are resolution errors in the boot classpath.
- //
- // It is also bad if classes fail verification. For example, we rely on things working
- // OK without verification when the decryption dialog is brought up. It is thus highly
- // recommended to compile the boot classpath with
- // --abort-on-hard-verifier-error --abort-on-soft-verifier-error
- // which is the default build system configuration.
- if (kIsDebugBuild) {
- if (manager_->GetCompiler()->GetCompilerOptions().IsBootImage()) {
- if (!klass->IsResolved() || klass->IsErroneous()) {
- LOG(FATAL) << "Boot classpath class " << klass->PrettyClass()
- << " failed to resolve/is erroneous: state= " << klass->GetStatus();
- UNREACHABLE();
- }
- }
- if (klass->IsVerified()) {
- DCHECK_EQ(failure_kind, verifier::FailureKind::kNoFailure);
- } else if (klass->ShouldVerifyAtRuntime()) {
- DCHECK_EQ(failure_kind, verifier::FailureKind::kSoftFailure);
- } else {
- DCHECK_EQ(failure_kind, verifier::FailureKind::kHardFailure);
- }
- }
- } else {
- // Make the skip a soft failure, essentially being considered as verify at runtime.
- failure_kind = verifier::FailureKind::kSoftFailure;
- }
- verifier::VerifierDeps::MaybeRecordVerificationStatus(dex_file, class_def, failure_kind);
- soa.Self()->AssertNoPendingException();
- }
-
- private:
- const ParallelCompilationManager* const manager_;
- const verifier::HardFailLogMode log_level_;
- const uint32_t sdk_version_;
-};
-
-void CompilerDriver::VerifyDexFile(jobject class_loader,
- const DexFile& dex_file,
- const std::vector<const DexFile*>& dex_files,
- ThreadPool* thread_pool,
- size_t thread_count,
- TimingLogger* timings) {
- TimingLogger::ScopedTiming t("Verify Dex File", timings);
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files,
- thread_pool);
- bool abort_on_verifier_failures = GetCompilerOptions().AbortOnHardVerifierFailure()
- || GetCompilerOptions().AbortOnSoftVerifierFailure();
- verifier::HardFailLogMode log_level = abort_on_verifier_failures
- ? verifier::HardFailLogMode::kLogInternalFatal
- : verifier::HardFailLogMode::kLogWarning;
- VerifyClassVisitor visitor(&context, log_level);
- context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count);
-}
-
-class SetVerifiedClassVisitor : public CompilationVisitor {
- public:
- explicit SetVerifiedClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {}
-
- void Visit(size_t class_def_index) REQUIRES(!Locks::mutator_lock_) override {
- ScopedTrace trace(__FUNCTION__);
- ScopedObjectAccess soa(Thread::Current());
- const DexFile& dex_file = *manager_->GetDexFile();
- const dex::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
- const char* descriptor = dex_file.GetClassDescriptor(class_def);
- ClassLinker* class_linker = manager_->GetClassLinker();
- jobject jclass_loader = manager_->GetClassLoader();
- StackHandleScope<3> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
- Handle<mirror::Class> klass(
- hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor, class_loader)));
- // Class might have failed resolution. Then don't set it to verified.
- if (klass != nullptr) {
- // Only do this if the class is resolved. If even resolution fails, quickening will go very,
- // very wrong.
- if (klass->IsResolved() && !klass->IsErroneousResolved()) {
- if (klass->GetStatus() < ClassStatus::kVerified) {
- ObjectLock<mirror::Class> lock(soa.Self(), klass);
- // Set class status to verified.
- mirror::Class::SetStatus(klass, ClassStatus::kVerified, soa.Self());
- // Mark methods as pre-verified. If we don't do this, the interpreter will run with
- // access checks.
- InstructionSet instruction_set =
- manager_->GetCompiler()->GetCompilerOptions().GetInstructionSet();
- klass->SetSkipAccessChecksFlagOnAllMethods(GetInstructionSetPointerSize(instruction_set));
- klass->SetVerificationAttempted();
- }
- // Record the final class status if necessary.
- ClassReference ref(manager_->GetDexFile(), class_def_index);
- manager_->GetCompiler()->RecordClassStatus(ref, klass->GetStatus());
- }
- } else {
- Thread* self = soa.Self();
- DCHECK(self->IsExceptionPending());
- self->ClearException();
- }
- }
-
- private:
- const ParallelCompilationManager* const manager_;
-};
-
-void CompilerDriver::SetVerifiedDexFile(jobject class_loader,
- const DexFile& dex_file,
- const std::vector<const DexFile*>& dex_files,
- ThreadPool* thread_pool,
- size_t thread_count,
- TimingLogger* timings) {
- TimingLogger::ScopedTiming t("Verify Dex File", timings);
- if (!compiled_classes_.HaveDexFile(&dex_file)) {
- compiled_classes_.AddDexFile(&dex_file);
- }
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- ParallelCompilationManager context(class_linker, class_loader, this, &dex_file, dex_files,
- thread_pool);
- SetVerifiedClassVisitor visitor(&context);
- context.ForAll(0, dex_file.NumClassDefs(), &visitor, thread_count);
-}
-
-class InitializeClassVisitor : public CompilationVisitor {
- public:
- explicit InitializeClassVisitor(const ParallelCompilationManager* manager) : manager_(manager) {}
-
- void Visit(size_t class_def_index) override {
- ScopedTrace trace(__FUNCTION__);
- jobject jclass_loader = manager_->GetClassLoader();
- const DexFile& dex_file = *manager_->GetDexFile();
- const dex::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
- const dex::TypeId& class_type_id = dex_file.GetTypeId(class_def.class_idx_);
- const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_);
-
- ScopedObjectAccess soa(Thread::Current());
- StackHandleScope<3> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
- Handle<mirror::Class> klass(
- hs.NewHandle(manager_->GetClassLinker()->FindClass(soa.Self(), descriptor, class_loader)));
-
- if (klass != nullptr) {
- if (!SkipClass(manager_->GetClassLoader(), dex_file, klass.Get())) {
- TryInitializeClass(klass, class_loader);
- }
- manager_->GetCompiler()->stats_->AddClassStatus(klass->GetStatus());
- }
- // Clear any class not found or verification exceptions.
- soa.Self()->ClearException();
- }
-
- // A helper function for initializing klass.
- void TryInitializeClass(Handle<mirror::Class> klass, Handle<mirror::ClassLoader>& class_loader)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile& dex_file = klass->GetDexFile();
- const dex::ClassDef* class_def = klass->GetClassDef();
- const dex::TypeId& class_type_id = dex_file.GetTypeId(class_def->class_idx_);
- const char* descriptor = dex_file.StringDataByIdx(class_type_id.descriptor_idx_);
- ScopedObjectAccessUnchecked soa(Thread::Current());
- StackHandleScope<3> hs(soa.Self());
- const bool is_boot_image = manager_->GetCompiler()->GetCompilerOptions().IsBootImage();
- const bool is_app_image = manager_->GetCompiler()->GetCompilerOptions().IsAppImage();
-
- ClassStatus old_status = klass->GetStatus();
- // Don't initialize classes in boot space when compiling app image
- if (is_app_image && klass->IsBootStrapClassLoaded()) {
- // Also return early and don't store the class status in the recorded class status.
- return;
- }
- // Only try to initialize classes that were successfully verified.
- if (klass->IsVerified()) {
- // Attempt to initialize the class but bail if we either need to initialize the super-class
- // or static fields.
- manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, false, false);
- old_status = klass->GetStatus();
- if (!klass->IsInitialized()) {
- // We don't want non-trivial class initialization occurring on multiple threads due to
- // deadlock problems. For example, a parent class is initialized (holding its lock) that
- // refers to a sub-class in its static/class initializer causing it to try to acquire the
- // sub-class' lock. While on a second thread the sub-class is initialized (holding its lock)
- // after first initializing its parents, whose locks are acquired. This leads to a
- // parent-to-child and a child-to-parent lock ordering and consequent potential deadlock.
- // We need to use an ObjectLock due to potential suspension in the interpreting code. Rather
- // than use a special Object for the purpose we use the Class of java.lang.Class.
- Handle<mirror::Class> h_klass(hs.NewHandle(klass->GetClass()));
- ObjectLock<mirror::Class> lock(soa.Self(), h_klass);
- // Attempt to initialize allowing initialization of parent classes but still not static
- // fields.
- // Initialize dependencies first only for app image, to make TryInitialize recursive.
- bool is_superclass_initialized = !is_app_image ? true :
- InitializeDependencies(klass, class_loader, soa.Self());
- if (!is_app_image || (is_app_image && is_superclass_initialized)) {
- manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, false, true);
- }
- // Otherwise it's in app image but superclasses can't be initialized, no need to proceed.
- old_status = klass->GetStatus();
-
- bool too_many_encoded_fields = !is_boot_image &&
- klass->NumStaticFields() > kMaxEncodedFields;
-
- // If the class was not initialized, we can proceed to see if we can initialize static
- // fields. Limit the max number of encoded fields.
- if (!klass->IsInitialized() &&
- (is_app_image || is_boot_image) &&
- is_superclass_initialized &&
- !too_many_encoded_fields &&
- manager_->GetCompiler()->GetCompilerOptions().IsImageClass(descriptor)) {
- bool can_init_static_fields = false;
- if (is_boot_image) {
- // We need to initialize static fields, we only do this for image classes that aren't
- // marked with the $NoPreloadHolder (which implies this should not be initialized
- // early).
- can_init_static_fields = !EndsWith(std::string_view(descriptor), "$NoPreloadHolder;");
- } else {
- CHECK(is_app_image);
- // The boot image case doesn't need to recursively initialize the dependencies with
- // special logic since the class linker already does this.
- can_init_static_fields =
- ClassLinker::kAppImageMayContainStrings &&
- !soa.Self()->IsExceptionPending() &&
- is_superclass_initialized &&
- NoClinitInDependency(klass, soa.Self(), &class_loader);
- // TODO The checking for clinit can be removed since it's already
- // checked when init superclass. Currently keep it because it contains
- // processing of intern strings. Will be removed later when intern strings
- // and clinit are both initialized.
- }
-
- if (can_init_static_fields) {
- VLOG(compiler) << "Initializing: " << descriptor;
- // TODO multithreading support. We should ensure the current compilation thread has
- // exclusive access to the runtime and the transaction. To achieve this, we could use
- // a ReaderWriterMutex but we're holding the mutator lock so we fail mutex sanity
- // checks in Thread::AssertThreadSuspensionIsAllowable.
- Runtime* const runtime = Runtime::Current();
- // Run the class initializer in transaction mode.
- runtime->EnterTransactionMode(is_app_image, klass.Get());
- bool success = manager_->GetClassLinker()->EnsureInitialized(soa.Self(), klass, true,
- true);
- // TODO we detach transaction from runtime to indicate we quit the transactional
- // mode which prevents the GC from visiting objects modified during the transaction.
- // Ensure GC is not run so don't access freed objects when aborting transaction.
-
- {
- ScopedAssertNoThreadSuspension ants("Transaction end");
-
- if (success) {
- runtime->ExitTransactionMode();
- DCHECK(!runtime->IsActiveTransaction());
-
- if (is_boot_image) {
- // For boot image, we want to put the updated status in the oat class since we
- // can't reject the image anyways.
- old_status = klass->GetStatus();
- }
- } else {
- CHECK(soa.Self()->IsExceptionPending());
- mirror::Throwable* exception = soa.Self()->GetException();
- VLOG(compiler) << "Initialization of " << descriptor << " aborted because of "
- << exception->Dump();
- std::ostream* file_log = manager_->GetCompiler()->
- GetCompilerOptions().GetInitFailureOutput();
- if (file_log != nullptr) {
- *file_log << descriptor << "\n";
- *file_log << exception->Dump() << "\n";
- }
- soa.Self()->ClearException();
- runtime->RollbackAllTransactions();
- CHECK_EQ(old_status, klass->GetStatus()) << "Previous class status not restored";
- }
- }
-
- if (!success) {
- // On failure, still intern strings of static fields and seen in <clinit>, as these
- // will be created in the zygote. This is separated from the transaction code just
- // above as we will allocate strings, so must be allowed to suspend.
- if (&klass->GetDexFile() == manager_->GetDexFile()) {
- InternStrings(klass, class_loader);
- } else {
- DCHECK(!is_boot_image) << "Boot image must have equal dex files";
- }
- }
- }
- }
- // If the class still isn't initialized, at least try some checks that initialization
- // would do so they can be skipped at runtime.
- if (!klass->IsInitialized() &&
- manager_->GetClassLinker()->ValidateSuperClassDescriptors(klass)) {
- old_status = ClassStatus::kSuperclassValidated;
- } else {
- soa.Self()->ClearException();
- }
- soa.Self()->AssertNoPendingException();
- }
- }
- // Record the final class status if necessary.
- ClassReference ref(&dex_file, klass->GetDexClassDefIndex());
- // Back up the status before doing initialization for static encoded fields,
- // because the static encoded branch wants to keep the status to uninitialized.
- manager_->GetCompiler()->RecordClassStatus(ref, old_status);
- }
-
- private:
- void InternStrings(Handle<mirror::Class> klass, Handle<mirror::ClassLoader> class_loader)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- DCHECK(manager_->GetCompiler()->GetCompilerOptions().IsBootImage());
- DCHECK(klass->IsVerified());
- DCHECK(!klass->IsInitialized());
-
- StackHandleScope<1> hs(Thread::Current());
- Handle<mirror::DexCache> dex_cache = hs.NewHandle(klass->GetDexCache());
- const dex::ClassDef* class_def = klass->GetClassDef();
- ClassLinker* class_linker = manager_->GetClassLinker();
-
- // Check encoded final field values for strings and intern.
- annotations::RuntimeEncodedStaticFieldValueIterator value_it(dex_cache,
- class_loader,
- manager_->GetClassLinker(),
- *class_def);
- for ( ; value_it.HasNext(); value_it.Next()) {
- if (value_it.GetValueType() == annotations::RuntimeEncodedStaticFieldValueIterator::kString) {
- // Resolve the string. This will intern the string.
- art::ObjPtr<mirror::String> resolved = class_linker->ResolveString(
- dex::StringIndex(value_it.GetJavaValue().i), dex_cache);
- CHECK(resolved != nullptr);
- }
- }
-
- // Intern strings seen in <clinit>.
- ArtMethod* clinit = klass->FindClassInitializer(class_linker->GetImagePointerSize());
- if (clinit != nullptr) {
- for (const DexInstructionPcPair& inst : clinit->DexInstructions()) {
- if (inst->Opcode() == Instruction::CONST_STRING) {
- ObjPtr<mirror::String> s = class_linker->ResolveString(
- dex::StringIndex(inst->VRegB_21c()), dex_cache);
- CHECK(s != nullptr);
- } else if (inst->Opcode() == Instruction::CONST_STRING_JUMBO) {
- ObjPtr<mirror::String> s = class_linker->ResolveString(
- dex::StringIndex(inst->VRegB_31c()), dex_cache);
- CHECK(s != nullptr);
- }
- }
- }
- }
-
- bool ResolveTypesOfMethods(Thread* self, ArtMethod* m)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- // Return value of ResolveReturnType() is discarded because resolve will be done internally.
- ObjPtr<mirror::Class> rtn_type = m->ResolveReturnType();
- if (rtn_type == nullptr) {
- self->ClearException();
- return false;
- }
- const dex::TypeList* types = m->GetParameterTypeList();
- if (types != nullptr) {
- for (uint32_t i = 0; i < types->Size(); ++i) {
- dex::TypeIndex param_type_idx = types->GetTypeItem(i).type_idx_;
- ObjPtr<mirror::Class> param_type = m->ResolveClassFromTypeIndex(param_type_idx);
- if (param_type == nullptr) {
- self->ClearException();
- return false;
- }
- }
- }
- return true;
- }
-
- // Pre resolve types mentioned in all method signatures before start a transaction
- // since ResolveType doesn't work in transaction mode.
- bool PreResolveTypes(Thread* self, const Handle<mirror::Class>& klass)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- PointerSize pointer_size = manager_->GetClassLinker()->GetImagePointerSize();
- for (ArtMethod& m : klass->GetMethods(pointer_size)) {
- if (!ResolveTypesOfMethods(self, &m)) {
- return false;
- }
- }
- if (klass->IsInterface()) {
- return true;
- } else if (klass->HasSuperClass()) {
- StackHandleScope<1> hs(self);
- MutableHandle<mirror::Class> super_klass(hs.NewHandle<mirror::Class>(klass->GetSuperClass()));
- for (int i = super_klass->GetVTableLength() - 1; i >= 0; --i) {
- ArtMethod* m = klass->GetVTableEntry(i, pointer_size);
- ArtMethod* super_m = super_klass->GetVTableEntry(i, pointer_size);
- if (!ResolveTypesOfMethods(self, m) || !ResolveTypesOfMethods(self, super_m)) {
- return false;
- }
- }
- for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
- super_klass.Assign(klass->GetIfTable()->GetInterface(i));
- if (klass->GetClassLoader() != super_klass->GetClassLoader()) {
- uint32_t num_methods = super_klass->NumVirtualMethods();
- for (uint32_t j = 0; j < num_methods; ++j) {
- ArtMethod* m = klass->GetIfTable()->GetMethodArray(i)->GetElementPtrSize<ArtMethod*>(
- j, pointer_size);
- ArtMethod* super_m = super_klass->GetVirtualMethod(j, pointer_size);
- if (!ResolveTypesOfMethods(self, m) || !ResolveTypesOfMethods(self, super_m)) {
- return false;
- }
- }
- }
- }
- }
- return true;
- }
-
- // Initialize the klass's dependencies recursively before initializing itself.
- // Checking for interfaces is also necessary since interfaces can contain
- // both default methods and static encoded fields.
- bool InitializeDependencies(const Handle<mirror::Class>& klass,
- Handle<mirror::ClassLoader> class_loader,
- Thread* self)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- if (klass->HasSuperClass()) {
- ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
- StackHandleScope<1> hs(self);
- Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class));
- if (!handle_scope_super->IsInitialized()) {
- this->TryInitializeClass(handle_scope_super, class_loader);
- if (!handle_scope_super->IsInitialized()) {
- return false;
- }
- }
- }
-
- uint32_t num_if = klass->NumDirectInterfaces();
- for (size_t i = 0; i < num_if; i++) {
- ObjPtr<mirror::Class>
- interface = mirror::Class::GetDirectInterface(self, klass.Get(), i);
- StackHandleScope<1> hs(self);
- Handle<mirror::Class> handle_interface(hs.NewHandle(interface));
-
- TryInitializeClass(handle_interface, class_loader);
-
- if (!handle_interface->IsInitialized()) {
- return false;
- }
- }
-
- return PreResolveTypes(self, klass);
- }
-
- // In this phase the classes containing class initializers are ignored. Make sure no
- // clinit appears in kalss's super class chain and interfaces.
- bool NoClinitInDependency(const Handle<mirror::Class>& klass,
- Thread* self,
- Handle<mirror::ClassLoader>* class_loader)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- ArtMethod* clinit =
- klass->FindClassInitializer(manager_->GetClassLinker()->GetImagePointerSize());
- if (clinit != nullptr) {
- VLOG(compiler) << klass->PrettyClass() << ' ' << clinit->PrettyMethod(true);
- return false;
- }
- if (klass->HasSuperClass()) {
- ObjPtr<mirror::Class> super_class = klass->GetSuperClass();
- StackHandleScope<1> hs(self);
- Handle<mirror::Class> handle_scope_super(hs.NewHandle(super_class));
- if (!NoClinitInDependency(handle_scope_super, self, class_loader)) {
- return false;
- }
- }
-
- uint32_t num_if = klass->NumDirectInterfaces();
- for (size_t i = 0; i < num_if; i++) {
- ObjPtr<mirror::Class>
- interface = mirror::Class::GetDirectInterface(self, klass.Get(), i);
- StackHandleScope<1> hs(self);
- Handle<mirror::Class> handle_interface(hs.NewHandle(interface));
- if (!NoClinitInDependency(handle_interface, self, class_loader)) {
- return false;
- }
- }
-
- return true;
- }
-
- const ParallelCompilationManager* const manager_;
-};
-
-void CompilerDriver::InitializeClasses(jobject jni_class_loader,
- const DexFile& dex_file,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings) {
- TimingLogger::ScopedTiming t("InitializeNoClinit", timings);
-
- // Initialization allocates objects and needs to run single-threaded to be deterministic.
- bool force_determinism = GetCompilerOptions().IsForceDeterminism();
- ThreadPool* init_thread_pool = force_determinism
- ? single_thread_pool_.get()
- : parallel_thread_pool_.get();
- size_t init_thread_count = force_determinism ? 1U : parallel_thread_count_;
-
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- ParallelCompilationManager context(class_linker, jni_class_loader, this, &dex_file, dex_files,
- init_thread_pool);
-
- if (GetCompilerOptions().IsBootImage() || GetCompilerOptions().IsAppImage()) {
- // Set the concurrency thread to 1 to support initialization for App Images since transaction
- // doesn't support multithreading now.
- // TODO: remove this when transactional mode supports multithreading.
- init_thread_count = 1U;
- }
- InitializeClassVisitor visitor(&context);
- context.ForAll(0, dex_file.NumClassDefs(), &visitor, init_thread_count);
-}
-
-class InitializeArrayClassesAndCreateConflictTablesVisitor : public ClassVisitor {
- public:
- explicit InitializeArrayClassesAndCreateConflictTablesVisitor(VariableSizedHandleScope& hs)
- : hs_(hs) {}
-
- bool operator()(ObjPtr<mirror::Class> klass) override
- REQUIRES_SHARED(Locks::mutator_lock_) {
- if (Runtime::Current()->GetHeap()->ObjectIsInBootImageSpace(klass)) {
- return true;
- }
- if (klass->IsArrayClass()) {
- StackHandleScope<1> hs(Thread::Current());
- auto h_klass = hs.NewHandleWrapper(&klass);
- Runtime::Current()->GetClassLinker()->EnsureInitialized(hs.Self(), h_klass, true, true);
- }
- // Collect handles since there may be thread suspension in future EnsureInitialized.
- to_visit_.push_back(hs_.NewHandle(klass));
- return true;
- }
-
- void FillAllIMTAndConflictTables() REQUIRES_SHARED(Locks::mutator_lock_) {
- for (Handle<mirror::Class> c : to_visit_) {
- // Create the conflict tables.
- FillIMTAndConflictTables(c.Get());
- }
- }
-
- private:
- void FillIMTAndConflictTables(ObjPtr<mirror::Class> klass)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- if (!klass->ShouldHaveImt()) {
- return;
- }
- if (visited_classes_.find(klass) != visited_classes_.end()) {
- return;
- }
- if (klass->HasSuperClass()) {
- FillIMTAndConflictTables(klass->GetSuperClass());
- }
- if (!klass->IsTemp()) {
- Runtime::Current()->GetClassLinker()->FillIMTAndConflictTables(klass);
- }
- visited_classes_.insert(klass);
- }
-
- VariableSizedHandleScope& hs_;
- std::vector<Handle<mirror::Class>> to_visit_;
- std::unordered_set<ObjPtr<mirror::Class>, HashObjPtr> visited_classes_;
-};
-
-void CompilerDriver::InitializeClasses(jobject class_loader,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings) {
- for (size_t i = 0; i != dex_files.size(); ++i) {
- const DexFile* dex_file = dex_files[i];
- CHECK(dex_file != nullptr);
- InitializeClasses(class_loader, *dex_file, dex_files, timings);
- }
- if (GetCompilerOptions().IsBootImage() || GetCompilerOptions().IsAppImage()) {
- // Make sure that we call EnsureIntiailized on all the array classes to call
- // SetVerificationAttempted so that the access flags are set. If we do not do this they get
- // changed at runtime resulting in more dirty image pages.
- // Also create conflict tables.
- // Only useful if we are compiling an image.
- ScopedObjectAccess soa(Thread::Current());
- VariableSizedHandleScope hs(soa.Self());
- InitializeArrayClassesAndCreateConflictTablesVisitor visitor(hs);
- Runtime::Current()->GetClassLinker()->VisitClassesWithoutClassesLock(&visitor);
- visitor.FillAllIMTAndConflictTables();
- }
- if (GetCompilerOptions().IsBootImage()) {
- // Prune garbage objects created during aborted transactions.
- Runtime::Current()->GetHeap()->CollectGarbage(/* clear_soft_references= */ true);
- }
-}
-
-template <typename CompileFn>
-static void CompileDexFile(CompilerDriver* driver,
- jobject class_loader,
- const DexFile& dex_file,
- const std::vector<const DexFile*>& dex_files,
- ThreadPool* thread_pool,
- size_t thread_count,
- TimingLogger* timings,
- const char* timing_name,
- CompileFn compile_fn) {
- TimingLogger::ScopedTiming t(timing_name, timings);
- ParallelCompilationManager context(Runtime::Current()->GetClassLinker(),
- class_loader,
- driver,
- &dex_file,
- dex_files,
- thread_pool);
-
- auto compile = [&context, &compile_fn](size_t class_def_index) {
- const DexFile& dex_file = *context.GetDexFile();
- SCOPED_TRACE << "compile " << dex_file.GetLocation() << "@" << class_def_index;
- ClassLinker* class_linker = context.GetClassLinker();
- jobject jclass_loader = context.GetClassLoader();
- ClassReference ref(&dex_file, class_def_index);
- const dex::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
- ClassAccessor accessor(dex_file, class_def_index);
- CompilerDriver* const driver = context.GetCompiler();
- // Skip compiling classes with generic verifier failures since they will still fail at runtime
- if (driver->GetCompilerOptions().GetVerificationResults()->IsClassRejected(ref)) {
- return;
- }
- // Use a scoped object access to perform to the quick SkipClass check.
- ScopedObjectAccess soa(Thread::Current());
- StackHandleScope<3> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader)));
- Handle<mirror::Class> klass(
- hs.NewHandle(class_linker->FindClass(soa.Self(), accessor.GetDescriptor(), class_loader)));
- Handle<mirror::DexCache> dex_cache;
- if (klass == nullptr) {
- soa.Self()->AssertPendingException();
- soa.Self()->ClearException();
- dex_cache = hs.NewHandle(class_linker->FindDexCache(soa.Self(), dex_file));
- } else if (SkipClass(jclass_loader, dex_file, klass.Get())) {
- return;
- } else if (&klass->GetDexFile() != &dex_file) {
- // Skip a duplicate class (as the resolved class is from another, earlier dex file).
- return; // Do not update state.
- } else {
- dex_cache = hs.NewHandle(klass->GetDexCache());
- }
-
- // Avoid suspension if there are no methods to compile.
- if (accessor.NumDirectMethods() + accessor.NumVirtualMethods() == 0) {
- return;
- }
-
- // Go to native so that we don't block GC during compilation.
- ScopedThreadSuspension sts(soa.Self(), kNative);
-
- // Can we run DEX-to-DEX compiler on this class ?
- optimizer::DexToDexCompiler::CompilationLevel dex_to_dex_compilation_level =
- GetDexToDexCompilationLevel(soa.Self(), *driver, jclass_loader, dex_file, class_def);
-
- // Compile direct and virtual methods.
- int64_t previous_method_idx = -1;
- for (const ClassAccessor::Method& method : accessor.GetMethods()) {
- const uint32_t method_idx = method.GetIndex();
- if (method_idx == previous_method_idx) {
- // smali can create dex files with two encoded_methods sharing the same method_idx
- // http://code.google.com/p/smali/issues/detail?id=119
- continue;
- }
- previous_method_idx = method_idx;
- compile_fn(soa.Self(),
- driver,
- method.GetCodeItem(),
- method.GetAccessFlags(),
- method.GetInvokeType(class_def.access_flags_),
- class_def_index,
- method_idx,
- class_loader,
- dex_file,
- dex_to_dex_compilation_level,
- dex_cache);
- }
- };
- context.ForAllLambda(0, dex_file.NumClassDefs(), compile, thread_count);
-}
-
-void CompilerDriver::Compile(jobject class_loader,
- const std::vector<const DexFile*>& dex_files,
- TimingLogger* timings) {
- if (kDebugProfileGuidedCompilation) {
- const ProfileCompilationInfo* profile_compilation_info =
- GetCompilerOptions().GetProfileCompilationInfo();
- LOG(INFO) << "[ProfileGuidedCompilation] " <<
- ((profile_compilation_info == nullptr)
- ? "null"
- : profile_compilation_info->DumpInfo(dex_files));
- }
-
- dex_to_dex_compiler_.ClearState();
- for (const DexFile* dex_file : dex_files) {
- CHECK(dex_file != nullptr);
- CompileDexFile(this,
- class_loader,
- *dex_file,
- dex_files,
- parallel_thread_pool_.get(),
- parallel_thread_count_,
- timings,
- "Compile Dex File Quick",
- CompileMethodQuick);
- const ArenaPool* const arena_pool = Runtime::Current()->GetArenaPool();
- const size_t arena_alloc = arena_pool->GetBytesAllocated();
- max_arena_alloc_ = std::max(arena_alloc, max_arena_alloc_);
- Runtime::Current()->ReclaimArenaPoolMemory();
- }
-
- if (dex_to_dex_compiler_.NumCodeItemsToQuicken(Thread::Current()) > 0u) {
- // TODO: Not visit all of the dex files, its probably rare that only one would have quickened
- // methods though.
- for (const DexFile* dex_file : dex_files) {
- CompileDexFile(this,
- class_loader,
- *dex_file,
- dex_files,
- parallel_thread_pool_.get(),
- parallel_thread_count_,
- timings,
- "Compile Dex File Dex2Dex",
- CompileMethodDex2Dex);
- }
- dex_to_dex_compiler_.ClearState();
- }
-
- VLOG(compiler) << "Compile: " << GetMemoryUsageString(false);
-}
-
-void CompilerDriver::AddCompiledMethod(const MethodReference& method_ref,
- CompiledMethod* const compiled_method) {
- DCHECK(GetCompiledMethod(method_ref) == nullptr) << method_ref.PrettyMethod();
- MethodTable::InsertResult result = compiled_methods_.Insert(method_ref,
- /*expected*/ nullptr,
- compiled_method);
- CHECK(result == MethodTable::kInsertResultSuccess);
- DCHECK(GetCompiledMethod(method_ref) != nullptr) << method_ref.PrettyMethod();
-}
-
-CompiledMethod* CompilerDriver::RemoveCompiledMethod(const MethodReference& method_ref) {
- CompiledMethod* ret = nullptr;
- CHECK(compiled_methods_.Remove(method_ref, &ret));
- return ret;
-}
-
-bool CompilerDriver::GetCompiledClass(const ClassReference& ref, ClassStatus* status) const {
- DCHECK(status != nullptr);
- // The table doesn't know if something wasn't inserted. For this case it will return
- // ClassStatus::kNotReady. To handle this, just assume anything we didn't try to verify
- // is not compiled.
- if (!compiled_classes_.Get(ref, status) ||
- *status < ClassStatus::kRetryVerificationAtRuntime) {
- return false;
- }
- return true;
-}
-
-ClassStatus CompilerDriver::GetClassStatus(const ClassReference& ref) const {
- ClassStatus status = ClassStatus::kNotReady;
- if (!GetCompiledClass(ref, &status)) {
- classpath_classes_.Get(ref, &status);
- }
- return status;
-}
-
-void CompilerDriver::RecordClassStatus(const ClassReference& ref, ClassStatus status) {
- switch (status) {
- case ClassStatus::kErrorResolved:
- case ClassStatus::kErrorUnresolved:
- case ClassStatus::kNotReady:
- case ClassStatus::kResolved:
- case ClassStatus::kRetryVerificationAtRuntime:
- case ClassStatus::kVerified:
- case ClassStatus::kSuperclassValidated:
- case ClassStatus::kInitialized:
- break; // Expected states.
- default:
- LOG(FATAL) << "Unexpected class status for class "
- << PrettyDescriptor(
- ref.dex_file->GetClassDescriptor(ref.dex_file->GetClassDef(ref.index)))
- << " of " << status;
- }
-
- ClassStateTable::InsertResult result;
- ClassStateTable* table = &compiled_classes_;
- do {
- ClassStatus existing = ClassStatus::kNotReady;
- if (!table->Get(ref, &existing)) {
- // A classpath class.
- if (kIsDebugBuild) {
- // Check to make sure it's not a dex file for an oat file we are compiling since these
- // should always succeed. These do not include classes in for used libraries.
- for (const DexFile* dex_file : GetCompilerOptions().GetDexFilesForOatFile()) {
- CHECK_NE(ref.dex_file, dex_file) << ref.dex_file->GetLocation();
- }
- }
- if (!classpath_classes_.HaveDexFile(ref.dex_file)) {
- // Boot classpath dex file.
- return;
- }
- table = &classpath_classes_;
- table->Get(ref, &existing);
- }
- if (existing >= status) {
- // Existing status is already better than we expect, break.
- break;
- }
- // Update the status if we now have a greater one. This happens with vdex,
- // which records a class is verified, but does not resolve it.
- result = table->Insert(ref, existing, status);
- CHECK(result != ClassStateTable::kInsertResultInvalidDexFile) << ref.dex_file->GetLocation();
- } while (result != ClassStateTable::kInsertResultSuccess);
-}
-
-CompiledMethod* CompilerDriver::GetCompiledMethod(MethodReference ref) const {
- CompiledMethod* compiled_method = nullptr;
- compiled_methods_.Get(ref, &compiled_method);
- return compiled_method;
-}
-
-std::string CompilerDriver::GetMemoryUsageString(bool extended) const {
- std::ostringstream oss;
- const gc::Heap* const heap = Runtime::Current()->GetHeap();
- const size_t java_alloc = heap->GetBytesAllocated();
- oss << "arena alloc=" << PrettySize(max_arena_alloc_) << " (" << max_arena_alloc_ << "B)";
- oss << " java alloc=" << PrettySize(java_alloc) << " (" << java_alloc << "B)";
-#if defined(__BIONIC__) || defined(__GLIBC__)
- const struct mallinfo info = mallinfo();
- const size_t allocated_space = static_cast<size_t>(info.uordblks);
- const size_t free_space = static_cast<size_t>(info.fordblks);
- oss << " native alloc=" << PrettySize(allocated_space) << " (" << allocated_space << "B)"
- << " free=" << PrettySize(free_space) << " (" << free_space << "B)";
-#endif
- compiled_method_storage_.DumpMemoryUsage(oss, extended);
- return oss.str();
-}
-
-void CompilerDriver::InitializeThreadPools() {
- size_t parallel_count = parallel_thread_count_ > 0 ? parallel_thread_count_ - 1 : 0;
- parallel_thread_pool_.reset(
- new ThreadPool("Compiler driver thread pool", parallel_count));
- single_thread_pool_.reset(new ThreadPool("Single-threaded Compiler driver thread pool", 0));
-}
-
-void CompilerDriver::FreeThreadPools() {
- parallel_thread_pool_.reset();
- single_thread_pool_.reset();
-}
-
-void CompilerDriver::SetClasspathDexFiles(const std::vector<const DexFile*>& dex_files) {
- classpath_classes_.AddDexFiles(dex_files);
-}
-
-} // namespace art
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2025-10-21 01:11:35 +0000