[DWARF] Support for DW_FORM_strx3 and completed support for DW_FORM_strx{1,2,4}/consumer

[wolfgangp]

Summary

This implements support for DWARF v5 DW_FORM_strx3 and completes support for the other strx<n> forms on the consumer side. The existing test for DWARF v5 string offset tables was augmented accordingly.

[aprantl]

This is just a general high-level comment: When adding new DWARF5 features it might also be a good idea to think about what checks could be added to DWARFVerifier to diagnose corrupt input (and potentially implement them as well :-)

[aprantl]

Seems generally straightforward/fine.

lib/Support/DataExtractor.cpp

80 ↗

(On Diff #103260)

perhaps make this a member UInt24_t::getAsUint32(LE?)() ?

[wolfgangp]

Addressed review comments: added a method getAsUint32 to the uint24_t struct.

lib/Support/DataExtractor.cpp

80 ↗

(On Diff #103260)

Thanks, yes, that looks cleaner.

llvm/trunk/include/llvm/Support/DataExtractor.h

 //===-- DataExtractor.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_DATAEXTRACTOR_H
 #define LLVM_SUPPORT_DATAEXTRACTOR_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
+
+/// An auxiliary type to facilitate extraction of 3-byte entities. 
+struct Uint24 {
+  uint8_t Bytes[3];
+  Uint24(uint8_t U) {
+    Bytes[0] = Bytes[1] = Bytes[2] = U;
+  }
+  Uint24(uint8_t U0, uint8_t U1, uint8_t U2) {
+    Bytes[0] = U0; Bytes[1] = U1; Bytes[2] = U2;
+  }
+  uint32_t getAsUint32(bool IsLittleEndian) const {
+    int LoIx = IsLittleEndian ? 0 : 2;
+    return Bytes[LoIx] + (Bytes[1] << 8) + (Bytes[2-LoIx] << 16);
+  }
+};
+
+using uint24_t = Uint24;
+static_assert(sizeof(uint24_t) == 3, "sizeof(uint24_t) != 3");
+
+/// Needed by swapByteOrder().
+inline uint24_t getSwappedBytes(uint24_t C) {
+  return uint24_t(C.Bytes[2], C.Bytes[1], C.Bytes[0]);
+}
+
 class DataExtractor {
   StringRef Data;
   uint8_t IsLittleEndian;
   uint8_t AddressSize;
 public:
   /// Construct with a buffer that is owned by the caller.
   ///
   /// This constructor allows us to use data that is owned by the
public:
   /// @param[in] count
   ///     The number of uint16_t values to extract.
   ///
   /// @return
   ///     \a dst if all values were properly extracted and copied,
   ///     NULL otherise.
   uint16_t *getU16(uint32_t *offset_ptr, uint16_t *dst, uint32_t count) const;
 
+  /// Extract a 24-bit unsigned value from \a *offset_ptr and return it
+  /// in a uint32_t.
+  ///
+  /// Extract 3 bytes from the binary data at the offset pointed to by
+  /// \a offset_ptr, construct a uint32_t from them and update the offset
+  /// on success.
+  ///
+  /// @param[in,out] offset_ptr
+  ///     A pointer to an offset within the data that will be advanced
+  ///     by the 3 bytes if the value is extracted correctly. If the offset
+  ///     is out of bounds or there are not enough bytes to extract this value,
+  ///     the offset will be left unmodified.
+  ///
+  /// @return
+  ///     The extracted 24-bit value represented in a uint32_t.
+  uint32_t getU24(uint32_t *offset_ptr) const;
+
   /// Extract a uint32_t value from \a *offset_ptr.
   ///
   /// Extract a single uint32_t from the binary data at the offset
   /// pointed to by \a offset_ptr, and update the offset on success.
   ///
   /// @param[in,out] offset_ptr
   ///     A pointer to an offset within the data that will be advanced
   ///     by the appropriate number of bytes if the value is extracted

llvm/trunk/lib/DebugInfo/DWARF/DWARFFormValue.cpp

case DW_FORM_addrx1:
     return 1;
 
   case DW_FORM_data2:
   case DW_FORM_ref2:
   case DW_FORM_strx2:
   case DW_FORM_addrx2:
     return 2;
 
+  case DW_FORM_strx3:
+    return 3;
+
   case DW_FORM_data4:
   case DW_FORM_ref4:
   case DW_FORM_ref_sup4:
   case DW_FORM_strx4:
   case DW_FORM_addrx4:
     return 4;
 
   case DW_FORM_strp:
bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   case DW_FORM_ref_sig8:
   case DW_FORM_GNU_ref_alt:
     return (FC == FC_Reference);
   case DW_FORM_GNU_addr_index:
     return (FC == FC_Address);
   case DW_FORM_GNU_str_index:
   case DW_FORM_GNU_strp_alt:
   case DW_FORM_strx:
+  case DW_FORM_strx1:
+  case DW_FORM_strx2:
+  case DW_FORM_strx3:
+  case DW_FORM_strx4:
     return (FC == FC_String);
   case DW_FORM_implicit_const:
     return (FC == FC_Constant);
   default:
     break;
   }
   // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section offset.
   // Don't check for DWARF version here, as some producers may still do this
case DW_FORM_addrx1:
       Value.uval = Data.getU8(OffsetPtr);
       break;
     case DW_FORM_data2:
     case DW_FORM_ref2:
     case DW_FORM_strx2:
     case DW_FORM_addrx2:
       Value.uval = Data.getU16(OffsetPtr);
       break;
+    case DW_FORM_strx3:
+      Value.uval = Data.getU24(OffsetPtr);
+      break;
     case DW_FORM_data4:
     case DW_FORM_ref4:
     case DW_FORM_ref_sup4:
     case DW_FORM_strx4:
     case DW_FORM_addrx4: {
       const RelocAddrMap *RelocMap = U ? U->getRelocMap() : nullptr;
       Value.uval = getRelocatedValue(Data, 4, OffsetPtr, RelocMap);
       break;
void DWARFFormValue::dump(raw_ostream &OS) const {
   case DW_FORM_udata:
     OS << Value.uval;
     break;
   case DW_FORM_strp:
     OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)UValue);
     dumpString(OS);
     break;
   case DW_FORM_strx:
+  case DW_FORM_strx1:
+  case DW_FORM_strx2:
+  case DW_FORM_strx3:
+  case DW_FORM_strx4:
   case DW_FORM_GNU_str_index:
     OS << format(" indexed (%8.8x) string = ", (uint32_t)UValue);
     dumpString(OS);
     break;
   case DW_FORM_GNU_strp_alt:
     OS << format("alt indirect string, offset: 0x%" PRIx64 "", UValue);
     dumpString(OS);
     break;
Optional<const char *> DWARFFormValue::getAsCString() const {
   if (!isFormClass(FC_String))
     return None;
   if (Form == DW_FORM_string)
     return Value.cstr;
   // FIXME: Add support for DW_FORM_GNU_strp_alt
   if (Form == DW_FORM_GNU_strp_alt || U == nullptr)
     return None;
   uint32_t Offset = Value.uval;
-  if (Form == DW_FORM_GNU_str_index || Form == DW_FORM_strx) {
+  if (Form == DW_FORM_GNU_str_index || Form == DW_FORM_strx ||
+      Form == DW_FORM_strx1 || Form == DW_FORM_strx2 || Form == DW_FORM_strx3 ||
+      Form == DW_FORM_strx4) {
     uint64_t StrOffset;
     if (!U->getStringOffsetSectionItem(Offset, StrOffset))
       return None;
     StrOffset += U->getStringOffsetSectionRelocation(Offset);
     Offset = StrOffset;
   }
   if (const char *Str = U->getStringExtractor().getCStr(&Offset)) {
     return Str;

llvm/trunk/lib/Support/DataExtractor.cpp

 }
 
 uint16_t *DataExtractor::getU16(uint32_t *offset_ptr, uint16_t *dst,
                                 uint32_t count) const {
   return getUs<uint16_t>(offset_ptr, dst, count, this, IsLittleEndian,
                         Data.data());
 }
 
+uint32_t DataExtractor::getU24(uint32_t *offset_ptr) const {
+  uint24_t ExtractedVal =
+      getU<uint24_t>(offset_ptr, this, IsLittleEndian, Data.data());
+  // The 3 bytes are in the correct byte order for the host.
+  return ExtractedVal.getAsUint32(sys::IsLittleEndianHost);
+}
+
 uint32_t DataExtractor::getU32(uint32_t *offset_ptr) const {
   return getU<uint32_t>(offset_ptr, this, IsLittleEndian, Data.data());
 }
 
 uint32_t *DataExtractor::getU32(uint32_t *offset_ptr, uint32_t *dst,
                                 uint32_t count) const {
   return getUs<uint32_t>(offset_ptr, dst, count, this, IsLittleEndian,
                         Data.data());

llvm/trunk/test/DebugInfo/Inputs/dwarfdump-str-offsets.s

 str_CU2:
         .asciz "Compile_Unit_2"
 str_CU2_dir:
         .asciz "/home/test/CU2"
 str_TU:
         .asciz "Type_Unit"
 str_TU_type:
         .asciz "MyStruct"
+str_Subprogram:
+        .asciz "MyFunc"
+str_Variable1:
+        .asciz "MyVar1"
+str_Variable2:
+        .asciz "MyVar2"
+str_Variable3:
+        .asciz "MyVar3"
 
 # Every unit contributes to the string_offsets table.
         .section .debug_str_offsets,"",@progbits
 # CU1's contribution
         .long .debug_str_offsets_segment0_end-.debug_str_offsets_base0
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base0:
         .long str_producer
         .long str_CU1
         .long str_CU1_dir
+        .long str_Subprogram
+        .long str_Variable1
+        .long str_Variable2
+        .long str_Variable3
 .debug_str_offsets_segment0_end:
 # CU2's contribution
         .long .debug_str_offsets_segment1_end-.debug_str_offsets_base1
         .short 5    # DWARF version
         .short 0    # Padding
 .debug_str_offsets_base1:
         .long str_producer
         .long str_CU2
.debug_dwo_str_offsets_base1:
         .long dwo_str_TU_5-.debug_str.dwo
         .long dwo_str_TU_5_type-.debug_str.dwo
 .debug_dwo_str_offsets_segment1_end:
 
 # All CUs/TUs use the same abbrev section for simplicity.
         .section .debug_abbrev,"",@progbits
         .byte 0x01  # Abbrev code
         .byte 0x11  # DW_TAG_compile_unit
-        .byte 0x00  # DW_CHILDREN_no
+        .byte 0x01  # DW_CHILDREN_yes
         .byte 0x25  # DW_AT_producer
         .byte 0x1a  # DW_FORM_strx
         .byte 0x03  # DW_AT_name
         .byte 0x1a  # DW_FORM_strx
         .byte 0x72  # DW_AT_str_offsets_base
         .byte 0x17  # DW_FORM_sec_offset
         .byte 0x1b  # DW_AT_comp_dir
         .byte 0x1a  # DW_FORM_strx
# All CUs/TUs use the same abbrev section for simplicity.
         .byte 0x00  # EOM(2)
         .byte 0x03  # Abbrev code
         .byte 0x13  # DW_TAG_structure_type
         .byte 0x00  # DW_CHILDREN_no (no members)
         .byte 0x03  # DW_AT_name
         .byte 0x1a  # DW_FORM_strx
         .byte 0x00  # EOM(1)
         .byte 0x00  # EOM(2)
+        .byte 0x04  # Abbrev code
+        .byte 0x2e  # DW_TAG_subprogram
+        .byte 0x01  # DW_CHILDREN_yes
+        .byte 0x03  # DW_AT_name
+        .byte 0x25  # DW_FORM_strx1
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x05  # Abbrev code
+        .byte 0x34  # DW_TAG_variable
+        .byte 0x00  # DW_CHILDREN_no
+        .byte 0x03  # DW_AT_name
+        .byte 0x26  # DW_FORM_strx2
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x06  # Abbrev code
+        .byte 0x34  # DW_TAG_variable
+        .byte 0x00  # DW_CHILDREN_no
+        .byte 0x03  # DW_AT_name
+        .byte 0x27  # DW_FORM_strx3
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x07  # Abbrev code
+        .byte 0x34  # DW_TAG_variable
+        .byte 0x00  # DW_CHILDREN_no
+        .byte 0x03  # DW_AT_name
+        .byte 0x28  # DW_FORM_strx4
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
         .byte 0x00  # EOM(3)
 
-# And a .dwo copy for the .dwo sections.
+# And a .dwo copy of a subset for the .dwo sections.
         .section .debug_abbrev.dwo,"",@progbits
         .byte 0x01  # Abbrev code
         .byte 0x11  # DW_TAG_compile_unit
         .byte 0x00  # DW_CHILDREN_no
         .byte 0x25  # DW_AT_producer
         .byte 0x1a  # DW_FORM_strx
         .byte 0x03  # DW_AT_name
         .byte 0x1a  # DW_FORM_strx
CU1_5_version:
         .long .debug_abbrev    # Offset Into Abbrev. Section
 # The compile-unit DIE, which has a DW_AT_producer, DW_AT_name, 
 # DW_AT_str_offsets and DW_AT_compdir.
         .byte 1                # Abbreviation code
         .byte 0                # The index of the producer string
         .byte 1                # The index of the CU name string
         .long .debug_str_offsets_base0
         .byte 2                # The index of the comp dir string
+# A subprogram DIE with DW_AT_name, using DW_FORM_strx1.
+        .byte 4                # Abbreviation code
+        .byte 3                # Subprogram name string (DW_FORM_strx1)
+# A variable DIE with DW_AT_name, using DW_FORM_strx2.
+        .byte 5                # Abbreviation code
+        .short 0x0004          # Subprogram name string (DW_FORM_strx2)
+# A variable DIE with DW_AT_name, using DW_FORM_strx3.
+        .byte 6                # Abbreviation code
+        .byte 5                # Subprogram name string (DW_FORM_strx3)
+        .short 0               # Subprogram name string (DW_FORM_strx3)
+# A variable DIE with DW_AT_name, using DW_FORM_strx4.
+        .byte 7                # Abbreviation code
+        .quad 0x00000006       # Subprogram name string (DW_FORM_strx4)
+        .byte 0 # NULL
+        .byte 0 # NULL
         .byte 0 # NULL
 CU1_5_end:
 
 # DWARF v5 CU header
         .long  CU2_5_end-CU2_5_version  # Length of Unit
 CU2_5_version:
         .short 5               # DWARF version number
         .byte 1                # DWARF Unit Type

llvm/trunk/test/DebugInfo/dwarfdump-str-offsets.test

 ; Verify that strings are displayed correctly as indexed strings
 CHECK:      .debug_info contents:
 CHECK-NOT:  contents:     
 CHECK:      DW_TAG_compile_unit
 CHECK-NEXT: DW_AT_producer [DW_FORM_strx] ( indexed (00000000) string = "Handmade DWARF producer")
 CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "Compile_Unit_1")
 CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
 CHECK-NEXT: DW_AT_comp_dir [DW_FORM_strx] ( indexed (00000002) string = "/home/test/CU1")
+CHECK-NOT:  NULL
+CHECK:      DW_TAG_subprogram
+CHECK-NEXT: DW_AT_name [DW_FORM_strx1] ( indexed (00000003) string = "MyFunc")
+CHECK-NOT:  NULL
+CHECK:      DW_TAG_variable
+CHECK-NEXT: DW_AT_name [DW_FORM_strx2] ( indexed (00000004) string = "MyVar1")
+CHECK-NOT:  NULL
+CHECK:      DW_TAG_variable
+CHECK-NEXT: DW_AT_name [DW_FORM_strx3] ( indexed (00000005) string = "MyVar2")
+CHECK-NOT:  NULL
+CHECK:      DW_TAG_variable
+CHECK-NEXT: DW_AT_name [DW_FORM_strx4] ( indexed (00000006) string = "MyVar3")
 
 ; Second compile unit (b.cpp)
 CHECK:      DW_TAG_compile_unit
 CHECK-NEXT: DW_AT_producer [DW_FORM_strx] ( indexed (00000000) string = "Handmade DWARF producer")
 CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "Compile_Unit_2")
-CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x0000001c)
+CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x0000002c)
 CHECK-NEXT: DW_AT_comp_dir [DW_FORM_strx] ( indexed (00000002) string = "/home/test/CU2")
 
 ; The split CU
 CHECK:      .debug_info.dwo contents:
 CHECK-NOT:  contents:
 CHECK:      DW_TAG_compile_unit
 CHECK-NEXT: DW_AT_producer [DW_FORM_strx] ( indexed (00000000) string = "Handmade split DWARF producer")
 CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "V5_split_compile_unit")
 CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
 CHECK-NEXT: DW_AT_comp_dir [DW_FORM_strx] ( indexed (00000002) string = "/home/test/splitCU")
 
 ; The type unit
 CHECK:      .debug_types contents:
 CHECK:      DW_TAG_type_unit
 CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000000) string = "Type_Unit")
-CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000030)
+CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x00000040)
 CHECK:      DW_TAG_structure_type
 CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "MyStruct")
 
 ; The split type unit
 CHECK:      .debug_types.dwo contents:
 CHECK:      DW_TAG_type_unit
 CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000000) string = "V5_split_type_unit")
 CHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset]       (0x0000001c)
 CHECK:      DW_TAG_structure_type
 CHECK-NEXT: DW_AT_name [DW_FORM_strx] ( indexed (00000001) string = "V5_split_Mystruct")
 
 ; The .debug_str_offsets section
 CHECK:      .debug_str_offsets contents:
-CHECK-NEXT: 0x00000000: Contribution size = 12, Version = 5
+CHECK-NEXT: 0x00000000: Contribution size = 28, Version = 5
 CHECK-NEXT: 0x00000008: 00000000 "Handmade DWARF producer"
 CHECK-NEXT: 0x0000000c: 00000018 "Compile_Unit_1"
 CHECK-NEXT: 0x00000010: 00000027 "/home/test/CU1"
-CHECK-NEXT: 0x00000014: Contribution size = 12, Version = 5
-CHECK-NEXT: 0x0000001c: 00000000 "Handmade DWARF producer"
-CHECK-NEXT: 0x00000020: 00000036 "Compile_Unit_2"
-CHECK-NEXT: 0x00000024: 00000045 "/home/test/CU2"
-CHECK-NEXT: 0x00000028: Contribution size = 8, Version = 5
-CHECK-NEXT: 0x00000030: 00000054 "Type_Unit"
-CHECK-NEXT: 0x00000034: 0000005e "MyStruct"
+CHECK-NEXT: 0x00000014: 00000067 "MyFunc"
+CHECK-NEXT: 0x00000018: 0000006e "MyVar1"
+CHECK-NEXT: 0x0000001c: 00000075 "MyVar2"
+CHECK-NEXT: 0x00000020: 0000007c "MyVar3"
+CHECK-NEXT: 0x00000024: Contribution size = 12, Version = 5
+CHECK-NEXT: 0x0000002c: 00000000 "Handmade DWARF producer"
+CHECK-NEXT: 0x00000030: 00000036 "Compile_Unit_2"
+CHECK-NEXT: 0x00000034: 00000045 "/home/test/CU2"
+CHECK-NEXT: 0x00000038: Contribution size = 8, Version = 5
+CHECK-NEXT: 0x00000040: 00000054 "Type_Unit"
+CHECK-NEXT: 0x00000044: 0000005e "MyStruct"
 
 CHECK:      .debug_str_offsets.dwo contents:
 CHECK-NEXT: 0x00000000: Contribution size = 12, Version = 5
 CHECK-NEXT: 0x00000008: 00000000 "Handmade split DWARF producer"
 CHECK-NEXT: 0x0000000c: 0000001e "V5_split_compile_unit"
 CHECK-NEXT: 0x00000010: 00000034 "/home/test/splitCU"
 CHECK-NEXT: 0x00000014: Contribution size = 8, Version = 5
 CHECK-NEXT: 0x0000001c: 00000047 "V5_split_type_unit"
 CHECK-NEXT: 0x00000020: 0000005a "V5_split_Mystruct"