Macro Support in Dwarf emission

[aaboud]

Summary

Added support for macro emission in dwarf (supporting DWARF version 4).

[aprantl]

test/DebugInfo/X86/debug-macro.ll

3 ↗

(On Diff #42719)

%llc_dwarf may be preferable over llc.

[aaboud]

Now fixed the LIT tests correctly.

[aaboud]

Do I have commit approval for this change list?

Thanks,
Amjad

[aprantl]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1874 ↗

(On Diff #42831)

If this violates the spec, this should be check in the debug info verifier instead of an assertion here.

1878 ↗

(On Diff #42831)

Is EOS supposed to be "end of string"? Maybe NUL or null-terminator is more common.

1891 ↗

(On Diff #42831)

Same here.

1912 ↗

(On Diff #42831)

maybe add an assertion/unreachable for unhandled cases?

1919 ↗

(On Diff #42831)

Both here and in emitMacro I'm feeling a little uneasy about all the replicated logic between .*emit and .*getSize. It's just waiting to get out of sync :-)
Is there any sensible way to fuse the emission and the size computation (either by templatizing or passing in a lambda)?

1954 ↗

(On Diff #42831)

else assert maybe?

lib/CodeGen/AsmPrinter/DwarfDebug.h

435 ↗

(On Diff #42831)

Ideally, these should be a separate NFC commit. Thanks for noticing!

[aaboud]

Applied changes according to Adrian comments.

• Moved assertion to Debug Info Verifier.
• Encapsulate Macro Node handling into a helper member function to share common code.

[aaboud]

Thanks Adrian for the comments.
I tried to answer most of them and uploaded a new version with the changes.
Please see my response below.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1919 ↗

(On Diff #43591)

I could not find an elegant and less messy way to do share code between these functions.
Also, in DIE.cpp you can see that there is a similar implementation for "EmitValue()" and "SizeOf()" where common code is not shared!

I tried at least to encapsulate the handling of the macro node array, as it is being repeated three times in the code.

Please, let me know if you have a better idea on how to share the common code above.

[aprantl]

Thanks for the changes!

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1919 ↗

(On Diff #43591)

I'll leave this up to you, but what I'm thinking is that we could define a wrapper class for the emission functions:

class AbstractAsmStreamer {
  /// Returns the byte size of the ULEB value.
  unsigned emitULEB128(unsigned Val);
  unsigned emitInt8(unsigned char Val);
  unsigned emitBytes(StringRef Data);
  ...
};

/// Streams objects using an MCAsmStreamer.
class AsmStreamEmitter : public AbstractAsmStreamer {
  AsmStreamEmitter(MCAsmStreamer ...);
};

/// Only reports the size of the streamed objects. Is there a better name?
class SizeReporter : public AbstractAsmStreamer {
  SizeReporter(MCAsmStreamer ...);
};

and have the emit* methods always return the size:

unsigned DwarfDebug::emitMacroFile(AbstractAsmStreamer &Streamer,
                                                             DIMacroFile &F, DwarfCompileUnit &U) {
  assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
  unsigned Size = 0;
  Size += Streamer.EmitULEB128(dwarf::DW_MACINFO_start_file);
  Size += Streamer.EmitULEB128(F.getLine());
  DIFile *File = F.getFile();
  unsigned FID =
      U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
  Size += Streamer.EmitULEB128(FID);

  Size += handleMacroNodes(F.getElements(), U);

  Size += Streamer.EmitULEB128(dwarf::DW_MACINFO_end_file);
  return Size;
}

Maybe it's possible to make this interface general enough that it also can be used in DIE.cpp. If we're worried about the performance of the virtual function call we could templatize on Streamer, but it probably doesn't matter.

[aaboud]

Applied Adrian comments/suggestion.
Introduced AbstractAsmStreamer class to share implementation between "Emitter" and "SizeOf" functions.

[aprantl]

Thanks!
LGTM with the above changes addressed.

include/llvm/CodeGen/DIE.h

43 ↗

(On Diff #44037)

Please move this comment into a doxygen comment for AbstractAsmStreamer that explains the purpose of the interface.

48 ↗

(On Diff #44037)

Please add a note that this (currently) doesn't actually report back the size.

52 ↗

(On Diff #44037)

Probably better to use override and drop the virtual here.

59 ↗

(On Diff #44037)

Are the names

class AsmStreamerBase;
class EmittingAsmStreamer;
class SizeReportingAsmStreamer;

any better?

lib/CodeGen/AsmPrinter/DIE.cpp

38 ↗

(On Diff #44037)

Feel free to put the one-liners into the header file, just leave the virtual destructor as an anchor.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

576 ↗

(On Diff #44037)

Couldn't this just be a stack-allocated object?

1912 ↗

(On Diff #44037)

Same here. Why not just a stack-allocated object?

llvm/trunk/include/llvm/CodeGen/DIE.h

 
 namespace llvm {
 class AsmPrinter;
 class MCExpr;
 class MCSymbol;
 class raw_ostream;
 class DwarfTypeUnit;
 
+// AsmStreamerBase - A base abstract interface class defines methods that
+// can be implemented to stream objects or can be implemented to
+// calculate the size of the streamed objects.
+// The derived classes will use an AsmPrinter to implement the methods.
+//
+// TODO: complete this interface and use it to merge EmitValue and SizeOf
+//       methods in the DIE classes below.
+class AsmStreamerBase {
+protected:
+  const AsmPrinter *AP;
+  AsmStreamerBase(const AsmPrinter *AP) : AP(AP) {}
+
+public:
+  virtual ~AsmStreamerBase() {}
+  virtual unsigned emitULEB128(uint64_t Value, const char *Desc = nullptr,
+                               unsigned PadTo = 0) = 0;
+  virtual unsigned emitInt8(unsigned char Value) = 0;
+  virtual unsigned emitBytes(StringRef Data) = 0;
+};
+
+/// EmittingAsmStreamer - Implements AbstractAsmStreamer to stream objects.
+/// Notice that the return value is not the actual size of the streamed object.
+/// For size calculation use SizeReporterAsmStreamer.
+class EmittingAsmStreamer : public AsmStreamerBase {
+public:
+  EmittingAsmStreamer(const AsmPrinter *AP) : AsmStreamerBase(AP) {}
+  unsigned emitULEB128(uint64_t Value, const char *Desc = nullptr,
+                       unsigned PadTo = 0) override;
+  unsigned emitInt8(unsigned char Value) override;
+  unsigned emitBytes(StringRef Data) override;
+};
+
+/// SizeReporterAsmStreamer - Only reports the size of the streamed objects.
+class SizeReporterAsmStreamer : public AsmStreamerBase {
+public:
+  SizeReporterAsmStreamer(const AsmPrinter *AP) : AsmStreamerBase(AP) {}
+  unsigned emitULEB128(uint64_t Value, const char *Desc = nullptr,
+                       unsigned PadTo = 0) override;
+  unsigned emitInt8(unsigned char Value) override;
+  unsigned emitBytes(StringRef Data) override;
+};
+
 //===--------------------------------------------------------------------===//
 /// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a
 /// Dwarf abbreviation.
 class DIEAbbrevData {
   /// Attribute - Dwarf attribute code.
   ///
   dwarf::Attribute Attribute;
 

llvm/trunk/include/llvm/MC/MCObjectFileInfo.h

protected:
   MCSection *DwarfLineSection;
   MCSection *DwarfFrameSection;
   MCSection *DwarfPubTypesSection;
   const MCSection *DwarfDebugInlineSection;
   MCSection *DwarfStrSection;
   MCSection *DwarfLocSection;
   MCSection *DwarfARangesSection;
   MCSection *DwarfRangesSection;
+  MCSection *DwarfMacinfoSection;
   // The pubnames section is no longer generated by default.  The generation
   // can be enabled by a compiler flag.
   MCSection *DwarfPubNamesSection;
 
   /// DWARF5 Experimental Debug Info Sections
   /// DwarfAccelNamesSection, DwarfAccelObjCSection,
   /// DwarfAccelNamespaceSection, DwarfAccelTypesSection -
   /// If we use the DWARF accelerated hash tables then we want to emit these
public:
   }
   const MCSection *getDwarfDebugInlineSection() const {
     return DwarfDebugInlineSection;
   }
   MCSection *getDwarfStrSection() const { return DwarfStrSection; }
   MCSection *getDwarfLocSection() const { return DwarfLocSection; }
   MCSection *getDwarfARangesSection() const { return DwarfARangesSection; }
   MCSection *getDwarfRangesSection() const { return DwarfRangesSection; }
+  MCSection *getDwarfMacinfoSection() const { return DwarfMacinfoSection; }
 
   // DWARF5 Experimental Debug Info Sections
   MCSection *getDwarfAccelNamesSection() const {
     return DwarfAccelNamesSection;
   }
   MCSection *getDwarfAccelObjCSection() const { return DwarfAccelObjCSection; }
   MCSection *getDwarfAccelNamespaceSection() const {
     return DwarfAccelNamespaceSection;

llvm/trunk/lib/CodeGen/AsmPrinter/DIE.cpp

 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
+// EmittingAsmStreamer Implementation
+//===----------------------------------------------------------------------===//
+unsigned EmittingAsmStreamer::emitULEB128(uint64_t Value, const char *Desc,
+                                          unsigned PadTo) {
+  AP->EmitULEB128(Value, Desc, PadTo);
+  return 0;
+}
+
+unsigned EmittingAsmStreamer::emitInt8(unsigned char Value) {
+  AP->EmitInt8(Value);
+  return 0;
+}
+
+unsigned EmittingAsmStreamer::emitBytes(StringRef Data) {
+  AP->OutStreamer->EmitBytes(Data);
+  return 0;
+}
+
+//===----------------------------------------------------------------------===//
+// SizeReporterAsmStreamer Implementation
+//===----------------------------------------------------------------------===//
+unsigned SizeReporterAsmStreamer::emitULEB128(uint64_t Value, const char *Desc,
+                                              unsigned PadTo) {
+  return getULEB128Size(Value);
+}
+
+unsigned SizeReporterAsmStreamer::emitInt8(unsigned char Value) { return 1; }
+
+unsigned SizeReporterAsmStreamer::emitBytes(StringRef Data) {
+  return Data.size();
+}
+
+//===----------------------------------------------------------------------===//
 // DIEAbbrevData Implementation
 //===----------------------------------------------------------------------===//
 
 /// Profile - Used to gather unique data for the abbreviation folding set.
 ///
 void DIEAbbrevData::Profile(FoldingSetNodeID &ID) const {
   // Explicitly cast to an integer type for which FoldingSetNodeID has
   // overloads.  Otherwise MSVC 2010 thinks this call is ambiguous.

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public AsmPrinterHandler {
 
   void emitDebugPubSection(
       bool GnuStyle, MCSection *PSec, StringRef Name,
       const StringMap<const DIE *> &(DwarfCompileUnit::*Accessor)() const);
 
   /// Emit visible names into a debug str section.
   void emitDebugStr();
 
-  /// Emit visible names into a debug loc section.
+  /// Emit variable locations into a debug loc section.
   void emitDebugLoc();
 
-  /// Emit visible names into a debug loc dwo section.
+  /// Emit variable locations into a debug loc dwo section.
   void emitDebugLocDWO();
 
-  /// Emit visible names into a debug aranges section.
+  /// Emit address ranges into a debug aranges section.
   void emitDebugARanges();
 
-  /// Emit visible names into a debug ranges section.
+  /// Emit address ranges into a debug ranges section.
   void emitDebugRanges();
 
+  /// Emit macros into a debug macinfo section.
+  void emitDebugMacinfo();
+  unsigned emitMacro(AsmStreamerBase *AS, DIMacro &M);
+  unsigned emitMacroFile(AsmStreamerBase *AS, DIMacroFile &F,
+                         DwarfCompileUnit &U);
+  unsigned handleMacroNodes(AsmStreamerBase *AS, 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<DwarfUnit> NewU);
 
   /// Construct the split debug info compile unit for the debug info
   /// section.

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::finalizeModuleInfo() {
 
   finishSubprogramDefinitions();
 
   finishVariableDefinitions();
 
   // Collect info for variables that were optimized out.
   collectDeadVariables();
 
+  unsigned MacroOffset = 0;
+  std::unique_ptr<AsmStreamerBase> AS(new SizeReporterAsmStreamer(Asm));
   // Handle anything that needs to be done on a per-unit basis after
   // all other generation.
   for (const auto &P : CUMap) {
     auto &TheCU = *P.second;
     // Emit DW_AT_containing_type attribute to connect types with their
     // vtable holding type.
     TheCU.constructContainingTypeDIEs();
 
if (unsigned NumRanges = TheCU.getRanges().size()) {
         // DW_AT_ranges to specify the default base address for use in
         // location lists (see Section 2.6.2) and range lists (see Section
         // 2.17.3).
         U.addUInt(U.getUnitDie(), dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
       else
         U.setBaseAddress(TheCU.getRanges().front().getStart());
       U.attachRangesOrLowHighPC(U.getUnitDie(), TheCU.takeRanges());
     }
+
+    auto *CUNode = cast<DICompileUnit>(P.first);
+    if (CUNode->getMacros()) {
+      // Compile Unit has macros, emit "DW_AT_macro_info" attribute.
+      U.addUInt(U.getUnitDie(), dwarf::DW_AT_macro_info,
+                dwarf::DW_FORM_sec_offset, MacroOffset);
+      // Update macro section offset
+      MacroOffset += handleMacroNodes(AS.get(), CUNode->getMacros(), U);
+    }
   }
 
   // Compute DIE offsets and sizes.
   InfoHolder.computeSizeAndOffsets();
   if (useSplitDwarf())
     SkeletonHolder.computeSizeAndOffsets();
 }
 
void DwarfDebug::endModule() {
 
   // Emit info into a debug aranges section.
   if (GenerateARangeSection)
     emitDebugARanges();
 
   // Emit info into a debug ranges section.
   emitDebugRanges();
 
+  // Emit info into a debug macinfo section.
+  emitDebugMacinfo();
+
   if (useSplitDwarf()) {
     emitDebugStrDWO();
     emitDebugInfoDWO();
     emitDebugAbbrevDWO();
     emitDebugLineDWO();
     // Emit DWO addresses.
     AddrPool.emit(*Asm, Asm->getObjFileLowering().getDwarfAddrSection());
   }
for (const RangeSpanList &List : TheCU->getRangeLists()) {
 
       // And terminate the list with two 0 values.
       Asm->OutStreamer->EmitIntValue(0, Size);
       Asm->OutStreamer->EmitIntValue(0, Size);
     }
   }
 }
 
+unsigned DwarfDebug::handleMacroNodes(AsmStreamerBase *AS,
+                                      DIMacroNodeArray Nodes,
+                                      DwarfCompileUnit &U) {
+  unsigned Size = 0;
+  for (auto *MN : Nodes) {
+    if (auto *M = dyn_cast<DIMacro>(MN))
+      Size += emitMacro(AS, *M);
+    else if (auto *F = dyn_cast<DIMacroFile>(MN))
+      Size += emitMacroFile(AS, *F, U);
+    else
+      llvm_unreachable("Unexpected DI type!");
+  }
+  return Size;
+}
+
+unsigned DwarfDebug::emitMacro(AsmStreamerBase *AS, DIMacro &M) {
+  int Size = 0;
+  Size += AS->emitULEB128(M.getMacinfoType());
+  Size += AS->emitULEB128(M.getLine());
+  StringRef Name = M.getName();
+  StringRef Value = M.getValue();
+  Size += AS->emitBytes(Name);
+  if (!Value.empty()) {
+    // There should be one space between macro name and macro value.
+    Size += AS->emitInt8(' ');
+    Size += AS->emitBytes(Value);
+  }
+  Size += AS->emitInt8('\0');
+  return Size;
+}
+
+unsigned DwarfDebug::emitMacroFile(AsmStreamerBase *AS, DIMacroFile &F,
+                                   DwarfCompileUnit &U) {
+  int Size = 0;
+  assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
+  Size += AS->emitULEB128(dwarf::DW_MACINFO_start_file);
+  Size += AS->emitULEB128(F.getLine());
+  DIFile *File = F.getFile();
+  unsigned FID =
+      U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
+  Size += AS->emitULEB128(FID);
+  Size += handleMacroNodes(AS, F.getElements(), U);
+  Size += AS->emitULEB128(dwarf::DW_MACINFO_end_file);
+  return Size;
+}
+
+// Emit visible names into a debug macinfo section.
+void DwarfDebug::emitDebugMacinfo() {
+  if (MCSection *Macinfo = Asm->getObjFileLowering().getDwarfMacinfoSection()) {
+    // Start the dwarf macinfo section.
+    Asm->OutStreamer->SwitchSection(Macinfo);
+  }
+  std::unique_ptr<AsmStreamerBase> AS(new EmittingAsmStreamer(Asm));
+  for (const auto &P : CUMap) {
+    auto &TheCU = *P.second;
+    auto *SkCU = TheCU.getSkeleton();
+    DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
+    auto *CUNode = cast<DICompileUnit>(P.first);
+    handleMacroNodes(AS.get(), CUNode->getMacros(), U);
+  }
+  Asm->OutStreamer->AddComment("End Of Macro List Mark");
+  Asm->EmitInt8(0);
+}
+
 // DWARF5 Experimental Separate Dwarf emitters.
 
 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
                                   std::unique_ptr<DwarfUnit> NewU) {
   NewU->addString(Die, dwarf::DW_AT_GNU_dwo_name,
                   U.getCUNode()->getSplitDebugFilename());
 
   if (!CompilationDir.empty())

llvm/trunk/lib/IR/Verifier.cpp

if (auto *S = N.getRawScope())
     Assert(isa<DIScope>(S), "invalid scope ref", &N, S);
 }
 
 void Verifier::visitDIMacro(const DIMacro &N) {
   Assert(N.getMacinfoType() == dwarf::DW_MACINFO_define ||
          N.getMacinfoType() == dwarf::DW_MACINFO_undef,
          "invalid macinfo type", &N);
   Assert(!N.getName().empty(), "anonymous macro", &N);
+  if (!N.getValue().empty()) {
+    assert(N.getValue().data()[0] != ' ' && "Macro value has a space prefix");
+  }
 }
 
 void Verifier::visitDIMacroFile(const DIMacroFile &N) {
   Assert(N.getMacinfoType() == dwarf::DW_MACINFO_start_file,
          "invalid macinfo type", &N);
   if (auto *F = N.getRawFile())
     Assert(isa<DIFile>(F), "invalid file", &N, F);
 

llvm/trunk/lib/MC/MCObjectFileInfo.cpp

DwarfLocSection =
       Ctx->getMachOSection("__DWARF", "__debug_loc", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "section_debug_loc");
   DwarfARangesSection =
       Ctx->getMachOSection("__DWARF", "__debug_aranges", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfRangesSection =
       Ctx->getMachOSection("__DWARF", "__debug_ranges", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "debug_range");
+  DwarfMacinfoSection =
+      Ctx->getMachOSection("__DWARF", "__debug_macinfo", MachO::S_ATTR_DEBUG,
+                           SectionKind::getMetadata());
   DwarfDebugInlineSection =
       Ctx->getMachOSection("__DWARF", "__debug_inlined", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfCUIndexSection =
       Ctx->getMachOSection("__DWARF", "__debug_cu_index", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata());
   DwarfTUIndexSection =
       Ctx->getMachOSection("__DWARF", "__debug_tu_index", MachO::S_ATTR_DEBUG,
void MCObjectFileInfo::initELFMCObjectFileInfo(Triple T) {
   DwarfStrSection =
       Ctx->getELFSection(".debug_str", ELF::SHT_PROGBITS,
                          ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
   DwarfLocSection = Ctx->getELFSection(".debug_loc", ELF::SHT_PROGBITS, 0);
   DwarfARangesSection =
       Ctx->getELFSection(".debug_aranges", ELF::SHT_PROGBITS, 0);
   DwarfRangesSection =
       Ctx->getELFSection(".debug_ranges", ELF::SHT_PROGBITS, 0, "debug_range");
+  DwarfMacinfoSection =
+      Ctx->getELFSection(".debug_macinfo", ELF::SHT_PROGBITS, 0);
 
   // DWARF5 Experimental Debug Info
 
   // Accelerator Tables
   DwarfAccelNamesSection =
       Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0, "names_begin");
   DwarfAccelObjCSection =
       Ctx->getELFSection(".apple_objc", ELF::SHT_PROGBITS, 0, "objc_begin");
DwarfARangesSection = Ctx->getCOFFSection(
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata());
   DwarfRangesSection = Ctx->getCOFFSection(
       ".debug_ranges",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "debug_range");
+  DwarfMacinfoSection = Ctx->getCOFFSection(
+      ".debug_macinfo",
+      COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+          COFF::IMAGE_SCN_MEM_READ,
+      SectionKind::getMetadata());
   DwarfInfoDWOSection = Ctx->getCOFFSection(
       ".debug_info.dwo",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "section_info_dwo");
   DwarfTypesDWOSection = Ctx->getCOFFSection(
       ".debug_types.dwo",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |

llvm/trunk/lib/Target/NVPTX/NVPTXISelLowering.cpp

NVPTXTargetObjectFile::~NVPTXTargetObjectFile() {
   delete static_cast<NVPTXSection *>(DwarfLineSection);
   delete static_cast<NVPTXSection *>(DwarfFrameSection);
   delete static_cast<NVPTXSection *>(DwarfPubTypesSection);
   delete static_cast<const NVPTXSection *>(DwarfDebugInlineSection);
   delete static_cast<NVPTXSection *>(DwarfStrSection);
   delete static_cast<NVPTXSection *>(DwarfLocSection);
   delete static_cast<NVPTXSection *>(DwarfARangesSection);
   delete static_cast<NVPTXSection *>(DwarfRangesSection);
+  delete static_cast<NVPTXSection *>(DwarfMacinfoSection);
 }
 
 MCSection *
 NVPTXTargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
                                               SectionKind Kind, Mangler &Mang,
                                               const TargetMachine &TM) const {
   return getDataSection();
 }

llvm/trunk/lib/Target/NVPTX/NVPTXTargetObjectFile.h

NVPTXTargetObjectFile() {
     DwarfLineSection = nullptr;
     DwarfFrameSection = nullptr;
     DwarfPubTypesSection = nullptr;
     DwarfDebugInlineSection = nullptr;
     DwarfStrSection = nullptr;
     DwarfLocSection = nullptr;
     DwarfARangesSection = nullptr;
     DwarfRangesSection = nullptr;
+    DwarfMacinfoSection = nullptr;
   }
 
   virtual ~NVPTXTargetObjectFile();
 
   void Initialize(MCContext &ctx, const TargetMachine &TM) override {
     TargetLoweringObjectFile::Initialize(ctx, TM);
     TextSection = new NVPTXSection(MCSection::SV_ELF, SectionKind::getText());
     DataSection = new NVPTXSection(MCSection::SV_ELF, SectionKind::getData());
void Initialize(MCContext &ctx, const TargetMachine &TM) override {
     DwarfStrSection =
         new NVPTXSection(MCSection::SV_ELF, SectionKind::getMetadata());
     DwarfLocSection =
         new NVPTXSection(MCSection::SV_ELF, SectionKind::getMetadata());
     DwarfARangesSection =
         new NVPTXSection(MCSection::SV_ELF, SectionKind::getMetadata());
     DwarfRangesSection =
         new NVPTXSection(MCSection::SV_ELF, SectionKind::getMetadata());
+    DwarfMacinfoSection =
+        new NVPTXSection(MCSection::SV_ELF, SectionKind::getMetadata());
   }
 
   MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
                                    const Constant *C) const override {
     return ReadOnlySection;
   }
 
   MCSection *getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,

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

+; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-dump=info - | FileCheck --check-prefix=CHECK-INFO %s
+; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-dump=macro - | FileCheck --check-prefix=CHECK-MACRO %s
+; RUN: %llc_dwarf -O0 -filetype=obj < %s | llvm-dwarfdump -debug-dump=line - | FileCheck --check-prefix=CHECK-LINE %s
+
+
+; CHECK-INFO: .debug_info contents:
+; CHECK-INFO: DW_TAG_compile_unit
+; CHECK-INFO-NOT: DW_TAG
+; CHECK-INFO:   DW_AT_name {{.*}}"debug-macro.cpp")
+; CHECK-INFO:   DW_AT_macro_info {{.*}}(0x00000000)
+; CHECK-INFO: DW_TAG_compile_unit
+; CHECK-INFO-NOT: DW_TAG
+; CHECK-INFO:   DW_AT_name {{.*}}"debug-macro1.cpp")
+; CHECK-INFO:   DW_AT_macro_info {{.*}}(0x00000044)
+; CHECK-INFO: DW_TAG_compile_unit
+; CHECK-INFO-NOT: DW_TAG
+; CHECK-INFO:   DW_AT_name {{.*}}"debug-macro2.cpp")
+; CHECK-INFO-NOT: DW_AT_macro_info
+
+; CHECK-MACRO:     .debug_macinfo contents:
+; CHECK-MACRO-NEXT: DW_MACINFO_define - lineno: 0 macro: NameCMD ValueCMD
+; CHECK-MACRO-NEXT: DW_MACINFO_start_file - lineno: 0 filenum: 1
+; CHECK-MACRO-NEXT:   DW_MACINFO_start_file - lineno: 9 filenum: 2
+; CHECK-MACRO-NEXT:     DW_MACINFO_define - lineno: 1 macro: NameDef Value
+; CHECK-MACRO-NEXT:     DW_MACINFO_undef - lineno: 11 macro: NameUndef
+; CHECK-MACRO-NEXT:   DW_MACINFO_end_file
+; CHECK-MACRO-NEXT:   DW_MACINFO_undef - lineno: 10 macro: NameUndef2
+; CHECK-MACRO-NEXT: DW_MACINFO_end_file
+; CHECK-MACRO-NEXT: DW_MACINFO_start_file - lineno: 0 filenum: 1
+; CHECK-MACRO-NEXT: DW_MACINFO_end_file
+
+; CHECK-LINE: .debug_line contents:
+; CHECK-LINE: Dir  Mod Time   File Len   File Name
+; CHECK-LINE: file_names[  1] {{.*}}debug-macro.cpp
+; CHECK-LINE: file_names[  2] {{.*}}debug-macro.h
+; CHECK-LINE: Dir  Mod Time   File Len   File Name
+; CHECK-LINE: file_names[  1] {{.*}}debug-macro1.cpp
+
+!llvm.dbg.cu = !{!0, !16, !20}
+!llvm.module.flags = !{!13, !14}
+!llvm.ident = !{!15}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang version 3.5.0 ", isOptimized: false, emissionKind: 1, file: !1, enums: !2, retainedTypes: !2, subprograms: !2, globals: !2, imports: !2, macros: !3)
+!1 = !DIFile(filename: "debug-macro.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4, !5}
+!4 = !DIMacro(type: DW_MACINFO_define, line: 0, name: "NameCMD", value: "ValueCMD")
+!5 = !DIMacroFile(line: 0, file: !1, nodes: !6)
+!6 = !{!7, !12}
+!7 = !DIMacroFile(line: 9, file: !8, nodes: !9)
+!8 = !DIFile(filename: "debug-macro.h", directory: "/")
+!9 = !{!10, !11}
+!10 = !DIMacro(type: DW_MACINFO_define, line: 1, name: "NameDef", value: "Value")
+!11 = !DIMacro(type: DW_MACINFO_undef, line: 11, name: "NameUndef")
+!12 = !DIMacro(type: DW_MACINFO_undef, line: 10, name: "NameUndef2")
+
+!13 = !{i32 2, !"Dwarf Version", i32 4}
+!14 = !{i32 1, !"Debug Info Version", i32 3}
+!15 = !{!"clang version 3.5.0 "}
+
+!16 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang version 3.5.0 ", isOptimized: false, emissionKind: 1, file: !17, enums: !2, retainedTypes: !2, subprograms: !2, globals: !2, imports: !2, macros: !18)
+!17 = !DIFile(filename: "debug-macro1.cpp", directory: "/")
+!18 = !{!19}
+!19 = !DIMacroFile(line: 0, file: !17, nodes: !2)
+
+!20 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang version 3.5.0 ", isOptimized: false, emissionKind: 1, file: !21, enums: !2, retainedTypes: !2, subprograms: !2, globals: !2, imports: !2)
+!21 = !DIFile(filename: "debug-macro2.cpp", directory: "/")