[DebugInfo] Support parsing and dumping of DWARF64 macro units.

[SouraVX]

LGTM, Thanks! Please wait for other reviewers, in case if they've any comments.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

31–32

This is a bit redundant and possibly confusing - the format is given by the flags. Perhaps the flags should be decomposed into their semantic values and rendered that way (& render the raw flag value if it contains other bits set that aren't described by the spec)?

Though I guess it's not entirely inconsistent with the way we print the format and the length in other sections, when the format is sort of described by the length..

[jhenderson]

llvm/test/DebugInfo/X86/debug-macro-dwarf64.s

54

Nit: no new line at EOF.

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

31–32

Sorry, but I do not fully understand what you are suggesting to change exactly.

I guess that reporting Flags in some cases while omitting it in others might not be a good practice. We discussed something similar for a patch that added reporting the format and the common consensus was that it is better to print the format for both variants rather than only for DWARF64.

We could decode the value of Flags in each case, but that is already done even if in a bit indirect way. We dump debug_line_offset only if the corresponding flag is set and, with this patch, we explicitly dump the format. The only remaining flag, opcode_operands_table, is not supported yet. But even if we decide to explicitly explain Flags, that should be a separate patch.

llvm/test/DebugInfo/X86/debug-macro-dwarf64.s

54

Thanks! Sorry. I guess it is time to tackle the settings of my VS Code.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

31–32

Fair enough - thanks for the explanation.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

struct MacroHeader {
     ///   the header is for a 64-bit DWARF format macro section and all offsets
     ///   are 8 bytes long.
     /// debug_line_offset_flag:
     ///   If the debug_line_offset_flag is one, the debug_line_offset field (see
     ///   below) is present. If zero, that field is omitted.
     /// opcode_operands_table_flag:
     ///   If the opcode_operands_table_flag is one, the opcode_operands_table
     ///   field (see below) is present. If zero, that field is omitted.
-    uint8_t Flags;
+    uint8_t Flags = 0;
 
     /// debug_line_offset
     ///   An offset in the .debug_line section of the beginning of the line
     ///   number information in the containing compilation unit, encoded as a
     ///   4-byte offset for a 32-bit DWARF format macro section and an 8-byte
     ///   offset for a 64-bit DWARF format macro section.
     uint64_t DebugLineOffset;
 
     /// Print the macro header from the debug_macro section.
     void dumpMacroHeader(raw_ostream &OS) const;
 
     /// Parse the debug_macro header.
     Error parseMacroHeader(DWARFDataExtractor Data, uint64_t *Offset);
+
+    /// Get the DWARF format according to the flags.
+    dwarf::DwarfFormat getDwarfFormat() const;
+
+    /// Get the size of a reference according to the DWARF format.
+    uint8_t getOffsetByteSize() const;
   };
 
   /// A single macro entry within a macro list.
   struct Entry {
     /// The type of the macro entry.
     uint32_t Type;
     union {
       /// The source line where the macro is defined.

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 
 using namespace llvm;
 using namespace dwarf;
 
+DwarfFormat DWARFDebugMacro::MacroHeader::getDwarfFormat() const {
+  return Flags & MACRO_OFFSET_SIZE ? DWARF64 : DWARF32;
+}
+
+uint8_t DWARFDebugMacro::MacroHeader::getOffsetByteSize() const {
+  return getDwarfOffsetByteSize(getDwarfFormat());
+}
+
 void DWARFDebugMacro::MacroHeader::dumpMacroHeader(raw_ostream &OS) const {
   // FIXME: Add support for dumping opcode_operands_table
-  OS << format("macro header: version = 0x%04" PRIx16 ", flags = 0x%02" PRIx8,
-               Version, Flags);
+  OS << format("macro header: version = 0x%04" PRIx16, Version)
+     << format(", flags = 0x%02" PRIx8, Flags)
+     << ", format = " << FormatString(getDwarfFormat());
   if (Flags & MACRO_DEBUG_LINE_OFFSET)
-    OS << format(", debug_line_offset = 0x%04" PRIx64 "\n", DebugLineOffset);
-  else
-    OS << "\n";
+    OS << format(", debug_line_offset = 0x%0*" PRIx64, 2 * getOffsetByteSize(),
+                 DebugLineOffset);
 }
 
 void DWARFDebugMacro::dump(raw_ostream &OS) const {
   unsigned IndLevel = 0;
   for (const auto &Macros : MacroLists) {
     OS << format("0x%08" PRIx64 ":\n", Macros.Offset);
     if (Macros.Header.Version >= 5)
       Macros.Header.dumpMacroHeader(OS);
for (const Entry &E : Macros.Macros) {
         OS << " - lineno: " << E.Line;
         OS << " macro: " << E.MacroStr;
         break;
       case DW_MACRO_start_file:
         OS << " - lineno: " << E.Line;
         OS << " filenum: " << E.File;
         break;
       case DW_MACRO_import:
-        OS << format(" - import offset: 0x%08" PRIx64, E.ImportOffset);
+        OS << format(" - import offset: 0x%0*" PRIx64,
+                     2 * Macros.Header.getOffsetByteSize(), E.ImportOffset);
         break;
       case DW_MACRO_end_file:
         break;
       case DW_MACINFO_vendor_ext:
         OS << " - constant: " << E.ExtConstant;
         OS << " string: " << E.ExtStr;
         break;
       }
case DW_MACRO_undef_strp: {
         // invalid entry, push it and halt parsing.
         E.Type = DW_MACINFO_invalid;
         return Error::success();
       }
       uint64_t StrOffset = 0;
       // 2. Source line
       E.Line = Data.getULEB128(&Offset);
       // 3. Macro string
-      // FIXME: Add support for DWARF64
-      StrOffset = Data.getRelocatedValue(/*OffsetSize=*/4, &Offset);
+      StrOffset =
+          Data.getRelocatedValue(M->Header.getOffsetByteSize(), &Offset);
       assert(StringExtractor && "String Extractor not found");
       E.MacroStr = StringExtractor->getCStr(&StrOffset);
       break;
     }
     case DW_MACRO_define_strx:
     case DW_MACRO_undef_strx: {
       if (!IsMacro) {
         // DW_MACRO_define_strx is a new form introduced in DWARFv5, it is
case DW_MACRO_start_file:
       // 2. Source line
       E.Line = Data.getULEB128(&Offset);
       // 3. Source file id
       E.File = Data.getULEB128(&Offset);
       break;
     case DW_MACRO_end_file:
       break;
     case DW_MACRO_import:
-      // FIXME: Add support for DWARF64
-      E.ImportOffset = Data.getRelocatedValue(/*OffsetSize=*/4, &Offset);
+      E.ImportOffset =
+          Data.getRelocatedValue(M->Header.getOffsetByteSize(), &Offset);
       break;
     case DW_MACINFO_vendor_ext:
       // 2. Vendor extension constant
       E.ExtConstant = Data.getULEB128(&Offset);
       // 3. Vendor extension string
       E.ExtStr = Data.getCStr(&Offset);
       break;
     }
   }
   return Error::success();
 }
 
 Error DWARFDebugMacro::MacroHeader::parseMacroHeader(DWARFDataExtractor Data,
                                                      uint64_t *Offset) {
   Version = Data.getU16(Offset);
   uint8_t FlagData = Data.getU8(Offset);
-  // FIXME: Add support for DWARF64
-  if (FlagData & MACRO_OFFSET_SIZE)
-    return createStringError(errc::not_supported, "DWARF64 is not supported");
 
   // FIXME: Add support for parsing opcode_operands_table
   if (FlagData & MACRO_OPCODE_OPERANDS_TABLE)
     return createStringError(errc::not_supported,
                              "opcode_operands_table is not supported");
   Flags = FlagData;
   if (Flags & MACRO_DEBUG_LINE_OFFSET)
-    DebugLineOffset = Data.getU32(Offset);
+    DebugLineOffset = Data.getUnsigned(Offset, getOffsetByteSize());
   return Error::success();
 }

llvm/test/DebugInfo/X86/debug-macro-dwarf64.s

+## This checks that llvm-dwarfdump can parse and dump DWARF64 macro units.
+
+# RUN: llvm-mc -triple x86_64 -filetype=obj %s -o - \
+# RUN:   | llvm-dwarfdump -debug-macro - \
+# RUN:   | FileCheck %s
+
+# CHECK:      .debug_macro contents:
+
+# CHECK:      0x00000000:
+# CHECK-NEXT: macro header: version = 0x0005, flags = 0x03, format = DWARF64, debug_line_offset = 0x0000000000000000
+# CHECK-NEXT: DW_MACRO_start_file - lineno: 0 filenum: 0
+# CHECK-NEXT:   DW_MACRO_import - import offset: 0x00000000[[MACRO1OFF:[[:xdigit:]]{8}]]
+# CHECK-NEXT: DW_MACRO_end_file
+
+# CHECK:      0x[[MACRO1OFF]]:
+# CHECK-NEXT: macro header: version = 0x0005, flags = 0x01, format = DWARF64
+# CHECK-NEXT: DW_MACRO_define_strp - lineno: 1 macro: FOO 1
+# CHECK-NEXT: DW_MACRO_undef_strp - lineno: 9 macro: BAR
+# CHECK-NEXT: DW_MACRO_undef_strp - lineno: 15 macro: BAZ
+
+    .section .debug_macro, "", @progbits
+.LMacro0:
+    .short 5            # Version
+    .byte 3             # Flags: offset_size_flag | debug_line_offset_flag
+    .quad 0             # Debug Line Offset
+    .byte 3             # DW_MACRO_start_file
+    .uleb128 0          # Line
+    .uleb128 0          # File
+    .byte 7             # DW_MACRO_import
+    .quad .LMacro1
+    .byte 4             # DW_MACRO_end_file
+    .byte 0             # End macro unit
+.LMacro1:
+    .short 5            # Version
+    .byte 1             # Flags: offset_size_flag
+    .byte 5             # DW_MACRO_define_strp
+    .uleb128 1          # Line
+    .quad .LStr0        # "FOO 1"
+    .byte 6             # DW_MACRO_undef_strp
+    .uleb128 9          # Line
+    .quad .LStr1        # "BAR"
+    .byte 6             # DW_MACRO_undef_strp
+    .uleb128 15         # Line
+    .quad .LStr2        # "BAZ"
+    .byte 0             # End macro unit
+
+    .section .debug_str, "MS", @progbits, 1
+.LStr0:
+    .asciz "FOO 1"
+.LStr1:
+    .asciz "BAR"
+.LStr2:
+    .asciz "BAZ"
 No newline at end of file

llvm/test/DebugInfo/X86/debug-macro-dwo.ll

 ; This test checks emission of .debug_macro.dwo section when
 ; -gdwarf-5 -gsplit-dwarf -fdebug-macro is specified.
 
 ; RUN: %llc_dwarf -dwarf-version=5 -O0 -filetype=obj \
 ; RUN: -split-dwarf-file=foo.dwo < %s | llvm-dwarfdump -v - | FileCheck %s
 
 ; CHECK-LABEL:  .debug_info contents:
 ; CHECK: DW_AT_macros [DW_FORM_sec_offset] (0x00000000)
 
 ; CHECK-LABEL:  .debug_macro.dwo contents:
 ; CHECK-NEXT: 0x00000000:
-; CHECK-NEXT: macro header: version = 0x0005, flags = 0x02
+; CHECK-NEXT: macro header: version = 0x0005, flags = 0x02, format = DWARF32
 ; CHECK-NEXT: DW_MACRO_start_file - lineno: 0 filenum: 0
 ; CHECK-NEXT:   DW_MACRO_start_file - lineno: 1 filenum: 1
 ; CHECK-NEXT:     DW_MACRO_define_strx - lineno: 1 macro: FOO 5
 ; CHECK-NEXT:   DW_MACRO_end_file
 ; CHECK-NEXT:   DW_MACRO_start_file - lineno: 2 filenum: 2
 ; CHECK-NEXT:     DW_MACRO_undef_strx - lineno: 14 macro: YEA
 ; CHECK-NEXT:   DW_MACRO_end_file
 ; CHECK-NEXT:   DW_MACRO_undef_strx - lineno: 14 macro: YEA

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

 ## This test checks that llvm-dwarfdump can dump both debug_macro and debug_macinfo
 ## sections present in the same object.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
 # RUN:   llvm-dwarfdump -debug-macro - | FileCheck -strict-whitespace -match-full-lines %s
 
 #      CHECK:.debug_macro contents:
 # CHECK-NEXT:0x00000000:
-# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, format = DWARF32, debug_line_offset = 0x00000000
 # CHECK-NEXT:DW_MACRO_start_file - lineno: 0 filenum: 0
 # CHECK-NEXT:  DW_MACRO_define_strp - lineno: 1 macro: DWARF_VERSION 5
 # CHECK-NEXT:DW_MACRO_end_file
 
 #      CHECK:.debug_macinfo contents:
 # CHECK-NEXT:0x00000000:
 # CHECK-NEXT:DW_MACINFO_start_file - lineno: 0 filenum: 2
 # CHECK-NEXT:  DW_MACINFO_define - lineno: 6 macro: DWARF_VERSION 4

llvm/test/DebugInfo/X86/debug-macro-multi-cu-strx.s

 ## This test checks that llvm-dwarfdump can dump debug_macro
 ## section containing contributions from multiple CU's represented
 ## using DW_MACRO_define_strx form.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
 # RUN:   llvm-dwarfdump -debug-macro - | FileCheck -strict-whitespace -match-full-lines %s
 
 #      CHECK:.debug_macro contents:
 # CHECK-NEXT:0x00000000:
-# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, format = DWARF32, debug_line_offset = 0x00000000
 # CHECK-NEXT:DW_MACRO_start_file - lineno: 0 filenum: 0
 # CHECK-NEXT:  DW_MACRO_define_strx - lineno: 1 macro: DWARF_VERSION 5
 # CHECK-NEXT:  DW_MACRO_define_strx - lineno: 2 macro: COMPILE_UNIT 1
 # CHECK-NEXT:  DW_MACRO_undef_strx - lineno: 3 macro: COMPILE_UNIT
 # CHECK-NEXT:DW_MACRO_end_file
 
 #      CHECK:0x00000015:
-# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, format = DWARF32, debug_line_offset = 0x00000000
 # CHECK-NEXT:DW_MACRO_start_file - lineno: 1 filenum: 3
 # CHECK-NEXT:  DW_MACRO_define_strx - lineno: 2 macro: COMPILE_UNIT 2
 # CHECK-NEXT:  DW_MACRO_undef_strx - lineno: 3 macro: COMPILE_UNIT
 # CHECK-NEXT:DW_MACRO_end_file
 
        .section        .debug_abbrev,"",@progbits
        .byte   1                       # Abbreviation Code
        .byte   17                      # DW_TAG_compile_unit

llvm/test/DebugInfo/X86/debug-macro-strp-dwo.s

 ## This test checks that llvm-dwarfdump can dump debug_macro.dwo
 ## section containing DW_MACRO_*_strp forms present in a dwo object.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
 # RUN:   llvm-dwarfdump -debug-macro - | FileCheck -strict-whitespace -match-full-lines %s
 
 #      CHECK:.debug_macro.dwo contents:
 # CHECK-NEXT:0x00000000:
-# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, format = DWARF32, debug_line_offset = 0x00000000
 # CHECK-NEXT:DW_MACRO_start_file - lineno: 0 filenum: 0
 # CHECK-NEXT:  DW_MACRO_define_strp - lineno: 1 macro: DWARF_VERSION 5
 # CHECK-NEXT:  DW_MACRO_undef_strp - lineno: 4 macro: DWARF_VERSION
 # CHECK-NEXT:DW_MACRO_end_file
 
   .section  .debug_macro.dwo,"e",@progbits
 .Lcu_macro_begin0:
   .short  5                      # Macro information version

llvm/test/DebugInfo/X86/debug-macro-strx-dwo.s

 ## This test checks that llvm-dwarfdump can dump debug_macro.dwo
 ## section containing DW_MACRO_*_strx forms present in a dwo object.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
 # RUN:   llvm-dwarfdump -debug-macro - | FileCheck -strict-whitespace -match-full-lines %s
 
 #      CHECK:.debug_macro.dwo contents:
 # CHECK-NEXT:0x00000000:
-# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, format = DWARF32, debug_line_offset = 0x00000000
 # CHECK-NEXT:DW_MACRO_start_file - lineno: 0 filenum: 0
 # CHECK-NEXT:  DW_MACRO_define_strx - lineno: 1 macro: DWARF_VERSION 5
 # CHECK-NEXT:  DW_MACRO_undef_strx - lineno: 4 macro: DWARF_VERSION
 # CHECK-NEXT:DW_MACRO_end_file
 
   .section  .debug_macro.dwo,"e",@progbits
 .Lcu_macro_begin0:
   .short  5                      # Macro information version

llvm/test/DebugInfo/X86/debug-macro-v5.ll

 ; This test checks emission of .debug_macro section when
 ; -gdwarf-5 -fdebug-macro is specified.
 
 ; RUN: %llc_dwarf -dwarf-version=5 -O0 -filetype=obj < %s | llvm-dwarfdump -v - | FileCheck %s
 
 ; CHECK-LABEL:  .debug_info contents:
 ; CHECK: DW_AT_macros [DW_FORM_sec_offset] (0x00000000)
 
 ; CHECK-LABEL:  .debug_macro contents:
 ; CHECK-NEXT: 0x00000000:
-; CHECK-NEXT: macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
+; CHECK-NEXT: macro header: version = 0x0005, flags = 0x02, format = DWARF32, debug_line_offset = 0x00000000
 ; CHECK-NEXT: DW_MACRO_start_file - lineno: 0 filenum: 0
 ; CHECK-NEXT:   DW_MACRO_start_file - lineno: 1 filenum: 1
 ; CHECK-NEXT:     DW_MACRO_define_strx - lineno: 1 macro: FOO 5
 ; CHECK-NEXT:   DW_MACRO_end_file
 ; CHECK-NEXT:   DW_MACRO_start_file - lineno: 2 filenum: 2
 ; CHECK-NEXT:     DW_MACRO_undef_strx - lineno: 14 macro: YEA
 ; CHECK-NEXT:   DW_MACRO_end_file
 ; CHECK-NEXT:   DW_MACRO_undef_strx - lineno: 14 macro: YEA

llvm/test/DebugInfo/X86/debug-macro-v5.s

 ## This test checks llvm-dwarfdump can dump debug_macro section containing
 ## multiple macro units.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
 # RUN:   llvm-dwarfdump -debug-macro - | FileCheck -strict-whitespace -match-full-lines %s
 
 #      CHECK:.debug_macro contents:
 # CHECK-NEXT:0x00000000:
-# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, format = DWARF32, debug_line_offset = 0x00000000
 # CHECK-NEXT:DW_MACRO_start_file - lineno: 0 filenum: 0
 # CHECK-NEXT:  DW_MACRO_start_file - lineno: 1 filenum: 6
 # CHECK-NEXT:    DW_MACRO_define_strp - lineno: 1 macro: FOO 5
 # CHECK-NEXT:  DW_MACRO_end_file
 # CHECK-NEXT:  DW_MACRO_undef_strp - lineno: 8 macro: WORLD1
 # CHECK-NEXT:  DW_MACRO_import - import offset: 0x[[OFFSET:[0-9]+]]
 # CHECK-NEXT:DW_MACRO_end_file
 
 #      CHECK:0x[[OFFSET]]:
-# CHECK-NEXT:macro header: version = 0x0005, flags = 0x00
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x00, format = DWARF32
 # CHECK-NEXT:DW_MACRO_define_strp - lineno: 0 macro: WORLD 2
 
   .section  .debug_macro,"",@progbits
 .Lcu_macro_begin0:
   .short  5                      # Macro information version
   .byte 2                       # Flags: 32 bit, debug_line_offset present
   .long 0                       # debug_line_offset
   .byte 3                       # DW_MACRO_start_file

llvm/test/DebugInfo/X86/unsupported-dwarf64-debug-macro-v5.s

-## This test checks llvm-dwarfdump emits correct error diagnostics for the
-## unsupported case where DWARF64 flag is present in the debug_macro section header.
-
-# RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
-# RUN:   not llvm-dwarfdump -debug-macro - /dev/null 2>&1 | FileCheck %s
-
-# CHECK:error: DWARF64 is not supported
-
-  .section  .debug_macro,"",@progbits
-.Lcu_macro_begin0:
-  .short  5                      # Macro information version
-  .byte 3                       # Flags: 64 bit, debug_line_offset present
-  .quad 0                       # debug_line_offset