/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "stack_map.h"
#include <stdint.h>
namespace art {
constexpr size_t DexRegisterLocationCatalog::kNoLocationEntryIndex;
constexpr uint32_t StackMap::kNoDexRegisterMap;
constexpr uint32_t StackMap::kNoInlineInfo;
DexRegisterLocation::Kind DexRegisterMap::GetLocationInternalKind(uint16_t dex_register_number,
uint16_t number_of_dex_registers,
const CodeInfo& code_info) const {
DexRegisterLocationCatalog dex_register_location_catalog =
code_info.GetDexRegisterLocationCatalog();
size_t location_catalog_entry_index = GetLocationCatalogEntryIndex(
dex_register_number,
number_of_dex_registers,
code_info.GetNumberOfDexRegisterLocationCatalogEntries());
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 {
DexRegisterLocationCatalog dex_register_location_catalog =
code_info.GetDexRegisterLocationCatalog();
size_t location_catalog_entry_index = GetLocationCatalogEntryIndex(
dex_register_number,
number_of_dex_registers,
code_info.GetNumberOfDexRegisterLocationCatalogEntries());
return dex_register_location_catalog.GetDexRegisterLocation(location_catalog_entry_index);
}
// 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.
static uint32_t LoadAt(MemoryRegion region,
size_t number_of_bytes,
size_t offset,
bool check_max = false) {
if (number_of_bytes == 0u) {
DCHECK(!check_max);
return 0;
} else if (number_of_bytes == 1u) {
uint8_t value = region.LoadUnaligned<uint8_t>(offset);
if (check_max && value == 0xFF) {
return -1;
} else {
return value;
}
} else if (number_of_bytes == 2u) {
uint16_t value = region.LoadUnaligned<uint16_t>(offset);
if (check_max && value == 0xFFFF) {
return -1;
} else {
return 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;
if (check_max && value == 0xFFFFFF) {
return -1;
} else {
return value;
}
} else {
DCHECK_EQ(number_of_bytes, 4u);
return region.LoadUnaligned<uint32_t>(offset);
}
}
static void StoreAt(MemoryRegion region, size_t number_of_bytes, size_t offset, uint32_t value) {
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);
}
}
uint32_t StackMap::GetDexPc(const CodeInfo& info) const {
return LoadAt(region_, info.NumberOfBytesForDexPc(), info.ComputeStackMapDexPcOffset());
}
void StackMap::SetDexPc(const CodeInfo& info, uint32_t dex_pc) {
StoreAt(region_, info.NumberOfBytesForDexPc(), info.ComputeStackMapDexPcOffset(), dex_pc);
}
uint32_t StackMap::GetNativePcOffset(const CodeInfo& info) const {
return LoadAt(region_, info.NumberOfBytesForNativePc(), info.ComputeStackMapNativePcOffset());
}
void StackMap::SetNativePcOffset(const CodeInfo& info, uint32_t native_pc_offset) {
StoreAt(region_, info.NumberOfBytesForNativePc(), info.ComputeStackMapNativePcOffset(), native_pc_offset);
}
uint32_t StackMap::GetDexRegisterMapOffset(const CodeInfo& info) const {
return LoadAt(region_,
info.NumberOfBytesForDexRegisterMap(),
info.ComputeStackMapDexRegisterMapOffset(),
/* check_max */ true);
}
void StackMap::SetDexRegisterMapOffset(const CodeInfo& info, uint32_t offset) {
StoreAt(region_,
info.NumberOfBytesForDexRegisterMap(),
info.ComputeStackMapDexRegisterMapOffset(),
offset);
}
uint32_t StackMap::GetInlineDescriptorOffset(const CodeInfo& info) const {
if (!info.HasInlineInfo()) return kNoInlineInfo;
return LoadAt(region_,
info.NumberOfBytesForInlineInfo(),
info.ComputeStackMapInlineInfoOffset(),
/* check_max */ true);
}
void StackMap::SetInlineDescriptorOffset(const CodeInfo& info, uint32_t offset) {
DCHECK(info.HasInlineInfo());
StoreAt(region_,
info.NumberOfBytesForInlineInfo(),
info.ComputeStackMapInlineInfoOffset(),
offset);
}
uint32_t StackMap::GetRegisterMask(const CodeInfo& info) const {
return LoadAt(region_,
info.NumberOfBytesForRegisterMask(),
info.ComputeStackMapRegisterMaskOffset());
}
void StackMap::SetRegisterMask(const CodeInfo& info, uint32_t mask) {
StoreAt(region_,
info.NumberOfBytesForRegisterMask(),
info.ComputeStackMapRegisterMaskOffset(),
mask);
}
size_t StackMap::ComputeStackMapSizeInternal(size_t stack_mask_size,
size_t number_of_bytes_for_inline_info,
size_t number_of_bytes_for_dex_map,
size_t number_of_bytes_for_dex_pc,
size_t number_of_bytes_for_native_pc,
size_t number_of_bytes_for_register_mask) {
return stack_mask_size
+ number_of_bytes_for_inline_info
+ number_of_bytes_for_dex_map
+ number_of_bytes_for_dex_pc
+ number_of_bytes_for_native_pc
+ number_of_bytes_for_register_mask;
}
size_t StackMap::ComputeStackMapSize(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 ComputeStackMapSizeInternal(
stack_mask_size,
inline_info_size == 0
? 0
// + 1 to also encode kNoInlineInfo.
: CodeInfo::EncodingSizeInBytes(inline_info_size + dex_register_map_size + 1),
// + 1 to also encode kNoDexRegisterMap.
CodeInfo::EncodingSizeInBytes(dex_register_map_size + 1),
CodeInfo::EncodingSizeInBytes(dex_pc_max),
CodeInfo::EncodingSizeInBytes(native_pc_max),
CodeInfo::EncodingSizeInBytes(register_mask_max));
}
MemoryRegion StackMap::GetStackMask(const CodeInfo& info) const {
return region_.Subregion(info.ComputeStackMapStackMaskOffset(), info.GetStackMaskSize());
}
static void DumpRegisterMapping(std::ostream& os,
size_t dex_register_num,
DexRegisterLocation location,
const std::string& prefix = "v",
const std::string& suffix = "") {
os << " " << prefix << dex_register_num << ": "
<< DexRegisterLocation::PrettyDescriptor(location.GetInternalKind())
<< " (" << location.GetValue() << ")" << suffix << '\n';
}
void CodeInfo::DumpStackMapHeader(std::ostream& os, size_t stack_map_num) const {
StackMap stack_map = GetStackMapAt(stack_map_num);
os << " StackMap " << stack_map_num
<< std::hex
<< " (dex_pc=0x" << stack_map.GetDexPc(*this)
<< ", native_pc_offset=0x" << stack_map.GetNativePcOffset(*this)
<< ", dex_register_map_offset=0x" << stack_map.GetDexRegisterMapOffset(*this)
<< ", inline_info_offset=0x" << stack_map.GetInlineDescriptorOffset(*this)
<< ", register_mask=0x" << stack_map.GetRegisterMask(*this)
<< std::dec
<< ", stack_mask=0b";
MemoryRegion stack_mask = stack_map.GetStackMask(*this);
for (size_t i = 0, e = stack_mask.size_in_bits(); i < e; ++i) {
os << stack_mask.LoadBit(e - i - 1);
}
os << ")\n";
};
void CodeInfo::Dump(std::ostream& os, uint16_t number_of_dex_registers) const {
uint32_t code_info_size = GetOverallSize();
size_t number_of_stack_maps = GetNumberOfStackMaps();
os << " Optimized CodeInfo (size=" << code_info_size
<< ", number_of_dex_registers=" << number_of_dex_registers
<< ", number_of_stack_maps=" << number_of_stack_maps
<< ", has_inline_info=" << HasInlineInfo()
<< ", number_of_bytes_for_inline_info=" << NumberOfBytesForInlineInfo()
<< ", number_of_bytes_for_dex_register_map=" << NumberOfBytesForDexRegisterMap()
<< ", number_of_bytes_for_dex_pc=" << NumberOfBytesForDexPc()
<< ", number_of_bytes_for_native_pc=" << NumberOfBytesForNativePc()
<< ", number_of_bytes_for_register_mask=" << NumberOfBytesForRegisterMask()
<< ")\n";
// Display the Dex register location catalog.
size_t number_of_location_catalog_entries = GetNumberOfDexRegisterLocationCatalogEntries();
size_t location_catalog_size_in_bytes = GetDexRegisterLocationCatalogSize();
os << " DexRegisterLocationCatalog (number_of_entries=" << number_of_location_catalog_entries
<< ", size_in_bytes=" << location_catalog_size_in_bytes << ")\n";
DexRegisterLocationCatalog dex_register_location_catalog = GetDexRegisterLocationCatalog();
for (size_t i = 0; i < number_of_location_catalog_entries; ++i) {
DexRegisterLocation location = dex_register_location_catalog.GetDexRegisterLocation(i);
DumpRegisterMapping(os, i, location, "entry ");
}
// Display stack maps along with (live) Dex register maps.
for (size_t i = 0; i < number_of_stack_maps; ++i) {
StackMap stack_map = GetStackMapAt(i);
DumpStackMapHeader(os, i);
if (stack_map.HasDexRegisterMap(*this)) {
DexRegisterMap dex_register_map = GetDexRegisterMapOf(stack_map, number_of_dex_registers);
// TODO: Display the bit mask of live Dex registers.
for (size_t j = 0; j < number_of_dex_registers; ++j) {
if (dex_register_map.IsDexRegisterLive(j)) {
size_t location_catalog_entry_index = dex_register_map.GetLocationCatalogEntryIndex(
j, number_of_dex_registers, number_of_location_catalog_entries);
DexRegisterLocation location =
dex_register_map.GetDexRegisterLocation(j, number_of_dex_registers, *this);
DumpRegisterMapping(
os, j, location, "v",
"\t[entry " + std::to_string(static_cast<int>(location_catalog_entry_index)) + "]");
}
}
}
}
// TODO: Dump the stack map's inline information.
}
} // namespace art