Add macro support to llvm-dwarfdump tool

[aaboud]

Summary

Added "macro" option to "-debug-dump" flag, which trigger parsing & dumping of the ".debug_macinfo" section.

Note: Once DWARF 5.0 is published this same option can be used to parse & dump ".debug_macro" section as well.

[samsonov]

include/llvm/DebugInfo/DWARF/DWARFContext.h

167

Remove DWARFContext::

include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

11

Please fix the header guard (LLVM_DEBUGINFO_DWARF_DWARFDEBUGMACRO_H)

31

Looks like all entries contain either a string, or an integer (file number). Maybe, we can use a union of them?

34

Why will uint16_t be enough?

lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

59

You can just call data.getU8() and then switch on that, breaking from the loop if parsed value was 0.

68

This wouldn't work: if the .debug_macinfo section is malformed, and record type is invalid (or it will be some value from new DWARF standard), this code will have undefined behavior. Generally this is the reason we don't use enums from Dwarf.h to hold types in parser library - we can't be sure that the values we parse will correspond to defined enum values.

72

see below - probably you just need to return that parsing was unsuccessful. Probably (if you're abandoning parsing), you should clear all entries parsed so far.

89

This is wrong: DW_MACINFO_vendor_ext is well described: it's a constant followed by a string - you should consume it, and ignore it.

93

You don't really need std::move here: let the compiler add it if necessary.

96

It's not nice when library prints some stuff to stderr(). You can either avoid diagnosing this error, or return some value from parse() indicating that parsing failed.

test/DebugInfo/debugmacinfo.test

28

Please fix (here and in another places)

[aaboud]

Hi Alexey,
Thanks for your comments.
I addressed most of them, however, there are couple of them that I am not sure how to resolve.

Please, see my answers below.

include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

11

I fixed this in this file.
However, all the headers files in this directory have the wrong guard name.

31

I tried to do that before, but it does not work when one of the fields is a class like StringRef.
This is the error I an getting:

'llvm::DWARFDebugMacro::Entry::MacroStr' : illegal union member; type 'llvm::StringRef' has a user-defined constructor or non-trivial default constructor.

Should I use char* and length instead of StringRef? Or just keep the code like this?

34

I really do not know.
I just copied that from "DWARFDebugLine.h", it is using uint16_t for File ID.

An unsigned integer indicating the identity of the source file

// corresponding to a machine instruction.
uint16_t File;

Should I use a bigger integer type?

lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

59

I am not sure about that.
If I call data.getU8(), it will read and remove the first byte.
If that byte is not '\0', I cannot use it to calculate the Type, as the Type is a ULEB128.

Am I missing something?

68

Once again, I was following other section implementation: "DWARFDebugLocDWO::parse()", it is casting to a dwarf enumeration.

Anyway, I just replaces the dwarf macro type with uint32_t.

72

Yes, I missed the "return;" statement here.
But I do not think we need to clean the parsed entries, let the user get an indication on at what point the object file get corrupted.

Notice that "DWARFDebugFrame.cpp" is using llvm_unreachable for corrupted code!

93

I will fix that in this file.
However, I copied it from "DWARFDebugLoc.cpp", maybe it should be fixed there as well.

96

Totally agree.

I will skip this error check for this patch.
Because, as this llvm-dwarfdump tool /LLVMDebugInfoDwarf library does not support error result communication, I do not think that we should do it in this patch.

I see that there is a place to fix this code (the one added in this patch and the existing code for other sections), however, I believe it is out of the scope of this patch.

Do you think otherwise?

[aaboud]

Applied Alexey comments.

Please, let me know if there is anything else I should change.

[samsonov]

include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

12

Right, thanks. The header guards in another files were probably not fixed properly when the files were moved.

32

Let's use const char * here instead.

35

It's unlikely that there will be more than 65536 files, but let's not introduce this restriction here: if we use union we can as well use uint64_t to keep the same size of Entry.

lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

32

Will it work correctly with nullptr string if E.Type is unknown? We might just output DW_MACINFO_unknown (0x...) instead of dying here.

60

Ah, sorry for confusion. ULEB128 encoding of zero is a single zero byte, so you can call

E.Type = data.getULEB128(&Offset);

and break the look if it's zero.

69

Thanks! I agree, that this practice is not followed everywhere in DWARF parser at the moment, and hopefully we will fix it one day. It would be nice to have at least the new code follow this.

73

I'd vote for eventually removing all llvm_unreachable from parsers... I agree that proper error reporting is out of the scope of this patch, but let's at least not print to stderr. You can just skip parsing the rest of the section, or clear all the entries parsed so far - I'm fine with either of this, as long as you document this in a method declaration in header.

90

Hm, if .debug_macinfo in my file contained DW_MACINFO_vendor_ext, I would expect to see it in llvm-dwarfdump output.

97

See above.

[aaboud]

Applied more changes according to Alexey comments.
The change Includes introducing a new DWARF Enumerator "DW_MACINFO_invalid".

Please, let me know if there is anything else I should change.

[samsonov]

Looks mostly good. A few remaining comments below.

lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

24

Do this only if IndLevel is positive

36

you don't use dwarf:: namespace specified in another places, remove from here?

78

Why do you cast it to unsigned? Line is uint64_t.

84

see above

86

see above - why uint16_t?

[aaboud]

Thanks Alexey for catching these leftovers that I forgot to modify to fit the recent changes.

I hope that this patch is good for commit.
Do I have an approval to commit?

Thanks,
Amjad

[samsonov]

LGTM, thanks!

include/llvm/DebugInfo/DIContext.h

enum DIDumpType {
   DIDT_Info,
   DIDT_InfoDwo,
   DIDT_Types,
   DIDT_TypesDwo,
   DIDT_Line,
   DIDT_LineDwo,
   DIDT_Loc,
   DIDT_LocDwo,
+  DIDT_Macro,
   DIDT_Ranges,
   DIDT_Pubnames,
   DIDT_Pubtypes,
   DIDT_GnuPubnames,
   DIDT_GnuPubtypes,
   DIDT_Str,
   DIDT_StrDwo,
   DIDT_StrOffsetsDwo,

include/llvm/DebugInfo/DWARF/DWARFContext.h

 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
 #include <vector>
 
 namespace llvm {
 
 // In place of applying the relocations to the data we've read from disk we use
class DWARFContext : public DIContext {
 
   DWARFUnitSection<DWARFCompileUnit> CUs;
   std::vector<DWARFUnitSection<DWARFTypeUnit>> TUs;
   std::unique_ptr<DWARFDebugAbbrev> Abbrev;
   std::unique_ptr<DWARFDebugLoc> Loc;
   std::unique_ptr<DWARFDebugAranges> Aranges;
   std::unique_ptr<DWARFDebugLine> Line;
   std::unique_ptr<DWARFDebugFrame> DebugFrame;
+  std::unique_ptr<DWARFDebugMacro> Macro;
 
   DWARFUnitSection<DWARFCompileUnit> DWOCUs;
   std::vector<DWARFUnitSection<DWARFTypeUnit>> DWOTUs;
   std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
   std::unique_ptr<DWARFDebugLocDWO> LocDWO;
 
   DWARFContext(DWARFContext &) = delete;
   DWARFContext &operator=(DWARFContext &) = delete;
public:
   const DWARFDebugLocDWO *getDebugLocDWO();
 
   /// Get a pointer to the parsed DebugAranges object.
   const DWARFDebugAranges *getDebugAranges();
 
   /// Get a pointer to the parsed frame information object.
   const DWARFDebugFrame *getDebugFrame();
 
+  /// Get a pointer to the parsed DebugMacro object.
+  const DWARFDebugMacro *getDebugMacro();
+
   /// Get a pointer to a parsed line table corresponding to a compile unit.
   const DWARFDebugLine::LineTable *getLineTableForUnit(DWARFUnit *cu);
 
   DILineInfo getLineInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
   DILineInfoTable getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
   DIInliningInfo getInliningInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
 
   virtual bool isLittleEndian() const = 0;
   virtual uint8_t getAddressSize() const = 0;
   virtual const DWARFSection &getInfoSection() = 0;
   typedef MapVector<object::SectionRef, DWARFSection,
                     std::map<object::SectionRef, unsigned>> TypeSectionMap;
   virtual const TypeSectionMap &getTypesSections() = 0;
   virtual StringRef getAbbrevSection() = 0;
   virtual const DWARFSection &getLocSection() = 0;
   virtual StringRef getARangeSection() = 0;
   virtual StringRef getDebugFrameSection() = 0;
   virtual const DWARFSection &getLineSection() = 0;
   virtual StringRef getStringSection() = 0;
   virtual StringRef getRangeSection() = 0;
+  virtual StringRef getMacinfoSection() = 0;
   virtual StringRef getPubNamesSection() = 0;
   virtual StringRef getPubTypesSection() = 0;
   virtual StringRef getGnuPubNamesSection() = 0;
   virtual StringRef getGnuPubTypesSection() = 0;
 
   // Sections for DWARF5 split dwarf proposal.
   virtual const DWARFSection &getInfoDWOSection() = 0;
   virtual const TypeSectionMap &getTypesDWOSections() = 0;
class DWARFContextInMemory : public DWARFContext {
   TypeSectionMap TypesSections;
   StringRef AbbrevSection;
   DWARFSection LocSection;
   StringRef ARangeSection;
   StringRef DebugFrameSection;
   DWARFSection LineSection;
   StringRef StringSection;
   StringRef RangeSection;
+  StringRef MacinfoSection;
   StringRef PubNamesSection;
   StringRef PubTypesSection;
   StringRef GnuPubNamesSection;
   StringRef GnuPubTypesSection;
 
   // Sections for DWARF5 split dwarf proposal.
   DWARFSection InfoDWOSection;
   TypeSectionMap TypesDWOSections;
public:
   const TypeSectionMap &getTypesSections() override { return TypesSections; }
   StringRef getAbbrevSection() override { return AbbrevSection; }
   const DWARFSection &getLocSection() override { return LocSection; }
   StringRef getARangeSection() override { return ARangeSection; }
   StringRef getDebugFrameSection() override { return DebugFrameSection; }
   const DWARFSection &getLineSection() override { return LineSection; }
   StringRef getStringSection() override { return StringSection; }
   StringRef getRangeSection() override { return RangeSection; }
+  StringRef getMacinfoSection() override { return MacinfoSection; }
   StringRef getPubNamesSection() override { return PubNamesSection; }
   StringRef getPubTypesSection() override { return PubTypesSection; }
   StringRef getGnuPubNamesSection() override { return GnuPubNamesSection; }
   StringRef getGnuPubTypesSection() override { return GnuPubTypesSection; }
   const DWARFSection& getAppleNamesSection() override { return AppleNamesSection; }
   const DWARFSection& getAppleTypesSection() override { return AppleTypesSection; }
   const DWARFSection& getAppleNamespacesSection() override { return AppleNamespacesSection; }
   const DWARFSection& getAppleObjCSection() override { return AppleObjCSection; }

include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

+//===-- DWARFDebugMacro.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_DEBUGINFO_DWARF_DWARFDEBUGMACRO_H
+#define LLVM_DEBUGINFO_DWARF_DWARFDEBUGMACRO_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/Dwarf.h"
+
+namespace llvm {
+
+class raw_ostream;
+
+class DWARFDebugMacro {
+  /// 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.
+      uint64_t Line;
+      /// Vendor extension constant value.
+      uint64_t ExtConstant;
+    };
+
+    union {
+      /// The string (name, value) of the macro entry.
+      const char *MacroStr;
+      // An unsigned integer indicating the identity of the source file.
+      uint64_t File;
+      /// Vendor extension string.
+      const char *ExtStr;
+    };
+  };
+
+  typedef SmallVector<Entry, 4> MacroList;
+
+  /// A list of all the macro entries in the debug_macinfo section.
+  MacroList Macros;
+
+public:
+  DWARFDebugMacro() {}
+  /// Print the macro list found within the debug_macinfo section.
+  void dump(raw_ostream &OS) const;
+  /// Parse the debug_macinfo section accessible via the 'data' parameter.
+  void parse(DataExtractor data);
+};
+
+}
+
+#endif

include/llvm/Support/Dwarf.h

 
 // Do not mix the following two enumerations sets.  DW_TAG_invalid changes the
 // enumeration base type.
 
 enum LLVMConstants : uint32_t {
   // LLVM mock tags (see also llvm/Support/Dwarf.def).
   DW_TAG_invalid = ~0U,        // Tag for invalid results.
   DW_VIRTUALITY_invalid = ~0U, // Virtuality for invalid results.
+  DW_MACINFO_invalid = ~0U,    // Macinfo type for invalid results.
 
   // Other constants.
   DWARF_VERSION = 4,       // Default dwarf version we output.
   DW_PUBTYPES_VERSION = 2, // Section version number for .debug_pubtypes.
   DW_PUBNAMES_VERSION = 2, // Section version number for .debug_pubnames.
   DW_ARANGES_VERSION = 2   // Section version number for .debug_aranges.
 };
 

lib/DebugInfo/DWARF/CMakeLists.txt

 add_llvm_library(LLVMDebugInfoDWARF
   DWARFAbbreviationDeclaration.cpp
   DWARFAcceleratorTable.cpp
   DWARFCompileUnit.cpp
   DWARFContext.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugArangeSet.cpp
   DWARFDebugAranges.cpp
   DWARFDebugFrame.cpp
   DWARFDebugInfoEntry.cpp
   DWARFDebugLine.cpp
   DWARFDebugLoc.cpp
+  DWARFDebugMacro.cpp
   DWARFDebugRangeList.cpp
   DWARFFormValue.cpp
   DWARFTypeUnit.cpp
   DWARFUnit.cpp
   SyntaxHighlighting.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/DWARF
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo
   )

lib/DebugInfo/DWARF/DWARFContext.cpp

if (DumpType == DIDT_All || DumpType == DIDT_LocDwo) {
     getDebugLocDWO()->dump(OS);
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_Frames) {
     OS << "\n.debug_frame contents:\n";
     getDebugFrame()->dump(OS);
   }
 
+  if (DumpType == DIDT_All || DumpType == DIDT_Macro) {
+    OS << "\n.debug_macinfo contents:\n";
+    getDebugMacro()->dump(OS);
+  }
+
   uint32_t offset = 0;
   if (DumpType == DIDT_All || DumpType == DIDT_Aranges) {
     OS << "\n.debug_aranges contents:\n";
     DataExtractor arangesData(getARangeSection(), isLittleEndian(), 0);
     DWARFDebugArangeSet set;
     while (set.extract(arangesData, &offset))
       set.dump(OS);
   }
const DWARFDebugFrame *DWARFContext::getDebugFrame() {
   // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
   DataExtractor debugFrameData(getDebugFrameSection(), isLittleEndian(),
                                getAddressSize());
   DebugFrame.reset(new DWARFDebugFrame());
   DebugFrame->parse(debugFrameData);
   return DebugFrame.get();
 }
 
+const DWARFDebugMacro *DWARFContext::getDebugMacro() {
+  if (Macro)
+    return Macro.get();
+
+  DataExtractor MacinfoData(getMacinfoSection(), isLittleEndian(), 0);
+  Macro.reset(new DWARFDebugMacro());
+  Macro->parse(MacinfoData);
+  return Macro.get();
+}
+
 const DWARFLineTable *
 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
   if (!Line)
     Line.reset(new DWARFDebugLine(&getLineSection().Relocs));
   const auto *UnitDIE = U->getUnitDIE();
   if (UnitDIE == nullptr)
     return nullptr;
   unsigned stmtOffset =
StringRef *SectionData =
             .Case("debug_info", &InfoSection.Data)
             .Case("debug_abbrev", &AbbrevSection)
             .Case("debug_loc", &LocSection.Data)
             .Case("debug_line", &LineSection.Data)
             .Case("debug_aranges", &ARangeSection)
             .Case("debug_frame", &DebugFrameSection)
             .Case("debug_str", &StringSection)
             .Case("debug_ranges", &RangeSection)
+            .Case("debug_macinfo", &MacinfoSection)
             .Case("debug_pubnames", &PubNamesSection)
             .Case("debug_pubtypes", &PubTypesSection)
             .Case("debug_gnu_pubnames", &GnuPubNamesSection)
             .Case("debug_gnu_pubtypes", &GnuPubTypesSection)
             .Case("debug_info.dwo", &InfoDWOSection.Data)
             .Case("debug_abbrev.dwo", &AbbrevDWOSection)
             .Case("debug_loc.dwo", &LocDWOSection.Data)
             .Case("debug_line.dwo", &LineDWOSection.Data)

lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

+//===-- DWARFDebugMacro.cpp -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SyntaxHighlighting.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+using namespace dwarf;
+using namespace syntax;
+
+void DWARFDebugMacro::dump(raw_ostream &OS) const {
+  unsigned IndLevel = 0;
+  for (const Entry &E : Macros) {
+    IndLevel -= (E.Type == DW_MACINFO_end_file);
+    // Print indentation.
+    for (unsigned I = 0; I < IndLevel; I++)
+      OS << "  ";
+    IndLevel += (E.Type == DW_MACINFO_start_file);
+
+    WithColor(OS, syntax::Macro).get() << MacinfoString(E.Type);
+    switch (E.Type) {
+    default:
+      // Got a corrupted ".debug_macinfo" section (invalid macinfo type).
+      break;
+    case DW_MACINFO_define:
+    case dwarf::DW_MACINFO_undef:
+      OS << " - lineno: " << E.Line;
+      OS << " macro: " << E.MacroStr;
+      break;
+    case DW_MACINFO_start_file:
+      OS << " - lineno: " << E.Line;
+      OS << " filenum: " << E.File;
+      break;
+    case DW_MACINFO_end_file:
+      break;
+    case DW_MACINFO_vendor_ext:
+      OS << " - constant: " << E.ExtConstant;
+      OS << " string: " << E.ExtStr;
+      break;
+    }
+    OS << "\n";
+  }
+}
+
+void DWARFDebugMacro::parse(DataExtractor data) {
+  uint32_t Offset = 0;
+  while (data.isValidOffset(Offset)) {
+    // A macro list entry consists of:
+    Entry E;
+    // 1. Macinfo type
+    E.Type = data.getULEB128(&Offset);
+
+    if (E.Type == 0) {
+      // Reached end of ".debug_macinfo" section.
+      return;
+    }
+
+    switch (E.Type) {
+    default:
+      // Got a corrupted ".debug_macinfo" section (invalid macinfo type).
+      // Push the corrupted entry to the list and halt parsing.
+      E.Type = DW_MACINFO_invalid;
+      Macros.push_back(E);
+      return;
+    case DW_MACINFO_define:
+    case DW_MACINFO_undef:
+      // 2. Source line
+      E.Line = (unsigned)data.getULEB128(&Offset);
+      // 3. Macro string
+      E.MacroStr = data.getCStr(&Offset);
+      break;
+    case DW_MACINFO_start_file:
+      // 2. Source line
+      E.Line = (unsigned)data.getULEB128(&Offset);
+      // 3. Source file id
+      E.File = (uint16_t)data.getULEB128(&Offset);
+      break;
+    case DW_MACINFO_end_file:
+      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;
+    }
+
+    Macros.push_back(E);
+  }
+}
+

lib/DebugInfo/DWARF/SyntaxHighlighting.h

 
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace dwarf {
 namespace syntax {
 
 // Symbolic names for various syntax elements.
-enum HighlightColor { Address, String, Tag, Attribute, Enumerator };
+enum HighlightColor { Address, String, Tag, Attribute, Enumerator, Macro };
 
 /// An RAII object that temporarily switches an output stream to a
 /// specific color.
 class WithColor {
   llvm::raw_ostream &OS;
 
 public:
   /// To be used like this: WithColor(OS, syntax::String) << "text";

lib/DebugInfo/DWARF/SyntaxHighlighting.cpp

WithColor::WithColor(llvm::raw_ostream &OS, enum HighlightColor Type) : OS(OS) {
   // Detect color from terminal type unless the user passed the --color option.
   if (UseColor == cl::BOU_UNSET ? OS.has_colors() : UseColor == cl::BOU_TRUE) {
     switch (Type) {
     case Address:    OS.changeColor(llvm::raw_ostream::YELLOW);  break;
     case String:     OS.changeColor(llvm::raw_ostream::GREEN);   break;
     case Tag:        OS.changeColor(llvm::raw_ostream::BLUE);    break;
     case Attribute:  OS.changeColor(llvm::raw_ostream::CYAN);    break;
     case Enumerator: OS.changeColor(llvm::raw_ostream::MAGENTA); break;
+    case Macro:      OS.changeColor(llvm::raw_ostream::RED);     break;
     }
   }
 }
 
 WithColor::~WithColor() {
   if (UseColor == cl::BOU_UNSET ? OS.has_colors() : UseColor == cl::BOU_TRUE)
     OS.resetColor();
 }

lib/Support/Dwarf.cpp

 const char *llvm::dwarf::MacinfoString(unsigned Encoding) {
   switch (Encoding) {
   // Macinfo Type Encodings
   case DW_MACINFO_define:                return "DW_MACINFO_define";
   case DW_MACINFO_undef:                 return "DW_MACINFO_undef";
   case DW_MACINFO_start_file:            return "DW_MACINFO_start_file";
   case DW_MACINFO_end_file:              return "DW_MACINFO_end_file";
   case DW_MACINFO_vendor_ext:            return "DW_MACINFO_vendor_ext";
+  case DW_MACINFO_invalid:               return "DW_MACINFO_invalid";
   }
   return nullptr;
 }
 
 const char *llvm::dwarf::CallFrameString(unsigned Encoding) {
   switch (Encoding) {
   case DW_CFA_nop:                       return "DW_CFA_nop";
   case DW_CFA_advance_loc:               return "DW_CFA_advance_loc";

test/DebugInfo/Inputs/dwarfdump-macro-cmd.h

+#define M4 Value4

test/DebugInfo/Inputs/dwarfdump-macro.h

+
+
+
+#undef M1
+#define M1 NewValue1

test/DebugInfo/Inputs/dwarfdump-macro.cc

+#define M1 Value1
+#include "dwarfdump-macro.h"
+#define M2(x, y)   ((x)+(y)* Value2)
+
+// Built with GCC
+// $ mkdir -p /tmp/dbginfo
+// $ cp dwarfdump-macro.cc /tmp/dbginfo
+// $ cp dwarfdump-macro.h /tmp/dbginfo
+// $ cp dwarfdump-macro-cmd.h /tmp/dbginfo
+// $ cd /tmp/dbginfo
+// $ g++ -c -g3 -O0 -DM3=Value3 -include dwarfdump-macro-cmd.h dwarfdump-macro.cc -o <output>

test/DebugInfo/debugmacinfo.test

+RUN: llvm-dwarfdump -debug-dump=macro %p/Inputs/dwarfdump-macro.o \
+RUN:   | FileCheck %s -check-prefix TEST_MACINFO
+RUN: llvm-dwarfdump -debug-dump=line %p/Inputs/dwarfdump-macro.o \
+RUN:   | FileCheck %s -check-prefix TEST_LINE
+
+
+; This test verifies that llvm-dwarfdump tools know how to read .debug_macinfo
+; section. It also checks that the file numbers fits with those in the
+; .debug_line section.
+TEST_MACINFO: .debug_macinfo contents:
+TEST_MACINFO: DW_MACINFO_define - lineno: 0 macro: M3 Value3
+TEST_MACINFO: DW_MACINFO_start_file - lineno: 0 filenum: 1
+TEST_MACINFO:   DW_MACINFO_start_file - lineno: 0 filenum: 2
+TEST_MACINFO:     DW_MACINFO_define - lineno: 1 macro: M4 Value4
+TEST_MACINFO:   DW_MACINFO_end_file
+TEST_MACINFO:   DW_MACINFO_define - lineno: 1 macro: M1 Value1
+TEST_MACINFO:   DW_MACINFO_start_file - lineno: 2 filenum: 3
+TEST_MACINFO:     DW_MACINFO_undef - lineno: 4 macro: M1
+TEST_MACINFO:     DW_MACINFO_define - lineno: 5 macro: M1 NewValue1
+TEST_MACINFO:   DW_MACINFO_end_file
+TEST_MACINFO:   DW_MACINFO_define - lineno: 3 macro: M2(x,y) ((x)+(y)* Value2)
+TEST_MACINFO: DW_MACINFO_end_file
+
+TEST_LINE: .debug_line contents:
+TEST_LINE: file_names[  1]    0 0x00000000 0x00000000 dwarfdump-macro.cc
+TEST_LINE: file_names[  2]    1 0x00000000 0x00000000 dwarfdump-macro-cmd.h
+TEST_LINE: file_names[  3]    0 0x00000000 0x00000000 dwarfdump-macro.h

tools/llvm-dwarfdump/llvm-dwarfdump.cpp

cl::values(
         clEnumValN(DIDT_InfoDwo, "info.dwo", ".debug_info.dwo"),
         clEnumValN(DIDT_Types, "types", ".debug_types"),
         clEnumValN(DIDT_TypesDwo, "types.dwo", ".debug_types.dwo"),
         clEnumValN(DIDT_Line, "line", ".debug_line"),
         clEnumValN(DIDT_LineDwo, "line.dwo", ".debug_line.dwo"),
         clEnumValN(DIDT_Loc, "loc", ".debug_loc"),
         clEnumValN(DIDT_LocDwo, "loc.dwo", ".debug_loc.dwo"),
         clEnumValN(DIDT_Frames, "frames", ".debug_frame"),
+        clEnumValN(DIDT_Macro, "macro", ".debug_macinfo"),
         clEnumValN(DIDT_Ranges, "ranges", ".debug_ranges"),
         clEnumValN(DIDT_Pubnames, "pubnames", ".debug_pubnames"),
         clEnumValN(DIDT_Pubtypes, "pubtypes", ".debug_pubtypes"),
         clEnumValN(DIDT_GnuPubnames, "gnu_pubnames", ".debug_gnu_pubnames"),
         clEnumValN(DIDT_GnuPubtypes, "gnu_pubtypes", ".debug_gnu_pubtypes"),
         clEnumValN(DIDT_Str, "str", ".debug_str"),
         clEnumValN(DIDT_StrDwo, "str.dwo", ".debug_str.dwo"),
         clEnumValN(DIDT_StrOffsetsDwo, "str_offsets.dwo", ".debug_str_offsets.dwo"),