Merge "Improve documentation of memory layouts in stack_map.h."

4 files changed, 133 insertions, 91 deletions

diff --git a/compiler/optimizing/stack_map_stream.cc b/compiler/optimizing/stack_map_stream.cc
index 65610d54a6..1f1530fa1e 100644
--- a/compiler/optimizing/stack_map_stream.cc
+++ b/compiler/optimizing/stack_map_stream.cc
@@ -248,7 +248,7 @@ void StackMapStream::FillIn(MemoryRegion region) {
   DCHECK_EQ(code_info.GetStackMapsSize(code_info.ExtractEncoding()), stack_maps_size_);
 
   // Set the Dex register location catalog.
-  code_info.SetNumberOfDexRegisterLocationCatalogEntries(location_catalog_entries_.Size());
+  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);
diff --git a/compiler/optimizing/stack_map_test.cc b/compiler/optimizing/stack_map_test.cc
index b4ac1b4d1a..33207d92d2 100644
--- a/compiler/optimizing/stack_map_test.cc
+++ b/compiler/optimizing/stack_map_test.cc
@@ -55,8 +55,7 @@ TEST(StackMapTest, Test1) {
   ASSERT_EQ(0u, encoding.NumberOfBytesForStackMask());
   ASSERT_EQ(1u, code_info.GetNumberOfStackMaps());
 
-  uint32_t number_of_location_catalog_entries =
-      code_info.GetNumberOfDexRegisterLocationCatalogEntries();
+  uint32_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
   ASSERT_EQ(2u, number_of_location_catalog_entries);
   DexRegisterLocationCatalog location_catalog = code_info.GetDexRegisterLocationCatalog(encoding);
   // The Dex register location catalog contains:
@@ -154,8 +153,7 @@ TEST(StackMapTest, Test2) {
   ASSERT_EQ(2u, encoding.NumberOfBytesForStackMask());
   ASSERT_EQ(2u, code_info.GetNumberOfStackMaps());
 
-  uint32_t number_of_location_catalog_entries =
-      code_info.GetNumberOfDexRegisterLocationCatalogEntries();
+  uint32_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
   ASSERT_EQ(4u, number_of_location_catalog_entries);
   DexRegisterLocationCatalog location_catalog = code_info.GetDexRegisterLocationCatalog(encoding);
   // The Dex register location catalog contains:
@@ -304,8 +302,7 @@ TEST(StackMapTest, TestNonLiveDexRegisters) {
   ASSERT_EQ(0u, encoding.NumberOfBytesForStackMask());
   ASSERT_EQ(1u, code_info.GetNumberOfStackMaps());
 
-  uint32_t number_of_location_catalog_entries =
-      code_info.GetNumberOfDexRegisterLocationCatalogEntries();
+  uint32_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
   ASSERT_EQ(1u, number_of_location_catalog_entries);
   DexRegisterLocationCatalog location_catalog = code_info.GetDexRegisterLocationCatalog(encoding);
   // The Dex register location catalog contains:
@@ -398,8 +395,7 @@ TEST(StackMapTest, DexRegisterMapOffsetOverflow) {
   // 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.GetNumberOfDexRegisterLocationCatalogEntries();
+  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));
 
@@ -501,8 +497,7 @@ TEST(StackMapTest, TestNoDexRegisterMap) {
   ASSERT_EQ(0u, encoding.NumberOfBytesForStackMask());
   ASSERT_EQ(1u, code_info.GetNumberOfStackMaps());
 
-  uint32_t number_of_location_catalog_entries =
-      code_info.GetNumberOfDexRegisterLocationCatalogEntries();
+  uint32_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
   ASSERT_EQ(0u, number_of_location_catalog_entries);
   DexRegisterLocationCatalog location_catalog = code_info.GetDexRegisterLocationCatalog(encoding);
   ASSERT_EQ(0u, location_catalog.Size());
diff --git a/runtime/stack_map.cc b/runtime/stack_map.cc
index 962132b29f..5544507c06 100644
--- a/runtime/stack_map.cc
+++ b/runtime/stack_map.cc
@@ -27,16 +27,17 @@ 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 StackMapEncoding& enc) const {
+DexRegisterLocation::Kind DexRegisterMap::GetLocationInternalKind(
+    uint16_t dex_register_number,
+    uint16_t number_of_dex_registers,
+    const CodeInfo& code_info,
+    const StackMapEncoding& 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.GetNumberOfDexRegisterLocationCatalogEntries());
+      code_info.GetNumberOfLocationCatalogEntries());
   return dex_register_location_catalog.GetLocationInternalKind(location_catalog_entry_index);
 }
 
@@ -49,7 +50,7 @@ DexRegisterLocation DexRegisterMap::GetDexRegisterLocation(uint16_t dex_register
   size_t location_catalog_entry_index = GetLocationCatalogEntryIndex(
       dex_register_number,
       number_of_dex_registers,
-      code_info.GetNumberOfDexRegisterLocationCatalogEntries());
+      code_info.GetNumberOfLocationCatalogEntries());
   return dex_register_location_catalog.GetDexRegisterLocation(location_catalog_entry_index);
 }
 
