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

%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

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

1878

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

1891

Same here.

1912

maybe add an assertion/unreachable for unhandled cases?

1919

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

else assert maybe?

lib/CodeGen/AsmPrinter/DwarfDebug.h

435

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

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

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

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

1916

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

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;

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 getMacroSize(DIMacro &M);
+  void emitMacro(DIMacro &M);
+  unsigned getMacroFileSize(DIMacroFile &F, DwarfCompileUnit &U);
+  void emitMacroFile(DIMacroFile &F, 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.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::finalizeModuleInfo() {
 
   finishSubprogramDefinitions();
 
   finishVariableDefinitions();
 
   // Collect info for variables that were optimized out.
   collectDeadVariables();
 
+  unsigned MacroOffset = 0;
   // 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();
 
     // Add CU specific attributes if we need to add any.
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
+    for (auto *MN : CUNode->getMacros()) {
+      if (auto *M = dyn_cast<DIMacro>(MN))
+        MacroOffset += getMacroSize(*M);
+      else if (auto *F = dyn_cast<DIMacroFile>(MN))
+        MacroOffset += getMacroFileSize(*F, 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::getMacroSize(DIMacro &M) {
+  unsigned Size = 0;
+  Size += getULEB128Size(M.getMacinfoType());
+  Size += getULEB128Size(M.getLine());
+  StringRef Name = M.getName();
+  StringRef Value = M.getValue();
+  Size += Name.size();
+  if (!Value.empty()) {
+    // Assure there is one space between macro name and macro value.
+    assert(Value.data()[0] != ' ' && "Macro value has a space prefix");
+    Size += 1; // Space
+    Size += Value.size();
+  }
+  Size += 1; // EOS
+
+  return Size;
+}
+
+void DwarfDebug::emitMacro(DIMacro &M) {
+  Asm->EmitULEB128(M.getMacinfoType());
+  Asm->EmitULEB128(M.getLine());
+  StringRef Name = M.getName();
+  StringRef Value = M.getValue();
+  Asm->OutStreamer->EmitBytes(Name);
+  if (!Value.empty()) {
+    // Assure there is one space between macro name and macro value.
+    assert(Value.data()[0] != ' ' && "Macro value has a space prefix");
+    Asm->EmitInt8(' ');
+    Asm->OutStreamer->EmitBytes(Value);
+  }
+  Asm->EmitInt8('\0');
+}
+
+unsigned DwarfDebug::getMacroFileSize(DIMacroFile &F, DwarfCompileUnit &U) {
+  unsigned Size = 0;
+  assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
+  Size += getULEB128Size(dwarf::DW_MACINFO_start_file);
+  Size += getULEB128Size(F.getLine());
+  DIFile *File = F.getFile();
+  unsigned FID =
+      U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
+  Size += getULEB128Size(FID);
+
+  for (auto *MN : F.getElements()) {
+    if (auto *M = dyn_cast<DIMacro>(MN))
+      Size += getMacroSize(*M);
+    else if (auto *F = dyn_cast<DIMacroFile>(MN))
+      Size += getMacroFileSize(*F, U);
+  }
+
+  Size += getULEB128Size(dwarf::DW_MACINFO_end_file);
+  return Size;
+}
+
+void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
+  assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
+  Asm->EmitULEB128(dwarf::DW_MACINFO_start_file);
+  Asm->EmitULEB128(F.getLine());
+  DIFile *File = F.getFile();
+  unsigned FID =
+      U.getOrCreateSourceID(File->getFilename(), File->getDirectory());
+  Asm->EmitULEB128(FID);
+
+  for (auto *MN : F.getElements()) {
+    if (auto *M = dyn_cast<DIMacro>(MN))
+      emitMacro(*M);
+    else if (auto *F = dyn_cast<DIMacroFile>(MN))
+      emitMacroFile(*F, U);
+  }
+
+  Asm->EmitULEB128(dwarf::DW_MACINFO_end_file);
+}
+
+// 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);
+  }
+
+  for (const auto &P : CUMap) {
+    auto &TheCU = *P.second;
+    auto *SkCU = TheCU.getSkeleton();
+    DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
+    auto *CUNode = cast<DICompileUnit>(P.first);
+    for (auto *MN : CUNode->getMacros()) {
+      if (auto *M = dyn_cast<DIMacro>(MN))
+        emitMacro(*M);
+      else if (auto *F = dyn_cast<DIMacroFile>(MN))
+        emitMacroFile(*F, 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())

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 |

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();
 }

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,

test/DebugInfo/X86/debug-macro.ll

+; RUN: llc -mtriple=x86_64-linux -O0 -filetype=obj < %s | llvm-dwarfdump -debug-dump=info - | FileCheck --check-prefix=CHECK-INFO %s
+; RUN: llc -mtriple=x86_64-linux -O0 -filetype=obj < %s | llvm-dwarfdump -debug-dump=macro - | FileCheck --check-prefix=CHECK-MACRO %s
+; RUN: llc -mtriple=x86_64-linux -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: "/")
 No newline at end of file