summaryrefslogtreecommitdiff
path: root/runtime
diff options
context:
space:
mode:
Diffstat (limited to 'runtime')
-rw-r--r--runtime/arch/stub_test.cc7
-rw-r--r--runtime/art_method.cc1
-rw-r--r--runtime/check_reference_map_visitor.h22
-rw-r--r--runtime/entrypoints/entrypoint_utils.cc26
-rw-r--r--runtime/exception_test.cc258
-rw-r--r--runtime/gc_map.h111
-rw-r--r--runtime/jit/jit_code_cache.cc12
-rw-r--r--runtime/jit/jit_code_cache.h4
-rw-r--r--runtime/oat.h2
-rw-r--r--runtime/oat_file-inl.h50
-rw-r--r--runtime/oat_file.cc1
-rw-r--r--runtime/oat_file.h8
-rw-r--r--runtime/oat_quick_method_header.cc81
-rw-r--r--runtime/oat_quick_method_header.h18
-rw-r--r--runtime/stack.cc93
-rw-r--r--runtime/stack.h9
-rw-r--r--runtime/thread.cc103
-rw-r--r--runtime/vmap_table.h126
18 files changed, 72 insertions, 860 deletions
diff --git a/runtime/arch/stub_test.cc b/runtime/arch/stub_test.cc
index 969a038523..75d9073cfb 100644
--- a/runtime/arch/stub_test.cc
+++ b/runtime/arch/stub_test.cc
@@ -1934,7 +1934,12 @@ TEST_F(StubTest, Fields64) {
TestFields(self, this, Primitive::Type::kPrimLong);
}
-TEST_F(StubTest, IMT) {
+// Disabled, b/27991555 .
+// FIXME: Hacking the entry point to point to art_quick_to_interpreter_bridge is broken.
+// The bridge calls through to GetCalleeSaveMethodCaller() which looks up the pre-header
+// and gets a bogus OatQuickMethodHeader* pointing into our assembly code just before
+// the bridge and uses that to check for inlined frames, crashing in the process.
+TEST_F(StubTest, DISABLED_IMT) {
#if defined(__i386__) || defined(__arm__) || defined(__aarch64__) || defined(__mips__) || \
(defined(__x86_64__) && !defined(__APPLE__))
Thread* self = Thread::Current();
diff --git a/runtime/art_method.cc b/runtime/art_method.cc
index f97ad51568..34d19d151b 100644
--- a/runtime/art_method.cc
+++ b/runtime/art_method.cc
@@ -31,7 +31,6 @@
#include "jit/jit_code_cache.h"
#include "jit/profiling_info.h"
#include "jni_internal.h"
-#include "mapping_table.h"
#include "mirror/abstract_method.h"
#include "mirror/class-inl.h"
#include "mirror/object_array-inl.h"
diff --git a/runtime/check_reference_map_visitor.h b/runtime/check_reference_map_visitor.h
index 7595d14101..0e2f9f2030 100644
--- a/runtime/check_reference_map_visitor.h
+++ b/runtime/check_reference_map_visitor.h
@@ -18,7 +18,6 @@
#define ART_RUNTIME_CHECK_REFERENCE_MAP_VISITOR_H_
#include "art_method-inl.h"
-#include "gc_map.h"
#include "oat_quick_method_header.h"
#include "scoped_thread_state_change.h"
#include "stack_map.h"
@@ -54,11 +53,8 @@ class CheckReferenceMapVisitor : public StackVisitor {
void CheckReferences(int* registers, int number_of_references, uint32_t native_pc_offset)
SHARED_REQUIRES(Locks::mutator_lock_) {
- if (GetCurrentOatQuickMethodHeader()->IsOptimized()) {
- CheckOptimizedMethod(registers, number_of_references, native_pc_offset);
- } else {
- CheckQuickMethod(registers, number_of_references, native_pc_offset);
- }
+ CHECK(GetCurrentOatQuickMethodHeader()->IsOptimized());
+ CheckOptimizedMethod(registers, number_of_references, native_pc_offset);
}
private:
@@ -104,20 +100,6 @@ class CheckReferenceMapVisitor : public StackVisitor {
}
}
}
-
- void CheckQuickMethod(int* registers, int number_of_references, uint32_t native_pc_offset)
- SHARED_REQUIRES(Locks::mutator_lock_) {
- ArtMethod* m = GetMethod();
- NativePcOffsetToReferenceMap map(GetCurrentOatQuickMethodHeader()->GetNativeGcMap());
- const uint8_t* ref_bitmap = map.FindBitMap(native_pc_offset);
- CHECK(ref_bitmap);
- for (int i = 0; i < number_of_references; ++i) {
- int reg = registers[i];
- CHECK(reg < m->GetCodeItem()->registers_size_);
- CHECK((*((ref_bitmap) + reg / 8) >> (reg % 8) ) & 0x01)
- << "Error: Reg @" << i << " is not in GC map";
- }
- }
};
} // namespace art
diff --git a/runtime/entrypoints/entrypoint_utils.cc b/runtime/entrypoints/entrypoint_utils.cc
index e46576e884..197caa1878 100644
--- a/runtime/entrypoints/entrypoint_utils.cc
+++ b/runtime/entrypoints/entrypoint_utils.cc
@@ -272,19 +272,19 @@ ArtMethod* GetCalleeSaveMethodCaller(ArtMethod** sp,
if (LIKELY(caller_pc != reinterpret_cast<uintptr_t>(GetQuickInstrumentationExitPc()))) {
if (outer_method != nullptr) {
const OatQuickMethodHeader* current_code = outer_method->GetOatQuickMethodHeader(caller_pc);
- if (current_code->IsOptimized()) {
- uintptr_t native_pc_offset = current_code->NativeQuickPcOffset(caller_pc);
- CodeInfo code_info = current_code->GetOptimizedCodeInfo();
- CodeInfoEncoding encoding = code_info.ExtractEncoding();
- StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
- DCHECK(stack_map.IsValid());
- if (stack_map.HasInlineInfo(encoding.stack_map_encoding)) {
- InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map, encoding);
- caller = GetResolvedMethod(outer_method,
- inline_info,
- encoding.inline_info_encoding,
- inline_info.GetDepth(encoding.inline_info_encoding) - 1);
- }
+ DCHECK(current_code != nullptr);
+ DCHECK(current_code->IsOptimized());
+ uintptr_t native_pc_offset = current_code->NativeQuickPcOffset(caller_pc);
+ CodeInfo code_info = current_code->GetOptimizedCodeInfo();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
+ DCHECK(stack_map.IsValid());
+ if (stack_map.HasInlineInfo(encoding.stack_map_encoding)) {
+ InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map, encoding);
+ caller = GetResolvedMethod(outer_method,
+ inline_info,
+ encoding.inline_info_encoding,
+ inline_info.GetDepth(encoding.inline_info_encoding) - 1);
}
}
if (kIsDebugBuild && do_caller_check) {
diff --git a/runtime/exception_test.cc b/runtime/exception_test.cc
deleted file mode 100644
index 18ccd082ec..0000000000
--- a/runtime/exception_test.cc
+++ /dev/null
@@ -1,258 +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 <memory>
-
-#include "class_linker.h"
-#include "common_runtime_test.h"
-#include "dex_file.h"
-#include "dex_file-inl.h"
-#include "gtest/gtest.h"
-#include "leb128.h"
-#include "mirror/class-inl.h"
-#include "mirror/object_array-inl.h"
-#include "mirror/object-inl.h"
-#include "mirror/stack_trace_element.h"
-#include "oat_quick_method_header.h"
-#include "runtime.h"
-#include "scoped_thread_state_change.h"
-#include "handle_scope-inl.h"
-#include "thread.h"
-#include "vmap_table.h"
-
-namespace art {
-
-class ExceptionTest : public CommonRuntimeTest {
- protected:
- virtual void SetUp() {
- CommonRuntimeTest::SetUp();
-
- ScopedObjectAccess soa(Thread::Current());
- StackHandleScope<2> hs(soa.Self());
- Handle<mirror::ClassLoader> class_loader(
- hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("ExceptionHandle"))));
- my_klass_ = class_linker_->FindClass(soa.Self(), "LExceptionHandle;", class_loader);
- ASSERT_TRUE(my_klass_ != nullptr);
- Handle<mirror::Class> klass(hs.NewHandle(my_klass_));
- class_linker_->EnsureInitialized(soa.Self(), klass, true, true);
- my_klass_ = klass.Get();
-
- dex_ = my_klass_->GetDexCache()->GetDexFile();
-
- uint32_t code_size = 12;
- for (size_t i = 0 ; i < code_size; i++) {
- fake_code_.push_back(0x70 | i);
- }
-
- fake_mapping_data_.PushBackUnsigned(4); // first element is count
- fake_mapping_data_.PushBackUnsigned(4); // total (non-length) elements
- fake_mapping_data_.PushBackUnsigned(2); // count of pc to dex elements
- // --- pc to dex table
- fake_mapping_data_.PushBackUnsigned(3 - 0); // offset 3
- fake_mapping_data_.PushBackSigned(3 - 0); // maps to dex offset 3
- // --- dex to pc table
- fake_mapping_data_.PushBackUnsigned(3 - 0); // offset 3
- fake_mapping_data_.PushBackSigned(3 - 0); // maps to dex offset 3
-
- fake_vmap_table_data_.PushBackUnsigned(0 + VmapTable::kEntryAdjustment);
-
- fake_gc_map_.push_back(0); // 0 bytes to encode references and native pc offsets.
- fake_gc_map_.push_back(0);
- fake_gc_map_.push_back(0); // 0 entries.
- fake_gc_map_.push_back(0);
-
- const std::vector<uint8_t>& fake_vmap_table_data = fake_vmap_table_data_.GetData();
- const std::vector<uint8_t>& fake_mapping_data = fake_mapping_data_.GetData();
- uint32_t vmap_table_offset = sizeof(OatQuickMethodHeader) + fake_vmap_table_data.size();
- uint32_t mapping_table_offset = vmap_table_offset + fake_mapping_data.size();
- uint32_t gc_map_offset = mapping_table_offset + fake_gc_map_.size();
- OatQuickMethodHeader method_header(mapping_table_offset, vmap_table_offset, gc_map_offset,
- 4 * sizeof(void*), 0u, 0u, code_size);
- fake_header_code_and_maps_.resize(sizeof(method_header));
- memcpy(&fake_header_code_and_maps_[0], &method_header, sizeof(method_header));
- fake_header_code_and_maps_.insert(fake_header_code_and_maps_.begin(),
- fake_vmap_table_data.begin(), fake_vmap_table_data.end());
- fake_header_code_and_maps_.insert(fake_header_code_and_maps_.begin(),
- fake_mapping_data.begin(), fake_mapping_data.end());
- fake_header_code_and_maps_.insert(fake_header_code_and_maps_.begin(),
- fake_gc_map_.begin(), fake_gc_map_.end());
- fake_header_code_and_maps_.insert(fake_header_code_and_maps_.end(),
- fake_code_.begin(), fake_code_.end());
-
- // Align the code.
- const size_t alignment = GetInstructionSetAlignment(kRuntimeISA);
- fake_header_code_and_maps_.reserve(fake_header_code_and_maps_.size() + alignment);
- const void* unaligned_code_ptr =
- fake_header_code_and_maps_.data() + (fake_header_code_and_maps_.size() - code_size);
- size_t offset = dchecked_integral_cast<size_t>(reinterpret_cast<uintptr_t>(unaligned_code_ptr));
- size_t padding = RoundUp(offset, alignment) - offset;
- // Make sure no resizing takes place.
- CHECK_GE(fake_header_code_and_maps_.capacity(), fake_header_code_and_maps_.size() + padding);
- fake_header_code_and_maps_.insert(fake_header_code_and_maps_.begin(), padding, 0);
- const void* code_ptr = reinterpret_cast<const uint8_t*>(unaligned_code_ptr) + padding;
- CHECK_EQ(code_ptr,
- static_cast<const void*>(fake_header_code_and_maps_.data() +
- (fake_header_code_and_maps_.size() - code_size)));
-
- if (kRuntimeISA == kArm) {
- // Check that the Thumb2 adjustment will be a NOP, see EntryPointToCodePointer().
- CHECK_ALIGNED(mapping_table_offset, 2);
- }
-
- method_f_ = my_klass_->FindVirtualMethod("f", "()I", sizeof(void*));
- ASSERT_TRUE(method_f_ != nullptr);
- method_f_->SetEntryPointFromQuickCompiledCode(code_ptr);
-
- method_g_ = my_klass_->FindVirtualMethod("g", "(I)V", sizeof(void*));
- ASSERT_TRUE(method_g_ != nullptr);
- method_g_->SetEntryPointFromQuickCompiledCode(code_ptr);
- }
-
- const DexFile* dex_;
-
- std::vector<uint8_t> fake_code_;
- Leb128EncodingVector<> fake_mapping_data_;
- Leb128EncodingVector<> fake_vmap_table_data_;
- std::vector<uint8_t> fake_gc_map_;
- std::vector<uint8_t> fake_header_code_and_maps_;
-
- ArtMethod* method_f_;
- ArtMethod* method_g_;
-
- private:
- mirror::Class* my_klass_;
-};
-
-TEST_F(ExceptionTest, FindCatchHandler) {
- ScopedObjectAccess soa(Thread::Current());
- const DexFile::CodeItem* code_item = dex_->GetCodeItem(method_f_->GetCodeItemOffset());
-
- ASSERT_TRUE(code_item != nullptr);
-
- ASSERT_EQ(2u, code_item->tries_size_);
- ASSERT_NE(0u, code_item->insns_size_in_code_units_);
-
- const DexFile::TryItem *t0, *t1;
- t0 = dex_->GetTryItems(*code_item, 0);
- t1 = dex_->GetTryItems(*code_item, 1);
- EXPECT_LE(t0->start_addr_, t1->start_addr_);
- {
- CatchHandlerIterator iter(*code_item, 4 /* Dex PC in the first try block */);
- EXPECT_STREQ("Ljava/io/IOException;", dex_->StringByTypeIdx(iter.GetHandlerTypeIndex()));
- ASSERT_TRUE(iter.HasNext());
- iter.Next();
- EXPECT_STREQ("Ljava/lang/Exception;", dex_->StringByTypeIdx(iter.GetHandlerTypeIndex()));
- ASSERT_TRUE(iter.HasNext());
- iter.Next();
- EXPECT_FALSE(iter.HasNext());
- }
- {
- CatchHandlerIterator iter(*code_item, 8 /* Dex PC in the second try block */);
- EXPECT_STREQ("Ljava/io/IOException;", dex_->StringByTypeIdx(iter.GetHandlerTypeIndex()));
- ASSERT_TRUE(iter.HasNext());
- iter.Next();
- EXPECT_FALSE(iter.HasNext());
- }
- {
- CatchHandlerIterator iter(*code_item, 11 /* Dex PC not in any try block */);
- EXPECT_FALSE(iter.HasNext());
- }
-}
-
-TEST_F(ExceptionTest, StackTraceElement) {
- Thread* thread = Thread::Current();
- thread->TransitionFromSuspendedToRunnable();
- bool started = runtime_->Start();
- CHECK(started);
- JNIEnv* env = thread->GetJniEnv();
- ScopedObjectAccess soa(env);
-
- std::vector<uintptr_t> fake_stack;
- Runtime* r = Runtime::Current();
- r->SetInstructionSet(kRuntimeISA);
- ArtMethod* save_method = r->CreateCalleeSaveMethod();
- r->SetCalleeSaveMethod(save_method, Runtime::kSaveAll);
- QuickMethodFrameInfo frame_info = r->GetRuntimeMethodFrameInfo(save_method);
-
- ASSERT_EQ(kStackAlignment, 16U);
- // ASSERT_EQ(sizeof(uintptr_t), sizeof(uint32_t));
-
-
- // Create three fake stack frames with mapping data created in SetUp. We map offset 3 in the
- // code to dex pc 3.
- const uint32_t dex_pc = 3;
-
- // Create the stack frame for the callee save method, expected by the runtime.
- fake_stack.push_back(reinterpret_cast<uintptr_t>(save_method));
- for (size_t i = 0; i < frame_info.FrameSizeInBytes() - 2 * sizeof(uintptr_t);
- i += sizeof(uintptr_t)) {
- fake_stack.push_back(0);
- }
-
- fake_stack.push_back(method_g_->GetOatQuickMethodHeader(0)->ToNativeQuickPc(
- method_g_, dex_pc, /* is_catch_handler */ false)); // return pc
-
- // Create/push fake 16byte stack frame for method g
- fake_stack.push_back(reinterpret_cast<uintptr_t>(method_g_));
- fake_stack.push_back(0);
- fake_stack.push_back(0);
- fake_stack.push_back(method_g_->GetOatQuickMethodHeader(0)->ToNativeQuickPc(
- method_g_, dex_pc, /* is_catch_handler */ false)); // return pc
-
- // Create/push fake 16byte stack frame for method f
- fake_stack.push_back(reinterpret_cast<uintptr_t>(method_f_));
- fake_stack.push_back(0);
- fake_stack.push_back(0);
- fake_stack.push_back(0xEBAD6070); // return pc
-
- // Push Method* of null to terminate the trace
- fake_stack.push_back(0);
-
- // Push null values which will become null incoming arguments.
- fake_stack.push_back(0);
- fake_stack.push_back(0);
- fake_stack.push_back(0);
-
- // Set up thread to appear as if we called out of method_g_ at pc dex 3
- thread->SetTopOfStack(reinterpret_cast<ArtMethod**>(&fake_stack[0]));
-
- jobject internal = thread->CreateInternalStackTrace<false>(soa);
- ASSERT_TRUE(internal != nullptr);
- jobjectArray ste_array = Thread::InternalStackTraceToStackTraceElementArray(soa, internal);
- ASSERT_TRUE(ste_array != nullptr);
- auto* trace_array = soa.Decode<mirror::ObjectArray<mirror::StackTraceElement>*>(ste_array);
-
- ASSERT_TRUE(trace_array != nullptr);
- ASSERT_TRUE(trace_array->Get(0) != nullptr);
- EXPECT_STREQ("ExceptionHandle",
- trace_array->Get(0)->GetDeclaringClass()->ToModifiedUtf8().c_str());
- EXPECT_STREQ("ExceptionHandle.java",
- trace_array->Get(0)->GetFileName()->ToModifiedUtf8().c_str());
- EXPECT_STREQ("g", trace_array->Get(0)->GetMethodName()->ToModifiedUtf8().c_str());
- EXPECT_EQ(37, trace_array->Get(0)->GetLineNumber());
-
- ASSERT_TRUE(trace_array->Get(1) != nullptr);
- EXPECT_STREQ("ExceptionHandle",
- trace_array->Get(1)->GetDeclaringClass()->ToModifiedUtf8().c_str());
- EXPECT_STREQ("ExceptionHandle.java",
- trace_array->Get(1)->GetFileName()->ToModifiedUtf8().c_str());
- EXPECT_STREQ("f", trace_array->Get(1)->GetMethodName()->ToModifiedUtf8().c_str());
- EXPECT_EQ(22, trace_array->Get(1)->GetLineNumber());
-
- thread->SetTopOfStack(nullptr); // Disarm the assertion that no code is running when we detach.
-}
-
-} // namespace art
diff --git a/runtime/gc_map.h b/runtime/gc_map.h
deleted file mode 100644
index b4ccdd6d54..0000000000
--- a/runtime/gc_map.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright (C) 2012 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_RUNTIME_GC_MAP_H_
-#define ART_RUNTIME_GC_MAP_H_
-
-#include <stdint.h>
-
-#include "base/logging.h"
-#include "base/macros.h"
-
-namespace art {
-
-// Lightweight wrapper for native PC offset to reference bit maps.
-class NativePcOffsetToReferenceMap {
- public:
- explicit NativePcOffsetToReferenceMap(const uint8_t* data) : data_(data) {
- CHECK(data_ != nullptr);
- }
-
- // The number of entries in the table.
- size_t NumEntries() const {
- return data_[2] | (data_[3] << 8);
- }
-
- // Return address of bitmap encoding what are live references.
- const uint8_t* GetBitMap(size_t index) const {
- size_t entry_offset = index * EntryWidth();
- return &Table()[entry_offset + NativeOffsetWidth()];
- }
-
- // Get the native PC encoded in the table at the given index.
- uintptr_t GetNativePcOffset(size_t index) const {
- size_t entry_offset = index * EntryWidth();
- uintptr_t result = 0;
- for (size_t i = 0; i < NativeOffsetWidth(); ++i) {
- result |= Table()[entry_offset + i] << (i * 8);
- }
- return result;
- }
-
- // Does the given offset have an entry?
- bool HasEntry(uintptr_t native_pc_offset) {
- for (size_t i = 0; i < NumEntries(); ++i) {
- if (GetNativePcOffset(i) == native_pc_offset) {
- return true;
- }
- }
- return false;
- }
-
- // Finds the bitmap associated with the native pc offset.
- const uint8_t* FindBitMap(uintptr_t native_pc_offset) {
- size_t num_entries = NumEntries();
- size_t index = Hash(native_pc_offset) % num_entries;
- size_t misses = 0;
- while (GetNativePcOffset(index) != native_pc_offset) {
- index = (index + 1) % num_entries;
- misses++;
- DCHECK_LT(misses, num_entries) << "Failed to find offset: " << native_pc_offset;
- }
- return GetBitMap(index);
- }
-
- static uint32_t Hash(uint32_t native_offset) {
- uint32_t hash = native_offset;
- hash ^= (hash >> 20) ^ (hash >> 12);
- hash ^= (hash >> 7) ^ (hash >> 4);
- return hash;
- }
-
- // The number of bytes used to encode registers.
- size_t RegWidth() const {
- return (static_cast<size_t>(data_[0]) | (static_cast<size_t>(data_[1]) << 8)) >> 3;
- }
-
- private:
- // Skip the size information at the beginning of data.
- const uint8_t* Table() const {
- return data_ + 4;
- }
-
- // Number of bytes used to encode a native offset.
- size_t NativeOffsetWidth() const {
- return data_[0] & 7;
- }
-
- // The width of an entry in the table.
- size_t EntryWidth() const {
- return NativeOffsetWidth() + RegWidth();
- }
-
- const uint8_t* const data_; // The header and table data
-};
-
-} // namespace art
-
-#endif // ART_RUNTIME_GC_MAP_H_
diff --git a/runtime/jit/jit_code_cache.cc b/runtime/jit/jit_code_cache.cc
index 53d645ce29..37ff6a5dd6 100644
--- a/runtime/jit/jit_code_cache.cc
+++ b/runtime/jit/jit_code_cache.cc
@@ -195,9 +195,7 @@ class ScopedCodeCacheWrite : ScopedTrace {
uint8_t* JitCodeCache::CommitCode(Thread* self,
ArtMethod* method,
- const uint8_t* mapping_table,
const uint8_t* vmap_table,
- const uint8_t* gc_map,
size_t frame_size_in_bytes,
size_t core_spill_mask,
size_t fp_spill_mask,
@@ -206,9 +204,7 @@ uint8_t* JitCodeCache::CommitCode(Thread* self,
bool osr) {
uint8_t* result = CommitCodeInternal(self,
method,
- mapping_table,
vmap_table,
- gc_map,
frame_size_in_bytes,
core_spill_mask,
fp_spill_mask,
@@ -220,9 +216,7 @@ uint8_t* JitCodeCache::CommitCode(Thread* self,
GarbageCollectCache(self);
result = CommitCodeInternal(self,
method,
- mapping_table,
vmap_table,
- gc_map,
frame_size_in_bytes,
core_spill_mask,
fp_spill_mask,
@@ -254,8 +248,6 @@ void JitCodeCache::FreeCode(const void* code_ptr, ArtMethod* method ATTRIBUTE_UN
// It does nothing if we are not using native debugger.
DeleteJITCodeEntryForAddress(reinterpret_cast<uintptr_t>(code_ptr));
- FreeData(const_cast<uint8_t*>(method_header->GetNativeGcMap()));
- FreeData(const_cast<uint8_t*>(method_header->GetMappingTable()));
// Use the offset directly to prevent sanity check that the method is
// compiled with optimizing.
// TODO(ngeoffray): Clean up.
@@ -314,9 +306,7 @@ void JitCodeCache::ClearGcRootsInInlineCaches(Thread* self) {
uint8_t* JitCodeCache::CommitCodeInternal(Thread* self,
ArtMethod* method,
- const uint8_t* mapping_table,
const uint8_t* vmap_table,
- const uint8_t* gc_map,
size_t frame_size_in_bytes,
size_t core_spill_mask,
size_t fp_spill_mask,
@@ -346,9 +336,7 @@ uint8_t* JitCodeCache::CommitCodeInternal(Thread* self,
std::copy(code, code + code_size, code_ptr);
method_header = OatQuickMethodHeader::FromCodePointer(code_ptr);
new (method_header) OatQuickMethodHeader(
- (mapping_table == nullptr) ? 0 : code_ptr - mapping_table,
(vmap_table == nullptr) ? 0 : code_ptr - vmap_table,
- (gc_map == nullptr) ? 0 : code_ptr - gc_map,
frame_size_in_bytes,
core_spill_mask,
fp_spill_mask,
diff --git a/runtime/jit/jit_code_cache.h b/runtime/jit/jit_code_cache.h
index a54f04faa4..6faa8f15b6 100644
--- a/runtime/jit/jit_code_cache.h
+++ b/runtime/jit/jit_code_cache.h
@@ -91,9 +91,7 @@ class JitCodeCache {
// Allocate and write code and its metadata to the code cache.
uint8_t* CommitCode(Thread* self,
ArtMethod* method,
- const uint8_t* mapping_table,
const uint8_t* vmap_table,
- const uint8_t* gc_map,
size_t frame_size_in_bytes,
size_t core_spill_mask,
size_t fp_spill_mask,
@@ -201,9 +199,7 @@ class JitCodeCache {
// allocation fails. Return null if the allocation fails.
uint8_t* CommitCodeInternal(Thread* self,
ArtMethod* method,
- const uint8_t* mapping_table,
const uint8_t* vmap_table,
- const uint8_t* gc_map,
size_t frame_size_in_bytes,
size_t core_spill_mask,
size_t fp_spill_mask,
diff --git a/runtime/oat.h b/runtime/oat.h
index 469a65f2de..543d99f2ad 100644
--- a/runtime/oat.h
+++ b/runtime/oat.h
@@ -32,7 +32,7 @@ class InstructionSetFeatures;
class PACKED(4) OatHeader {
public:
static constexpr uint8_t kOatMagic[] = { 'o', 'a', 't', '\n' };
- static constexpr uint8_t kOatVersion[] = { '0', '7', '8', '\0' };
+ static constexpr uint8_t kOatVersion[] = { '0', '7', '9', '\0' };
static constexpr const char* kImageLocationKey = "image-location";
static constexpr const char* kDex2OatCmdLineKey = "dex2oat-cmdline";
diff --git a/runtime/oat_file-inl.h b/runtime/oat_file-inl.h
index 7b92120fde..d7d0c4f733 100644
--- a/runtime/oat_file-inl.h
+++ b/runtime/oat_file-inl.h
@@ -71,44 +71,6 @@ inline uint32_t OatFile::OatMethod::GetFpSpillMask() const {
return reinterpret_cast<const OatQuickMethodHeader*>(code)[-1].frame_info_.FpSpillMask();
}
-inline const uint8_t* OatFile::OatMethod::GetGcMap() const {
- const void* code = EntryPointToCodePointer(GetOatPointer<const void*>(code_offset_));
- if (code == nullptr) {
- return nullptr;
- }
- uint32_t offset = reinterpret_cast<const OatQuickMethodHeader*>(code)[-1].gc_map_offset_;
- if (UNLIKELY(offset == 0u)) {
- return nullptr;
- }
- return reinterpret_cast<const uint8_t*>(code) - offset;
-}
-
-inline uint32_t OatFile::OatMethod::GetGcMapOffset() const {
- const uint8_t* gc_map = GetGcMap();
- return static_cast<uint32_t>(gc_map != nullptr ? gc_map - begin_ : 0u);
-}
-
-inline uint32_t OatFile::OatMethod::GetGcMapOffsetOffset() const {
- const OatQuickMethodHeader* method_header = GetOatQuickMethodHeader();
- if (method_header == nullptr) {
- return 0u;
- }
- return reinterpret_cast<const uint8_t*>(&method_header->gc_map_offset_) - begin_;
-}
-
-inline uint32_t OatFile::OatMethod::GetMappingTableOffset() const {
- const uint8_t* mapping_table = GetMappingTable();
- return static_cast<uint32_t>(mapping_table != nullptr ? mapping_table - begin_ : 0u);
-}
-
-inline uint32_t OatFile::OatMethod::GetMappingTableOffsetOffset() const {
- const OatQuickMethodHeader* method_header = GetOatQuickMethodHeader();
- if (method_header == nullptr) {
- return 0u;
- }
- return reinterpret_cast<const uint8_t*>(&method_header->mapping_table_offset_) - begin_;
-}
-
inline uint32_t OatFile::OatMethod::GetVmapTableOffset() const {
const uint8_t* vmap_table = GetVmapTable();
return static_cast<uint32_t>(vmap_table != nullptr ? vmap_table - begin_ : 0u);
@@ -122,18 +84,6 @@ inline uint32_t OatFile::OatMethod::GetVmapTableOffsetOffset() const {
return reinterpret_cast<const uint8_t*>(&method_header->vmap_table_offset_) - begin_;
}
-inline const uint8_t* OatFile::OatMethod::GetMappingTable() const {
- const void* code = EntryPointToCodePointer(GetOatPointer<const void*>(code_offset_));
- if (code == nullptr) {
- return nullptr;
- }
- uint32_t offset = reinterpret_cast<const OatQuickMethodHeader*>(code)[-1].mapping_table_offset_;
- if (UNLIKELY(offset == 0u)) {
- return nullptr;
- }
- return reinterpret_cast<const uint8_t*>(code) - offset;
-}
-
inline const uint8_t* OatFile::OatMethod::GetVmapTable() const {
const void* code = EntryPointToCodePointer(GetOatPointer<const void*>(code_offset_));
if (code == nullptr) {
diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc
index 7c83715ff5..46fc3a3cdc 100644
--- a/runtime/oat_file.cc
+++ b/runtime/oat_file.cc
@@ -50,7 +50,6 @@
#include "type_lookup_table.h"
#include "utils.h"
#include "utils/dex_cache_arrays_layout-inl.h"
-#include "vmap_table.h"
namespace art {
diff --git a/runtime/oat_file.h b/runtime/oat_file.h
index 705ba0d976..11a9d76dad 100644
--- a/runtime/oat_file.h
+++ b/runtime/oat_file.h
@@ -123,18 +123,10 @@ class OatFile {
uint32_t GetCoreSpillMask() const;
uint32_t GetFpSpillMask() const;
- const uint8_t* GetMappingTable() const;
- uint32_t GetMappingTableOffset() const;
- uint32_t GetMappingTableOffsetOffset() const;
-
const uint8_t* GetVmapTable() const;
uint32_t GetVmapTableOffset() const;
uint32_t GetVmapTableOffsetOffset() const;
- const uint8_t* GetGcMap() const;
- uint32_t GetGcMapOffset() const;
- uint32_t GetGcMapOffsetOffset() const;
-
// Create an OatMethod with offsets relative to the given base address
OatMethod(const uint8_t* base, const uint32_t code_offset)
: begin_(base), code_offset_(code_offset) {
diff --git a/runtime/oat_quick_method_header.cc b/runtime/oat_quick_method_header.cc
index 07a112fb7f..0ab2bfe80e 100644
--- a/runtime/oat_quick_method_header.cc
+++ b/runtime/oat_quick_method_header.cc
@@ -17,23 +17,18 @@
#include "oat_quick_method_header.h"
#include "art_method.h"
-#include "mapping_table.h"
#include "scoped_thread_state_change.h"
#include "thread.h"
namespace art {
OatQuickMethodHeader::OatQuickMethodHeader(
- uint32_t mapping_table_offset,
uint32_t vmap_table_offset,
- uint32_t gc_map_offset,
uint32_t frame_size_in_bytes,
uint32_t core_spill_mask,
uint32_t fp_spill_mask,
uint32_t code_size)
- : mapping_table_offset_(mapping_table_offset),
- vmap_table_offset_(vmap_table_offset),
- gc_map_offset_(gc_map_offset),
+ : vmap_table_offset_(vmap_table_offset),
frame_info_(frame_size_in_bytes, core_spill_mask, fp_spill_mask),
code_size_(code_size) {}
@@ -52,28 +47,8 @@ uint32_t OatQuickMethodHeader::ToDexPc(ArtMethod* method,
return stack_map.GetDexPc(encoding.stack_map_encoding);
}
} else {
- MappingTable table(GetMappingTable());
- // NOTE: Special methods (see Mir2Lir::GenSpecialCase()) have an empty mapping
- // but they have no suspend checks and, consequently, we never call ToDexPc() for them.
- if (table.TotalSize() == 0) {
- DCHECK(method->IsNative());
- return DexFile::kDexNoIndex;
- }
-
- // Assume the caller wants a pc-to-dex mapping so check here first.
- typedef MappingTable::PcToDexIterator It;
- for (It cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
- if (cur.NativePcOffset() == sought_offset) {
- return cur.DexPc();
- }
- }
- // Now check dex-to-pc mappings.
- typedef MappingTable::DexToPcIterator It2;
- for (It2 cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
- if (cur.NativePcOffset() == sought_offset) {
- return cur.DexPc();
- }
- }
+ DCHECK(method->IsNative());
+ return DexFile::kDexNoIndex;
}
if (abort_on_failure) {
ScopedObjectAccess soa(Thread::Current());
@@ -91,44 +66,22 @@ uintptr_t OatQuickMethodHeader::ToNativeQuickPc(ArtMethod* method,
bool is_for_catch_handler,
bool abort_on_failure) const {
const void* entry_point = GetEntryPoint();
- if (IsOptimized()) {
- // Optimized code does not have a mapping table. Search for the dex-to-pc
- // mapping in stack maps.
- CodeInfo code_info = GetOptimizedCodeInfo();
- CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ DCHECK(!method->IsNative());
+ DCHECK(IsOptimized());
+ // Search for the dex-to-pc mapping in stack maps.
+ CodeInfo code_info = GetOptimizedCodeInfo();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
- // All stack maps are stored in the same CodeItem section, safepoint stack
- // maps first, then catch stack maps. We use `is_for_catch_handler` to select
- // the order of iteration.
- StackMap stack_map =
- LIKELY(is_for_catch_handler) ? code_info.GetCatchStackMapForDexPc(dex_pc, encoding)
- : code_info.GetStackMapForDexPc(dex_pc, encoding);
- if (stack_map.IsValid()) {
- return reinterpret_cast<uintptr_t>(entry_point) +
- stack_map.GetNativePcOffset(encoding.stack_map_encoding);
- }
- } else {
- MappingTable table(GetMappingTable());
- if (table.TotalSize() == 0) {
- DCHECK_EQ(dex_pc, 0U);
- return 0; // Special no mapping/pc == 0 case
- }
- // Assume the caller wants a dex-to-pc mapping so check here first.
- typedef MappingTable::DexToPcIterator It;
- for (It cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
- if (cur.DexPc() == dex_pc) {
- return reinterpret_cast<uintptr_t>(entry_point) + cur.NativePcOffset();
- }
- }
- // Now check pc-to-dex mappings.
- typedef MappingTable::PcToDexIterator It2;
- for (It2 cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
- if (cur.DexPc() == dex_pc) {
- return reinterpret_cast<uintptr_t>(entry_point) + cur.NativePcOffset();
- }
- }
+ // All stack maps are stored in the same CodeItem section, safepoint stack
+ // maps first, then catch stack maps. We use `is_for_catch_handler` to select
+ // the order of iteration.
+ StackMap stack_map =
+ LIKELY(is_for_catch_handler) ? code_info.GetCatchStackMapForDexPc(dex_pc, encoding)
+ : code_info.GetStackMapForDexPc(dex_pc, encoding);
+ if (stack_map.IsValid()) {
+ return reinterpret_cast<uintptr_t>(entry_point) +
+ stack_map.GetNativePcOffset(encoding.stack_map_encoding);
}
-
if (abort_on_failure) {
ScopedObjectAccess soa(Thread::Current());
LOG(FATAL) << "Failed to find native offset for dex pc 0x" << std::hex << dex_pc
diff --git a/runtime/oat_quick_method_header.h b/runtime/oat_quick_method_header.h
index daabc6ee09..abddc6d7a0 100644
--- a/runtime/oat_quick_method_header.h
+++ b/runtime/oat_quick_method_header.h
@@ -30,9 +30,7 @@ class ArtMethod;
// OatQuickMethodHeader precedes the raw code chunk generated by the compiler.
class PACKED(4) OatQuickMethodHeader {
public:
- OatQuickMethodHeader(uint32_t mapping_table_offset = 0U,
- uint32_t vmap_table_offset = 0U,
- uint32_t gc_map_offset = 0U,
+ OatQuickMethodHeader(uint32_t vmap_table_offset = 0U,
uint32_t frame_size_in_bytes = 0U,
uint32_t core_spill_mask = 0U,
uint32_t fp_spill_mask = 0U,
@@ -60,7 +58,7 @@ class PACKED(4) OatQuickMethodHeader {
}
bool IsOptimized() const {
- return gc_map_offset_ == 0 && vmap_table_offset_ != 0;
+ return code_size_ != 0 && vmap_table_offset_ != 0;
}
const void* GetOptimizedCodeInfoPtr() const {
@@ -81,14 +79,6 @@ class PACKED(4) OatQuickMethodHeader {
return code_size_;
}
- const uint8_t* GetNativeGcMap() const {
- return (gc_map_offset_ == 0) ? nullptr : code_ - gc_map_offset_;
- }
-
- const uint8_t* GetMappingTable() const {
- return (mapping_table_offset_ == 0) ? nullptr : code_ - mapping_table_offset_;
- }
-
const uint8_t* GetVmapTable() const {
CHECK(!IsOptimized()) << "Unimplemented vmap table for optimizing compiler";
return (vmap_table_offset_ == 0) ? nullptr : code_ - vmap_table_offset_;
@@ -135,12 +125,8 @@ class PACKED(4) OatQuickMethodHeader {
uint32_t ToDexPc(ArtMethod* method, const uintptr_t pc, bool abort_on_failure = true) const;
- // The offset in bytes from the start of the mapping table to the end of the header.
- uint32_t mapping_table_offset_;
// The offset in bytes from the start of the vmap table to the end of the header.
uint32_t vmap_table_offset_;
- // The offset in bytes from the start of the gc map to the end of the header.
- uint32_t gc_map_offset_;
// The stack frame information.
QuickMethodFrameInfo frame_info_;
// The code size in bytes.
diff --git a/runtime/stack.cc b/runtime/stack.cc
index c22eb92f54..56ef5aaa90 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -21,7 +21,6 @@
#include "base/hex_dump.h"
#include "entrypoints/entrypoint_utils-inl.h"
#include "entrypoints/runtime_asm_entrypoints.h"
-#include "gc_map.h"
#include "gc/space/image_space.h"
#include "gc/space/space-inl.h"
#include "jit/jit.h"
@@ -36,7 +35,6 @@
#include "thread.h"
#include "thread_list.h"
#include "verify_object-inl.h"
-#include "vmap_table.h"
namespace art {
@@ -215,33 +213,6 @@ size_t StackVisitor::GetNativePcOffset() const {
return GetCurrentOatQuickMethodHeader()->NativeQuickPcOffset(cur_quick_frame_pc_);
}
-bool StackVisitor::IsReferenceVReg(ArtMethod* m, uint16_t vreg) {
- DCHECK_EQ(m, GetMethod());
- // Process register map (which native and runtime methods don't have)
- if (m->IsNative() || m->IsRuntimeMethod() || m->IsProxyMethod()) {
- return false;
- }
- const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
- if (method_header->IsOptimized()) {
- return true; // TODO: Implement.
- }
- const uint8_t* native_gc_map = method_header->GetNativeGcMap();
- CHECK(native_gc_map != nullptr) << PrettyMethod(m);
- const DexFile::CodeItem* code_item = m->GetCodeItem();
- // Can't be null or how would we compile its instructions?
- DCHECK(code_item != nullptr) << PrettyMethod(m);
- NativePcOffsetToReferenceMap map(native_gc_map);
- size_t num_regs = std::min(map.RegWidth() * 8, static_cast<size_t>(code_item->registers_size_));
- const uint8_t* reg_bitmap = nullptr;
- if (num_regs > 0) {
- uintptr_t native_pc_offset = method_header->NativeQuickPcOffset(GetCurrentQuickFramePc());
- reg_bitmap = map.FindBitMap(native_pc_offset);
- DCHECK(reg_bitmap != nullptr);
- }
- // Does this register hold a reference?
- return vreg < num_regs && TestBitmap(vreg, reg_bitmap);
-}
-
bool StackVisitor::GetVRegFromDebuggerShadowFrame(uint16_t vreg,
VRegKind kind,
uint32_t* val) const {
@@ -273,11 +244,8 @@ bool StackVisitor::GetVReg(ArtMethod* m, uint16_t vreg, VRegKind kind, uint32_t*
if (GetVRegFromDebuggerShadowFrame(vreg, kind, val)) {
return true;
}
- if (cur_oat_quick_method_header_->IsOptimized()) {
- return GetVRegFromOptimizedCode(m, vreg, kind, val);
- } else {
- return GetVRegFromQuickCode(m, vreg, kind, val);
- }
+ DCHECK(cur_oat_quick_method_header_->IsOptimized());
+ return GetVRegFromOptimizedCode(m, vreg, kind, val);
} else {
DCHECK(cur_shadow_frame_ != nullptr);
if (kind == kReferenceVReg) {
@@ -290,29 +258,6 @@ bool StackVisitor::GetVReg(ArtMethod* m, uint16_t vreg, VRegKind kind, uint32_t*
}
}
-bool StackVisitor::GetVRegFromQuickCode(ArtMethod* m, uint16_t vreg, VRegKind kind,
- uint32_t* val) const {
- DCHECK_EQ(m, GetMethod());
- const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
- QuickMethodFrameInfo frame_info = method_header->GetFrameInfo();
- const VmapTable vmap_table(method_header->GetVmapTable());
- uint32_t vmap_offset;
- // TODO: IsInContext stops before spotting floating point registers.
- if (vmap_table.IsInContext(vreg, kind, &vmap_offset)) {
- bool is_float = (kind == kFloatVReg) || (kind == kDoubleLoVReg) || (kind == kDoubleHiVReg);
- uint32_t spill_mask = is_float ? frame_info.FpSpillMask() : frame_info.CoreSpillMask();
- uint32_t reg = vmap_table.ComputeRegister(spill_mask, vmap_offset, kind);
- return GetRegisterIfAccessible(reg, kind, val);
- } else {
- const DexFile::CodeItem* code_item = m->GetCodeItem();
- DCHECK(code_item != nullptr) << PrettyMethod(m); // Can't be null or how would we compile
- // its instructions?
- *val = *GetVRegAddrFromQuickCode(cur_quick_frame_, code_item, frame_info.CoreSpillMask(),
- frame_info.FpSpillMask(), frame_info.FrameSizeInBytes(), vreg);
- return true;
- }
-}
-
bool StackVisitor::GetVRegFromOptimizedCode(ArtMethod* m, uint16_t vreg, VRegKind kind,
uint32_t* val) const {
DCHECK_EQ(m, GetMethod());
@@ -432,11 +377,8 @@ bool StackVisitor::GetVRegPair(ArtMethod* m, uint16_t vreg, VRegKind kind_lo,
if (cur_quick_frame_ != nullptr) {
DCHECK(context_ != nullptr); // You can't reliably read registers without a context.
DCHECK(m == GetMethod());
- if (cur_oat_quick_method_header_->IsOptimized()) {
- return GetVRegPairFromOptimizedCode(m, vreg, kind_lo, kind_hi, val);
- } else {
- return GetVRegPairFromQuickCode(m, vreg, kind_lo, kind_hi, val);
- }
+ DCHECK(cur_oat_quick_method_header_->IsOptimized());
+ return GetVRegPairFromOptimizedCode(m, vreg, kind_lo, kind_hi, val);
} else {
DCHECK(cur_shadow_frame_ != nullptr);
*val = cur_shadow_frame_->GetVRegLong(vreg);
@@ -444,33 +386,6 @@ bool StackVisitor::GetVRegPair(ArtMethod* m, uint16_t vreg, VRegKind kind_lo,
}
}
-bool StackVisitor::GetVRegPairFromQuickCode(ArtMethod* m, uint16_t vreg, VRegKind kind_lo,
- VRegKind kind_hi, uint64_t* val) const {
- DCHECK_EQ(m, GetMethod());
- const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
- QuickMethodFrameInfo frame_info = method_header->GetFrameInfo();
- const VmapTable vmap_table(method_header->GetVmapTable());
- uint32_t vmap_offset_lo, vmap_offset_hi;
- // TODO: IsInContext stops before spotting floating point registers.
- if (vmap_table.IsInContext(vreg, kind_lo, &vmap_offset_lo) &&
- vmap_table.IsInContext(vreg + 1, kind_hi, &vmap_offset_hi)) {
- bool is_float = (kind_lo == kDoubleLoVReg);
- uint32_t spill_mask = is_float ? frame_info.FpSpillMask() : frame_info.CoreSpillMask();
- uint32_t reg_lo = vmap_table.ComputeRegister(spill_mask, vmap_offset_lo, kind_lo);
- uint32_t reg_hi = vmap_table.ComputeRegister(spill_mask, vmap_offset_hi, kind_hi);
- return GetRegisterPairIfAccessible(reg_lo, reg_hi, kind_lo, val);
- } else {
- const DexFile::CodeItem* code_item = m->GetCodeItem();
- DCHECK(code_item != nullptr) << PrettyMethod(m); // Can't be null or how would we compile
- // its instructions?
- uint32_t* addr = GetVRegAddrFromQuickCode(
- cur_quick_frame_, code_item, frame_info.CoreSpillMask(),
- frame_info.FpSpillMask(), frame_info.FrameSizeInBytes(), vreg);
- *val = *reinterpret_cast<uint64_t*>(addr);
- return true;
- }
-}
-
bool StackVisitor::GetVRegPairFromOptimizedCode(ArtMethod* m, uint16_t vreg,
VRegKind kind_lo, VRegKind kind_hi,
uint64_t* val) const {
diff --git a/runtime/stack.h b/runtime/stack.h
index 3659560555..51f7d6368b 100644
--- a/runtime/stack.h
+++ b/runtime/stack.h
@@ -634,9 +634,6 @@ class StackVisitor {
bool GetNextMethodAndDexPc(ArtMethod** next_method, uint32_t* next_dex_pc)
SHARED_REQUIRES(Locks::mutator_lock_);
- bool IsReferenceVReg(ArtMethod* m, uint16_t vreg)
- SHARED_REQUIRES(Locks::mutator_lock_);
-
bool GetVReg(ArtMethod* m, uint16_t vreg, VRegKind kind, uint32_t* val) const
SHARED_REQUIRES(Locks::mutator_lock_);
@@ -798,9 +795,6 @@ class StackVisitor {
bool GetVRegFromDebuggerShadowFrame(uint16_t vreg, VRegKind kind, uint32_t* val) const
SHARED_REQUIRES(Locks::mutator_lock_);
- bool GetVRegFromQuickCode(ArtMethod* m, uint16_t vreg, VRegKind kind,
- uint32_t* val) const
- SHARED_REQUIRES(Locks::mutator_lock_);
bool GetVRegFromOptimizedCode(ArtMethod* m, uint16_t vreg, VRegKind kind,
uint32_t* val) const
SHARED_REQUIRES(Locks::mutator_lock_);
@@ -808,9 +802,6 @@ class StackVisitor {
bool GetVRegPairFromDebuggerShadowFrame(uint16_t vreg, VRegKind kind_lo, VRegKind kind_hi,
uint64_t* val) const
SHARED_REQUIRES(Locks::mutator_lock_);
- bool GetVRegPairFromQuickCode(ArtMethod* m, uint16_t vreg, VRegKind kind_lo,
- VRegKind kind_hi, uint64_t* val) const
- SHARED_REQUIRES(Locks::mutator_lock_);
bool GetVRegPairFromOptimizedCode(ArtMethod* m, uint16_t vreg,
VRegKind kind_lo, VRegKind kind_hi,
uint64_t* val) const
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 3ecb04185f..57ccabc09c 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -42,7 +42,6 @@
#include "dex_file-inl.h"
#include "entrypoints/entrypoint_utils.h"
#include "entrypoints/quick/quick_alloc_entrypoints.h"
-#include "gc_map.h"
#include "gc/accounting/card_table-inl.h"
#include "gc/accounting/heap_bitmap-inl.h"
#include "gc/allocator/rosalloc.h"
@@ -72,7 +71,6 @@
#include "utils.h"
#include "verifier/method_verifier.h"
#include "verify_object-inl.h"
-#include "vmap_table.h"
#include "well_known_classes.h"
#include "interpreter/interpreter.h"
@@ -2765,83 +2763,36 @@ class ReferenceMapVisitor : public StackVisitor {
// Process register map (which native and runtime methods don't have)
if (!m->IsNative() && !m->IsRuntimeMethod() && !m->IsProxyMethod()) {
const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
- if (method_header->IsOptimized()) {
- auto* vreg_base = reinterpret_cast<StackReference<mirror::Object>*>(
- reinterpret_cast<uintptr_t>(cur_quick_frame));
- uintptr_t native_pc_offset = method_header->NativeQuickPcOffset(GetCurrentQuickFramePc());
- CodeInfo code_info = method_header->GetOptimizedCodeInfo();
- CodeInfoEncoding encoding = code_info.ExtractEncoding();
- StackMap map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
- DCHECK(map.IsValid());
- // Visit stack entries that hold pointers.
- size_t number_of_bits = map.GetNumberOfStackMaskBits(encoding.stack_map_encoding);
- for (size_t i = 0; i < number_of_bits; ++i) {
- if (map.GetStackMaskBit(encoding.stack_map_encoding, i)) {
- auto* ref_addr = vreg_base + i;
- mirror::Object* ref = ref_addr->AsMirrorPtr();
- if (ref != nullptr) {
- mirror::Object* new_ref = ref;
- visitor_(&new_ref, -1, this);
- if (ref != new_ref) {
- ref_addr->Assign(new_ref);
- }
+ DCHECK(method_header->IsOptimized());
+ auto* vreg_base = reinterpret_cast<StackReference<mirror::Object>*>(
+ reinterpret_cast<uintptr_t>(cur_quick_frame));
+ uintptr_t native_pc_offset = method_header->NativeQuickPcOffset(GetCurrentQuickFramePc());
+ CodeInfo code_info = method_header->GetOptimizedCodeInfo();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ StackMap map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
+ DCHECK(map.IsValid());
+ // Visit stack entries that hold pointers.
+ size_t number_of_bits = map.GetNumberOfStackMaskBits(encoding.stack_map_encoding);
+ for (size_t i = 0; i < number_of_bits; ++i) {
+ if (map.GetStackMaskBit(encoding.stack_map_encoding, i)) {
+ auto* ref_addr = vreg_base + i;
+ mirror::Object* ref = ref_addr->AsMirrorPtr();
+ if (ref != nullptr) {
+ mirror::Object* new_ref = ref;
+ visitor_(&new_ref, -1, this);
+ if (ref != new_ref) {
+ ref_addr->Assign(new_ref);
}
}
}
- // Visit callee-save registers that hold pointers.
- uint32_t register_mask = map.GetRegisterMask(encoding.stack_map_encoding);
- for (size_t i = 0; i < BitSizeOf<uint32_t>(); ++i) {
- if (register_mask & (1 << i)) {
- mirror::Object** ref_addr = reinterpret_cast<mirror::Object**>(GetGPRAddress(i));
- if (*ref_addr != nullptr) {
- visitor_(ref_addr, -1, this);
- }
- }
- }
- } else {
- const uint8_t* native_gc_map = method_header->GetNativeGcMap();
- CHECK(native_gc_map != nullptr) << PrettyMethod(m);
- const DexFile::CodeItem* code_item = m->GetCodeItem();
- // Can't be null or how would we compile its instructions?
- DCHECK(code_item != nullptr) << PrettyMethod(m);
- NativePcOffsetToReferenceMap map(native_gc_map);
- size_t num_regs = map.RegWidth() * 8;
- if (num_regs > 0) {
- uintptr_t native_pc_offset = method_header->NativeQuickPcOffset(GetCurrentQuickFramePc());
- const uint8_t* reg_bitmap = map.FindBitMap(native_pc_offset);
- DCHECK(reg_bitmap != nullptr);
- const VmapTable vmap_table(method_header->GetVmapTable());
- QuickMethodFrameInfo frame_info = method_header->GetFrameInfo();
- // For all dex registers in the bitmap
- DCHECK(cur_quick_frame != nullptr);
- for (size_t reg = 0; reg < num_regs; ++reg) {
- // Does this register hold a reference?
- if (TestBitmap(reg, reg_bitmap)) {
- uint32_t vmap_offset;
- if (vmap_table.IsInContext(reg, kReferenceVReg, &vmap_offset)) {
- int vmap_reg = vmap_table.ComputeRegister(frame_info.CoreSpillMask(), vmap_offset,
- kReferenceVReg);
- // This is sound as spilled GPRs will be word sized (ie 32 or 64bit).
- mirror::Object** ref_addr =
- reinterpret_cast<mirror::Object**>(GetGPRAddress(vmap_reg));
- if (*ref_addr != nullptr) {
- visitor_(ref_addr, reg, this);
- }
- } else {
- StackReference<mirror::Object>* ref_addr =
- reinterpret_cast<StackReference<mirror::Object>*>(GetVRegAddrFromQuickCode(
- cur_quick_frame, code_item, frame_info.CoreSpillMask(),
- frame_info.FpSpillMask(), frame_info.FrameSizeInBytes(), reg));
- mirror::Object* ref = ref_addr->AsMirrorPtr();
- if (ref != nullptr) {
- mirror::Object* new_ref = ref;
- visitor_(&new_ref, reg, this);
- if (ref != new_ref) {
- ref_addr->Assign(new_ref);
- }
- }
- }
- }
+ }
+ // Visit callee-save registers that hold pointers.
+ uint32_t register_mask = map.GetRegisterMask(encoding.stack_map_encoding);
+ for (size_t i = 0; i < BitSizeOf<uint32_t>(); ++i) {
+ if (register_mask & (1 << i)) {
+ mirror::Object** ref_addr = reinterpret_cast<mirror::Object**>(GetGPRAddress(i));
+ if (*ref_addr != nullptr) {
+ visitor_(ref_addr, -1, this);
}
}
}
diff --git a/runtime/vmap_table.h b/runtime/vmap_table.h
deleted file mode 100644
index db9e1ea5cb..0000000000
--- a/runtime/vmap_table.h
+++ /dev/null
@@ -1,126 +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.
- */
-
-#ifndef ART_RUNTIME_VMAP_TABLE_H_
-#define ART_RUNTIME_VMAP_TABLE_H_
-
-#include "base/logging.h"
-#include "leb128.h"
-#include "stack.h"
-
-namespace art {
-
-class VmapTable {
- public:
- // For efficient encoding of special values, entries are adjusted by 2.
- static constexpr uint16_t kEntryAdjustment = 2u;
- static constexpr uint16_t kAdjustedFpMarker = static_cast<uint16_t>(0xffffu + kEntryAdjustment);
-
- explicit VmapTable(const uint8_t* table) : table_(table) {
- }
-
- // Look up nth entry, not called from performance critical code.
- uint16_t operator[](size_t n) const {
- const uint8_t* table = table_;
- size_t size = DecodeUnsignedLeb128(&table);
- CHECK_LT(n, size);
- uint16_t adjusted_entry = DecodeUnsignedLeb128(&table);
- for (size_t i = 0; i < n; ++i) {
- adjusted_entry = DecodeUnsignedLeb128(&table);
- }
- return adjusted_entry - kEntryAdjustment;
- }
-
- size_t Size() const {
- const uint8_t* table = table_;
- return DecodeUnsignedLeb128(&table);
- }
-
- // Is the dex register 'vreg' in the context or on the stack? Should not be called when the
- // 'kind' is unknown or constant.
- bool IsInContext(size_t vreg, VRegKind kind, uint32_t* vmap_offset) const {
- DCHECK(kind == kReferenceVReg || kind == kIntVReg || kind == kFloatVReg ||
- kind == kLongLoVReg || kind == kLongHiVReg || kind == kDoubleLoVReg ||
- kind == kDoubleHiVReg || kind == kImpreciseConstant);
- *vmap_offset = 0xEBAD0FF5;
- // TODO: take advantage of the registers being ordered
- // TODO: we treat kImpreciseConstant as an integer below, need to ensure that such values
- // are never promoted to floating point registers.
- bool is_float = (kind == kFloatVReg) || (kind == kDoubleLoVReg) || (kind == kDoubleHiVReg);
- bool in_floats = false;
- const uint8_t* table = table_;
- uint16_t adjusted_vreg = vreg + kEntryAdjustment;
- size_t end = DecodeUnsignedLeb128(&table);
- bool high_reg = (kind == kLongHiVReg) || (kind == kDoubleHiVReg);
- bool target64 = (kRuntimeISA == kArm64) || (kRuntimeISA == kX86_64) || (kRuntimeISA == kMips64);
- if (target64 && high_reg) {
- // Wide promoted registers are associated with the sreg of the low portion.
- adjusted_vreg--;
- }
- for (size_t i = 0; i < end; ++i) {
- // Stop if we find what we are are looking for.
- uint16_t adjusted_entry = DecodeUnsignedLeb128(&table);
- if ((adjusted_entry == adjusted_vreg) && (in_floats == is_float)) {
- *vmap_offset = i;
- return true;
- }
- // 0xffff is the marker for LR (return PC on x86), following it are spilled float registers.
- if (adjusted_entry == kAdjustedFpMarker) {
- in_floats = true;
- }
- }
- return false;
- }
-
- // Compute the register number that corresponds to the entry in the vmap (vmap_offset, computed
- // by IsInContext above). If the kind is floating point then the result will be a floating point
- // register number, otherwise it will be an integer register number.
- uint32_t ComputeRegister(uint32_t spill_mask, uint32_t vmap_offset, VRegKind kind) const {
- // Compute the register we need to load from the context.
- DCHECK(kind == kReferenceVReg || kind == kIntVReg || kind == kFloatVReg ||
- kind == kLongLoVReg || kind == kLongHiVReg || kind == kDoubleLoVReg ||
- kind == kDoubleHiVReg || kind == kImpreciseConstant);
- // TODO: we treat kImpreciseConstant as an integer below, need to ensure that such values
- // are never promoted to floating point registers.
- bool is_float = (kind == kFloatVReg) || (kind == kDoubleLoVReg) || (kind == kDoubleHiVReg);
- uint32_t matches = 0;
- if (UNLIKELY(is_float)) {
- const uint8_t* table = table_;
- DecodeUnsignedLeb128(&table); // Skip size.
- while (DecodeUnsignedLeb128(&table) != kAdjustedFpMarker) {
- matches++;
- }
- matches++;
- }
- CHECK_LT(vmap_offset - matches, static_cast<uint32_t>(POPCOUNT(spill_mask)));
- uint32_t spill_shifts = 0;
- while (matches != (vmap_offset + 1)) {
- DCHECK_NE(spill_mask, 0u);
- matches += spill_mask & 1; // Add 1 if the low bit is set
- spill_mask >>= 1;
- spill_shifts++;
- }
- spill_shifts--; // wind back one as we want the last match
- return spill_shifts;
- }
-
- private:
- const uint8_t* const table_;
-};
-
-} // namespace art
-
-#endif // ART_RUNTIME_VMAP_TABLE_H_
generated by cgit v1.2.3-59-g8ed1b (git 2.39.0) at 2026-01-07 09:55:22 +0000