Pack stack map entries on bit level to save space.
Use only the minimum number of bits required to store stack map data.
For example, if native_pc needs 5 bits and dex_pc needs 3 bits, they
will share the first byte of the stack map entry.
The header is changed to store bit offsets of the fields rather than
byte sizes. Offsets also make it easier to access later fields without
calculating sum of all previous sizes.
All of the header fields are byte sized or encoded as ULEB128 instead
of the previous fixed size encoding. This shrinks it by about half.
It saves 3.6 MB from non-debuggable boot.oat (AOSP).
It saves 3.1 MB from debuggable boot.oat (AOSP).
It saves 2.8 MB (of 99.4 MB) from /system/framework/arm/ (GOOG).
It saves 1.0 MB (of 27.8 MB) from /system/framework/oat/arm/ (GOOG).
Field loads from stackmaps seem to get around 10% faster.
(based on the time it takes to load all stackmap entries from boot.oat)
Bug: 27640410
Change-Id: I8bf0996b4eb24300c1b0dfc6e9d99fe85d04a1b7
diff --git a/compiler/debug/elf_debug_info_writer.h b/compiler/debug/elf_debug_info_writer.h
index a6e6f8b..e8e278d 100644
--- a/compiler/debug/elf_debug_info_writer.h
+++ b/compiler/debug/elf_debug_info_writer.h
@@ -180,8 +180,8 @@
std::vector<DexRegisterMap> dex_reg_maps;
if (mi->code_info != nullptr) {
const CodeInfo code_info(mi->code_info);
- StackMapEncoding encoding = code_info.ExtractEncoding();
- for (size_t s = 0; s < code_info.GetNumberOfStackMaps(); ++s) {
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ for (size_t s = 0; s < code_info.GetNumberOfStackMaps(encoding); ++s) {
const StackMap& stack_map = code_info.GetStackMapAt(s, encoding);
dex_reg_maps.push_back(code_info.GetDexRegisterMapOf(
stack_map, encoding, dex_code->registers_size_));
diff --git a/compiler/debug/elf_debug_line_writer.h b/compiler/debug/elf_debug_line_writer.h
index 66e135f..3db7306 100644
--- a/compiler/debug/elf_debug_line_writer.h
+++ b/compiler/debug/elf_debug_line_writer.h
@@ -98,15 +98,15 @@
if (mi->code_info != nullptr) {
// Use stack maps to create mapping table from pc to dex.
const CodeInfo code_info(mi->code_info);
- const StackMapEncoding encoding = code_info.ExtractEncoding();
- pc2dex_map.reserve(code_info.GetNumberOfStackMaps());
- for (uint32_t s = 0; s < code_info.GetNumberOfStackMaps(); s++) {
+ const CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ pc2dex_map.reserve(code_info.GetNumberOfStackMaps(encoding));
+ for (uint32_t s = 0; s < code_info.GetNumberOfStackMaps(encoding); s++) {
StackMap stack_map = code_info.GetStackMapAt(s, encoding);
DCHECK(stack_map.IsValid());
- const uint32_t pc = stack_map.GetNativePcOffset(encoding);
- const int32_t dex = stack_map.GetDexPc(encoding);
+ const uint32_t pc = stack_map.GetNativePcOffset(encoding.stack_map_encoding);
+ const int32_t dex = stack_map.GetDexPc(encoding.stack_map_encoding);
pc2dex_map.push_back({pc, dex});
- if (stack_map.HasDexRegisterMap(encoding)) {
+ if (stack_map.HasDexRegisterMap(encoding.stack_map_encoding)) {
// Guess that the first map with local variables is the end of prologue.
prologue_end = std::min(prologue_end, pc);
}
diff --git a/compiler/debug/elf_debug_loc_writer.h b/compiler/debug/elf_debug_loc_writer.h
index 4712d47..9645643 100644
--- a/compiler/debug/elf_debug_loc_writer.h
+++ b/compiler/debug/elf_debug_loc_writer.h
@@ -98,12 +98,12 @@
// Get stack maps sorted by pc (they might not be sorted internally).
// TODO(dsrbecky) Remove this once stackmaps get sorted by pc.
const CodeInfo code_info(method_info->code_info);
- const StackMapEncoding encoding = code_info.ExtractEncoding();
+ const CodeInfoEncoding encoding = code_info.ExtractEncoding();
std::map<uint32_t, uint32_t> stack_maps; // low_pc -> stack_map_index.
- for (uint32_t s = 0; s < code_info.GetNumberOfStackMaps(); s++) {
+ for (uint32_t s = 0; s < code_info.GetNumberOfStackMaps(encoding); s++) {
StackMap stack_map = code_info.GetStackMapAt(s, encoding);
DCHECK(stack_map.IsValid());
- if (!stack_map.HasDexRegisterMap(encoding)) {
+ if (!stack_map.HasDexRegisterMap(encoding.stack_map_encoding)) {
// The compiler creates stackmaps without register maps at the start of
// basic blocks in order to keep instruction-accurate line number mapping.
// However, we never stop at those (breakpoint locations always have map).
@@ -111,7 +111,7 @@
// The main reason for this is to save space by avoiding undefined gaps.
continue;
}
- const uint32_t pc_offset = stack_map.GetNativePcOffset(encoding);
+ const uint32_t pc_offset = stack_map.GetNativePcOffset(encoding.stack_map_encoding);
DCHECK_LE(pc_offset, method_info->code_size);
DCHECK_LE(compilation_unit_code_address, method_info->code_address);
const uint32_t low_pc = dchecked_integral_cast<uint32_t>(
@@ -135,7 +135,7 @@
}
// Check that the stack map is in the requested range.
- uint32_t dex_pc = stack_map.GetDexPc(encoding);
+ uint32_t dex_pc = stack_map.GetDexPc(encoding.stack_map_encoding);
if (!(dex_pc_low <= dex_pc && dex_pc < dex_pc_high)) {
// The variable is not in scope at this PC. Therefore omit the entry.
// Note that this is different to None() entry which means in scope, but unknown location.
diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc
index 32869ec..216f03d 100644
--- a/compiler/optimizing/code_generator.cc
+++ b/compiler/optimizing/code_generator.cc
@@ -641,7 +641,7 @@
const CodeInfo& code_info,
const ArenaVector<HSuspendCheck*>& loop_headers,
ArenaVector<size_t>* covered) {
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
for (size_t i = 0; i < loop_headers.size(); ++i) {
if (loop_headers[i]->GetDexPc() == dex_pc) {
if (graph.IsCompilingOsr()) {
diff --git a/compiler/optimizing/stack_map_stream.cc b/compiler/optimizing/stack_map_stream.cc
index 3f41e35..c571312 100644
--- a/compiler/optimizing/stack_map_stream.cc
+++ b/compiler/optimizing/stack_map_stream.cc
@@ -137,34 +137,41 @@
size_t StackMapStream::PrepareForFillIn() {
int stack_mask_number_of_bits = stack_mask_max_ + 1; // Need room for max element too.
- stack_mask_size_ = RoundUp(stack_mask_number_of_bits, kBitsPerByte) / kBitsPerByte;
inline_info_size_ = ComputeInlineInfoSize();
dex_register_maps_size_ = ComputeDexRegisterMapsSize();
uint32_t max_native_pc_offset = ComputeMaxNativePcOffset();
- stack_map_encoding_ = StackMapEncoding::CreateFromSizes(stack_mask_size_,
- inline_info_size_,
- dex_register_maps_size_,
- dex_pc_max_,
- max_native_pc_offset,
- register_mask_max_);
- stack_maps_size_ = stack_maps_.size() * stack_map_encoding_.ComputeStackMapSize();
+ size_t stack_map_size = stack_map_encoding_.SetFromSizes(max_native_pc_offset,
+ dex_pc_max_,
+ dex_register_maps_size_,
+ inline_info_size_,
+ register_mask_max_,
+ stack_mask_number_of_bits);
+ stack_maps_size_ = stack_maps_.size() * stack_map_size;
dex_register_location_catalog_size_ = ComputeDexRegisterLocationCatalogSize();
- // Note: use RoundUp to word-size here if you want CodeInfo objects to be word aligned.
- needed_size_ = CodeInfo::kFixedSize
- + stack_maps_size_
- + dex_register_location_catalog_size_
- + dex_register_maps_size_
- + inline_info_size_;
+ size_t non_header_size =
+ stack_maps_size_ +
+ dex_register_location_catalog_size_ +
+ dex_register_maps_size_ +
+ inline_info_size_;
- stack_maps_start_ = CodeInfo::kFixedSize;
+ // Prepare the CodeInfo variable-sized encoding.
+ CodeInfoEncoding code_info_encoding;
+ code_info_encoding.non_header_size = non_header_size;
+ code_info_encoding.stack_map_encoding = stack_map_encoding_;
+ code_info_encoding.number_of_stack_maps = stack_maps_.size();
+ code_info_encoding.stack_map_size_in_bytes = stack_map_size;
+ code_info_encoding.number_of_location_catalog_entries = location_catalog_entries_.size();
+ code_info_encoding.Compress(&code_info_encoding_);
+
// TODO: Move the catalog at the end. It is currently too expensive at runtime
// to compute its size (note that we do not encode that size in the CodeInfo).
- dex_register_location_catalog_start_ = stack_maps_start_ + stack_maps_size_;
+ dex_register_location_catalog_start_ = code_info_encoding_.size() + stack_maps_size_;
dex_register_maps_start_ =
dex_register_location_catalog_start_ + dex_register_location_catalog_size_;
inline_infos_start_ = dex_register_maps_start_ + dex_register_maps_size_;
+ needed_size_ = code_info_encoding_.size() + non_header_size;
return needed_size_;
}
@@ -227,9 +234,13 @@
DCHECK_EQ(0u, current_entry_.dex_pc) << "EndStackMapEntry not called after BeginStackMapEntry";
DCHECK_NE(0u, needed_size_) << "PrepareForFillIn not called before FillIn";
- CodeInfo code_info(region);
DCHECK_EQ(region.size(), needed_size_);
- code_info.SetOverallSize(region.size());
+
+ // Note that the memory region does not have to be zeroed when we JIT code
+ // because we do not use the arena allocator there.
+
+ // Write the CodeInfo header.
+ region.CopyFrom(0, MemoryRegion(code_info_encoding_.data(), code_info_encoding_.size()));
MemoryRegion dex_register_locations_region = region.Subregion(
dex_register_maps_start_, dex_register_maps_size_);
@@ -237,12 +248,11 @@
MemoryRegion inline_infos_region = region.Subregion(
inline_infos_start_, inline_info_size_);
- code_info.SetEncoding(stack_map_encoding_);
- code_info.SetNumberOfStackMaps(stack_maps_.size());
- DCHECK_EQ(code_info.GetStackMapsSize(code_info.ExtractEncoding()), stack_maps_size_);
+ CodeInfo code_info(region);
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ DCHECK_EQ(code_info.GetStackMapsSize(encoding), stack_maps_size_);
// Set the Dex register location catalog.
- code_info.SetNumberOfLocationCatalogEntries(location_catalog_entries_.size());
MemoryRegion dex_register_location_catalog_region = region.Subregion(
dex_register_location_catalog_start_, dex_register_location_catalog_size_);
DexRegisterLocationCatalog dex_register_location_catalog(dex_register_location_catalog_region);
@@ -260,17 +270,22 @@
uintptr_t next_dex_register_map_offset = 0;
uintptr_t next_inline_info_offset = 0;
for (size_t i = 0, e = stack_maps_.size(); i < e; ++i) {
- StackMap stack_map = code_info.GetStackMapAt(i, stack_map_encoding_);
+ StackMap stack_map = code_info.GetStackMapAt(i, encoding);
StackMapEntry entry = stack_maps_[i];
stack_map.SetDexPc(stack_map_encoding_, entry.dex_pc);
stack_map.SetNativePcOffset(stack_map_encoding_, entry.native_pc_offset);
stack_map.SetRegisterMask(stack_map_encoding_, entry.register_mask);
+ size_t number_of_stack_mask_bits = stack_map.GetNumberOfStackMaskBits(stack_map_encoding_);
if (entry.sp_mask != nullptr) {
- stack_map.SetStackMask(stack_map_encoding_, *entry.sp_mask);
+ for (size_t bit = 0; bit < number_of_stack_mask_bits; bit++) {
+ stack_map.SetStackMaskBit(stack_map_encoding_, bit, entry.sp_mask->IsBitSet(bit));
+ }
} else {
// The MemoryRegion does not have to be zeroed, so make sure we clear the bits.
- stack_map.SetStackMask(stack_map_encoding_, empty_bitmask);
+ for (size_t bit = 0; bit < number_of_stack_mask_bits; bit++) {
+ stack_map.SetStackMaskBit(stack_map_encoding_, bit, false);
+ }
}
if (entry.num_dex_registers == 0 || (entry.live_dex_registers_mask->NumSetBits() == 0)) {
@@ -282,7 +297,7 @@
// If we have a hit reuse the offset.
stack_map.SetDexRegisterMapOffset(
stack_map_encoding_,
- code_info.GetStackMapAt(entry.same_dex_register_map_as_, stack_map_encoding_)
+ code_info.GetStackMapAt(entry.same_dex_register_map_as_, encoding)
.GetDexRegisterMapOffset(stack_map_encoding_));
} else {
// New dex registers maps should be added to the stack map.
@@ -437,7 +452,7 @@
size_t num_dex_registers,
BitVector* live_dex_registers_mask,
size_t dex_register_locations_index) const {
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
for (size_t reg = 0; reg < num_dex_registers; reg++) {
// Find the location we tried to encode.
DexRegisterLocation expected = DexRegisterLocation::None();
@@ -464,25 +479,26 @@
// Check that all StackMapStream inputs are correctly encoded by trying to read them back.
void StackMapStream::CheckCodeInfo(MemoryRegion region) const {
CodeInfo code_info(region);
- StackMapEncoding encoding = code_info.ExtractEncoding();
- DCHECK_EQ(code_info.GetNumberOfStackMaps(), stack_maps_.size());
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ DCHECK_EQ(code_info.GetNumberOfStackMaps(encoding), stack_maps_.size());
for (size_t s = 0; s < stack_maps_.size(); ++s) {
const StackMap stack_map = code_info.GetStackMapAt(s, encoding);
+ const StackMapEncoding& stack_map_encoding = encoding.stack_map_encoding;
StackMapEntry entry = stack_maps_[s];
// Check main stack map fields.
- DCHECK_EQ(stack_map.GetNativePcOffset(encoding), entry.native_pc_offset);
- DCHECK_EQ(stack_map.GetDexPc(encoding), entry.dex_pc);
- DCHECK_EQ(stack_map.GetRegisterMask(encoding), entry.register_mask);
- MemoryRegion stack_mask = stack_map.GetStackMask(encoding);
+ DCHECK_EQ(stack_map.GetNativePcOffset(stack_map_encoding), entry.native_pc_offset);
+ DCHECK_EQ(stack_map.GetDexPc(stack_map_encoding), entry.dex_pc);
+ DCHECK_EQ(stack_map.GetRegisterMask(stack_map_encoding), entry.register_mask);
+ size_t num_stack_mask_bits = stack_map.GetNumberOfStackMaskBits(stack_map_encoding);
if (entry.sp_mask != nullptr) {
- DCHECK_GE(stack_mask.size_in_bits(), entry.sp_mask->GetNumberOfBits());
- for (size_t b = 0; b < stack_mask.size_in_bits(); b++) {
- DCHECK_EQ(stack_mask.LoadBit(b), entry.sp_mask->IsBitSet(b));
+ DCHECK_GE(num_stack_mask_bits, entry.sp_mask->GetNumberOfBits());
+ for (size_t b = 0; b < num_stack_mask_bits; b++) {
+ DCHECK_EQ(stack_map.GetStackMaskBit(stack_map_encoding, b), entry.sp_mask->IsBitSet(b));
}
} else {
- for (size_t b = 0; b < stack_mask.size_in_bits(); b++) {
- DCHECK_EQ(stack_mask.LoadBit(b), 0u);
+ for (size_t b = 0; b < num_stack_mask_bits; b++) {
+ DCHECK_EQ(stack_map.GetStackMaskBit(stack_map_encoding, b), 0u);
}
}
@@ -494,7 +510,7 @@
entry.dex_register_locations_start_index);
// Check inline info.
- DCHECK_EQ(stack_map.HasInlineInfo(encoding), (entry.inlining_depth != 0));
+ DCHECK_EQ(stack_map.HasInlineInfo(stack_map_encoding), (entry.inlining_depth != 0));
if (entry.inlining_depth != 0) {
InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map, encoding);
DCHECK_EQ(inline_info.GetDepth(), entry.inlining_depth);
diff --git a/compiler/optimizing/stack_map_stream.h b/compiler/optimizing/stack_map_stream.h
index 016a911..b686748 100644
--- a/compiler/optimizing/stack_map_stream.h
+++ b/compiler/optimizing/stack_map_stream.h
@@ -74,13 +74,12 @@
allocator->Adapter(kArenaAllocStackMapStream)),
current_entry_(),
current_inline_info_(),
- stack_mask_size_(0),
+ code_info_encoding_(allocator->Adapter(kArenaAllocStackMapStream)),
inline_info_size_(0),
dex_register_maps_size_(0),
stack_maps_size_(0),
dex_register_location_catalog_size_(0),
dex_register_location_catalog_start_(0),
- stack_maps_start_(0),
dex_register_maps_start_(0),
inline_infos_start_(0),
needed_size_(0),
@@ -90,6 +89,7 @@
location_catalog_entries_.reserve(4);
dex_register_locations_.reserve(10 * 4);
inline_infos_.reserve(2);
+ code_info_encoding_.reserve(16);
}
// See runtime/stack_map.h to know what these fields contain.
@@ -200,13 +200,12 @@
StackMapEntry current_entry_;
InlineInfoEntry current_inline_info_;
StackMapEncoding stack_map_encoding_;
- size_t stack_mask_size_;
+ ArenaVector<uint8_t> code_info_encoding_;
size_t inline_info_size_;
size_t dex_register_maps_size_;
size_t stack_maps_size_;
size_t dex_register_location_catalog_size_;
size_t dex_register_location_catalog_start_;
- size_t stack_maps_start_;
size_t dex_register_maps_start_;
size_t inline_infos_start_;
size_t needed_size_;
diff --git a/compiler/optimizing/stack_map_test.cc b/compiler/optimizing/stack_map_test.cc
index 604787f..3552487 100644
--- a/compiler/optimizing/stack_map_test.cc
+++ b/compiler/optimizing/stack_map_test.cc
@@ -23,9 +23,18 @@
namespace art {
-static bool SameBits(MemoryRegion region, const BitVector& bit_vector) {
- for (size_t i = 0; i < region.size_in_bits(); ++i) {
- if (region.LoadBit(i) != bit_vector.IsBitSet(i)) {
+// Check that the stack mask of given stack map is identical
+// to the given bit vector. Returns true if they are same.
+static bool CheckStackMask(
+ const StackMap& stack_map,
+ StackMapEncoding& encoding,
+ const BitVector& bit_vector) {
+ int number_of_bits = stack_map.GetNumberOfStackMaskBits(encoding);
+ if (bit_vector.GetHighestBitSet() >= number_of_bits) {
+ return false;
+ }
+ for (int i = 0; i < number_of_bits; ++i) {
+ if (stack_map.GetStackMaskBit(encoding, i) != bit_vector.IsBitSet(i)) {
return false;
}
}
@@ -52,12 +61,11 @@
stream.FillIn(region);
CodeInfo code_info(region);
- StackMapEncoding encoding = code_info.ExtractEncoding();
- ASSERT_EQ(0u, encoding.NumberOfBytesForStackMask());
- ASSERT_EQ(1u, code_info.GetNumberOfStackMaps());
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ ASSERT_EQ(1u, code_info.GetNumberOfStackMaps(encoding));
- uint32_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
- ASSERT_EQ(2u, number_of_location_catalog_entries);
+ uint32_t number_of_catalog_entries = code_info.GetNumberOfLocationCatalogEntries(encoding);
+ ASSERT_EQ(2u, number_of_catalog_entries);
DexRegisterLocationCatalog location_catalog = code_info.GetDexRegisterLocationCatalog(encoding);
// The Dex register location catalog contains:
// - one 1-byte short Dex register location, and
@@ -68,14 +76,13 @@
StackMap stack_map = code_info.GetStackMapAt(0, encoding);
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForDexPc(0, encoding)));
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForNativePcOffset(64, encoding)));
- ASSERT_EQ(0u, stack_map.GetDexPc(encoding));
- ASSERT_EQ(64u, stack_map.GetNativePcOffset(encoding));
- ASSERT_EQ(0x3u, stack_map.GetRegisterMask(encoding));
+ ASSERT_EQ(0u, stack_map.GetDexPc(encoding.stack_map_encoding));
+ ASSERT_EQ(64u, stack_map.GetNativePcOffset(encoding.stack_map_encoding));
+ ASSERT_EQ(0x3u, stack_map.GetRegisterMask(encoding.stack_map_encoding));
- MemoryRegion stack_mask = stack_map.GetStackMask(encoding);
- ASSERT_TRUE(SameBits(stack_mask, sp_mask));
+ ASSERT_TRUE(CheckStackMask(stack_map, encoding.stack_map_encoding, sp_mask));
- ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding));
+ ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding.stack_map_encoding));
DexRegisterMap dex_register_map =
code_info.GetDexRegisterMapOf(stack_map, encoding, number_of_dex_registers);
ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
@@ -100,9 +107,9 @@
ASSERT_EQ(-2, dex_register_map.GetConstant(1, number_of_dex_registers, code_info, encoding));
size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
- 0, number_of_dex_registers, number_of_location_catalog_entries);
+ 0, number_of_dex_registers, number_of_catalog_entries);
size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
- 1, number_of_dex_registers, number_of_location_catalog_entries);
+ 1, number_of_dex_registers, number_of_catalog_entries);
ASSERT_EQ(0u, index0);
ASSERT_EQ(1u, index1);
DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -114,7 +121,7 @@
ASSERT_EQ(0, location0.GetValue());
ASSERT_EQ(-2, location1.GetValue());
- ASSERT_FALSE(stack_map.HasInlineInfo(encoding));
+ ASSERT_FALSE(stack_map.HasInlineInfo(encoding.stack_map_encoding));
}
TEST(StackMapTest, Test2) {
@@ -166,12 +173,11 @@
stream.FillIn(region);
CodeInfo code_info(region);
- StackMapEncoding encoding = code_info.ExtractEncoding();
- ASSERT_EQ(2u, encoding.NumberOfBytesForStackMask());
- ASSERT_EQ(4u, code_info.GetNumberOfStackMaps());
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ ASSERT_EQ(4u, code_info.GetNumberOfStackMaps(encoding));
- uint32_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
- ASSERT_EQ(7u, number_of_location_catalog_entries);
+ uint32_t number_of_catalog_entries = code_info.GetNumberOfLocationCatalogEntries(encoding);
+ ASSERT_EQ(7u, number_of_catalog_entries);
DexRegisterLocationCatalog location_catalog = code_info.GetDexRegisterLocationCatalog(encoding);
// The Dex register location catalog contains:
// - six 1-byte short Dex register locations, and
@@ -184,14 +190,13 @@
StackMap stack_map = code_info.GetStackMapAt(0, encoding);
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForDexPc(0, encoding)));
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForNativePcOffset(64, encoding)));
- ASSERT_EQ(0u, stack_map.GetDexPc(encoding));
- ASSERT_EQ(64u, stack_map.GetNativePcOffset(encoding));
- ASSERT_EQ(0x3u, stack_map.GetRegisterMask(encoding));
+ ASSERT_EQ(0u, stack_map.GetDexPc(encoding.stack_map_encoding));
+ ASSERT_EQ(64u, stack_map.GetNativePcOffset(encoding.stack_map_encoding));
+ ASSERT_EQ(0x3u, stack_map.GetRegisterMask(encoding.stack_map_encoding));
- MemoryRegion stack_mask = stack_map.GetStackMask(encoding);
- ASSERT_TRUE(SameBits(stack_mask, sp_mask1));
+ ASSERT_TRUE(CheckStackMask(stack_map, encoding.stack_map_encoding, sp_mask1));
- ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding));
+ ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding.stack_map_encoding));
DexRegisterMap dex_register_map =
code_info.GetDexRegisterMapOf(stack_map, encoding, number_of_dex_registers);
ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
@@ -216,9 +221,9 @@
ASSERT_EQ(-2, dex_register_map.GetConstant(1, number_of_dex_registers, code_info, encoding));
size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
- 0, number_of_dex_registers, number_of_location_catalog_entries);
+ 0, number_of_dex_registers, number_of_catalog_entries);
size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
- 1, number_of_dex_registers, number_of_location_catalog_entries);
+ 1, number_of_dex_registers, number_of_catalog_entries);
ASSERT_EQ(0u, index0);
ASSERT_EQ(1u, index1);
DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -230,7 +235,7 @@
ASSERT_EQ(0, location0.GetValue());
ASSERT_EQ(-2, location1.GetValue());
- ASSERT_TRUE(stack_map.HasInlineInfo(encoding));
+ ASSERT_TRUE(stack_map.HasInlineInfo(encoding.stack_map_encoding));
InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map, encoding);
ASSERT_EQ(2u, inline_info.GetDepth());
ASSERT_EQ(82u, inline_info.GetMethodIndexAtDepth(0));
@@ -246,14 +251,13 @@
StackMap stack_map = code_info.GetStackMapAt(1, encoding);
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForDexPc(1u, encoding)));
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForNativePcOffset(128u, encoding)));
- ASSERT_EQ(1u, stack_map.GetDexPc(encoding));
- ASSERT_EQ(128u, stack_map.GetNativePcOffset(encoding));
- ASSERT_EQ(0xFFu, stack_map.GetRegisterMask(encoding));
+ ASSERT_EQ(1u, stack_map.GetDexPc(encoding.stack_map_encoding));
+ ASSERT_EQ(128u, stack_map.GetNativePcOffset(encoding.stack_map_encoding));
+ ASSERT_EQ(0xFFu, stack_map.GetRegisterMask(encoding.stack_map_encoding));
- MemoryRegion stack_mask = stack_map.GetStackMask(encoding);
- ASSERT_TRUE(SameBits(stack_mask, sp_mask2));
+ ASSERT_TRUE(CheckStackMask(stack_map, encoding.stack_map_encoding, sp_mask2));
- ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding));
+ ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding.stack_map_encoding));
DexRegisterMap dex_register_map =
code_info.GetDexRegisterMapOf(stack_map, encoding, number_of_dex_registers);
ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
@@ -279,9 +283,9 @@
1, number_of_dex_registers, code_info, encoding));
size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
- 0, number_of_dex_registers, number_of_location_catalog_entries);
+ 0, number_of_dex_registers, number_of_catalog_entries);
size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
- 1, number_of_dex_registers, number_of_location_catalog_entries);
+ 1, number_of_dex_registers, number_of_catalog_entries);
ASSERT_EQ(2u, index0);
ASSERT_EQ(3u, index1);
DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -293,7 +297,7 @@
ASSERT_EQ(18, location0.GetValue());
ASSERT_EQ(3, location1.GetValue());
- ASSERT_FALSE(stack_map.HasInlineInfo(encoding));
+ ASSERT_FALSE(stack_map.HasInlineInfo(encoding.stack_map_encoding));
}
// Third stack map.
@@ -301,14 +305,13 @@
StackMap stack_map = code_info.GetStackMapAt(2, encoding);
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForDexPc(2u, encoding)));
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForNativePcOffset(192u, encoding)));
- ASSERT_EQ(2u, stack_map.GetDexPc(encoding));
- ASSERT_EQ(192u, stack_map.GetNativePcOffset(encoding));
- ASSERT_EQ(0xABu, stack_map.GetRegisterMask(encoding));
+ ASSERT_EQ(2u, stack_map.GetDexPc(encoding.stack_map_encoding));
+ ASSERT_EQ(192u, stack_map.GetNativePcOffset(encoding.stack_map_encoding));
+ ASSERT_EQ(0xABu, stack_map.GetRegisterMask(encoding.stack_map_encoding));
- MemoryRegion stack_mask = stack_map.GetStackMask(encoding);
- ASSERT_TRUE(SameBits(stack_mask, sp_mask3));
+ ASSERT_TRUE(CheckStackMask(stack_map, encoding.stack_map_encoding, sp_mask3));
- ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding));
+ ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding.stack_map_encoding));
DexRegisterMap dex_register_map =
code_info.GetDexRegisterMapOf(stack_map, encoding, number_of_dex_registers);
ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
@@ -334,9 +337,9 @@
1, number_of_dex_registers, code_info, encoding));
size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
- 0, number_of_dex_registers, number_of_location_catalog_entries);
+ 0, number_of_dex_registers, number_of_catalog_entries);
size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
- 1, number_of_dex_registers, number_of_location_catalog_entries);
+ 1, number_of_dex_registers, number_of_catalog_entries);
ASSERT_EQ(4u, index0);
ASSERT_EQ(5u, index1);
DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -348,7 +351,7 @@
ASSERT_EQ(6, location0.GetValue());
ASSERT_EQ(8, location1.GetValue());
- ASSERT_FALSE(stack_map.HasInlineInfo(encoding));
+ ASSERT_FALSE(stack_map.HasInlineInfo(encoding.stack_map_encoding));
}
// Fourth stack map.
@@ -356,14 +359,13 @@
StackMap stack_map = code_info.GetStackMapAt(3, encoding);
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForDexPc(3u, encoding)));
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForNativePcOffset(256u, encoding)));
- ASSERT_EQ(3u, stack_map.GetDexPc(encoding));
- ASSERT_EQ(256u, stack_map.GetNativePcOffset(encoding));
- ASSERT_EQ(0xCDu, stack_map.GetRegisterMask(encoding));
+ ASSERT_EQ(3u, stack_map.GetDexPc(encoding.stack_map_encoding));
+ ASSERT_EQ(256u, stack_map.GetNativePcOffset(encoding.stack_map_encoding));
+ ASSERT_EQ(0xCDu, stack_map.GetRegisterMask(encoding.stack_map_encoding));
- MemoryRegion stack_mask = stack_map.GetStackMask(encoding);
- ASSERT_TRUE(SameBits(stack_mask, sp_mask4));
+ ASSERT_TRUE(CheckStackMask(stack_map, encoding.stack_map_encoding, sp_mask4));
- ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding));
+ ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding.stack_map_encoding));
DexRegisterMap dex_register_map =
code_info.GetDexRegisterMapOf(stack_map, encoding, number_of_dex_registers);
ASSERT_TRUE(dex_register_map.IsDexRegisterLive(0));
@@ -389,9 +391,9 @@
1, number_of_dex_registers, code_info, encoding));
size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
- 0, number_of_dex_registers, number_of_location_catalog_entries);
+ 0, number_of_dex_registers, number_of_catalog_entries);
size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
- 1, number_of_dex_registers, number_of_location_catalog_entries);
+ 1, number_of_dex_registers, number_of_catalog_entries);
ASSERT_EQ(3u, index0); // Shared with second stack map.
ASSERT_EQ(6u, index1);
DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -403,7 +405,7 @@
ASSERT_EQ(3, location0.GetValue());
ASSERT_EQ(1, location1.GetValue());
- ASSERT_FALSE(stack_map.HasInlineInfo(encoding));
+ ASSERT_FALSE(stack_map.HasInlineInfo(encoding.stack_map_encoding));
}
}
@@ -425,12 +427,11 @@
stream.FillIn(region);
CodeInfo code_info(region);
- StackMapEncoding encoding = code_info.ExtractEncoding();
- ASSERT_EQ(0u, encoding.NumberOfBytesForStackMask());
- ASSERT_EQ(1u, code_info.GetNumberOfStackMaps());
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ ASSERT_EQ(1u, code_info.GetNumberOfStackMaps(encoding));
- uint32_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
- ASSERT_EQ(1u, number_of_location_catalog_entries);
+ uint32_t number_of_catalog_entries = code_info.GetNumberOfLocationCatalogEntries(encoding);
+ ASSERT_EQ(1u, number_of_catalog_entries);
DexRegisterLocationCatalog location_catalog = code_info.GetDexRegisterLocationCatalog(encoding);
// The Dex register location catalog contains:
// - one 5-byte large Dex register location.
@@ -440,11 +441,11 @@
StackMap stack_map = code_info.GetStackMapAt(0, encoding);
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForDexPc(0, encoding)));
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForNativePcOffset(64, encoding)));
- ASSERT_EQ(0u, stack_map.GetDexPc(encoding));
- ASSERT_EQ(64u, stack_map.GetNativePcOffset(encoding));
- ASSERT_EQ(0x3u, stack_map.GetRegisterMask(encoding));
+ ASSERT_EQ(0u, stack_map.GetDexPc(encoding.stack_map_encoding));
+ ASSERT_EQ(64u, stack_map.GetNativePcOffset(encoding.stack_map_encoding));
+ ASSERT_EQ(0x3u, stack_map.GetRegisterMask(encoding.stack_map_encoding));
- ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding));
+ ASSERT_TRUE(stack_map.HasDexRegisterMap(encoding.stack_map_encoding));
DexRegisterMap dex_register_map =
code_info.GetDexRegisterMapOf(stack_map, encoding, number_of_dex_registers);
ASSERT_FALSE(dex_register_map.IsDexRegisterLive(0));
@@ -467,9 +468,9 @@
ASSERT_EQ(-2, dex_register_map.GetConstant(1, number_of_dex_registers, code_info, encoding));
size_t index0 = dex_register_map.GetLocationCatalogEntryIndex(
- 0, number_of_dex_registers, number_of_location_catalog_entries);
+ 0, number_of_dex_registers, number_of_catalog_entries);
size_t index1 = dex_register_map.GetLocationCatalogEntryIndex(
- 1, number_of_dex_registers, number_of_location_catalog_entries);
+ 1, number_of_dex_registers, number_of_catalog_entries);
ASSERT_EQ(DexRegisterLocationCatalog::kNoLocationEntryIndex, index0);
ASSERT_EQ(0u, index1);
DexRegisterLocation location0 = location_catalog.GetDexRegisterLocation(index0);
@@ -481,7 +482,7 @@
ASSERT_EQ(0, location0.GetValue());
ASSERT_EQ(-2, location1.GetValue());
- ASSERT_FALSE(stack_map.HasInlineInfo(encoding));
+ ASSERT_FALSE(stack_map.HasInlineInfo(encoding.stack_map_encoding));
}
// Generate a stack map whose dex register offset is
@@ -518,13 +519,13 @@
stream.FillIn(region);
CodeInfo code_info(region);
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
// The location catalog contains two entries (DexRegisterLocation(kConstant, 0)
// and DexRegisterLocation(kConstant, 1)), therefore the location catalog index
// has a size of 1 bit.
- uint32_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
- ASSERT_EQ(2u, number_of_location_catalog_entries);
- ASSERT_EQ(1u, DexRegisterMap::SingleEntrySizeInBits(number_of_location_catalog_entries));
+ uint32_t number_of_catalog_entries = code_info.GetNumberOfLocationCatalogEntries(encoding);
+ ASSERT_EQ(2u, number_of_catalog_entries);
+ ASSERT_EQ(1u, DexRegisterMap::SingleEntrySizeInBits(number_of_catalog_entries));
// The first Dex register map contains:
// - a live register bit mask for 1024 registers (that is, 128 bytes of
@@ -537,16 +538,17 @@
DexRegisterMap dex_register_map0 =
code_info.GetDexRegisterMapOf(stack_map0, encoding, number_of_dex_registers);
ASSERT_EQ(127u, dex_register_map0.GetLocationMappingDataSize(number_of_dex_registers,
- number_of_location_catalog_entries));
+ number_of_catalog_entries));
ASSERT_EQ(255u, dex_register_map0.Size());
StackMap stack_map1 = code_info.GetStackMapAt(1, encoding);
- ASSERT_TRUE(stack_map1.HasDexRegisterMap(encoding));
+ ASSERT_TRUE(stack_map1.HasDexRegisterMap(encoding.stack_map_encoding));
// ...the offset of the second Dex register map (relative to the
// beginning of the Dex register maps region) is 255 (i.e.,
// kNoDexRegisterMapSmallEncoding).
- ASSERT_NE(stack_map1.GetDexRegisterMapOffset(encoding), StackMap::kNoDexRegisterMap);
- ASSERT_EQ(stack_map1.GetDexRegisterMapOffset(encoding), 0xFFu);
+ ASSERT_NE(stack_map1.GetDexRegisterMapOffset(encoding.stack_map_encoding),
+ StackMap::kNoDexRegisterMap);
+ ASSERT_EQ(stack_map1.GetDexRegisterMapOffset(encoding.stack_map_encoding), 0xFFu);
}
TEST(StackMapTest, TestShareDexRegisterMap) {
@@ -578,7 +580,7 @@
stream.FillIn(region);
CodeInfo ci(region);
- StackMapEncoding encoding = ci.ExtractEncoding();
+ CodeInfoEncoding encoding = ci.ExtractEncoding();
// Verify first stack map.
StackMap sm0 = ci.GetStackMapAt(0, encoding);
@@ -599,9 +601,12 @@
ASSERT_EQ(-2, dex_registers2.GetConstant(1, number_of_dex_registers, ci, encoding));
// Verify dex register map offsets.
- ASSERT_EQ(sm0.GetDexRegisterMapOffset(encoding), sm1.GetDexRegisterMapOffset(encoding));
- ASSERT_NE(sm0.GetDexRegisterMapOffset(encoding), sm2.GetDexRegisterMapOffset(encoding));
- ASSERT_NE(sm1.GetDexRegisterMapOffset(encoding), sm2.GetDexRegisterMapOffset(encoding));
+ ASSERT_EQ(sm0.GetDexRegisterMapOffset(encoding.stack_map_encoding),
+ sm1.GetDexRegisterMapOffset(encoding.stack_map_encoding));
+ ASSERT_NE(sm0.GetDexRegisterMapOffset(encoding.stack_map_encoding),
+ sm2.GetDexRegisterMapOffset(encoding.stack_map_encoding));
+ ASSERT_NE(sm1.GetDexRegisterMapOffset(encoding.stack_map_encoding),
+ sm2.GetDexRegisterMapOffset(encoding.stack_map_encoding));
}
TEST(StackMapTest, TestNoDexRegisterMap) {
@@ -624,34 +629,33 @@
stream.FillIn(region);
CodeInfo code_info(region);
- StackMapEncoding encoding = code_info.ExtractEncoding();
- ASSERT_EQ(0u, encoding.NumberOfBytesForStackMask());
- ASSERT_EQ(2u, code_info.GetNumberOfStackMaps());
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ ASSERT_EQ(2u, code_info.GetNumberOfStackMaps(encoding));
- uint32_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
- ASSERT_EQ(0u, number_of_location_catalog_entries);
+ uint32_t number_of_catalog_entries = code_info.GetNumberOfLocationCatalogEntries(encoding);
+ ASSERT_EQ(0u, number_of_catalog_entries);
DexRegisterLocationCatalog location_catalog = code_info.GetDexRegisterLocationCatalog(encoding);
ASSERT_EQ(0u, location_catalog.Size());
StackMap stack_map = code_info.GetStackMapAt(0, encoding);
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForDexPc(0, encoding)));
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForNativePcOffset(64, encoding)));
- ASSERT_EQ(0u, stack_map.GetDexPc(encoding));
- ASSERT_EQ(64u, stack_map.GetNativePcOffset(encoding));
- ASSERT_EQ(0x3u, stack_map.GetRegisterMask(encoding));
+ ASSERT_EQ(0u, stack_map.GetDexPc(encoding.stack_map_encoding));
+ ASSERT_EQ(64u, stack_map.GetNativePcOffset(encoding.stack_map_encoding));
+ ASSERT_EQ(0x3u, stack_map.GetRegisterMask(encoding.stack_map_encoding));
- ASSERT_FALSE(stack_map.HasDexRegisterMap(encoding));
- ASSERT_FALSE(stack_map.HasInlineInfo(encoding));
+ ASSERT_FALSE(stack_map.HasDexRegisterMap(encoding.stack_map_encoding));
+ ASSERT_FALSE(stack_map.HasInlineInfo(encoding.stack_map_encoding));
stack_map = code_info.GetStackMapAt(1, encoding);
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForDexPc(1, encoding)));
ASSERT_TRUE(stack_map.Equals(code_info.GetStackMapForNativePcOffset(67, encoding)));
- ASSERT_EQ(1u, stack_map.GetDexPc(encoding));
- ASSERT_EQ(67u, stack_map.GetNativePcOffset(encoding));
- ASSERT_EQ(0x4u, stack_map.GetRegisterMask(encoding));
+ ASSERT_EQ(1u, stack_map.GetDexPc(encoding.stack_map_encoding));
+ ASSERT_EQ(67u, stack_map.GetNativePcOffset(encoding.stack_map_encoding));
+ ASSERT_EQ(0x4u, stack_map.GetRegisterMask(encoding.stack_map_encoding));
- ASSERT_FALSE(stack_map.HasDexRegisterMap(encoding));
- ASSERT_FALSE(stack_map.HasInlineInfo(encoding));
+ ASSERT_FALSE(stack_map.HasDexRegisterMap(encoding.stack_map_encoding));
+ ASSERT_FALSE(stack_map.HasInlineInfo(encoding.stack_map_encoding));
}
TEST(StackMapTest, InlineTest) {
@@ -726,7 +730,7 @@
stream.FillIn(region);
CodeInfo ci(region);
- StackMapEncoding encoding = ci.ExtractEncoding();
+ CodeInfoEncoding encoding = ci.ExtractEncoding();
{
// Verify first stack map.
@@ -792,7 +796,7 @@
DexRegisterMap dex_registers0 = ci.GetDexRegisterMapOf(sm2, encoding, 2);
ASSERT_FALSE(dex_registers0.IsDexRegisterLive(0));
ASSERT_EQ(4, dex_registers0.GetConstant(1, 2, ci, encoding));
- ASSERT_FALSE(sm2.HasInlineInfo(encoding));
+ ASSERT_FALSE(sm2.HasInlineInfo(encoding.stack_map_encoding));
}
{
diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc
index 48a9d91..a280c64 100644
--- a/oatdump/oatdump.cc
+++ b/oatdump/oatdump.cc
@@ -1374,7 +1374,7 @@
const void* raw_code_info = oat_method.GetVmapTable();
if (raw_code_info != nullptr) {
CodeInfo code_info(raw_code_info);
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
StackMap stack_map = code_info.GetStackMapForNativePcOffset(offset, encoding);
if (stack_map.IsValid()) {
stack_map.Dump(vios, code_info, encoding, oat_method.GetCodeOffset(),
diff --git a/runtime/base/bit_utils.h b/runtime/base/bit_utils.h
index 8430d68..f279f45 100644
--- a/runtime/base/bit_utils.h
+++ b/runtime/base/bit_utils.h
@@ -269,7 +269,7 @@
template <typename T>
static constexpr T MaxInt(size_t bits) {
return
- DCHECK_CONSTEXPR(bits > 0, "bits cannot be zero", 0)
+ DCHECK_CONSTEXPR(std::is_unsigned<T>::value || bits > 0, "bits cannot be zero for signed", 0)
DCHECK_CONSTEXPR(bits <= BitSizeOf<T>(), "kBits must be < max.", 0)
bits == BitSizeOf<T>()
? std::numeric_limits<T>::max()
@@ -283,7 +283,7 @@
template <typename T>
static constexpr T MinInt(size_t bits) {
return
- DCHECK_CONSTEXPR(bits > 0, "bits cannot be zero", 0)
+ DCHECK_CONSTEXPR(std::is_unsigned<T>::value || bits > 0, "bits cannot be zero for signed", 0)
DCHECK_CONSTEXPR(bits <= BitSizeOf<T>(), "kBits must be < max.", 0)
bits == BitSizeOf<T>()
? std::numeric_limits<T>::min()
diff --git a/runtime/check_reference_map_visitor.h b/runtime/check_reference_map_visitor.h
index fcf3326..7595d14 100644
--- a/runtime/check_reference_map_visitor.h
+++ b/runtime/check_reference_map_visitor.h
@@ -66,13 +66,12 @@
SHARED_REQUIRES(Locks::mutator_lock_) {
ArtMethod* m = GetMethod();
CodeInfo code_info = GetCurrentOatQuickMethodHeader()->GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
uint16_t number_of_dex_registers = m->GetCodeItem()->registers_size_;
DexRegisterMap dex_register_map =
code_info.GetDexRegisterMapOf(stack_map, encoding, number_of_dex_registers);
- MemoryRegion stack_mask = stack_map.GetStackMask(encoding);
- uint32_t register_mask = stack_map.GetRegisterMask(encoding);
+ uint32_t register_mask = stack_map.GetRegisterMask(encoding.stack_map_encoding);
for (int i = 0; i < number_of_references; ++i) {
int reg = registers[i];
CHECK(reg < m->GetCodeItem()->registers_size_);
@@ -85,7 +84,8 @@
break;
case DexRegisterLocation::Kind::kInStack:
DCHECK_EQ(location.GetValue() % kFrameSlotSize, 0);
- CHECK(stack_mask.LoadBit(location.GetValue() / kFrameSlotSize));
+ CHECK(stack_map.GetStackMaskBit(encoding.stack_map_encoding,
+ location.GetValue() / kFrameSlotSize));
break;
case DexRegisterLocation::Kind::kInRegister:
case DexRegisterLocation::Kind::kInRegisterHigh:
diff --git a/runtime/entrypoints/entrypoint_utils.cc b/runtime/entrypoints/entrypoint_utils.cc
index 3dfad76..3368411 100644
--- a/runtime/entrypoints/entrypoint_utils.cc
+++ b/runtime/entrypoints/entrypoint_utils.cc
@@ -275,10 +275,10 @@
if (current_code->IsOptimized()) {
uintptr_t native_pc_offset = current_code->NativeQuickPcOffset(caller_pc);
CodeInfo code_info = current_code->GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
DCHECK(stack_map.IsValid());
- if (stack_map.HasInlineInfo(encoding)) {
+ if (stack_map.HasInlineInfo(encoding.stack_map_encoding)) {
InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map, encoding);
caller = GetResolvedMethod(outer_method, inline_info, inline_info.GetDepth() - 1);
}
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index 35f2102..27926e0 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -327,14 +327,14 @@
if (current_code->IsOptimized()) {
CodeInfo code_info = current_code->GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
StackMap stack_map = code_info.GetStackMapForNativePcOffset(outer_pc_offset, encoding);
DCHECK(stack_map.IsValid());
- if (stack_map.HasInlineInfo(encoding)) {
+ if (stack_map.HasInlineInfo(encoding.stack_map_encoding)) {
InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map, encoding);
return inline_info.GetDexPcAtDepth(inline_info.GetDepth() - 1);
} else {
- return stack_map.GetDexPc(encoding);
+ return stack_map.GetDexPc(encoding.stack_map_encoding);
}
} else {
return current_code->ToDexPc(*caller_sp, outer_pc);
diff --git a/runtime/jit/jit.cc b/runtime/jit/jit.cc
index 6496afd..73aaf04 100644
--- a/runtime/jit/jit.cc
+++ b/runtime/jit/jit.cc
@@ -362,7 +362,7 @@
}
CodeInfo code_info = osr_method->GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
// Find stack map starting at the target dex_pc.
StackMap stack_map = code_info.GetOsrStackMapForDexPc(dex_pc + dex_pc_offset, encoding);
@@ -421,7 +421,8 @@
}
}
- native_pc = stack_map.GetNativePcOffset(encoding) + osr_method->GetEntryPoint();
+ native_pc = stack_map.GetNativePcOffset(encoding.stack_map_encoding) +
+ osr_method->GetEntryPoint();
VLOG(jit) << "Jumping to "
<< method_name
<< "@"
diff --git a/runtime/memory_region.h b/runtime/memory_region.h
index 13c69ac..fbb0441 100644
--- a/runtime/memory_region.h
+++ b/runtime/memory_region.h
@@ -138,7 +138,7 @@
// bit of the stored `value`. `value` must not be larger than `length`
// bits.
void StoreBits(uintptr_t bit_offset, uint32_t value, size_t length) {
- CHECK_LT(value, 2u << length);
+ CHECK_LE(value, MaxInt<uint32_t>(length));
for (size_t i = 0; i < length; ++i) {
bool ith_bit = value & (1 << i);
StoreBit(bit_offset + i, ith_bit);
diff --git a/runtime/oat.h b/runtime/oat.h
index 0dcc52e..4e595a1 100644
--- a/runtime/oat.h
+++ b/runtime/oat.h
@@ -32,7 +32,7 @@
class PACKED(4) OatHeader {
public:
static constexpr uint8_t kOatMagic[] = { 'o', 'a', 't', '\n' };
- static constexpr uint8_t kOatVersion[] = { '0', '7', '6', '\0' };
+ static constexpr uint8_t kOatVersion[] = { '0', '7', '7', '\0' };
static constexpr const char* kImageLocationKey = "image-location";
static constexpr const char* kDex2OatCmdLineKey = "dex2oat-cmdline";
diff --git a/runtime/oat_quick_method_header.cc b/runtime/oat_quick_method_header.cc
index 9786c05..07a112f 100644
--- a/runtime/oat_quick_method_header.cc
+++ b/runtime/oat_quick_method_header.cc
@@ -46,10 +46,10 @@
uint32_t sought_offset = pc - reinterpret_cast<uintptr_t>(entry_point);
if (IsOptimized()) {
CodeInfo code_info = GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
StackMap stack_map = code_info.GetStackMapForNativePcOffset(sought_offset, encoding);
if (stack_map.IsValid()) {
- return stack_map.GetDexPc(encoding);
+ return stack_map.GetDexPc(encoding.stack_map_encoding);
}
} else {
MappingTable table(GetMappingTable());
@@ -95,7 +95,7 @@
// Optimized code does not have a mapping table. Search for the dex-to-pc
// mapping in stack maps.
CodeInfo code_info = GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ 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
@@ -104,7 +104,8 @@
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);
+ return reinterpret_cast<uintptr_t>(entry_point) +
+ stack_map.GetNativePcOffset(encoding.stack_map_encoding);
}
} else {
MappingTable table(GetMappingTable());
diff --git a/runtime/quick_exception_handler.cc b/runtime/quick_exception_handler.cc
index 6317f5e..b9cd677 100644
--- a/runtime/quick_exception_handler.cc
+++ b/runtime/quick_exception_handler.cc
@@ -220,7 +220,7 @@
const size_t number_of_vregs = handler_method_->GetCodeItem()->registers_size_;
CodeInfo code_info = handler_method_header_->GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
// Find stack map of the catch block.
StackMap catch_stack_map = code_info.GetCatchStackMapForDexPc(GetHandlerDexPc(), encoding);
@@ -386,11 +386,10 @@
const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
CodeInfo code_info = method_header->GetOptimizedCodeInfo();
uintptr_t native_pc_offset = method_header->NativeQuickPcOffset(GetCurrentQuickFramePc());
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
const size_t number_of_vregs = m->GetCodeItem()->registers_size_;
- MemoryRegion stack_mask = stack_map.GetStackMask(encoding);
- uint32_t register_mask = stack_map.GetRegisterMask(encoding);
+ uint32_t register_mask = stack_map.GetRegisterMask(encoding.stack_map_encoding);
DexRegisterMap vreg_map = IsInInlinedFrame()
? code_info.GetDexRegisterMapAtDepth(GetCurrentInliningDepth() - 1,
code_info.GetInlineInfoOf(stack_map, encoding),
@@ -423,7 +422,8 @@
const uint8_t* addr = reinterpret_cast<const uint8_t*>(GetCurrentQuickFrame()) + offset;
value = *reinterpret_cast<const uint32_t*>(addr);
uint32_t bit = (offset >> 2);
- if (stack_mask.size_in_bits() > bit && stack_mask.LoadBit(bit)) {
+ if (stack_map.GetNumberOfStackMaskBits(encoding.stack_map_encoding) > bit &&
+ stack_map.GetStackMaskBit(encoding.stack_map_encoding, bit)) {
is_reference = true;
}
break;
diff --git a/runtime/stack.cc b/runtime/stack.cc
index ee5da8e..838678b 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -117,7 +117,7 @@
const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
uint32_t native_pc_offset = method_header->NativeQuickPcOffset(cur_quick_frame_pc_);
CodeInfo code_info = method_header->GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
DCHECK(stack_map.IsValid());
return code_info.GetInlineInfoOf(stack_map, encoding);
@@ -308,7 +308,7 @@
DCHECK_LT(vreg, code_item->registers_size_);
const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
CodeInfo code_info = method_header->GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
uint32_t native_pc_offset = method_header->NativeQuickPcOffset(cur_quick_frame_pc_);
StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
@@ -863,11 +863,11 @@
&& (cur_oat_quick_method_header_ != nullptr)
&& cur_oat_quick_method_header_->IsOptimized()) {
CodeInfo code_info = cur_oat_quick_method_header_->GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
uint32_t native_pc_offset =
cur_oat_quick_method_header_->NativeQuickPcOffset(cur_quick_frame_pc_);
StackMap stack_map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
- if (stack_map.IsValid() && stack_map.HasInlineInfo(encoding)) {
+ if (stack_map.IsValid() && stack_map.HasInlineInfo(encoding.stack_map_encoding)) {
InlineInfo inline_info = code_info.GetInlineInfoOf(stack_map, encoding);
DCHECK_EQ(current_inlining_depth_, 0u);
for (current_inlining_depth_ = inline_info.GetDepth();
diff --git a/runtime/stack_map.cc b/runtime/stack_map.cc
index 3093436..b51baf1 100644
--- a/runtime/stack_map.cc
+++ b/runtime/stack_map.cc
@@ -56,66 +56,29 @@
uint16_t dex_register_number,
uint16_t number_of_dex_registers,
const CodeInfo& code_info,
- const StackMapEncoding& enc) const {
+ const CodeInfoEncoding& enc) const {
DexRegisterLocationCatalog dex_register_location_catalog =
code_info.GetDexRegisterLocationCatalog(enc);
size_t location_catalog_entry_index = GetLocationCatalogEntryIndex(
dex_register_number,
number_of_dex_registers,
- code_info.GetNumberOfLocationCatalogEntries());
+ code_info.GetNumberOfLocationCatalogEntries(enc));
return dex_register_location_catalog.GetLocationInternalKind(location_catalog_entry_index);
}
DexRegisterLocation DexRegisterMap::GetDexRegisterLocation(uint16_t dex_register_number,
uint16_t number_of_dex_registers,
const CodeInfo& code_info,
- const StackMapEncoding& enc) const {
+ const CodeInfoEncoding& enc) const {
DexRegisterLocationCatalog dex_register_location_catalog =
code_info.GetDexRegisterLocationCatalog(enc);
size_t location_catalog_entry_index = GetLocationCatalogEntryIndex(
dex_register_number,
number_of_dex_registers,
- code_info.GetNumberOfLocationCatalogEntries());
+ code_info.GetNumberOfLocationCatalogEntries(enc));
return dex_register_location_catalog.GetDexRegisterLocation(location_catalog_entry_index);
}
-uint32_t StackMap::LoadAt(size_t number_of_bytes, size_t offset, bool check_max) const {
- if (number_of_bytes == 0u) {
- DCHECK(!check_max);
- return 0;
- } else if (number_of_bytes == 1u) {
- uint8_t value = region_.LoadUnaligned<uint8_t>(offset);
- return (check_max && value == 0xFF) ? -1 : value;
- } else if (number_of_bytes == 2u) {
- uint16_t value = region_.LoadUnaligned<uint16_t>(offset);
- return (check_max && value == 0xFFFF) ? -1 : value;
- } else if (number_of_bytes == 3u) {
- uint16_t low = region_.LoadUnaligned<uint16_t>(offset);
- uint16_t high = region_.LoadUnaligned<uint8_t>(offset + sizeof(uint16_t));
- uint32_t value = (high << 16) + low;
- return (check_max && value == 0xFFFFFF) ? -1 : value;
- } else {
- DCHECK_EQ(number_of_bytes, 4u);
- return region_.LoadUnaligned<uint32_t>(offset);
- }
-}
-
-void StackMap::StoreAt(size_t number_of_bytes, size_t offset, uint32_t value) const {
- if (number_of_bytes == 0u) {
- DCHECK_EQ(value, 0u);
- } else if (number_of_bytes == 1u) {
- region_.StoreUnaligned<uint8_t>(offset, value);
- } else if (number_of_bytes == 2u) {
- region_.StoreUnaligned<uint16_t>(offset, value);
- } else if (number_of_bytes == 3u) {
- region_.StoreUnaligned<uint16_t>(offset, Low16Bits(value));
- region_.StoreUnaligned<uint8_t>(offset + sizeof(uint16_t), High16Bits(value));
- } else {
- region_.StoreUnaligned<uint32_t>(offset, value);
- DCHECK_EQ(number_of_bytes, 4u);
- }
-}
-
static void DumpRegisterMapping(std::ostream& os,
size_t dex_register_num,
DexRegisterLocation location,
@@ -126,25 +89,30 @@
<< " (" << location.GetValue() << ")" << suffix << '\n';
}
+void StackMapEncoding::Dump(VariableIndentationOutputStream* vios) const {
+ vios->Stream()
+ << "StackMapEncoding"
+ << " (native_pc_bit_offset=" << static_cast<uint32_t>(kNativePcBitOffset)
+ << ", dex_pc_bit_offset=" << static_cast<uint32_t>(dex_pc_bit_offset_)
+ << ", dex_register_map_bit_offset=" << static_cast<uint32_t>(dex_register_map_bit_offset_)
+ << ", inline_info_bit_offset=" << static_cast<uint32_t>(inline_info_bit_offset_)
+ << ", register_mask_bit_offset=" << static_cast<uint32_t>(register_mask_bit_offset_)
+ << ", stack_mask_bit_offset=" << static_cast<uint32_t>(stack_mask_bit_offset_)
+ << ")\n";
+}
+
void CodeInfo::Dump(VariableIndentationOutputStream* vios,
uint32_t code_offset,
uint16_t number_of_dex_registers,
bool dump_stack_maps) const {
- StackMapEncoding encoding = ExtractEncoding();
- uint32_t code_info_size = GetOverallSize();
- size_t number_of_stack_maps = GetNumberOfStackMaps();
+ CodeInfoEncoding encoding = ExtractEncoding();
+ size_t number_of_stack_maps = GetNumberOfStackMaps(encoding);
vios->Stream()
- << "Optimized CodeInfo (size=" << code_info_size
- << ", number_of_dex_registers=" << number_of_dex_registers
+ << "Optimized CodeInfo (number_of_dex_registers=" << number_of_dex_registers
<< ", number_of_stack_maps=" << number_of_stack_maps
- << ", has_inline_info=" << encoding.HasInlineInfo()
- << ", number_of_bytes_for_inline_info=" << encoding.NumberOfBytesForInlineInfo()
- << ", number_of_bytes_for_dex_register_map=" << encoding.NumberOfBytesForDexRegisterMap()
- << ", number_of_bytes_for_dex_pc=" << encoding.NumberOfBytesForDexPc()
- << ", number_of_bytes_for_native_pc=" << encoding.NumberOfBytesForNativePc()
- << ", number_of_bytes_for_register_mask=" << encoding.NumberOfBytesForRegisterMask()
<< ")\n";
ScopedIndentation indent1(vios);
+ encoding.stack_map_encoding.Dump(vios);
// Display the Dex register location catalog.
GetDexRegisterLocationCatalog(encoding).Dump(vios, *this);
// Display stack maps along with (live) Dex register maps.
@@ -165,8 +133,8 @@
void DexRegisterLocationCatalog::Dump(VariableIndentationOutputStream* vios,
const CodeInfo& code_info) {
- StackMapEncoding encoding = code_info.ExtractEncoding();
- size_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ size_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries(encoding);
size_t location_catalog_size_in_bytes = code_info.GetDexRegisterLocationCatalogSize(encoding);
vios->Stream()
<< "DexRegisterLocationCatalog (number_of_entries=" << number_of_location_catalog_entries
@@ -181,8 +149,8 @@
void DexRegisterMap::Dump(VariableIndentationOutputStream* vios,
const CodeInfo& code_info,
uint16_t number_of_dex_registers) const {
- StackMapEncoding encoding = code_info.ExtractEncoding();
- size_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
+ size_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries(encoding);
// TODO: Display the bit mask of live Dex registers.
for (size_t j = 0; j < number_of_dex_registers; ++j) {
if (IsDexRegisterLive(j)) {
@@ -202,32 +170,32 @@
void StackMap::Dump(VariableIndentationOutputStream* vios,
const CodeInfo& code_info,
- const StackMapEncoding& encoding,
+ const CodeInfoEncoding& encoding,
uint32_t code_offset,
uint16_t number_of_dex_registers,
const std::string& header_suffix) const {
+ StackMapEncoding stack_map_encoding = encoding.stack_map_encoding;
vios->Stream()
<< "StackMap" << header_suffix
<< std::hex
- << " [native_pc=0x" << code_offset + GetNativePcOffset(encoding) << "]"
- << " (dex_pc=0x" << GetDexPc(encoding)
- << ", native_pc_offset=0x" << GetNativePcOffset(encoding)
- << ", dex_register_map_offset=0x" << GetDexRegisterMapOffset(encoding)
- << ", inline_info_offset=0x" << GetInlineDescriptorOffset(encoding)
- << ", register_mask=0x" << GetRegisterMask(encoding)
+ << " [native_pc=0x" << code_offset + GetNativePcOffset(stack_map_encoding) << "]"
+ << " (dex_pc=0x" << GetDexPc(stack_map_encoding)
+ << ", native_pc_offset=0x" << GetNativePcOffset(stack_map_encoding)
+ << ", dex_register_map_offset=0x" << GetDexRegisterMapOffset(stack_map_encoding)
+ << ", inline_info_offset=0x" << GetInlineDescriptorOffset(stack_map_encoding)
+ << ", register_mask=0x" << GetRegisterMask(stack_map_encoding)
<< std::dec
<< ", stack_mask=0b";
- MemoryRegion stack_mask = GetStackMask(encoding);
- for (size_t i = 0, e = stack_mask.size_in_bits(); i < e; ++i) {
- vios->Stream() << stack_mask.LoadBit(e - i - 1);
+ for (size_t i = 0, e = GetNumberOfStackMaskBits(stack_map_encoding); i < e; ++i) {
+ vios->Stream() << GetStackMaskBit(stack_map_encoding, e - i - 1);
}
vios->Stream() << ")\n";
- if (HasDexRegisterMap(encoding)) {
+ if (HasDexRegisterMap(stack_map_encoding)) {
DexRegisterMap dex_register_map = code_info.GetDexRegisterMapOf(
*this, encoding, number_of_dex_registers);
dex_register_map.Dump(vios, code_info, number_of_dex_registers);
}
- if (HasInlineInfo(encoding)) {
+ if (HasInlineInfo(stack_map_encoding)) {
InlineInfo inline_info = code_info.GetInlineInfoOf(*this, encoding);
// We do not know the length of the dex register maps of inlined frames
// at this level, so we just pass null to `InlineInfo::Dump` to tell
@@ -251,7 +219,7 @@
<< ", invoke_type=" << static_cast<InvokeType>(GetInvokeTypeAtDepth(i))
<< ")\n";
if (HasDexRegisterMapAtDepth(i) && (number_of_dex_registers != nullptr)) {
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
DexRegisterMap dex_register_map =
code_info.GetDexRegisterMapAtDepth(i, *this, encoding, number_of_dex_registers[i]);
ScopedIndentation indent1(vios);
diff --git a/runtime/stack_map.h b/runtime/stack_map.h
index dbf23aa..9e8884e 100644
--- a/runtime/stack_map.h
+++ b/runtime/stack_map.h
@@ -20,6 +20,7 @@
#include "base/bit_vector.h"
#include "base/bit_utils.h"
#include "memory_region.h"
+#include "leb128.h"
namespace art {
@@ -39,13 +40,9 @@
// Size of Dex virtual registers.
static constexpr size_t kVRegSize = 4;
-// We encode the number of bytes needed for writing a value on 3 bits
-// (i.e. up to 8 values), for values that we know are maximum 32-bit
-// long.
-static constexpr size_t kNumberOfBitForNumberOfBytesForEncoding = 3;
-
class CodeInfo;
class StackMapEncoding;
+struct CodeInfoEncoding;
/**
* Classes in the following file are wrapper on stack map information backed
@@ -459,7 +456,7 @@
DexRegisterLocation::Kind GetLocationKind(uint16_t dex_register_number,
uint16_t number_of_dex_registers,
const CodeInfo& code_info,
- const StackMapEncoding& enc) const {
+ const CodeInfoEncoding& enc) const {
return DexRegisterLocation::ConvertToSurfaceKind(
GetLocationInternalKind(dex_register_number, number_of_dex_registers, code_info, enc));
}
@@ -468,18 +465,18 @@
DexRegisterLocation::Kind GetLocationInternalKind(uint16_t dex_register_number,
uint16_t number_of_dex_registers,
const CodeInfo& code_info,
- const StackMapEncoding& enc) const;
+ const CodeInfoEncoding& enc) const;
// Get the Dex register location `dex_register_number`.
DexRegisterLocation GetDexRegisterLocation(uint16_t dex_register_number,
uint16_t number_of_dex_registers,
const CodeInfo& code_info,
- const StackMapEncoding& enc) const;
+ const CodeInfoEncoding& enc) const;
int32_t GetStackOffsetInBytes(uint16_t dex_register_number,
uint16_t number_of_dex_registers,
const CodeInfo& code_info,
- const StackMapEncoding& enc) const {
+ const CodeInfoEncoding& enc) const {
DexRegisterLocation location =
GetDexRegisterLocation(dex_register_number, number_of_dex_registers, code_info, enc);
DCHECK(location.GetKind() == DexRegisterLocation::Kind::kInStack);
@@ -490,7 +487,7 @@
int32_t GetConstant(uint16_t dex_register_number,
uint16_t number_of_dex_registers,
const CodeInfo& code_info,
- const StackMapEncoding& enc) const {
+ const CodeInfoEncoding& enc) const {
DexRegisterLocation location =
GetDexRegisterLocation(dex_register_number, number_of_dex_registers, code_info, enc);
DCHECK_EQ(location.GetKind(), DexRegisterLocation::Kind::kConstant);
@@ -500,7 +497,7 @@
int32_t GetMachineRegister(uint16_t dex_register_number,
uint16_t number_of_dex_registers,
const CodeInfo& code_info,
- const StackMapEncoding& enc) const {
+ const CodeInfoEncoding& enc) const {
DexRegisterLocation location =
GetDexRegisterLocation(dex_register_number, number_of_dex_registers, code_info, enc);
DCHECK(location.GetInternalKind() == DexRegisterLocation::Kind::kInRegister ||
@@ -657,109 +654,131 @@
friend class StackMapStream;
};
+// Represents bit range of bit-packed integer field.
+// We reuse the idea from ULEB128p1 to support encoding of -1 (aka 0xFFFFFFFF).
+// If min_value is set to -1, we implicitly subtract one from any loaded value,
+// and add one to any stored value. This is generalized to any negative values.
+// In other words, min_value acts as a base and the stored value is added to it.
+struct FieldEncoding {
+ FieldEncoding(size_t start_offset, size_t end_offset, int32_t min_value = 0)
+ : start_offset_(start_offset), end_offset_(end_offset), min_value_(min_value) {
+ DCHECK_LE(start_offset_, end_offset_);
+ DCHECK_LE(BitSize(), 32u);
+ }
+
+ ALWAYS_INLINE size_t BitSize() const { return end_offset_ - start_offset_; }
+
+ ALWAYS_INLINE int32_t Load(const MemoryRegion& region) const {
+ DCHECK_LE(end_offset_, region.size_in_bits());
+ const size_t bit_count = BitSize();
+ if (bit_count == 0) {
+ // Do not touch any memory if the range is empty.
+ return min_value_;
+ }
+ uint8_t* address = region.start() + start_offset_ / kBitsPerByte;
+ const uint32_t shift = start_offset_ & (kBitsPerByte - 1);
+ // Load the value (reading only the strictly needed bytes).
+ const uint32_t load_bit_count = shift + bit_count;
+ uint32_t value = *address++ >> shift;
+ if (load_bit_count > 8) {
+ value |= static_cast<uint32_t>(*address++) << (8 - shift);
+ if (load_bit_count > 16) {
+ value |= static_cast<uint32_t>(*address++) << (16 - shift);
+ if (load_bit_count > 24) {
+ value |= static_cast<uint32_t>(*address++) << (24 - shift);
+ if (load_bit_count > 32) {
+ value |= static_cast<uint32_t>(*address++) << (32 - shift);
+ }
+ }
+ }
+ }
+ // Clear unwanted most significant bits.
+ uint32_t clear_bit_count = 32 - bit_count;
+ value = (value << clear_bit_count) >> clear_bit_count;
+ return value + min_value_;
+ }
+
+ ALWAYS_INLINE void Store(MemoryRegion region, int32_t value) const {
+ region.StoreBits(start_offset_, value - min_value_, BitSize());
+ DCHECK_EQ(Load(region), value);
+ }
+
+ private:
+ size_t start_offset_;
+ size_t end_offset_;
+ int32_t min_value_;
+};
+
class StackMapEncoding {
public:
StackMapEncoding() {}
- StackMapEncoding(size_t stack_mask_size,
- size_t bytes_for_inline_info,
- size_t bytes_for_dex_register_map,
- size_t bytes_for_dex_pc,
- size_t bytes_for_native_pc,
- size_t bytes_for_register_mask)
- : bytes_for_stack_mask_(stack_mask_size),
- bytes_for_inline_info_(bytes_for_inline_info),
- bytes_for_dex_register_map_(bytes_for_dex_register_map),
- bytes_for_dex_pc_(bytes_for_dex_pc),
- bytes_for_native_pc_(bytes_for_native_pc),
- bytes_for_register_mask_(bytes_for_register_mask) {}
+ // Set stack map bit layout based on given sizes.
+ // Returns the size of stack map in bytes.
+ size_t SetFromSizes(size_t native_pc_max,
+ size_t dex_pc_max,
+ size_t dex_register_map_size,
+ size_t inline_info_size,
+ size_t register_mask_max,
+ size_t stack_mask_bit_size) {
+ size_t bit_offset = 0;
+ DCHECK_EQ(kNativePcBitOffset, bit_offset);
+ bit_offset += MinimumBitsToStore(native_pc_max);
- static StackMapEncoding CreateFromSizes(size_t stack_mask_size,
- size_t inline_info_size,
- size_t dex_register_map_size,
- size_t dex_pc_max,
- size_t native_pc_max,
- size_t register_mask_max) {
- return StackMapEncoding(
- stack_mask_size,
- // + 1 to also encode kNoInlineInfo: if an inline info offset
- // is at 0xFF, we want to overflow to a larger encoding, because it will
- // conflict with kNoInlineInfo.
- // The offset is relative to the dex register map. TODO: Change this.
- inline_info_size == 0
- ? 0
- : EncodingSizeInBytes(dex_register_map_size + inline_info_size + 1),
- // + 1 to also encode kNoDexRegisterMap: if a dex register map offset
- // is at 0xFF, we want to overflow to a larger encoding, because it will
- // conflict with kNoDexRegisterMap.
- EncodingSizeInBytes(dex_register_map_size + 1),
- EncodingSizeInBytes(dex_pc_max),
- EncodingSizeInBytes(native_pc_max),
- EncodingSizeInBytes(register_mask_max));
+ dex_pc_bit_offset_ = dchecked_integral_cast<uint8_t>(bit_offset);
+ bit_offset += MinimumBitsToStore(1 /* kNoDexPc */ + dex_pc_max);
+
+ // We also need +1 for kNoDexRegisterMap, but since the size is strictly
+ // greater than any offset we might try to encode, we already implicitly have it.
+ dex_register_map_bit_offset_ = dchecked_integral_cast<uint8_t>(bit_offset);
+ bit_offset += MinimumBitsToStore(dex_register_map_size);
+
+ // We also need +1 for kNoInlineInfo, but since the inline_info_size is strictly
+ // greater than the offset we might try to encode, we already implicitly have it.
+ // If inline_info_size is zero, we can encode only kNoInlineInfo (in zero bits).
+ inline_info_bit_offset_ = dchecked_integral_cast<uint8_t>(bit_offset);
+ if (inline_info_size != 0) {
+ bit_offset += MinimumBitsToStore(dex_register_map_size + inline_info_size);
+ }
+
+ register_mask_bit_offset_ = dchecked_integral_cast<uint8_t>(bit_offset);
+ bit_offset += MinimumBitsToStore(register_mask_max);
+
+ stack_mask_bit_offset_ = dchecked_integral_cast<uint8_t>(bit_offset);
+ bit_offset += stack_mask_bit_size;
+
+ return RoundUp(bit_offset, kBitsPerByte) / kBitsPerByte;
}
- // Get the size of one stack map of this CodeInfo object, in bytes.
- // All stack maps of a CodeInfo have the same size.
- size_t ComputeStackMapSize() const {
- return bytes_for_register_mask_
- + bytes_for_stack_mask_
- + bytes_for_inline_info_
- + bytes_for_dex_register_map_
- + bytes_for_dex_pc_
- + bytes_for_native_pc_;
+ ALWAYS_INLINE FieldEncoding GetNativePcEncoding() const {
+ return FieldEncoding(kNativePcBitOffset, dex_pc_bit_offset_);
+ }
+ ALWAYS_INLINE FieldEncoding GetDexPcEncoding() const {
+ return FieldEncoding(dex_pc_bit_offset_, dex_register_map_bit_offset_, -1 /* min_value */);
+ }
+ ALWAYS_INLINE FieldEncoding GetDexRegisterMapEncoding() const {
+ return FieldEncoding(dex_register_map_bit_offset_, inline_info_bit_offset_, -1 /* min_value */);
+ }
+ ALWAYS_INLINE FieldEncoding GetInlineInfoEncoding() const {
+ return FieldEncoding(inline_info_bit_offset_, register_mask_bit_offset_, -1 /* min_value */);
+ }
+ ALWAYS_INLINE FieldEncoding GetRegisterMaskEncoding() const {
+ return FieldEncoding(register_mask_bit_offset_, stack_mask_bit_offset_);
+ }
+ ALWAYS_INLINE size_t GetStackMaskBitOffset() const {
+ // The end offset is not encoded. It is implicitly the end of stack map entry.
+ return stack_mask_bit_offset_;
}
- bool HasInlineInfo() const { return bytes_for_inline_info_ > 0; }
-
- size_t NumberOfBytesForStackMask() const { return bytes_for_stack_mask_; }
- size_t NumberOfBytesForInlineInfo() const { return bytes_for_inline_info_; }
- size_t NumberOfBytesForDexRegisterMap() const { return bytes_for_dex_register_map_; }
- size_t NumberOfBytesForDexPc() const { return bytes_for_dex_pc_; }
- size_t NumberOfBytesForNativePc() const { return bytes_for_native_pc_; }
- size_t NumberOfBytesForRegisterMask() const { return bytes_for_register_mask_; }
-
- size_t ComputeStackMapRegisterMaskOffset() const {
- return kRegisterMaskOffset;
- }
-
- size_t ComputeStackMapStackMaskOffset() const {
- return ComputeStackMapRegisterMaskOffset() + bytes_for_register_mask_;
- }
-
- size_t ComputeStackMapDexPcOffset() const {
- return ComputeStackMapStackMaskOffset() + bytes_for_stack_mask_;
- }
-
- size_t ComputeStackMapNativePcOffset() const {
- return ComputeStackMapDexPcOffset() + bytes_for_dex_pc_;
- }
-
- size_t ComputeStackMapDexRegisterMapOffset() const {
- return ComputeStackMapNativePcOffset() + bytes_for_native_pc_;
- }
-
- size_t ComputeStackMapInlineInfoOffset() const {
- return ComputeStackMapDexRegisterMapOffset() + bytes_for_dex_register_map_;
- }
+ void Dump(VariableIndentationOutputStream* vios) const;
private:
- static size_t EncodingSizeInBytes(size_t max_element) {
- DCHECK(IsUint<32>(max_element));
- return (max_element == 0) ? 0
- : IsUint<8>(max_element) ? 1
- : IsUint<16>(max_element) ? 2
- : IsUint<24>(max_element) ? 3
- : 4;
- }
-
- static constexpr int kRegisterMaskOffset = 0;
-
- size_t bytes_for_stack_mask_;
- size_t bytes_for_inline_info_;
- size_t bytes_for_dex_register_map_;
- size_t bytes_for_dex_pc_;
- size_t bytes_for_native_pc_;
- size_t bytes_for_register_mask_;
+ static constexpr size_t kNativePcBitOffset = 0;
+ uint8_t dex_pc_bit_offset_;
+ uint8_t dex_register_map_bit_offset_;
+ uint8_t inline_info_bit_offset_;
+ uint8_t register_mask_bit_offset_;
+ uint8_t stack_mask_bit_offset_;
};
/**
@@ -772,7 +791,7 @@
*
* The information is of the form:
*
- * [dex_pc, native_pc_offset, dex_register_map_offset, inlining_info_offset, register_mask,
+ * [native_pc_offset, dex_pc, dex_register_map_offset, inlining_info_offset, register_mask,
* stack_mask].
*/
class StackMap {
@@ -780,89 +799,75 @@
StackMap() {}
explicit StackMap(MemoryRegion region) : region_(region) {}
- bool IsValid() const { return region_.pointer() != nullptr; }
+ ALWAYS_INLINE bool IsValid() const { return region_.pointer() != nullptr; }
- uint32_t GetDexPc(const StackMapEncoding& encoding) const {
- return LoadAt(encoding.NumberOfBytesForDexPc(), encoding.ComputeStackMapDexPcOffset());
+ ALWAYS_INLINE uint32_t GetDexPc(const StackMapEncoding& encoding) const {
+ return encoding.GetDexPcEncoding().Load(region_);
}
- void SetDexPc(const StackMapEncoding& encoding, uint32_t dex_pc) {
- StoreAt(encoding.NumberOfBytesForDexPc(), encoding.ComputeStackMapDexPcOffset(), dex_pc);
+ ALWAYS_INLINE void SetDexPc(const StackMapEncoding& encoding, uint32_t dex_pc) {
+ encoding.GetDexPcEncoding().Store(region_, dex_pc);
}
- uint32_t GetNativePcOffset(const StackMapEncoding& encoding) const {
- return LoadAt(encoding.NumberOfBytesForNativePc(), encoding.ComputeStackMapNativePcOffset());
+ ALWAYS_INLINE uint32_t GetNativePcOffset(const StackMapEncoding& encoding) const {
+ return encoding.GetNativePcEncoding().Load(region_);
}
- void SetNativePcOffset(const StackMapEncoding& encoding, uint32_t native_pc_offset) {
- StoreAt(encoding.NumberOfBytesForNativePc(),
- encoding.ComputeStackMapNativePcOffset(),
- native_pc_offset);
+ ALWAYS_INLINE void SetNativePcOffset(const StackMapEncoding& encoding, uint32_t native_pc_offset) {
+ encoding.GetNativePcEncoding().Store(region_, native_pc_offset);
}
- uint32_t GetDexRegisterMapOffset(const StackMapEncoding& encoding) const {
- return LoadAt(encoding.NumberOfBytesForDexRegisterMap(),
- encoding.ComputeStackMapDexRegisterMapOffset(),
- /* check_max */ true);
+ ALWAYS_INLINE uint32_t GetDexRegisterMapOffset(const StackMapEncoding& encoding) const {
+ return encoding.GetDexRegisterMapEncoding().Load(region_);
}
- void SetDexRegisterMapOffset(const StackMapEncoding& encoding, uint32_t offset) {
- StoreAt(encoding.NumberOfBytesForDexRegisterMap(),
- encoding.ComputeStackMapDexRegisterMapOffset(),
- offset);
+ ALWAYS_INLINE void SetDexRegisterMapOffset(const StackMapEncoding& encoding, uint32_t offset) {
+ encoding.GetDexRegisterMapEncoding().Store(region_, offset);
}
- uint32_t GetInlineDescriptorOffset(const StackMapEncoding& encoding) const {
- if (!encoding.HasInlineInfo()) return kNoInlineInfo;
- return LoadAt(encoding.NumberOfBytesForInlineInfo(),
- encoding.ComputeStackMapInlineInfoOffset(),
- /* check_max */ true);
+ ALWAYS_INLINE uint32_t GetInlineDescriptorOffset(const StackMapEncoding& encoding) const {
+ return encoding.GetInlineInfoEncoding().Load(region_);
}
- void SetInlineDescriptorOffset(const StackMapEncoding& encoding, uint32_t offset) {
- DCHECK(encoding.HasInlineInfo());
- StoreAt(encoding.NumberOfBytesForInlineInfo(),
- encoding.ComputeStackMapInlineInfoOffset(),
- offset);
+ ALWAYS_INLINE void SetInlineDescriptorOffset(const StackMapEncoding& encoding, uint32_t offset) {
+ encoding.GetInlineInfoEncoding().Store(region_, offset);
}
- uint32_t GetRegisterMask(const StackMapEncoding& encoding) const {
- return LoadAt(encoding.NumberOfBytesForRegisterMask(),
- encoding.ComputeStackMapRegisterMaskOffset());
+ ALWAYS_INLINE uint32_t GetRegisterMask(const StackMapEncoding& encoding) const {
+ return encoding.GetRegisterMaskEncoding().Load(region_);
}
- void SetRegisterMask(const StackMapEncoding& encoding, uint32_t mask) {
- StoreAt(encoding.NumberOfBytesForRegisterMask(),
- encoding.ComputeStackMapRegisterMaskOffset(),
- mask);
+ ALWAYS_INLINE void SetRegisterMask(const StackMapEncoding& encoding, uint32_t mask) {
+ encoding.GetRegisterMaskEncoding().Store(region_, mask);
}
- MemoryRegion GetStackMask(const StackMapEncoding& encoding) const {
- return region_.Subregion(encoding.ComputeStackMapStackMaskOffset(),
- encoding.NumberOfBytesForStackMask());
+ ALWAYS_INLINE size_t GetNumberOfStackMaskBits(const StackMapEncoding& encoding) const {
+ return region_.size_in_bits() - encoding.GetStackMaskBitOffset();
}
- void SetStackMask(const StackMapEncoding& encoding, const BitVector& sp_map) {
- MemoryRegion region = GetStackMask(encoding);
- sp_map.CopyTo(region.start(), region.size());
+ ALWAYS_INLINE bool GetStackMaskBit(const StackMapEncoding& encoding, size_t index) const {
+ return region_.LoadBit(encoding.GetStackMaskBitOffset() + index);
}
- bool HasDexRegisterMap(const StackMapEncoding& encoding) const {
+ ALWAYS_INLINE void SetStackMaskBit(const StackMapEncoding& encoding, size_t index, bool value) {
+ region_.StoreBit(encoding.GetStackMaskBitOffset() + index, value);
+ }
+
+ ALWAYS_INLINE bool HasDexRegisterMap(const StackMapEncoding& encoding) const {
return GetDexRegisterMapOffset(encoding) != kNoDexRegisterMap;
}
- bool HasInlineInfo(const StackMapEncoding& encoding) const {
+ ALWAYS_INLINE bool HasInlineInfo(const StackMapEncoding& encoding) const {
return GetInlineDescriptorOffset(encoding) != kNoInlineInfo;
}
- bool Equals(const StackMap& other) const {
- return region_.pointer() == other.region_.pointer()
- && region_.size() == other.region_.size();
+ ALWAYS_INLINE bool Equals(const StackMap& other) const {
+ return region_.pointer() == other.region_.pointer() && region_.size() == other.region_.size();
}
void Dump(VariableIndentationOutputStream* vios,
const CodeInfo& code_info,
- const StackMapEncoding& encoding,
+ const CodeInfoEncoding& encoding,
uint32_t code_offset,
uint16_t number_of_dex_registers,
const std::string& header_suffix = "") const;
@@ -878,11 +883,6 @@
private:
static constexpr int kFixedSize = 0;
- // Loads `number_of_bytes` at the given `offset` and assemble a uint32_t. If `check_max` is true,
- // this method converts a maximum value of size `number_of_bytes` into a uint32_t 0xFFFFFFFF.
- uint32_t LoadAt(size_t number_of_bytes, size_t offset, bool check_max = false) const;
- void StoreAt(size_t number_of_bytes, size_t offset, uint32_t value) const;
-
MemoryRegion region_;
friend class StackMapStream;
@@ -986,142 +986,121 @@
friend class StackMapStream;
};
+// Most of the fields are encoded as ULEB128 to save space.
+struct CodeInfoEncoding {
+ uint32_t non_header_size;
+ uint32_t number_of_stack_maps;
+ uint32_t stack_map_size_in_bytes;
+ uint32_t number_of_location_catalog_entries;
+ StackMapEncoding stack_map_encoding;
+ uint8_t header_size;
+
+ CodeInfoEncoding() { }
+
+ explicit CodeInfoEncoding(const void* data) {
+ const uint8_t* ptr = reinterpret_cast<const uint8_t*>(data);
+ non_header_size = DecodeUnsignedLeb128(&ptr);
+ number_of_stack_maps = DecodeUnsignedLeb128(&ptr);
+ stack_map_size_in_bytes = DecodeUnsignedLeb128(&ptr);
+ number_of_location_catalog_entries = DecodeUnsignedLeb128(&ptr);
+ static_assert(alignof(StackMapEncoding) == 1, "StackMapEncoding should not require alignment");
+ stack_map_encoding = *reinterpret_cast<const StackMapEncoding*>(ptr);
+ ptr += sizeof(StackMapEncoding);
+ header_size = dchecked_integral_cast<uint8_t>(ptr - reinterpret_cast<const uint8_t*>(data));
+ }
+
+ template<typename Vector>
+ void Compress(Vector* dest) const {
+ EncodeUnsignedLeb128(dest, non_header_size);
+ EncodeUnsignedLeb128(dest, number_of_stack_maps);
+ EncodeUnsignedLeb128(dest, stack_map_size_in_bytes);
+ EncodeUnsignedLeb128(dest, number_of_location_catalog_entries);
+ const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&stack_map_encoding);
+ dest->insert(dest->end(), ptr, ptr + sizeof(stack_map_encoding));
+ }
+};
+
/**
* Wrapper around all compiler information collected for a method.
* The information is of the form:
*
- * [overall_size, encoding_info, number_of_location_catalog_entries, number_of_stack_maps,
- * stack_mask_size, DexRegisterLocationCatalog+, StackMap+, DexRegisterMap+, InlineInfo*]
+ * [CodeInfoEncoding, StackMap+, DexRegisterLocationCatalog+, DexRegisterMap+, InlineInfo*]
*
- * where `encoding_info` is of the form:
+ * where CodeInfoEncoding is of the form:
*
- * [has_inline_info, inline_info_size_in_bytes, dex_register_map_size_in_bytes,
- * dex_pc_size_in_bytes, native_pc_size_in_bytes, register_mask_size_in_bytes].
+ * [non_header_size, number_of_stack_maps, stack_map_size_in_bytes,
+ * number_of_location_catalog_entries, StackMapEncoding]
*/
class CodeInfo {
public:
- // Memory layout: fixed contents.
- typedef uint32_t OverallSizeType;
- typedef uint16_t EncodingInfoType;
- typedef uint32_t NumberOfLocationCatalogEntriesType;
- typedef uint32_t NumberOfStackMapsType;
- typedef uint32_t StackMaskSizeType;
-
- // Memory (bit) layout: encoding info.
- static constexpr int HasInlineInfoBitSize = 1;
- static constexpr int InlineInfoBitSize = kNumberOfBitForNumberOfBytesForEncoding;
- static constexpr int DexRegisterMapBitSize = kNumberOfBitForNumberOfBytesForEncoding;
- static constexpr int DexPcBitSize = kNumberOfBitForNumberOfBytesForEncoding;
- static constexpr int NativePcBitSize = kNumberOfBitForNumberOfBytesForEncoding;
- static constexpr int RegisterMaskBitSize = kNumberOfBitForNumberOfBytesForEncoding;
-
- explicit CodeInfo(MemoryRegion region) : region_(region) {}
+ explicit CodeInfo(MemoryRegion region) : region_(region) {
+ }
explicit CodeInfo(const void* data) {
- uint32_t size = reinterpret_cast<const uint32_t*>(data)[0];
- region_ = MemoryRegion(const_cast<void*>(data), size);
+ CodeInfoEncoding encoding = CodeInfoEncoding(data);
+ region_ = MemoryRegion(const_cast<void*>(data),
+ encoding.header_size + encoding.non_header_size);
}
- StackMapEncoding ExtractEncoding() const {
- return StackMapEncoding(region_.LoadUnaligned<uint32_t>(kStackMaskSizeOffset),
- GetNumberOfBytesForEncoding(kInlineInfoBitOffset),
- GetNumberOfBytesForEncoding(kDexRegisterMapBitOffset),
- GetNumberOfBytesForEncoding(kDexPcBitOffset),
- GetNumberOfBytesForEncoding(kNativePcBitOffset),
- GetNumberOfBytesForEncoding(kRegisterMaskBitOffset));
+ CodeInfoEncoding ExtractEncoding() const {
+ return CodeInfoEncoding(region_.start());
}
- void SetEncoding(const StackMapEncoding& encoding) {
- region_.StoreUnaligned<uint32_t>(kStackMaskSizeOffset, encoding.NumberOfBytesForStackMask());
- region_.StoreBit(kHasInlineInfoBitOffset, encoding.NumberOfBytesForInlineInfo() != 0);
- SetEncodingAt(kInlineInfoBitOffset, encoding.NumberOfBytesForInlineInfo());
- SetEncodingAt(kDexRegisterMapBitOffset, encoding.NumberOfBytesForDexRegisterMap());
- SetEncodingAt(kDexPcBitOffset, encoding.NumberOfBytesForDexPc());
- SetEncodingAt(kNativePcBitOffset, encoding.NumberOfBytesForNativePc());
- SetEncodingAt(kRegisterMaskBitOffset, encoding.NumberOfBytesForRegisterMask());
+ bool HasInlineInfo(const CodeInfoEncoding& encoding) const {
+ return encoding.stack_map_encoding.GetInlineInfoEncoding().BitSize() > 0;
}
- void SetEncodingAt(size_t bit_offset, size_t number_of_bytes) {
- region_.StoreBits(bit_offset, number_of_bytes, kNumberOfBitForNumberOfBytesForEncoding);
- }
-
- size_t GetNumberOfBytesForEncoding(size_t bit_offset) const {
- return region_.LoadBits(bit_offset, kNumberOfBitForNumberOfBytesForEncoding);
- }
-
- bool HasInlineInfo() const {
- return region_.LoadBit(kHasInlineInfoBitOffset);
- }
-
- DexRegisterLocationCatalog GetDexRegisterLocationCatalog(const StackMapEncoding& encoding) const {
+ DexRegisterLocationCatalog GetDexRegisterLocationCatalog(const CodeInfoEncoding& encoding) const {
return DexRegisterLocationCatalog(region_.Subregion(
GetDexRegisterLocationCatalogOffset(encoding),
GetDexRegisterLocationCatalogSize(encoding)));
}
- StackMap GetStackMapAt(size_t i, const StackMapEncoding& encoding) const {
- size_t stack_map_size = encoding.ComputeStackMapSize();
+ StackMap GetStackMapAt(size_t i, const CodeInfoEncoding& encoding) const {
+ size_t stack_map_size = encoding.stack_map_size_in_bytes;
return StackMap(GetStackMaps(encoding).Subregion(i * stack_map_size, stack_map_size));
}
- OverallSizeType GetOverallSize() const {
- return region_.LoadUnaligned<OverallSizeType>(kOverallSizeOffset);
+ uint32_t GetNumberOfLocationCatalogEntries(const CodeInfoEncoding& encoding) const {
+ return encoding.number_of_location_catalog_entries;
}
- void SetOverallSize(OverallSizeType size) {
- region_.StoreUnaligned<OverallSizeType>(kOverallSizeOffset, size);
- }
-
- NumberOfLocationCatalogEntriesType GetNumberOfLocationCatalogEntries() const {
- return region_.LoadUnaligned<NumberOfLocationCatalogEntriesType>(
- kNumberOfLocationCatalogEntriesOffset);
- }
-
- void SetNumberOfLocationCatalogEntries(NumberOfLocationCatalogEntriesType num_entries) {
- region_.StoreUnaligned<NumberOfLocationCatalogEntriesType>(
- kNumberOfLocationCatalogEntriesOffset, num_entries);
- }
-
- uint32_t GetDexRegisterLocationCatalogSize(const StackMapEncoding& encoding) const {
+ uint32_t GetDexRegisterLocationCatalogSize(const CodeInfoEncoding& encoding) const {
return ComputeDexRegisterLocationCatalogSize(GetDexRegisterLocationCatalogOffset(encoding),
- GetNumberOfLocationCatalogEntries());
+ GetNumberOfLocationCatalogEntries(encoding));
}
- NumberOfStackMapsType GetNumberOfStackMaps() const {
- return region_.LoadUnaligned<NumberOfStackMapsType>(kNumberOfStackMapsOffset);
- }
-
- void SetNumberOfStackMaps(NumberOfStackMapsType number_of_stack_maps) {
- region_.StoreUnaligned<NumberOfStackMapsType>(kNumberOfStackMapsOffset, number_of_stack_maps);
+ uint32_t GetNumberOfStackMaps(const CodeInfoEncoding& encoding) const {
+ return encoding.number_of_stack_maps;
}
// Get the size of all the stack maps of this CodeInfo object, in bytes.
- size_t GetStackMapsSize(const StackMapEncoding& encoding) const {
- return encoding.ComputeStackMapSize() * GetNumberOfStackMaps();
+ size_t GetStackMapsSize(const CodeInfoEncoding& encoding) const {
+ return encoding.stack_map_size_in_bytes * GetNumberOfStackMaps(encoding);
}
- uint32_t GetDexRegisterLocationCatalogOffset(const StackMapEncoding& encoding) const {
- return GetStackMapsOffset() + GetStackMapsSize(encoding);
+ uint32_t GetDexRegisterLocationCatalogOffset(const CodeInfoEncoding& encoding) const {
+ return GetStackMapsOffset(encoding) + GetStackMapsSize(encoding);
}
- size_t GetDexRegisterMapsOffset(const StackMapEncoding& encoding) const {
+ size_t GetDexRegisterMapsOffset(const CodeInfoEncoding& encoding) const {
return GetDexRegisterLocationCatalogOffset(encoding)
+ GetDexRegisterLocationCatalogSize(encoding);
}
- uint32_t GetStackMapsOffset() const {
- return kFixedSize;
+ uint32_t GetStackMapsOffset(const CodeInfoEncoding& encoding) const {
+ return encoding.header_size;
}
DexRegisterMap GetDexRegisterMapOf(StackMap stack_map,
- const StackMapEncoding& encoding,
+ const CodeInfoEncoding& encoding,
uint32_t number_of_dex_registers) const {
- if (!stack_map.HasDexRegisterMap(encoding)) {
+ if (!stack_map.HasDexRegisterMap(encoding.stack_map_encoding)) {
return DexRegisterMap();
} else {
uint32_t offset = GetDexRegisterMapsOffset(encoding)
- + stack_map.GetDexRegisterMapOffset(encoding);
- size_t size = ComputeDexRegisterMapSizeOf(offset, number_of_dex_registers);
+ + stack_map.GetDexRegisterMapOffset(encoding.stack_map_encoding);
+ size_t size = ComputeDexRegisterMapSizeOf(encoding, offset, number_of_dex_registers);
return DexRegisterMap(region_.Subregion(offset, size));
}
}
@@ -1129,31 +1108,31 @@
// Return the `DexRegisterMap` pointed by `inline_info` at depth `depth`.
DexRegisterMap GetDexRegisterMapAtDepth(uint8_t depth,
InlineInfo inline_info,
- const StackMapEncoding& encoding,
+ const CodeInfoEncoding& encoding,
uint32_t number_of_dex_registers) const {
if (!inline_info.HasDexRegisterMapAtDepth(depth)) {
return DexRegisterMap();
} else {
uint32_t offset = GetDexRegisterMapsOffset(encoding)
+ inline_info.GetDexRegisterMapOffsetAtDepth(depth);
- size_t size = ComputeDexRegisterMapSizeOf(offset, number_of_dex_registers);
+ size_t size = ComputeDexRegisterMapSizeOf(encoding, offset, number_of_dex_registers);
return DexRegisterMap(region_.Subregion(offset, size));
}
}
- InlineInfo GetInlineInfoOf(StackMap stack_map, const StackMapEncoding& encoding) const {
- DCHECK(stack_map.HasInlineInfo(encoding));
- uint32_t offset = stack_map.GetInlineDescriptorOffset(encoding)
+ InlineInfo GetInlineInfoOf(StackMap stack_map, const CodeInfoEncoding& encoding) const {
+ DCHECK(stack_map.HasInlineInfo(encoding.stack_map_encoding));
+ uint32_t offset = stack_map.GetInlineDescriptorOffset(encoding.stack_map_encoding)
+ GetDexRegisterMapsOffset(encoding);
uint8_t depth = region_.LoadUnaligned<uint8_t>(offset);
return InlineInfo(region_.Subregion(offset,
InlineInfo::kFixedSize + depth * InlineInfo::SingleEntrySize()));
}
- StackMap GetStackMapForDexPc(uint32_t dex_pc, const StackMapEncoding& encoding) const {
- for (size_t i = 0, e = GetNumberOfStackMaps(); i < e; ++i) {
+ StackMap GetStackMapForDexPc(uint32_t dex_pc, const CodeInfoEncoding& encoding) const {
+ for (size_t i = 0, e = GetNumberOfStackMaps(encoding); i < e; ++i) {
StackMap stack_map = GetStackMapAt(i, encoding);
- if (stack_map.GetDexPc(encoding) == dex_pc) {
+ if (stack_map.GetDexPc(encoding.stack_map_encoding) == dex_pc) {
return stack_map;
}
}
@@ -1162,37 +1141,39 @@
// Searches the stack map list backwards because catch stack maps are stored
// at the end.
- StackMap GetCatchStackMapForDexPc(uint32_t dex_pc, const StackMapEncoding& encoding) const {
- for (size_t i = GetNumberOfStackMaps(); i > 0; --i) {
+ StackMap GetCatchStackMapForDexPc(uint32_t dex_pc, const CodeInfoEncoding& encoding) const {
+ for (size_t i = GetNumberOfStackMaps(encoding); i > 0; --i) {
StackMap stack_map = GetStackMapAt(i - 1, encoding);
- if (stack_map.GetDexPc(encoding) == dex_pc) {
+ if (stack_map.GetDexPc(encoding.stack_map_encoding) == dex_pc) {
return stack_map;
}
}
return StackMap();
}
- StackMap GetOsrStackMapForDexPc(uint32_t dex_pc, const StackMapEncoding& encoding) const {
- size_t e = GetNumberOfStackMaps();
+ StackMap GetOsrStackMapForDexPc(uint32_t dex_pc, const CodeInfoEncoding& encoding) const {
+ size_t e = GetNumberOfStackMaps(encoding);
if (e == 0) {
// There cannot be OSR stack map if there is no stack map.
return StackMap();
}
// Walk over all stack maps. If two consecutive stack maps are identical, then we
// have found a stack map suitable for OSR.
+ const StackMapEncoding& stack_map_encoding = encoding.stack_map_encoding;
for (size_t i = 0; i < e - 1; ++i) {
StackMap stack_map = GetStackMapAt(i, encoding);
- if (stack_map.GetDexPc(encoding) == dex_pc) {
+ if (stack_map.GetDexPc(stack_map_encoding) == dex_pc) {
StackMap other = GetStackMapAt(i + 1, encoding);
- if (other.GetDexPc(encoding) == dex_pc &&
- other.GetNativePcOffset(encoding) == stack_map.GetNativePcOffset(encoding)) {
- DCHECK_EQ(other.GetDexRegisterMapOffset(encoding),
- stack_map.GetDexRegisterMapOffset(encoding));
- DCHECK(!stack_map.HasInlineInfo(encoding));
+ if (other.GetDexPc(stack_map_encoding) == dex_pc &&
+ other.GetNativePcOffset(stack_map_encoding) ==
+ stack_map.GetNativePcOffset(stack_map_encoding)) {
+ DCHECK_EQ(other.GetDexRegisterMapOffset(stack_map_encoding),
+ stack_map.GetDexRegisterMapOffset(stack_map_encoding));
+ DCHECK(!stack_map.HasInlineInfo(stack_map_encoding));
if (i < e - 2) {
// Make sure there are not three identical stack maps following each other.
- DCHECK_NE(stack_map.GetNativePcOffset(encoding),
- GetStackMapAt(i + 2, encoding).GetNativePcOffset(encoding));
+ DCHECK_NE(stack_map.GetNativePcOffset(stack_map_encoding),
+ GetStackMapAt(i + 2, encoding).GetNativePcOffset(stack_map_encoding));
}
return stack_map;
}
@@ -1202,13 +1183,13 @@
}
StackMap GetStackMapForNativePcOffset(uint32_t native_pc_offset,
- const StackMapEncoding& encoding) const {
+ const CodeInfoEncoding& encoding) const {
// TODO: Safepoint stack maps are sorted by native_pc_offset but catch stack
// maps are not. If we knew that the method does not have try/catch,
// we could do binary search.
- for (size_t i = 0, e = GetNumberOfStackMaps(); i < e; ++i) {
+ for (size_t i = 0, e = GetNumberOfStackMaps(encoding); i < e; ++i) {
StackMap stack_map = GetStackMapAt(i, encoding);
- if (stack_map.GetNativePcOffset(encoding) == native_pc_offset) {
+ if (stack_map.GetNativePcOffset(encoding.stack_map_encoding) == native_pc_offset) {
return stack_map;
}
}
@@ -1226,38 +1207,16 @@
bool dump_stack_maps) const;
private:
- static constexpr int kOverallSizeOffset = 0;
- static constexpr int kEncodingInfoOffset = ELEMENT_BYTE_OFFSET_AFTER(OverallSize);
- static constexpr int kNumberOfLocationCatalogEntriesOffset =
- ELEMENT_BYTE_OFFSET_AFTER(EncodingInfo);
- static constexpr int kNumberOfStackMapsOffset =
- ELEMENT_BYTE_OFFSET_AFTER(NumberOfLocationCatalogEntries);
- static constexpr int kStackMaskSizeOffset = ELEMENT_BYTE_OFFSET_AFTER(NumberOfStackMaps);
- static constexpr int kFixedSize = ELEMENT_BYTE_OFFSET_AFTER(StackMaskSize);
-
- static constexpr int kHasInlineInfoBitOffset = kEncodingInfoOffset * kBitsPerByte;
- static constexpr int kInlineInfoBitOffset = ELEMENT_BIT_OFFSET_AFTER(HasInlineInfo);
- static constexpr int kDexRegisterMapBitOffset = ELEMENT_BIT_OFFSET_AFTER(InlineInfo);
- static constexpr int kDexPcBitOffset = ELEMENT_BIT_OFFSET_AFTER(DexRegisterMap);
- static constexpr int kNativePcBitOffset = ELEMENT_BIT_OFFSET_AFTER(DexPc);
- static constexpr int kRegisterMaskBitOffset = ELEMENT_BIT_OFFSET_AFTER(NativePc);
-
- static constexpr int kEncodingInfoPastTheEndBitOffset = ELEMENT_BIT_OFFSET_AFTER(RegisterMask);
- static constexpr int kEncodingInfoOverallBitSize =
- kEncodingInfoPastTheEndBitOffset - kHasInlineInfoBitOffset;
-
- static_assert(kEncodingInfoOverallBitSize <= (sizeof(EncodingInfoType) * kBitsPerByte),
- "art::CodeInfo::EncodingInfoType is too short to hold all encoding info elements.");
-
- MemoryRegion GetStackMaps(const StackMapEncoding& encoding) const {
+ MemoryRegion GetStackMaps(const CodeInfoEncoding& encoding) const {
return region_.size() == 0
? MemoryRegion()
- : region_.Subregion(GetStackMapsOffset(), GetStackMapsSize(encoding));
+ : region_.Subregion(GetStackMapsOffset(encoding), GetStackMapsSize(encoding));
}
// Compute the size of the Dex register map associated to the stack map at
// `dex_register_map_offset_in_code_info`.
- size_t ComputeDexRegisterMapSizeOf(uint32_t dex_register_map_offset_in_code_info,
+ size_t ComputeDexRegisterMapSizeOf(const CodeInfoEncoding& encoding,
+ uint32_t dex_register_map_offset_in_code_info,
uint16_t number_of_dex_registers) const {
// Offset where the actual mapping data starts within art::DexRegisterMap.
size_t location_mapping_data_offset_in_dex_register_map =
@@ -1270,7 +1229,7 @@
size_t number_of_live_dex_registers =
dex_register_map_without_locations.GetNumberOfLiveDexRegisters(number_of_dex_registers);
size_t location_mapping_data_size_in_bits =
- DexRegisterMap::SingleEntrySizeInBits(GetNumberOfLocationCatalogEntries())
+ DexRegisterMap::SingleEntrySizeInBits(GetNumberOfLocationCatalogEntries(encoding))
* number_of_live_dex_registers;
size_t location_mapping_data_size_in_bytes =
RoundUp(location_mapping_data_size_in_bits, kBitsPerByte) / kBitsPerByte;
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 42b5a4a..8cc94e8 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -2772,13 +2772,13 @@
reinterpret_cast<uintptr_t>(cur_quick_frame));
uintptr_t native_pc_offset = method_header->NativeQuickPcOffset(GetCurrentQuickFramePc());
CodeInfo code_info = method_header->GetOptimizedCodeInfo();
- StackMapEncoding encoding = code_info.ExtractEncoding();
+ CodeInfoEncoding encoding = code_info.ExtractEncoding();
StackMap map = code_info.GetStackMapForNativePcOffset(native_pc_offset, encoding);
DCHECK(map.IsValid());
- MemoryRegion mask = map.GetStackMask(encoding);
// Visit stack entries that hold pointers.
- for (size_t i = 0; i < mask.size_in_bits(); ++i) {
- if (mask.LoadBit(i)) {
+ 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) {
@@ -2791,7 +2791,7 @@
}
}
// Visit callee-save registers that hold pointers.
- uint32_t register_mask = map.GetRegisterMask(encoding);
+ 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));
diff --git a/test/566-polymorphic-inlining/polymorphic_inline.cc b/test/566-polymorphic-inlining/polymorphic_inline.cc
index b2934ed..167a575 100644
--- a/test/566-polymorphic-inlining/polymorphic_inline.cc
+++ b/test/566-polymorphic-inlining/polymorphic_inline.cc
@@ -43,7 +43,8 @@
}
CodeInfo info = header->GetOptimizedCodeInfo();
- CHECK(info.HasInlineInfo());
+ CodeInfoEncoding encoding = info.ExtractEncoding();
+ CHECK(info.HasInlineInfo(encoding));
}
extern "C" JNIEXPORT void JNICALL Java_Main_ensureJittedAndPolymorphicInline(JNIEnv*, jclass cls) {