@@ -140,8 +141,7 @@ void CodeInfo::Dump(VariableIndentationOutputStream* vios,
 void DexRegisterLocationCatalog::Dump(VariableIndentationOutputStream* vios,
                                       const CodeInfo& code_info) {
   StackMapEncoding encoding = code_info.ExtractEncoding();
-  size_t number_of_location_catalog_entries =
-      code_info.GetNumberOfDexRegisterLocationCatalogEntries();
+  size_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
   size_t location_catalog_size_in_bytes = code_info.GetDexRegisterLocationCatalogSize(encoding);
   vios->Stream()
       << "DexRegisterLocationCatalog (number_of_entries=" << number_of_location_catalog_entries
@@ -157,8 +157,7 @@ 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.GetNumberOfDexRegisterLocationCatalogEntries();
+  size_t number_of_location_catalog_entries = code_info.GetNumberOfLocationCatalogEntries();
   // TODO: Display the bit mask of live Dex registers.
   for (size_t j = 0; j < number_of_dex_registers; ++j) {
     if (IsDexRegisterLive(j)) {
diff --git a/runtime/stack_map.h b/runtime/stack_map.h
index 1acc44291c..0d3816b97e 100644
--- a/runtime/stack_map.h
+++ b/runtime/stack_map.h
@@ -23,6 +23,12 @@
 
 namespace art {
 
+#define ELEMENT_BYTE_OFFSET_AFTER(PreviousElement) \
+  k ## PreviousElement ## Offset + sizeof(PreviousElement ## Type)
+
+#define ELEMENT_BIT_OFFSET_AFTER(PreviousElement) \
+  k ## PreviousElement ## BitOffset + PreviousElement ## BitSize
+
 class VariableIndentationOutputStream;
 
 // Size of a frame slot, in bytes.  This constant is a signed value,
@@ -195,7 +201,9 @@ class DexRegisterLocation {
 /**
  * Store information on unique Dex register locations used in a method.
  * The information is of the form:
- * [DexRegisterLocation+].
+ *
+ *   [DexRegisterLocation+].
+ *
  * DexRegisterLocations are either 1- or 5-byte wide (see art::DexRegisterLocation::Kind).
  */
 class DexRegisterLocationCatalog {
@@ -432,7 +440,9 @@ class DexRegisterLocationCatalog {
 /* Information on Dex register locations for a specific PC, mapping a
  * stack map's Dex register to a location entry in a DexRegisterLocationCatalog.
  * The information is of the form:
- * [live_bit_mask, entries*]
+ *
+ *   [live_bit_mask, entries*]
+ *
  * where entries are concatenated unsigned integer values encoded on a number
  * of bits (fixed per DexRegisterMap instances of a CodeInfo object) depending
  * on the number of entries in the Dex register location catalog
@@ -757,8 +767,9 @@ class StackMapEncoding {
  * - Knowing the values of dex registers.
  *
  * The information is of the form:
- * [dex_pc, native_pc_offset, dex_register_map_offset, inlining_info_offset, register_mask,
- * stack_mask].
+ *
+ *   [dex_pc, native_pc_offset, dex_register_map_offset, inlining_info_offset, register_mask,
+ *   stack_mask].
  */
 class StackMap {
  public:
@@ -861,8 +872,6 @@ class StackMap {
   static constexpr uint32_t kNoInlineInfo = -1;
 
  private:
-  // TODO: Instead of plain types such as "uint32_t", introduce
-  // typedefs (and document the memory layout of StackMap).
   static constexpr int kFixedSize = 0;
 
   // Loads `number_of_bytes` at the given `offset` and assemble a uint32_t. If `check_max` is true,
@@ -877,61 +886,74 @@ class StackMap {
 
 /**
  * Inline information for a specific PC. The information is of the form:
- * [inlining_depth, [dex_pc, method_index, dex_register_map_offset]+]
+ *
+ *   [inlining_depth, entry+]
+ *
+ * where `entry` is of the form:
+ *
+ *   [dex_pc, method_index, dex_register_map_offset].
  */
 class InlineInfo {
  public:
+  // Memory layout: fixed contents.
+  typedef uint8_t DepthType;
+  // Memory layout: single entry contents.
+  typedef uint32_t MethodIndexType;
+  typedef uint32_t DexPcType;
+  typedef uint8_t InvokeTypeType;
+  typedef uint32_t DexRegisterMapType;
+
   explicit InlineInfo(MemoryRegion region) : region_(region) {}
 
-  uint8_t GetDepth() const {
-    return region_.LoadUnaligned<uint8_t>(kDepthOffset);
+  DepthType GetDepth() const {
+    return region_.LoadUnaligned<DepthType>(kDepthOffset);
   }
 
-  void SetDepth(uint8_t depth) {
-    region_.StoreUnaligned<uint8_t>(kDepthOffset, depth);
+  void SetDepth(DepthType depth) {
+    region_.StoreUnaligned<DepthType>(kDepthOffset, depth);
   }
 
-  uint32_t GetMethodIndexAtDepth(uint8_t depth) const {
-    return region_.LoadUnaligned<uint32_t>(
+  MethodIndexType GetMethodIndexAtDepth(DepthType depth) const {
+    return region_.LoadUnaligned<MethodIndexType>(
         kFixedSize + depth * SingleEntrySize() + kMethodIndexOffset);
   }
 
-  void SetMethodIndexAtDepth(uint8_t depth, uint32_t index) {
-    region_.StoreUnaligned<uint32_t>(
+  void SetMethodIndexAtDepth(DepthType depth, MethodIndexType index) {
+    region_.StoreUnaligned<MethodIndexType>(
         kFixedSize + depth * SingleEntrySize() + kMethodIndexOffset, index);
   }
 
-  uint32_t GetDexPcAtDepth(uint8_t depth) const {
-    return region_.LoadUnaligned<uint32_t>(
+  DexPcType GetDexPcAtDepth(DepthType depth) const {
+    return region_.LoadUnaligned<DexPcType>(
         kFixedSize + depth * SingleEntrySize() + kDexPcOffset);
   }
 
-  void SetDexPcAtDepth(uint8_t depth, uint32_t dex_pc) {
-    region_.StoreUnaligned<uint32_t>(
+  void SetDexPcAtDepth(DepthType depth, DexPcType dex_pc) {
+    region_.StoreUnaligned<DexPcType>(
         kFixedSize + depth * SingleEntrySize() + kDexPcOffset, dex_pc);
   }
 
-  uint8_t GetInvokeTypeAtDepth(uint8_t depth) const {
-    return region_.LoadUnaligned<uint8_t>(
+  InvokeTypeType GetInvokeTypeAtDepth(DepthType depth) const {
+    return region_.LoadUnaligned<InvokeTypeType>(
         kFixedSize + depth * SingleEntrySize() + kInvokeTypeOffset);
   }
 
-  void SetInvokeTypeAtDepth(uint8_t depth, uint8_t invoke_type) {
-    region_.StoreUnaligned<uint8_t>(
+  void SetInvokeTypeAtDepth(DepthType depth, InvokeTypeType invoke_type) {
+    region_.StoreUnaligned<InvokeTypeType>(
         kFixedSize + depth * SingleEntrySize() + kInvokeTypeOffset, invoke_type);
   }
 
-  uint32_t GetDexRegisterMapOffsetAtDepth(uint8_t depth) const {
-    return region_.LoadUnaligned<uint32_t>(
+  DexRegisterMapType GetDexRegisterMapOffsetAtDepth(DepthType depth) const {
+    return region_.LoadUnaligned<DexRegisterMapType>(
         kFixedSize + depth * SingleEntrySize() + kDexRegisterMapOffset);
   }
 
-  void SetDexRegisterMapOffsetAtDepth(uint8_t depth, uint32_t offset) {
-    region_.StoreUnaligned<uint32_t>(
+  void SetDexRegisterMapOffsetAtDepth(DepthType depth, DexRegisterMapType offset) {
+    region_.StoreUnaligned<DexRegisterMapType>(
         kFixedSize + depth * SingleEntrySize() + kDexRegisterMapOffset, offset);
   }
 
-  bool HasDexRegisterMapAtDepth(uint8_t depth) const {
+  bool HasDexRegisterMapAtDepth(DepthType depth) const {
     return GetDexRegisterMapOffsetAtDepth(depth) != StackMap::kNoDexRegisterMap;
   }
 
@@ -942,17 +964,16 @@ class InlineInfo {
   void Dump(VariableIndentationOutputStream* vios,
             const CodeInfo& info, uint16_t* number_of_dex_registers) const;
 
+
  private:
-  // TODO: Instead of plain types such as "uint8_t", introduce
-  // typedefs (and document the memory layout of InlineInfo).
   static constexpr int kDepthOffset = 0;
-  static constexpr int kFixedSize = kDepthOffset + sizeof(uint8_t);
+  static constexpr int kFixedSize = ELEMENT_BYTE_OFFSET_AFTER(Depth);
 
   static constexpr int kMethodIndexOffset = 0;
-  static constexpr int kDexPcOffset = kMethodIndexOffset + sizeof(uint32_t);
-  static constexpr int kInvokeTypeOffset = kDexPcOffset + sizeof(uint32_t);
-  static constexpr int kDexRegisterMapOffset = kInvokeTypeOffset + sizeof(uint8_t);
-  static constexpr int kFixedEntrySize = kDexRegisterMapOffset + sizeof(uint32_t);
+  static constexpr int kDexPcOffset = ELEMENT_BYTE_OFFSET_AFTER(MethodIndex);
+  static constexpr int kInvokeTypeOffset = ELEMENT_BYTE_OFFSET_AFTER(DexPc);
+  static constexpr int kDexRegisterMapOffset = ELEMENT_BYTE_OFFSET_AFTER(InvokeType);
+  static constexpr int kFixedEntrySize = ELEMENT_BYTE_OFFSET_AFTER(DexRegisterMap);
 
   MemoryRegion region_;
 
@@ -964,11 +985,32 @@ class InlineInfo {
 /**
  * Wrapper around all compiler information collected for a method.
  * The information is of the form:
- * [overall_size, number_of_location_catalog_entries, number_of_stack_maps, stack_mask_size,
- * DexRegisterLocationCatalog+, StackMap+, DexRegisterMap+, InlineInfo*].
+ *
+ *   [overall_size, encoding_info, number_of_location_catalog_entries, number_of_stack_maps,
+ *   stack_mask_size, DexRegisterLocationCatalog+, StackMap+, DexRegisterMap+, InlineInfo*]
+ *
+ * where `encoding_info` 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].
  */
 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(const void* data) {
@@ -1018,33 +1060,35 @@ class CodeInfo {
     return StackMap(GetStackMaps(encoding).Subregion(i * stack_map_size, stack_map_size));
   }
 
-  uint32_t GetOverallSize() const {
-    return region_.LoadUnaligned<uint32_t>(kOverallSizeOffset);
+  OverallSizeType GetOverallSize() const {
+    return region_.LoadUnaligned<OverallSizeType>(kOverallSizeOffset);
   }
 
-  void SetOverallSize(uint32_t size) {
-    region_.StoreUnaligned<uint32_t>(kOverallSizeOffset, size);
+  void SetOverallSize(OverallSizeType size) {
+    region_.StoreUnaligned<OverallSizeType>(kOverallSizeOffset, size);
   }
 
-  uint32_t GetNumberOfDexRegisterLocationCatalogEntries() const {
-    return region_.LoadUnaligned<uint32_t>(kNumberOfDexRegisterLocationCatalogEntriesOffset);
+  NumberOfLocationCatalogEntriesType GetNumberOfLocationCatalogEntries() const {
+    return region_.LoadUnaligned<NumberOfLocationCatalogEntriesType>(
+        kNumberOfLocationCatalogEntriesOffset);
   }
 
-  void SetNumberOfDexRegisterLocationCatalogEntries(uint32_t num_entries) {
-    region_.StoreUnaligned<uint32_t>(kNumberOfDexRegisterLocationCatalogEntriesOffset, num_entries);
+  void SetNumberOfLocationCatalogEntries(NumberOfLocationCatalogEntriesType num_entries) {
+    region_.StoreUnaligned<NumberOfLocationCatalogEntriesType>(
+        kNumberOfLocationCatalogEntriesOffset, num_entries);
   }
 
   uint32_t GetDexRegisterLocationCatalogSize(const StackMapEncoding& encoding) const {
     return ComputeDexRegisterLocationCatalogSize(GetDexRegisterLocationCatalogOffset(encoding),
-                                                 GetNumberOfDexRegisterLocationCatalogEntries());
+                                                 GetNumberOfLocationCatalogEntries());
   }
 
-  size_t GetNumberOfStackMaps() const {
-    return region_.LoadUnaligned<uint32_t>(kNumberOfStackMapsOffset);
+  NumberOfStackMapsType GetNumberOfStackMaps() const {
+    return region_.LoadUnaligned<NumberOfStackMapsType>(kNumberOfStackMapsOffset);
   }
 
-  void SetNumberOfStackMaps(uint32_t number_of_stack_maps) {
-    region_.StoreUnaligned<uint32_t>(kNumberOfStackMapsOffset, number_of_stack_maps);
+  void SetNumberOfStackMaps(NumberOfStackMapsType number_of_stack_maps) {
+    region_.StoreUnaligned<NumberOfStackMapsType>(kNumberOfStackMapsOffset, number_of_stack_maps);
   }
 
   // Get the size all the stack maps of this CodeInfo object, in bytes.
@@ -1129,27 +1173,28 @@ class CodeInfo {
             bool dump_stack_maps) const;
 
  private:
-  // TODO: Instead of plain types such as "uint32_t", introduce
-  // typedefs (and document the memory layout of CodeInfo).
   static constexpr int kOverallSizeOffset = 0;
-  static constexpr int kEncodingInfoOffset = kOverallSizeOffset + sizeof(uint32_t);
-  static constexpr int kNumberOfDexRegisterLocationCatalogEntriesOffset =
-      kEncodingInfoOffset + sizeof(uint16_t);
+  static constexpr int kEncodingInfoOffset = ELEMENT_BYTE_OFFSET_AFTER(OverallSize);
+  static constexpr int kNumberOfLocationCatalogEntriesOffset =
+      ELEMENT_BYTE_OFFSET_AFTER(EncodingInfo);
   static constexpr int kNumberOfStackMapsOffset =
-      kNumberOfDexRegisterLocationCatalogEntriesOffset + sizeof(uint32_t);
-  static constexpr int kStackMaskSizeOffset = kNumberOfStackMapsOffset + sizeof(uint32_t);
-  static constexpr int kFixedSize = kStackMaskSizeOffset + sizeof(uint32_t);
-
-  static constexpr int kHasInlineInfoBitOffset = (kEncodingInfoOffset * kBitsPerByte);
-  static constexpr int kInlineInfoBitOffset = kHasInlineInfoBitOffset + 1;
-  static constexpr int kDexRegisterMapBitOffset =
-      kInlineInfoBitOffset + kNumberOfBitForNumberOfBytesForEncoding;
-  static constexpr int kDexPcBitOffset =
-      kDexRegisterMapBitOffset + kNumberOfBitForNumberOfBytesForEncoding;
-  static constexpr int kNativePcBitOffset =
-      kDexPcBitOffset + kNumberOfBitForNumberOfBytesForEncoding;
-  static constexpr int kRegisterMaskBitOffset =
-      kNativePcBitOffset + kNumberOfBitForNumberOfBytesForEncoding;
+      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 {
     return region_.size() == 0
@@ -1172,7 +1217,7 @@ class CodeInfo {
     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(GetNumberOfDexRegisterLocationCatalogEntries())
+        DexRegisterMap::SingleEntrySizeInBits(GetNumberOfLocationCatalogEntries())
         * number_of_live_dex_registers;
     size_t location_mapping_data_size_in_bytes =
         RoundUp(location_mapping_data_size_in_bits, kBitsPerByte) / kBitsPerByte;
@@ -1214,6 +1259,9 @@ class CodeInfo {
   friend class StackMapStream;
 };
 
+#undef ELEMENT_BYTE_OFFSET_AFTER
+#undef ELEMENT_BIT_OFFSET_AFTER
+
 }  // namespace art
 
 #endif  // ART_RUNTIME_STACK_MAP_H_