[DebugInfo] Allow GNU macro extension to be read

[dstenb]

Summary

Allow the GNU .debug_macro extension to be parsed and printed by
llvm-dwarfdump. In an upcoming patch support will be added for emitting
that format also.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

3055–3059 ↗

(On Diff #274832)

I'd probably inline the lambda into the call expression - it's short/simple enough.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

535 ↗

(On Diff #274832)

Probably llvm::function_ref here, since the functor doesn't escape the callee

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

57

If this is written like

<< (Macros.Header.Version < 5 ? GnuMacroString(E.type) : MacroString(E.type)) ;

then llvm::dwarf::MacroString() can be left as is and most of the changes are not needed.

[dstenb]

Address comments.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

3055–3059 ↗

(On Diff #274832)

This change is now removed. I'll inline the expression in the follow-up patch.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

535 ↗

(On Diff #274832)

Yes, thanks! Since I moved out the GNU defines to a separate GnuMacroString() function this change is done in the patch which introduces emission of the extension.

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

57

Yes, thanks! Since there are so few uses where we conditionally want to select either the DWARF or GNU defines that seems cleaner.

llvm/include/llvm/BinaryFormat/Dwarf.h

 StringRef CaseString(unsigned Case);
 StringRef ConventionString(unsigned Convention);
 StringRef InlineCodeString(unsigned Code);
 StringRef ArrayOrderString(unsigned Order);
 StringRef LNStandardString(unsigned Standard);
 StringRef LNExtendedString(unsigned Encoding);
 StringRef MacinfoString(unsigned Encoding);
 StringRef MacroString(unsigned Encoding);
+StringRef GnuMacroString(unsigned Encoding);
 StringRef RangeListEncodingString(unsigned Encoding);
 StringRef LocListEncodingString(unsigned Encoding);
 StringRef CallFrameString(unsigned Encoding, Triple::ArchType Arch);
 StringRef ApplePropertyString(unsigned);
 StringRef UnitTypeString(unsigned);
 StringRef AtomTypeString(unsigned Atom);
 StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind);
 StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage);

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

#include "llvm/BinaryFormat/Dwarf.def"
 
   struct MacroList {
     // A value 0 in the `Header.Version` field indicates that we're parsing
     // a macinfo[.dwo] section which doesn't have header itself, hence
     // for that case other fields in the `Header` are uninitialized.
     MacroHeader Header;
     SmallVector<Entry, 4> Macros;
     uint64_t Offset;
+
+    /// Whether or not this is a .debug_macro section.
+    bool IsDebugMacro;
   };
 
   /// A list of all the macro entries in the debug_macinfo section.
   std::vector<MacroList> MacroLists;
 
 public:
   DWARFDebugMacro() = default;
 

llvm/lib/BinaryFormat/Dwarf.cpp

default:
     return StringRef();
 #define HANDLE_DW_MACRO(ID, NAME)                                              \
   case DW_MACRO_##NAME:                                                        \
     return "DW_MACRO_" #NAME;
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
+StringRef llvm::dwarf::GnuMacroString(unsigned Encoding) {
+  switch (Encoding) {
+  default:
+    return StringRef();
+#define HANDLE_DW_MACRO_GNU(ID, NAME)                                          \
+  case DW_MACRO_GNU_##NAME:                                                    \
+    return "DW_MACRO_GNU_" #NAME;
+#include "llvm/BinaryFormat/Dwarf.def"
+  }
+}
+
 unsigned llvm::dwarf::getMacro(StringRef MacroString) {
   return StringSwitch<unsigned>(MacroString)
 #define HANDLE_DW_MACRO(ID, NAME) .Case("DW_MACRO_" #NAME, ID)
 #include "llvm/BinaryFormat/Dwarf.def"
       .Default(DW_MACINFO_invalid);
 }
 StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) {
   switch (Encoding) {

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

OS << format(", debug_line_offset = 0x%0*" PRIx64, 2 * getOffsetByteSize(),
                  DebugLineOffset);
   OS << "\n";
 }
 
 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)
+    if (Macros.IsDebugMacro)
       Macros.Header.dumpMacroHeader(OS);
     for (const Entry &E : Macros.Macros) {
       // There should not be DW_MACINFO_end_file when IndLevel is Zero. However,
       // this check handles the case of corrupted ".debug_macinfo" section.
       if (IndLevel > 0)
         IndLevel -= (E.Type == DW_MACINFO_end_file);
       // Print indentation.
       for (unsigned I = 0; I < IndLevel; I++)
         OS << "  ";
       IndLevel += (E.Type == DW_MACINFO_start_file);
       // Based on which version we are handling choose appropriate macro forms.
-      if (Macros.Header.Version >= 5)
-        WithColor(OS, HighlightColor::Macro).get() << MacroString(E.Type);
+      if (Macros.IsDebugMacro)
+        WithColor(OS, HighlightColor::Macro).get()
+            << (Macros.Header.Version < 5 ? GnuMacroString(E.Type)
+                                          : MacroString(E.Type));
       else
         WithColor(OS, HighlightColor::Macro).get() << MacinfoString(E.Type);
       switch (E.Type) {
       default:
         // Got a corrupted ".debug_macinfo/.debug_macro" section (invalid
         // macinfo type).
         break;
         // debug_macro and debug_macinfo share some common encodings.
         // DW_MACRO_define     == DW_MACINFO_define
         // DW_MACRO_undef      == DW_MACINFO_undef
         // DW_MACRO_start_file == DW_MACINFO_start_file
         // DW_MACRO_end_file   == DW_MACINFO_end_file
         // For readability/uniformity we are using DW_MACRO_*.
+        //
+        // The GNU .debug_macro extension's entries have the same encoding
+        // as DWARF 5's DW_MACRO_* entries, so we only use the latter here.
       case DW_MACRO_define:
       case DW_MACRO_undef:
       case DW_MACRO_define_strp:
       case DW_MACRO_undef_strp:
       case DW_MACRO_define_strx:
       case DW_MACRO_undef_strx:
         OS << " - lineno: " << E.Line;
         OS << " macro: " << E.MacroStr;
for (const auto &U : Units.getValue())
         if (auto MacroOffset = toSectionOffset(CUDIE.find(DW_AT_macros)))
           MacroToUnits.try_emplace(*MacroOffset, U.get());
   }
   while (Data.isValidOffset(Offset)) {
     if (!M) {
       MacroLists.emplace_back();
       M = &MacroLists.back();
       M->Offset = Offset;
+      M->IsDebugMacro = IsMacro;
       if (IsMacro) {
         auto Err = M->Header.parseMacroHeader(Data, &Offset);
         if (Err)
           return Err;
       }
     }
     // A macro list entry consists of:
     M->Macros.emplace_back();

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

+## This test checks that llvm-dwarfdump can dump a .debug_macro section
+## with the GNU extension format.
+
+# 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 = 0x0004, flags = 0x02, format = DWARF32, debug_line_offset = 0x00000000
+# CHECK-NEXT:DW_MACRO_GNU_start_file - lineno: 0 filenum: 0
+# CHECK-NEXT:  DW_MACRO_GNU_start_file - lineno: 1 filenum: 6
+# CHECK-NEXT:    DW_MACRO_GNU_define_indirect - lineno: 1 macro: FOO 5
+# CHECK-NEXT:  DW_MACRO_GNU_end_file
+# CHECK-NEXT:  DW_MACRO_GNU_undef_indirect - lineno: 8 macro: WORLD1
+# CHECK-NEXT:  DW_MACRO_GNU_transparent_include - import offset: 0x[[OFFSET:[0-9]+]]
+# CHECK-NEXT:DW_MACRO_GNU_end_file
+
+#      CHECK:0x[[OFFSET]]:
+# CHECK-NEXT:macro header: version = 0x0004, flags = 0x00, format = DWARF32
+# CHECK-NEXT:DW_MACRO_GNU_define_indirect - lineno: 0 macro: WORLD 2
+
+  .section  .debug_macro,"",@progbits
+.Lcu_macro_begin0:
+  .short  4                      # Macro information version
+  .byte 2                       # Flags: 32 bit, debug_line_offset present
+  .long 0                       # debug_line_offset
+  .byte 3                       # DW_MACRO_GNU_start_file
+  .byte 0                       # Line Number
+  .byte 0                       # File Number
+  .byte 3                       # DW_MACRO_GNU_start_file
+  .byte 1                       # Line Number
+  .byte 6                       # File Number
+  .byte 5                       # DW_MACRO_GNU_define_indirect
+  .byte 1                       # Line Number
+  .long .Linfo_string0          # Macro String
+  .byte 4                       # DW_MACRO_GNU_end_file
+  .byte 6                       # DW_MACRO_GNU_undef_indirect
+  .byte 8                       # Line Number
+  .long .Linfo_string1          # Macro String
+  .byte 7                       # DW_MACRO_GNU_transparent_include
+  .long .Lmacro1                # Macro Unit Offset
+  .byte 4                       # DW_MACRO_GNU_end_file
+  .byte 0                       # End Of Macro List Mark
+
+.Lmacro1:
+  .short  4                      # Macro information version
+  .byte 0                       # Flags: 32 bit
+  .byte 5                       # DW_MACRO_GNU_define_indirect
+  .byte 0                       # Line Number
+  .long .Linfo_string2          # Macro String
+  .byte 0                       # End Of Macro List Mark
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "FOO 5"
+.Linfo_string1:
+  .asciz  "WORLD1"
+.Linfo_string2:
+  .asciz  "WORLD 2"