runtime/stack_map.cc

/*
 * 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"

namespace art {

constexpr size_t DexRegisterLocationCatalog::kNoLocationEntryIndex;

constexpr uint32_t StackMap::kNoDexRegisterMapSmallEncoding;
constexpr uint32_t StackMap::kNoInlineInfoSmallEncoding;
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);
}

uint32_t StackMap::GetDexPc(const CodeInfo& info) const {
  return info.HasSmallDexPc()
      ? region_.LoadUnaligned<kSmallEncoding>(info.ComputeStackMapDexPcOffset())
      : region_.LoadUnaligned<kLargeEncoding>(info.ComputeStackMapDexPcOffset());
}

void StackMap::SetDexPc(const CodeInfo& info, uint32_t dex_pc) {
  DCHECK(!info.HasSmallDexPc() || IsUint<kBitsForSmallEncoding>(dex_pc)) << dex_pc;
  info.HasSmallDexPc()
      ? region_.StoreUnaligned<kSmallEncoding>(info.ComputeStackMapDexPcOffset(), dex_pc)
      : region_.StoreUnaligned<kLargeEncoding>(info.ComputeStackMapDexPcOffset(), dex_pc);
}

uint32_t StackMap::GetNativePcOffset(const CodeInfo& info) const {
  return info.HasSmallNativePc()
      ? region_.LoadUnaligned<kSmallEncoding>(info.ComputeStackMapNativePcOffset())
      : region_.LoadUnaligned<kLargeEncoding>(info.ComputeStackMapNativePcOffset());
}

void StackMap::SetNativePcOffset(const CodeInfo& info, uint32_t native_pc_offset) {
  DCHECK(!info.HasSmallNativePc()
         || IsUint<kBitsForSmallEncoding>(native_pc_offset)) << native_pc_offset;
  uint32_t entry = info.ComputeStackMapNativePcOffset();
  info.HasSmallNativePc()
      ? region_.StoreUnaligned<kSmallEncoding>(entry, native_pc_offset)
      : region_.StoreUnaligned<kLargeEncoding>(entry, native_pc_offset);
}

uint32_t StackMap::GetDexRegisterMapOffset(const CodeInfo& info) const {
  if (info.HasSmallDexRegisterMap()) {
    uint8_t value = region_.LoadUnaligned<kSmallEncoding>(
        info.ComputeStackMapDexRegisterMapOffset());
    if (value == kNoDexRegisterMapSmallEncoding) {
      return kNoDexRegisterMap;
    } else {
      return value;
    }
  } else {
    return region_.LoadUnaligned<kLargeEncoding>(info.ComputeStackMapDexRegisterMapOffset());
  }
}

void StackMap::SetDexRegisterMapOffset(const CodeInfo& info, uint32_t offset) {
  DCHECK(!info.HasSmallDexRegisterMap()
         || (IsUint<kBitsForSmallEncoding>(offset)
             || (offset == kNoDexRegisterMap))) << offset;
  size_t dex_register_map_entry = info.ComputeStackMapDexRegisterMapOffset();
  info.HasSmallDexRegisterMap()
      ? region_.StoreUnaligned<kSmallEncoding>(dex_register_map_entry, offset)
      : region_.StoreUnaligned<kLargeEncoding>(dex_register_map_entry, offset);
}

uint32_t StackMap::GetInlineDescriptorOffset(const CodeInfo& info) const {
  if (!info.HasInlineInfo()) return kNoInlineInfo;
  if (info.HasSmallInlineInfo()) {
    uint8_t value = region_.LoadUnaligned<kSmallEncoding>(
        info.ComputeStackMapInlineInfoOffset());
    if (value == kNoInlineInfoSmallEncoding) {
      return kNoInlineInfo;
    } else {
      return value;
    }
  } else {
    return region_.LoadUnaligned<kLargeEncoding>(info.ComputeStackMapInlineInfoOffset());
  }
}

void StackMap::SetInlineDescriptorOffset(const CodeInfo& info, uint32_t offset) {
  DCHECK(info.HasInlineInfo());
  DCHECK(!info.HasSmallInlineInfo()
         || (IsUint<kBitsForSmallEncoding>(offset)
             || (offset == kNoInlineInfo))) << offset;
  size_t inline_entry = info.ComputeStackMapInlineInfoOffset();
  info.HasSmallInlineInfo()
      ? region_.StoreUnaligned<kSmallEncoding>(inline_entry, offset)
      : region_.StoreUnaligned<kLargeEncoding>(inline_entry, offset);
}

uint32_t StackMap::GetRegisterMask(const CodeInfo& info) const {
  return region_.LoadUnaligned<kLargeEncoding>(info.ComputeStackMapRegisterMaskOffset());
}

void StackMap::SetRegisterMask(const CodeInfo& info, uint32_t mask) {
  region_.StoreUnaligned<kLargeEncoding>(info.ComputeStackMapRegisterMaskOffset(), mask);
}

size_t StackMap::ComputeStackMapSize(size_t stack_mask_size,
                                     bool has_inline_info,
                                     bool is_small_inline_info,
                                     bool is_small_dex_map,
                                     bool is_small_dex_pc,
                                     bool is_small_native_pc) {
  return StackMap::kFixedSize
      + stack_mask_size
      + (has_inline_info ? NumberOfBytesForEntry(is_small_inline_info) : 0)
      + NumberOfBytesForEntry(is_small_dex_map)
      + NumberOfBytesForEntry(is_small_dex_pc)
      + NumberOfBytesForEntry(is_small_native_pc);
}

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) {
  return ComputeStackMapSize(
      stack_mask_size,
      inline_info_size != 0,
      // + 1 to also encode kNoInlineInfo.
      IsUint<kBitsForSmallEncoding>(inline_info_size + dex_register_map_size + 1),
      // + 1 to also encode kNoDexRegisterMap.
      IsUint<kBitsForSmallEncoding>(dex_register_map_size + 1),
      IsUint<kBitsForSmallEncoding>(dex_pc_max),
      IsUint<kBitsForSmallEncoding>(native_pc_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()
     << ", has_small_inline_info=" << HasSmallInlineInfo()
     << ", has_small_dex_register_map=" << HasSmallDexRegisterMap()
     << ", has_small_dex_pc=" << HasSmallDexPc()
     << ", has_small_native_pc=" << HasSmallNativePc()
     << ")\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