Move compiler code out of method verifier.
We want to detect small methods for inlining at the end of
the method verification. Instead of adding more compiler
code to the runtime, we create a callback from the runtime
into the compiler, so that we can keep the code there.
Additionally, we move the compiler-related code that was
already in the method verifier to the compiler since it
doesn't really belong to the runtime in the first place.
Change-Id: I708ca13227c809e07917ff3879a89722017e83a9
diff --git a/compiler/Android.mk b/compiler/Android.mk
index a2419d5..d9a573f 100644
--- a/compiler/Android.mk
+++ b/compiler/Android.mk
@@ -57,6 +57,7 @@
dex/frontend.cc \
dex/mir_graph.cc \
dex/mir_analysis.cc \
+ dex/verified_methods_data.cc \
dex/vreg_analysis.cc \
dex/ssa_transformation.cc \
driver/compiler_driver.cc \
diff --git a/compiler/dex/quick/codegen_util.cc b/compiler/dex/quick/codegen_util.cc
index 5d78ed5..bae8ff3 100644
--- a/compiler/dex/quick/codegen_util.cc
+++ b/compiler/dex/quick/codegen_util.cc
@@ -19,6 +19,7 @@
#include "gc_map.h"
#include "mapping_table.h"
#include "mir_to_lir-inl.h"
+#include "dex/verified_methods_data.h"
#include "verifier/dex_gc_map.h"
#include "verifier/method_verifier.h"
@@ -746,7 +747,8 @@
}
}
MethodReference method_ref(cu_->dex_file, cu_->method_idx);
- const std::vector<uint8_t>* gc_map_raw = verifier::MethodVerifier::GetDexGcMap(method_ref);
+ const std::vector<uint8_t>* gc_map_raw =
+ cu_->compiler_driver->GetVerifiedMethodsData()->GetDexGcMap(method_ref);
verifier::DexPcToReferenceMap dex_gc_map(&(*gc_map_raw)[0]);
DCHECK_EQ(gc_map_raw->size(), dex_gc_map.RawSize());
// Compute native offset to references size.
diff --git a/compiler/dex/verified_methods_data.cc b/compiler/dex/verified_methods_data.cc
new file mode 100644
index 0000000..454b92c
--- /dev/null
+++ b/compiler/dex/verified_methods_data.cc
@@ -0,0 +1,451 @@
+/*
+ * Copyright (C) 2013 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 "base/stl_util.h"
+#include "dex_file.h"
+#include "dex_instruction.h"
+#include "dex_instruction-inl.h"
+#include "base/mutex.h"
+#include "base/mutex-inl.h"
+#include "mirror/art_method.h"
+#include "mirror/art_method-inl.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/dex_cache.h"
+#include "mirror/dex_cache-inl.h"
+#include "mirror/object.h"
+#include "mirror/object-inl.h"
+#include "verified_methods_data.h"
+#include "verifier/dex_gc_map.h"
+#include "verifier/method_verifier.h"
+#include "verifier/method_verifier-inl.h"
+#include "verifier/register_line.h"
+#include "verifier/register_line-inl.h"
+
+namespace art {
+
+VerifiedMethodsData::VerifiedMethodsData()
+ : dex_gc_maps_lock_("compiler GC maps lock"),
+ dex_gc_maps_(),
+ safecast_map_lock_("compiler Cast Elision lock"),
+ safecast_map_(),
+ devirt_maps_lock_("compiler Devirtualization lock"),
+ devirt_maps_(),
+ rejected_classes_lock_("compiler rejected classes lock"),
+ rejected_classes_() {
+}
+
+VerifiedMethodsData::~VerifiedMethodsData() {
+ Thread* self = Thread::Current();
+ {
+ WriterMutexLock mu(self, dex_gc_maps_lock_);
+ STLDeleteValues(&dex_gc_maps_);
+ }
+ {
+ WriterMutexLock mu(self, safecast_map_lock_);
+ STLDeleteValues(&safecast_map_);
+ }
+ {
+ WriterMutexLock mu(self, devirt_maps_lock_);
+ STLDeleteValues(&devirt_maps_);
+ }
+}
+
+bool VerifiedMethodsData::ProcessVerifiedMethod(verifier::MethodVerifier* method_verifier) {
+ MethodReference ref = method_verifier->GetMethodReference();
+ bool compile = IsCandidateForCompilation(ref, method_verifier->GetAccessFlags());
+ if (compile) {
+ /* Generate a register map and add it to the method. */
+ const std::vector<uint8_t>* dex_gc_map = GenerateGcMap(method_verifier);
+ if (dex_gc_map == NULL) {
+ DCHECK(method_verifier->HasFailures());
+ return false; // Not a real failure, but a failure to encode
+ }
+ if (kIsDebugBuild) {
+ VerifyGcMap(method_verifier, *dex_gc_map);
+ }
+ SetDexGcMap(ref, dex_gc_map);
+ }
+
+ if (method_verifier->HasCheckCasts()) {
+ MethodSafeCastSet* method_to_safe_casts = GenerateSafeCastSet(method_verifier);
+ if (method_to_safe_casts != NULL) {
+ SetSafeCastMap(ref, method_to_safe_casts);
+ }
+ }
+
+ if (method_verifier->HasVirtualOrInterfaceInvokes()) {
+ PcToConcreteMethodMap* pc_to_concrete_method = GenerateDevirtMap(method_verifier);
+ if (pc_to_concrete_method != NULL) {
+ SetDevirtMap(ref, pc_to_concrete_method);
+ }
+ }
+ return true;
+}
+
+const std::vector<uint8_t>* VerifiedMethodsData::GetDexGcMap(MethodReference ref) {
+ ReaderMutexLock mu(Thread::Current(), dex_gc_maps_lock_);
+ DexGcMapTable::const_iterator it = dex_gc_maps_.find(ref);
+ CHECK(it != dex_gc_maps_.end())
+ << "Didn't find GC map for: " << PrettyMethod(ref.dex_method_index, *ref.dex_file);
+ CHECK(it->second != NULL);
+ return it->second;
+}
+
+const MethodReference* VerifiedMethodsData::GetDevirtMap(const MethodReference& ref,
+ uint32_t dex_pc) {
+ ReaderMutexLock mu(Thread::Current(), devirt_maps_lock_);
+ DevirtualizationMapTable::const_iterator it = devirt_maps_.find(ref);
+ if (it == devirt_maps_.end()) {
+ return NULL;
+ }
+
+ // Look up the PC in the map, get the concrete method to execute and return its reference.
+ PcToConcreteMethodMap::const_iterator pc_to_concrete_method = it->second->find(dex_pc);
+ if (pc_to_concrete_method != it->second->end()) {
+ return &(pc_to_concrete_method->second);
+ } else {
+ return NULL;
+ }
+}
+
+bool VerifiedMethodsData::IsSafeCast(MethodReference ref, uint32_t pc) {
+ ReaderMutexLock mu(Thread::Current(), safecast_map_lock_);
+ SafeCastMap::const_iterator it = safecast_map_.find(ref);
+ if (it == safecast_map_.end()) {
+ return false;
+ }
+
+ // Look up the cast address in the set of safe casts
+ MethodSafeCastSet::const_iterator cast_it = it->second->find(pc);
+ return cast_it != it->second->end();
+}
+
+void VerifiedMethodsData::AddRejectedClass(ClassReference ref) {
+ {
+ WriterMutexLock mu(Thread::Current(), rejected_classes_lock_);
+ rejected_classes_.insert(ref);
+ }
+ DCHECK(IsClassRejected(ref));
+}
+
+bool VerifiedMethodsData::IsClassRejected(ClassReference ref) {
+ ReaderMutexLock mu(Thread::Current(), rejected_classes_lock_);
+ return (rejected_classes_.find(ref) != rejected_classes_.end());
+}
+
+bool VerifiedMethodsData::IsCandidateForCompilation(MethodReference& method_ref,
+ const uint32_t access_flags) {
+#ifdef ART_SEA_IR_MODE
+ bool use_sea = Runtime::Current()->IsSeaIRMode();
+ use_sea = use_sea && (std::string::npos != PrettyMethod(
+ method_ref.dex_method_index, *(method_ref.dex_file)).find("fibonacci"));
+ if (use_sea) return true;
+#endif
+ // Don't compile class initializers, ever.
+ if (((access_flags & kAccConstructor) != 0) && ((access_flags & kAccStatic) != 0)) {
+ return false;
+ }
+ return (Runtime::Current()->GetCompilerFilter() != Runtime::kInterpretOnly);
+}
+
+const std::vector<uint8_t>* VerifiedMethodsData::GenerateGcMap(
+ verifier::MethodVerifier* method_verifier) {
+ size_t num_entries, ref_bitmap_bits, pc_bits;
+ ComputeGcMapSizes(method_verifier, &num_entries, &ref_bitmap_bits, &pc_bits);
+ // There's a single byte to encode the size of each bitmap
+ if (ref_bitmap_bits >= (8 /* bits per byte */ * 8192 /* 13-bit size */ )) {
+ // TODO: either a better GC map format or per method failures
+ method_verifier->Fail(verifier::VERIFY_ERROR_BAD_CLASS_HARD)
+ << "Cannot encode GC map for method with " << ref_bitmap_bits << " registers";
+ return NULL;
+ }
+ size_t ref_bitmap_bytes = (ref_bitmap_bits + 7) / 8;
+ // There are 2 bytes to encode the number of entries
+ if (num_entries >= 65536) {
+ // TODO: either a better GC map format or per method failures
+ method_verifier->Fail(verifier::VERIFY_ERROR_BAD_CLASS_HARD)
+ << "Cannot encode GC map for method with " << num_entries << " entries";
+ return NULL;
+ }
+ size_t pc_bytes;
+ verifier::RegisterMapFormat format;
+ if (pc_bits <= 8) {
+ format = verifier::kRegMapFormatCompact8;
+ pc_bytes = 1;
+ } else if (pc_bits <= 16) {
+ format = verifier::kRegMapFormatCompact16;
+ pc_bytes = 2;
+ } else {
+ // TODO: either a better GC map format or per method failures
+ method_verifier->Fail(verifier::VERIFY_ERROR_BAD_CLASS_HARD)
+ << "Cannot encode GC map for method with "
+ << (1 << pc_bits) << " instructions (number is rounded up to nearest power of 2)";
+ return NULL;
+ }
+ size_t table_size = ((pc_bytes + ref_bitmap_bytes) * num_entries) + 4;
+ std::vector<uint8_t>* table = new std::vector<uint8_t>;
+ if (table == NULL) {
+ method_verifier->Fail(verifier::VERIFY_ERROR_BAD_CLASS_HARD)
+ << "Failed to encode GC map (size=" << table_size << ")";
+ return NULL;
+ }
+ table->reserve(table_size);
+ // Write table header
+ table->push_back(format | ((ref_bitmap_bytes & ~0xFF) >> 5));
+ table->push_back(ref_bitmap_bytes & 0xFF);
+ table->push_back(num_entries & 0xFF);
+ table->push_back((num_entries >> 8) & 0xFF);
+ // Write table data
+ const DexFile::CodeItem* code_item = method_verifier->CodeItem();
+ for (size_t i = 0; i < code_item->insns_size_in_code_units_; i++) {
+ if (method_verifier->GetInstructionFlags(i).IsCompileTimeInfoPoint()) {
+ table->push_back(i & 0xFF);
+ if (pc_bytes == 2) {
+ table->push_back((i >> 8) & 0xFF);
+ }
+ verifier::RegisterLine* line = method_verifier->GetRegLine(i);
+ line->WriteReferenceBitMap(*table, ref_bitmap_bytes);
+ }
+ }
+ DCHECK_EQ(table->size(), table_size);
+ return table;
+}
+
+void VerifiedMethodsData::VerifyGcMap(verifier::MethodVerifier* method_verifier,
+ const std::vector<uint8_t>& data) {
+ // Check that for every GC point there is a map entry, there aren't entries for non-GC points,
+ // that the table data is well formed and all references are marked (or not) in the bitmap
+ verifier::DexPcToReferenceMap map(&data[0]);
+ DCHECK_EQ(data.size(), map.RawSize());
+ size_t map_index = 0;
+ const DexFile::CodeItem* code_item = method_verifier->CodeItem();
+ for (size_t i = 0; i < code_item->insns_size_in_code_units_; i++) {
+ const uint8_t* reg_bitmap = map.FindBitMap(i, false);
+ if (method_verifier->GetInstructionFlags(i).IsCompileTimeInfoPoint()) {
+ CHECK_LT(map_index, map.NumEntries());
+ CHECK_EQ(map.GetDexPc(map_index), i);
+ CHECK_EQ(map.GetBitMap(map_index), reg_bitmap);
+ map_index++;
+ verifier::RegisterLine* line = method_verifier->GetRegLine(i);
+ for (size_t j = 0; j < code_item->registers_size_; j++) {
+ if (line->GetRegisterType(j).IsNonZeroReferenceTypes()) {
+ CHECK_LT(j / 8, map.RegWidth());
+ CHECK_EQ((reg_bitmap[j / 8] >> (j % 8)) & 1, 1);
+ } else if ((j / 8) < map.RegWidth()) {
+ CHECK_EQ((reg_bitmap[j / 8] >> (j % 8)) & 1, 0);
+ } else {
+ // If a register doesn't contain a reference then the bitmap may be shorter than the line
+ }
+ }
+ } else {
+ CHECK(reg_bitmap == NULL);
+ }
+ }
+}
+
+void VerifiedMethodsData::ComputeGcMapSizes(verifier::MethodVerifier* method_verifier,
+ size_t* gc_points, size_t* ref_bitmap_bits,
+ size_t* log2_max_gc_pc) {
+ size_t local_gc_points = 0;
+ size_t max_insn = 0;
+ size_t max_ref_reg = -1;
+ const DexFile::CodeItem* code_item = method_verifier->CodeItem();
+ for (size_t i = 0; i < code_item->insns_size_in_code_units_; i++) {
+ if (method_verifier->GetInstructionFlags(i).IsCompileTimeInfoPoint()) {
+ local_gc_points++;
+ max_insn = i;
+ verifier::RegisterLine* line = method_verifier->GetRegLine(i);
+ max_ref_reg = line->GetMaxNonZeroReferenceReg(max_ref_reg);
+ }
+ }
+ *gc_points = local_gc_points;
+ *ref_bitmap_bits = max_ref_reg + 1; // if max register is 0 we need 1 bit to encode (ie +1)
+ size_t i = 0;
+ while ((1U << i) <= max_insn) {
+ i++;
+ }
+ *log2_max_gc_pc = i;
+}
+
+void VerifiedMethodsData::SetDexGcMap(MethodReference ref, const std::vector<uint8_t>* gc_map) {
+ DCHECK(Runtime::Current()->IsCompiler());
+ {
+ WriterMutexLock mu(Thread::Current(), dex_gc_maps_lock_);
+ DexGcMapTable::iterator it = dex_gc_maps_.find(ref);
+ if (it != dex_gc_maps_.end()) {
+ delete it->second;
+ dex_gc_maps_.erase(it);
+ }
+ dex_gc_maps_.Put(ref, gc_map);
+ }
+ DCHECK(GetDexGcMap(ref) != NULL);
+}
+
+VerifiedMethodsData::MethodSafeCastSet* VerifiedMethodsData::GenerateSafeCastSet(
+ verifier::MethodVerifier* method_verifier) {
+ /*
+ * Walks over the method code and adds any cast instructions in which
+ * the type cast is implicit to a set, which is used in the code generation
+ * to elide these casts.
+ */
+ if (method_verifier->HasFailures()) {
+ return NULL;
+ }
+ UniquePtr<MethodSafeCastSet> mscs;
+ const DexFile::CodeItem* code_item = method_verifier->CodeItem();
+ const Instruction* inst = Instruction::At(code_item->insns_);
+ const Instruction* end = Instruction::At(code_item->insns_ +
+ code_item->insns_size_in_code_units_);
+
+ for (; inst < end; inst = inst->Next()) {
+ Instruction::Code code = inst->Opcode();
+ if ((code == Instruction::CHECK_CAST) || (code == Instruction::APUT_OBJECT)) {
+ uint32_t dex_pc = inst->GetDexPc(code_item->insns_);
+ const verifier::RegisterLine* line = method_verifier->GetRegLine(dex_pc);
+ bool is_safe_cast = false;
+ if (code == Instruction::CHECK_CAST) {
+ const verifier::RegType& reg_type(line->GetRegisterType(inst->VRegA_21c()));
+ const verifier::RegType& cast_type =
+ method_verifier->ResolveCheckedClass(inst->VRegB_21c());
+ is_safe_cast = cast_type.IsStrictlyAssignableFrom(reg_type);
+ } else {
+ const verifier::RegType& array_type(line->GetRegisterType(inst->VRegB_23x()));
+ // We only know its safe to assign to an array if the array type is precise. For example,
+ // an Object[] can have any type of object stored in it, but it may also be assigned a
+ // String[] in which case the stores need to be of Strings.
+ if (array_type.IsPreciseReference()) {
+ const verifier::RegType& value_type(line->GetRegisterType(inst->VRegA_23x()));
+ const verifier::RegType& component_type = method_verifier->GetRegTypeCache()
+ ->GetComponentType(array_type, method_verifier->GetClassLoader());
+ is_safe_cast = component_type.IsStrictlyAssignableFrom(value_type);
+ }
+ }
+ if (is_safe_cast) {
+ if (mscs.get() == nullptr) {
+ mscs.reset(new MethodSafeCastSet());
+ }
+ mscs->insert(dex_pc);
+ }
+ }
+ }
+ return mscs.release();
+}
+
+void VerifiedMethodsData::SetSafeCastMap(MethodReference ref, const MethodSafeCastSet* cast_set) {
+ WriterMutexLock mu(Thread::Current(), safecast_map_lock_);
+ SafeCastMap::iterator it = safecast_map_.find(ref);
+ if (it != safecast_map_.end()) {
+ delete it->second;
+ safecast_map_.erase(it);
+ }
+ safecast_map_.Put(ref, cast_set);
+ DCHECK(safecast_map_.find(ref) != safecast_map_.end());
+}
+
+VerifiedMethodsData::PcToConcreteMethodMap* VerifiedMethodsData::GenerateDevirtMap(
+ verifier::MethodVerifier* method_verifier) {
+ // It is risky to rely on reg_types for sharpening in cases of soft
+ // verification, we might end up sharpening to a wrong implementation. Just abort.
+ if (method_verifier->HasFailures()) {
+ return NULL;
+ }
+
+ UniquePtr<PcToConcreteMethodMap> pc_to_concrete_method_map;
+ const DexFile::CodeItem* code_item = method_verifier->CodeItem();
+ const uint16_t* insns = code_item->insns_;
+ const Instruction* inst = Instruction::At(insns);
+ const Instruction* end = Instruction::At(insns + code_item->insns_size_in_code_units_);
+
+ for (; inst < end; inst = inst->Next()) {
+ bool is_virtual = (inst->Opcode() == Instruction::INVOKE_VIRTUAL) ||
+ (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE);
+ bool is_interface = (inst->Opcode() == Instruction::INVOKE_INTERFACE) ||
+ (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE);
+
+ if (!is_interface && !is_virtual) {
+ continue;
+ }
+ // Get reg type for register holding the reference to the object that will be dispatched upon.
+ uint32_t dex_pc = inst->GetDexPc(insns);
+ verifier::RegisterLine* line = method_verifier->GetRegLine(dex_pc);
+ bool is_range = (inst->Opcode() == Instruction::INVOKE_VIRTUAL_RANGE) ||
+ (inst->Opcode() == Instruction::INVOKE_INTERFACE_RANGE);
+ const verifier::RegType&
+ reg_type(line->GetRegisterType(is_range ? inst->VRegC_3rc() : inst->VRegC_35c()));
+
+ if (!reg_type.HasClass()) {
+ // We will compute devirtualization information only when we know the Class of the reg type.
+ continue;
+ }
+ mirror::Class* reg_class = reg_type.GetClass();
+ if (reg_class->IsInterface()) {
+ // We can't devirtualize when the known type of the register is an interface.
+ continue;
+ }
+ if (reg_class->IsAbstract() && !reg_class->IsArrayClass()) {
+ // We can't devirtualize abstract classes except on arrays of abstract classes.
+ continue;
+ }
+ mirror::ArtMethod* abstract_method = method_verifier->GetDexCache()->GetResolvedMethod(
+ is_range ? inst->VRegB_3rc() : inst->VRegB_35c());
+ if (abstract_method == NULL) {
+ // If the method is not found in the cache this means that it was never found
+ // by ResolveMethodAndCheckAccess() called when verifying invoke_*.
+ continue;
+ }
+ // Find the concrete method.
+ mirror::ArtMethod* concrete_method = NULL;
+ if (is_interface) {
+ concrete_method = reg_type.GetClass()->FindVirtualMethodForInterface(abstract_method);
+ }
+ if (is_virtual) {
+ concrete_method = reg_type.GetClass()->FindVirtualMethodForVirtual(abstract_method);
+ }
+ if (concrete_method == NULL || concrete_method->IsAbstract()) {
+ // In cases where concrete_method is not found, or is abstract, continue to the next invoke.
+ continue;
+ }
+ if (reg_type.IsPreciseReference() || concrete_method->IsFinal() ||
+ concrete_method->GetDeclaringClass()->IsFinal()) {
+ // If we knew exactly the class being dispatched upon, or if the target method cannot be
+ // overridden record the target to be used in the compiler driver.
+ if (pc_to_concrete_method_map.get() == NULL) {
+ pc_to_concrete_method_map.reset(new PcToConcreteMethodMap());
+ }
+ MethodReference concrete_ref(
+ concrete_method->GetDeclaringClass()->GetDexCache()->GetDexFile(),
+ concrete_method->GetDexMethodIndex());
+ pc_to_concrete_method_map->Put(dex_pc, concrete_ref);
+ }
+ }
+ return pc_to_concrete_method_map.release();
+}
+
+void VerifiedMethodsData::SetDevirtMap(MethodReference ref,
+ const PcToConcreteMethodMap* devirt_map) {
+ WriterMutexLock mu(Thread::Current(), devirt_maps_lock_);
+ DevirtualizationMapTable::iterator it = devirt_maps_.find(ref);
+ if (it != devirt_maps_.end()) {
+ delete it->second;
+ devirt_maps_.erase(it);
+ }
+
+ devirt_maps_.Put(ref, devirt_map);
+ DCHECK(devirt_maps_.find(ref) != devirt_maps_.end());
+}
+
+} // namespace art
diff --git a/compiler/dex/verified_methods_data.h b/compiler/dex/verified_methods_data.h
new file mode 100644
index 0000000..8d5058a
--- /dev/null
+++ b/compiler/dex/verified_methods_data.h
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#ifndef ART_COMPILER_DEX_VERIFIED_METHODS_DATA_H_
+#define ART_COMPILER_DEX_VERIFIED_METHODS_DATA_H_
+
+#include <stdint.h>
+#include <set>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/mutex.h"
+#include "class_reference.h"
+#include "method_reference.h"
+#include "safe_map.h"
+
+namespace art {
+
+namespace verifier {
+class MethodVerifier;
+} // namespace verifier
+
+class VerifiedMethodsData {
+ public:
+ VerifiedMethodsData();
+ ~VerifiedMethodsData();
+
+ bool ProcessVerifiedMethod(verifier::MethodVerifier* method_verifier)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
+ LOCKS_EXCLUDED(dex_gc_maps_lock_, devirt_maps_lock_, safecast_map_lock_);
+
+ const std::vector<uint8_t>* GetDexGcMap(MethodReference ref)
+ LOCKS_EXCLUDED(dex_gc_maps_lock_);
+
+ const MethodReference* GetDevirtMap(const MethodReference& ref, uint32_t dex_pc)
+ LOCKS_EXCLUDED(devirt_maps_lock_);
+
+ // Returns true if the cast can statically be verified to be redundant
+ // by using the check-cast elision peephole optimization in the verifier
+ bool IsSafeCast(MethodReference ref, uint32_t pc) LOCKS_EXCLUDED(safecast_map_lock_);
+
+ void AddRejectedClass(ClassReference ref) LOCKS_EXCLUDED(rejected_classes_lock_);
+ bool IsClassRejected(ClassReference ref) LOCKS_EXCLUDED(rejected_classes_lock_);
+
+ static bool IsCandidateForCompilation(MethodReference& method_ref,
+ const uint32_t access_flags);
+
+ private:
+ /*
+ * Generate the GC map for a method that has just been verified (i.e. we're doing this as part of
+ * verification). For type-precise determination we have all the data we need, so we just need to
+ * encode it in some clever fashion.
+ * Returns a pointer to a newly-allocated RegisterMap, or NULL on failure.
+ */
+ const std::vector<uint8_t>* GenerateGcMap(verifier::MethodVerifier* method_verifier);
+
+ // Verify that the GC map associated with method_ is well formed
+ void VerifyGcMap(verifier::MethodVerifier* method_verifier, const std::vector<uint8_t>& data);
+
+ // Compute sizes for GC map data
+ void ComputeGcMapSizes(verifier::MethodVerifier* method_verifier,
+ size_t* gc_points, size_t* ref_bitmap_bits, size_t* log2_max_gc_pc);
+
+ // All the GC maps that the verifier has created
+ typedef SafeMap<const MethodReference, const std::vector<uint8_t>*,
+ MethodReferenceComparator> DexGcMapTable;
+ ReaderWriterMutex dex_gc_maps_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+ DexGcMapTable dex_gc_maps_ GUARDED_BY(dex_gc_maps_lock_);
+ void SetDexGcMap(MethodReference ref, const std::vector<uint8_t>* dex_gc_map)
+ LOCKS_EXCLUDED(dex_gc_maps_lock_);
+
+ // Cast elision types.
+ typedef std::set<uint32_t> MethodSafeCastSet;
+ typedef SafeMap<MethodReference, const MethodSafeCastSet*,
+ MethodReferenceComparator> SafeCastMap;
+ MethodSafeCastSet* GenerateSafeCastSet(verifier::MethodVerifier* method_verifier)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetSafeCastMap(MethodReference ref, const MethodSafeCastSet* mscs)
+ LOCKS_EXCLUDED(safecast_map_lock_);
+ ReaderWriterMutex safecast_map_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+ SafeCastMap safecast_map_ GUARDED_BY(safecast_map_lock_);
+
+ // Devirtualization map.
+ typedef SafeMap<uint32_t, MethodReference> PcToConcreteMethodMap;
+ typedef SafeMap<MethodReference, const PcToConcreteMethodMap*,
+ MethodReferenceComparator> DevirtualizationMapTable;
+ PcToConcreteMethodMap* GenerateDevirtMap(verifier::MethodVerifier* method_verifier)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ ReaderWriterMutex devirt_maps_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+ DevirtualizationMapTable devirt_maps_ GUARDED_BY(devirt_maps_lock_);
+ void SetDevirtMap(MethodReference ref, const PcToConcreteMethodMap* pc_method_map)
+ LOCKS_EXCLUDED(devirt_maps_lock_);
+
+ // Rejected classes
+ typedef std::set<ClassReference> RejectedClassesTable;
+ ReaderWriterMutex rejected_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+ RejectedClassesTable rejected_classes_ GUARDED_BY(rejected_classes_lock_);
+};
+
+} // namespace art
+
+#endif // ART_COMPILER_DEX_VERIFIED_METHODS_DATA_H_
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index af18c05..dbebd26 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -27,6 +27,7 @@
#include "class_linker.h"
#include "dex_compilation_unit.h"
#include "dex_file-inl.h"
+#include "dex/verified_methods_data.h"
#include "jni_internal.h"
#include "object_utils.h"
#include "runtime.h"
@@ -335,11 +336,13 @@
extern "C" void compilerLLVMSetBitcodeFileName(art::CompilerDriver& driver,
std::string const& filename);
-CompilerDriver::CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
+CompilerDriver::CompilerDriver(VerifiedMethodsData* verified_methods_data,
+ CompilerBackend compiler_backend, InstructionSet instruction_set,
InstructionSetFeatures instruction_set_features,
bool image, DescriptorSet* image_classes, size_t thread_count,
bool dump_stats)
- : compiler_backend_(compiler_backend),
+ : verified_methods_data_(verified_methods_data),
+ compiler_backend_(compiler_backend),
instruction_set_(instruction_set),
instruction_set_features_(instruction_set_features),
freezing_constructor_lock_("freezing constructor lock"),
@@ -1253,7 +1256,7 @@
// Did the verifier record a more precise invoke target based on its type information?
const MethodReference caller_method(mUnit->GetDexFile(), mUnit->GetDexMethodIndex());
const MethodReference* devirt_map_target =
- verifier::MethodVerifier::GetDevirtMap(caller_method, dex_pc);
+ verified_methods_data_->GetDevirtMap(caller_method, dex_pc);
if (devirt_map_target != NULL) {
SirtRef<mirror::DexCache> target_dex_cache(soa.Self(), mUnit->GetClassLinker()->FindDexCache(*devirt_map_target->dex_file));
SirtRef<mirror::ClassLoader> class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(mUnit->GetClassLoader()));
@@ -1301,7 +1304,7 @@
}
bool CompilerDriver::IsSafeCast(const MethodReference& mr, uint32_t dex_pc) {
- bool result = verifier::MethodVerifier::IsSafeCast(mr, dex_pc);
+ bool result = verified_methods_data_->IsSafeCast(mr, dex_pc);
if (result) {
stats_->SafeCast();
} else {
@@ -2240,7 +2243,7 @@
}
ClassReference ref(&dex_file, class_def_index);
// Skip compiling classes with generic verifier failures since they will still fail at runtime
- if (verifier::MethodVerifier::IsClassRejected(ref)) {
+ if (manager->GetCompiler()->verified_methods_data_->IsClassRejected(ref)) {
return;
}
const byte* class_data = dex_file.GetClassData(class_def);
@@ -2323,7 +2326,7 @@
} else if ((access_flags & kAccAbstract) != 0) {
} else {
MethodReference method_ref(&dex_file, method_idx);
- bool compile = verifier::MethodVerifier::IsCandidateForCompilation(method_ref, access_flags);
+ bool compile = VerifiedMethodsData::IsCandidateForCompilation(method_ref, access_flags);
if (compile) {
CompilerFn compiler = compiler_;
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index 7e81849..14bfde6 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -43,6 +43,7 @@
class DexCompilationUnit;
class OatWriter;
class TimingLogger;
+class VerifiedMethodsData;
enum CompilerBackend {
kQuick,
@@ -90,7 +91,8 @@
// enabled. "image_classes" lets the compiler know what classes it
// can assume will be in the image, with NULL implying all available
// classes.
- explicit CompilerDriver(CompilerBackend compiler_backend, InstructionSet instruction_set,
+ explicit CompilerDriver(VerifiedMethodsData* verified_methods_data,
+ CompilerBackend compiler_backend, InstructionSet instruction_set,
InstructionSetFeatures instruction_set_features,
bool image, DescriptorSet* image_classes,
size_t thread_count, bool dump_stats);
@@ -105,6 +107,10 @@
void CompileOne(const mirror::ArtMethod* method, TimingLogger& timings)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ VerifiedMethodsData* GetVerifiedMethodsData() const {
+ return verified_methods_data_;
+ }
+
const InstructionSet& GetInstructionSet() const {
return instruction_set_;
}
@@ -390,6 +396,8 @@
std::vector<const PatchInformation*> code_to_patch_;
std::vector<const PatchInformation*> methods_to_patch_;
+ VerifiedMethodsData* verified_methods_data_;
+
CompilerBackend compiler_backend_;
const InstructionSet instruction_set_;
diff --git a/compiler/llvm/compiler_llvm.cc b/compiler/llvm/compiler_llvm.cc
index d59afd4..35d1ecd 100644
--- a/compiler/llvm/compiler_llvm.cc
+++ b/compiler/llvm/compiler_llvm.cc
@@ -20,6 +20,7 @@
#include "base/stl_util.h"
#include "class_linker.h"
#include "compiled_method.h"
+#include "dex/verified_methods_data.h"
#include "driver/compiler_driver.h"
#include "driver/dex_compilation_unit.h"
#include "globals.h"
@@ -155,7 +156,8 @@
MethodReference mref(dex_compilation_unit->GetDexFile(),
dex_compilation_unit->GetDexMethodIndex());
return new CompiledMethod(*compiler_driver_, compiler_driver_->GetInstructionSet(),
- cunit->GetElfObject(), *verifier::MethodVerifier::GetDexGcMap(mref),
+ cunit->GetElfObject(),
+ *compiler_driver_->GetVerifiedMethodsData()->GetDexGcMap(mref),
cunit->GetDexCompilationUnit()->GetSymbol());
}
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index 8382469..199a2b8 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -23,6 +23,7 @@
#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "dex_file-inl.h"
+#include "dex/verified_methods_data.h"
#include "gc/space/space.h"
#include "mirror/art_method-inl.h"
#include "mirror/array.h"
@@ -217,7 +218,7 @@
mirror::Class::Status status;
if (compiled_class != NULL) {
status = compiled_class->GetStatus();
- } else if (verifier::MethodVerifier::IsClassRejected(class_ref)) {
+ } else if (compiler_driver_->GetVerifiedMethodsData()->IsClassRejected(class_ref)) {
status = mirror::Class::kStatusError;
} else {
status = mirror::Class::kStatusNotReady;
@@ -432,7 +433,7 @@
mirror::Class::Status status;
if (compiled_class != NULL) {
status = compiled_class->GetStatus();
- } else if (verifier::MethodVerifier::IsClassRejected(class_ref)) {
+ } else if (compiler_driver_->GetVerifiedMethodsData()->IsClassRejected(class_ref)) {
status = mirror::Class::kStatusError;
} else {
status = mirror::Class::kStatusNotReady;
diff --git a/compiler/sea_ir/frontend.cc b/compiler/sea_ir/frontend.cc
index 3512911..6c779c8 100644
--- a/compiler/sea_ir/frontend.cc
+++ b/compiler/sea_ir/frontend.cc
@@ -59,7 +59,7 @@
std::string llvm_code = llvm_data->GetElf(compiler.GetInstructionSet());
CompiledMethod* compiled_method =
new CompiledMethod(compiler, compiler.GetInstructionSet(), llvm_code,
- *verifier::MethodVerifier::GetDexGcMap(mref), symbol);
+ *compiler.GetVerifiedMethodsData()->GetDexGcMap(mref), symbol);
LOG(INFO) << "Compiled SEA IR method " << PrettyMethod(method_idx, dex_file) << ".";
return compiled_method;
}