[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

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

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

535

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

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

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

535

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 LanguageString(unsigned Language);
 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 MacroString(unsigned Encoding, bool GNU);
 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

return StringSwitch<unsigned>(MacinfoString)
       .Case("DW_MACINFO_define", DW_MACINFO_define)
       .Case("DW_MACINFO_undef", DW_MACINFO_undef)
       .Case("DW_MACINFO_start_file", DW_MACINFO_start_file)
       .Case("DW_MACINFO_end_file", DW_MACINFO_end_file)
       .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext)
       .Default(DW_MACINFO_invalid);
 }
 
-StringRef llvm::dwarf::MacroString(unsigned Encoding) {
+static StringRef getGnuMacroString(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"
+  }
+}
+
+StringRef llvm::dwarf::MacroString(unsigned Encoding, bool GNU) {
+  if (GNU)
+    return getGnuMacroString(Encoding);
+
   switch (Encoding) {
   default:
     return StringRef();
 #define HANDLE_DW_MACRO(ID, NAME)                                              \
   case DW_MACRO_##NAME:                                                        \
     return "DW_MACRO_" #NAME;
 #include "llvm/BinaryFormat/Dwarf.def"
   }

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
 
   /// Emit macros into a debug macinfo section.
   void emitDebugMacinfo();
   /// Emit macros into a debug macinfo.dwo section.
   void emitDebugMacinfoDWO();
   void emitDebugMacinfoImpl(MCSection *Section);
   void emitMacro(DIMacro &M);
   void emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U);
-  void emitMacroFileImpl(DIMacroFile &F, DwarfCompileUnit &U,
-                         unsigned StartFile, unsigned EndFile,
-                         StringRef (*MacroFormToString)(unsigned Form));
+  void
+  emitMacroFileImpl(DIMacroFile &F, DwarfCompileUnit &U, unsigned StartFile,
+                    unsigned EndFile,
+                    std::function<StringRef(unsigned Form)> MacroFormToString);
   void handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U);
 
   /// DWARF 5 Experimental Split Dwarf Emitters
 
   /// Initialize common features of skeleton units.
   void initSkeletonUnit(const DwarfUnit &U, DIE &Die,
                         std::unique_ptr<DwarfCompileUnit> NewU);
 

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 void DwarfDebug::emitMacro(DIMacro &M) {
   StringRef Name = M.getName();
   StringRef Value = M.getValue();
 
   if (UseDebugMacroSection) {
     unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define
                         ? dwarf::DW_MACRO_define_strx
                         : dwarf::DW_MACRO_undef_strx;
-    Asm->OutStreamer->AddComment(dwarf::MacroString(Type));
+    Asm->OutStreamer->AddComment(dwarf::MacroString(Type, /*GNU=*/false));
     Asm->emitULEB128(Type);
     Asm->OutStreamer->AddComment("Line Number");
     Asm->emitULEB128(M.getLine());
     Asm->OutStreamer->AddComment("Macro String");
     if (!Value.empty())
       Asm->emitULEB128(this->InfoHolder.getStringPool()
                            .getIndexedEntry(*Asm, (Name + " " + Value).str())
                            .getIndex());
if (!Value.empty()) {
       Asm->OutStreamer->emitBytes(Value);
     }
     Asm->emitInt8('\0');
   }
 }
 
 void DwarfDebug::emitMacroFileImpl(
     DIMacroFile &F, DwarfCompileUnit &U, unsigned StartFile, unsigned EndFile,
-    StringRef (*MacroFormToString)(unsigned Form)) {
+    std::function<StringRef(unsigned Form)> MacroFormToString) {
 
   Asm->OutStreamer->AddComment(MacroFormToString(StartFile));
   Asm->emitULEB128(StartFile);
   Asm->OutStreamer->AddComment("Line Number");
   Asm->emitULEB128(F.getLine());
   Asm->OutStreamer->AddComment("File Number");
   Asm->emitULEB128(U.getOrCreateSourceID(F.getFile()));
   handleMacroNodes(F.getElements(), U);
   Asm->OutStreamer->AddComment(MacroFormToString(EndFile));
   Asm->emitULEB128(EndFile);
 }
 
 void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
   // DWARFv5 macro and DWARFv4 macinfo share some common encodings,
   // so for readibility/uniformity, We are explicitly emitting those.
   assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
-  if (UseDebugMacroSection)
+  if (UseDebugMacroSection) {
+    auto FormToString = [](unsigned Form) {
+      return dwarf::MacroString(Form, /*GNU=*/false);
+    };
     emitMacroFileImpl(F, U, dwarf::DW_MACRO_start_file,
-                      dwarf::DW_MACRO_end_file, dwarf::MacroString);
-  else
+                      dwarf::DW_MACRO_end_file, FormToString);
+  } else
     emitMacroFileImpl(F, U, dwarf::DW_MACINFO_start_file,
                       dwarf::DW_MACINFO_end_file, dwarf::MacinfoString);
 }
 
 void DwarfDebug::emitDebugMacinfoImpl(MCSection *Section) {
   for (const auto &P : CUMap) {
     auto &TheCU = *P.second;
     auto *SkCU = TheCU.getSkeleton();

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()
+            << MacroString(E.Type, /*GNU=*/Macros.Header.Version < 5);
       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"