[DWARF5] Added support for emission of debug_macro section.

[SouraVX]

Summary

This patch adds support for emission of following DWARFv5 macro forms in debug_macro section.

1. DW_MACRO_start_file
2. DW_MACRO_end_file
3. DW_MACRO_define_strp
4. DW_MACRO_undef_strp.

[merge_guards_bot]

Unit tests: fail. 61911 tests passed, 1 failed and 783 were skipped.

failed: LLVM.MC/WebAssembly/debug-info.ll

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[SouraVX]

Rebase

[aprantl]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1187

this check is oddly redundant?

2772

///

[SouraVX]

Thank you @aprantl , for reviewing this.
Addressed minor review comment by @aprantl

[SouraVX]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1187

Oh Sorry, that must've crept up/left while segregating the dwarf-dump and this patch.

[dblaikie]

Please implement the dwarfdump support first (this patch can be reviewed during that time - but shouldn't be committed without tests & ideally those tests should be written using dwarfdump (sometimes there are exceptions for especially complicated dumping situations, where raw assembly testing is used instead, but I don't think it's necessary to make that tradeoff here))

& I'm surprised this patch causes updates to the tests - what changes in the patch caused changes in these tests? (stringpool and dbg-stack-value-range.mir) - ah, because debug_str now needs to be emitted after debug_macro because the macro section might introduce new strings? OK. Could you separate that ordering change/test update out into a standalone patch. It'll make the rest of this more targeted when reviewing.

llvm/lib/BinaryFormat/Dwarf.cpp

464–475

Build this with Dwarf.def rather than writing it out explicitly. Something like this:

return StringSwitch<unsigned>(MacroString)
#define HANDLE_DW_MACRO(ID, NAME)
  .Case("DW_MACRO_" #NAME, ID)
#include "llvm/BinaryFormat/Dwarf.def"
  .Default(DW_MACINFO_invalid);

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2779

This should probably be 4, not 3, since it's a bit field column. (if you tried to | in OPCODE_OPERANDS_TABLE of 3 into the table, you'd overwrite bits 1 and 2 (changing the value of offset_size and debug_line_offset, rather than specifying the value of opcode_operands))

2785–2786

This looks to be backwards - since OFFSET_SIZE_32 is zero, these two lines don't have any effect (& 32 bit is the default - if the bit is zero).

So it should /probably/ be:

if (offset byte size == 8)
  Flags |= OFFSET_SIZE_32;

2787–2788

Seems this line offset is optional and the DWARF spec doesn't mention what it might be useful for. Do you have any specific use in mind? Otherwise I'd leave it out. (@aprantl @probinson )

2789–2790

I don't think this is a FIXME situation - LLVM has no extensions here, so there's no need for the opcode_operands_table.

2819–2827

Perhaps refactor this to only have "AddComment / EMitULEB128" written once, but parameterized on the enum, eg:

unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define ? dwarf::DW_MACRO_define_strp : dwarf::DW_MACRO_undef_strp;
Asm->OutStreamer->AddComment(dwarf::MacroString(Type));
Asm->EmitULEB128(Type);

2868

Parsing constant strings back into constants is a bit suboptimal (both in terms of compile time performance, chance of mistakes (the string is checked at runtime whereas a reference to an enum would be checked at compile time)) & is curiously inverted compared to the line before - which uses an enum, then converts that to a string for the comment. There are a few other cases of this - in general, don't write string constants like this due to the lack of error/type checking, prefer using the enums & calling stringifying functions if needed.

It'd be nice to simplify this code a bit in general - the fact that this adds comments to the new debug_macro paths that are then missing from the debug_macinfo paths, etc, isn't ideal.

I'm wondering if it'd make sense to instead phrase this whole function parameterized on the type of enums, so it'd be implemented a bit like this:

if (UseMacro) {
  emitMacroFileImpl(F, U, dwarf::DW_MACRO_start_file, dwarf::DW_MACRO_end_file, dwarf::MacroString);
} else {
  emitMacroFileImpl(F, U, dwarf::DW_MACINFO_start_file, dwarf::DW_MACINFO_end_file, dwarf::MacinfoString);
}

So the implementation doesn't have conditionals in several places, keeps it consistent, etc.

2895–2899

This might be more legible using the conditional (?:) operator to pass the specific debug section - so it's obvious to the reader that that's the only difference (that they're not calling subtly differently named functions, etc - just calling the same function with a different argument), eg:

auto &ObjLower = Asm->getObjFileLowering();
emitDebugMacinfoImpl(getDwarfVersion() >= 5 ? ObjLower.getDwarfMacroSection() : ObjLower.getDwarfMacInfoSection());

[SouraVX]

In D72828#1824527, @dblaikie wrote:

Please implement the dwarfdump support first (this patch can be reviewed during that time - but shouldn't be committed without tests & ideally those tests should be written using dwarfdump (sometimes there are exceptions for especially complicated dumping situations, where raw assembly testing is used instead, but I don't think it's necessary to make that tradeoff here))

I'm trying to get that patch ready. As for this, this patch doesn't have dependency on dwarfdump except that testing the section contents part. I've verified integrity of section content using objdump and lldb/gdb. My rationale behind this was this patch can get in, till we discuss and agree on dwarfdump extension to accommodate macro support.

& I'm surprised this patch causes updates to the tests - what changes in the patch caused changes in these tests? (stringpool and dbg-stack-value-range.mir) - ah, because debug_str now needs to be emitted after debug_macro because the macro section might introduce new strings? OK. Could you separate that ordering change/test update out into a standalone patch. It'll make the rest of this more targeted when reviewing.

Yes, that' s intentional. I've shifted the string emission to post macro emission to put macro content in string section. BTW are you suggesting here to do that change/patch commit separately ??

Thanks David for reviewing/sharing your thoughts on this.
Refactoring suggestion, I will address those in next revision.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2785–2786

I may be wrong here. Are you trying to suggest this ??

if (offset byte size == 8)
 Flags |= OFFSET_SIZE_64;

I think we only need that in DWARF64 case, which this patch does not support.
So for consistency/readibility, I intentionally set OFFSET_byte_size_32 that even that has no effect.
Should we leave it as it is OR remove it and add comment that in default case DWARF32 Offset size will be 32.

2787–2788

Yes, One crucial thing I noticed while verifying section content is that, consumers objdump/lldb/gdb agrees on this representation and expect offset of debug_line section within macro section. So if we omit that, I'm afraid we might loose debuggability.

[probinson]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2763

DWARF does not define symbols for the flag bits, but I'd still expect to see these in Dwarf.def where they could be shared with the dumper code.
Also, OPCODE_OPERANDS_TABLE should be 4 not 3; these are masks, not bit numbers.

2785–2786

If you're not supporting 64-bit offsets (which is entirely reasonable) you should have an assert() that the offset size is 4.

2787–2788

@dblaikie The reference to .debug_line is required for DW_MACRO_start_file, because that opcode has an operand that is a file number from the line-number program's file table. It's optional if that opcode is not used.

@SouraVX it is inconsistent to conditionalize setting the flag bit, and then unconditionally emit the debug_line_offset field. I have no problem with always emitting the field, but in that case you should unconditionally set the flag bit as well.

llvm/test/DebugInfo/X86/stringpool.ll

45

This captures the string offset into YYYY, but never uses the captured value. The old version of the test did verify the offset was used, presumably somewhere in the __debug_info section. So, this change has lost coverage.

[SouraVX]

Thanks @probinson for sharing thoughts.
Refactored code based on @dblaikie review
Addressed and implemented @probinson concerns

[SouraVX]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2763

Thanks for sharing this, I've added forms in Dwarf.def and exapanded the enum here.
Will try to reuse this in corresponding dumping part.

llvm/test/DebugInfo/X86/stringpool.ll

45

Thanks for pointing this out.
Added corresponding debug info variable. Now we have back reference to info section from str section.

[SouraVX]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2816

Since my emitMacroFileImpl causes the comments to be emitted in asm for both macinfo and macro section which is good. But this is sort of incomplete, since we're not emitting comments for macinfo type.
I'm planning to do a small factor on macinfo part also. To emit macro form comments for DW_MACINFO_define and others.
Making asm more readeable.

[probinson]

My comments have been addressed, but leaving final approval to @dblaikie.

[SouraVX]

Corresponding llvm-dwarfdump revision D73086

[SouraVX]

Gentle, friendly Ping! to all reviewers!
Child Revision - D73086

[SouraVX]

Comments emission in ASM for macinfo section. completed! + Rebase.

[SouraVX]

Gentle/Friendly Ping! @dblaikie @aprantl and all other reviewers!

[aprantl]

lgtm if David is happy.

[SouraVX]

In D72828#1850038, @aprantl wrote:

lgtm if David is happy.

Thank You, @aprantl, for your acceptance. I agree, that part of macro implementation needs refactoring/In my opinion/. That was the reason, I was delaying and created separate patch for llvm-dwarfdump D73086. So that, even if we disagree/want changes, for a better implementation of dumping part.
We can still have emission part i.e this patch in LLVM {/tested/beneficial from consumer perspective GDB or LLDB/}

[SouraVX]

Ping!
Hi @dblaikie, Could you please share your thoughts/acceptance on this. All other reviewers had shared their acceptance.

[dblaikie]

This doesn't seem to be tested - the couple of test updates are to keep them passing after changing the ordering of sections - ideally that change (changing the ordering of sections, so strings can come after macros) should be committed separately (just change the order and update the few tests that need it) & explicit/full test coverage for this feature should be added and should use llvm-dwarfdump (so this patch should come after the one that adds functionality to llvm-dwarfdump for dumping this section).

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2812

Could this be Name + ' ' + Value? (perhaps it could be (Name + ' ' + Value).str() if it needs to be a string in the end - that would be a bit more efficient than the current code that stringifies the Name and Value separately)

2825

Probably skip the "= + Value" part here (the same isn't done for the "Macro String"/name above - because the string itself is probably legible in the assembly? So the description is useful, but the value itself will be evident in the assembly without needing to be repeated in the comment)

2834

Rename "Func" to a more informative name - "MacToString", perhaps?

[SouraVX]

Incorporated @dblaikie comments!
Committed string emission part separately.
Incorporated, other minor comments.

[dblaikie]

Ping this when the llvm-dwarfdump support for debug_macro is in and this patch has been updated with test coverage using that support.

[SouraVX]

Hi @dblaikie , it's already in pipeline. I mentioned in this revision. Corresponding dwarfdump emission D73086.

[ikudrin]

llvm/include/llvm/BinaryFormat/Dwarf.def

830

Remove OFFSET_SIZE_32, as this value does not define any real flag.

831

This should be just OFFSET_SIZE to correspond to the other flags.

833

The value for OPCODE_OPERANDS_TABLE should be 0x04. It looks like @dblaikie already said that for one of previous versions of the patch.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2767

This crashes on a Debug build, probably because DwarfParams is not initialized.

[SouraVX]

Incorporated @ikudrin comments,
Removed a redundant check and a FIXME:Not emitting opcode_operands_table

[SouraVX]

llvm/include/llvm/BinaryFormat/Dwarf.def

830

Yes, theirs no particular flag in Spec. Spec says about "offset_size_flag" and how it's value is interpreted
0 - DWARF32 1 - DWARF64. I created these flags for readable/informative purpose.

833

Sorry for the trouble, I forgot to replace this with "0x03". Since, their was a discussion to keep this or not in first place because we are not emitting opcode_operands_table, So this flag is not used, at least right now.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2767

Oh.., Yeah I also noticed this, even after initalizing dwarf::FormParams DwarfParams({5, 8, DWARF32}).
Still
assert(DwarfParams.getDwarfOffsetByteSize() == 4 && "DWARF64 not supported!"); not on release build.
this is failing, some how getDwarfOffsetByteSize() is not returning correctly.
Anyway I found this check to be a bit redundant in it's own way. So removed it.

[ikudrin]

llvm/include/llvm/BinaryFormat/Dwarf.def

830

This is false readability. You still have to remember that the value is not real and treat it accordingly. There is no distinct value for DWARF32 in the specs. The value of 0 means that the contribution has DWARF32 format AND does not have a debug_line_offset field AND does not have an opcode_operands_table. Moreover, you do not define pairs of values for the other flags, which makes all the definition inconsistent. So, please, remove that fictitious value and make the set of flags follow the documentation.

[SouraVX]

Revised and Addressed comments by @ikudrin.
Changes summary -
-No dependency on D73086, just the Macro flags defined in Dwarf.def are reused here while writing macro header flags field.
-Contents verification has been done using llvm-dwarfdump generated from D73086.

[ikudrin]

While this can be applied to master cleanly, it cannot be built, because it requires D73086; it applies after D73086 with some conflicts. Please, prepare a diff which will be applied after D73086 cleanly and add D73086 as a parent revision to show the dependency.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2770

Flags = MACRO_FLAG_DEBUG_LINE_OFFSET;

[SouraVX]

In D72828#1907639, @ikudrin wrote:

While this can be applied to master cleanly, it cannot be built, because it requires D73086; it applies after D73086 with some conflicts. Please, prepare a diff which will be applied after D73086 cleanly and add D73086 as a parent revision to show the dependency.

Hi @ikudrin and other reviewers, How about committing Dwarf.def and Dwarf.h changes/Mostly Flag encodings/ and stringify encoding functionalties as separate commit. That will resolve most of false dependencies. In my opinion that part adding those flags and encoding is independent of these patches(for instance, most of other encodings/flags described by dwarfv5 spec are their, even when LLVM/consumer might not be using them at present) and should be committed separately.
Any thoughts on this?

[SouraVX]

Addressed nits by @ikudrin

[probinson]

In D72828#1908583, @SouraVX wrote:

In D72828#1907639, @ikudrin wrote:

While this can be applied to master cleanly, it cannot be built, because it requires D73086; it applies after D73086 with some conflicts. Please, prepare a diff which will be applied after D73086 cleanly and add D73086 as a parent revision to show the dependency.

Hi @ikudrin and other reviewers, How about committing Dwarf.def and Dwarf.h changes/Mostly Flag encodings/ and stringify encoding functionalties as separate commit. That will resolve most of false dependencies. In my opinion that part adding those flags and encoding is independent of these patches(for instance, most of other encodings/flags described by dwarfv5 spec are their, even when LLVM/consumer might not be using them at present) and should be committed separately.
Any thoughts on this?

That would be perfectly fine.

[ikudrin]

In my understanding, this should still depend on D73086 because this revision requires the dumper for the test(s).

[SouraVX]

Rebase!
@ikudrin this still depends on D73086, I've not removed parent-child relationship of revisions.

[SouraVX]

nit: Modified macro header comment emission. Previously we were emitting lineptr.
Based on @ikudrin comment on D73086 this is modified to debug_line_offset for consistency and correlation with v5 macro definition in spec.
Thanks for this!

[SouraVX]

Since most of this patch is reviewed already and this was blocking on D73086. Now D73086 is mostly ready to land so could you guys @dblaikie and @ikudrin can share some final comments on this one also.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2856–2861

Rather than duplicating the code here from DwarfCompileUnit::initStmtList, please refactor so that this value is computed once and shared from there. (perhaps DwarfCompileUnit can have a getLineTableStartSym function that can be used from here.

[SouraVX]

Addressed review comments by @dblaikie. Thanks for this!
-Refactored and rebased on trunk.
-Added a brief descriptive comment stating intention of the test case.
-Edited summary to remove previously stated objdump based testing statement.

[dblaikie]

Looks good to me - please wait for @ikudrin to circle back on this and approve it as well.

[ikudrin]

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

5 ↗

(On Diff #255190)

The test fails because this line lacks the RUN: prefix.

27–41 ↗

(On Diff #255190)

The function @main() and its dependencies are not required for the test. Please, shrink the test so that it includes only that is necessary.

[SouraVX]

Addressed comments by @ikudrin. Thanks for this!
-Reduced the test case to minimal.

[SouraVX]

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

5 ↗

(On Diff #255190)

Sorry, somehow the presence of line continuation(Previously inserted since the RUN line was long) was causing this test to be UnResolved.

Test has unterminated run lines (with '\')
Unresolved Tests (1):
    LLVM :: DebugInfo/X86/debug-macro-v5.ll

Anyways removed the line continuation, Now this is passing.

[ikudrin]

LGTM.

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

 /// @{
 unsigned getTag(StringRef TagString);
 unsigned getOperationEncoding(StringRef OperationEncodingString);
 unsigned getVirtuality(StringRef VirtualityString);
 unsigned getLanguage(StringRef LanguageString);
 unsigned getCallingConvention(StringRef LanguageString);
 unsigned getAttributeEncoding(StringRef EncodingString);
 unsigned getMacinfo(StringRef MacinfoString);
+unsigned getMacro(StringRef MacroString);
 /// @}
 
 /// \defgroup DwarfConstantsVersioning Dwarf version for constants
 ///
 /// For constants defined by DWARF, returns the DWARF version when the constant
 /// was first defined. For vendor extensions, if there is a version-related
 /// policy for when to emit it, returns a version number for that policy.
 /// Otherwise returns 0.

llvm/include/llvm/BinaryFormat/Dwarf.def

 
 // TODO: Add other DW-based macros.
 #if !(                                                                         \
     defined HANDLE_DW_TAG || defined HANDLE_DW_AT || defined HANDLE_DW_FORM || \
     defined HANDLE_DW_OP || defined HANDLE_DW_LANG || defined HANDLE_DW_ATE || \
     defined HANDLE_DW_VIRTUALITY || defined HANDLE_DW_DEFAULTED ||             \
     defined HANDLE_DW_CC || defined HANDLE_DW_LNS || defined HANDLE_DW_LNE ||  \
     defined HANDLE_DW_LNCT || defined HANDLE_DW_MACRO ||                       \
+    defined HANDLE_MACRO_FLAGS ||                                              \
     defined HANDLE_DW_RLE || defined HANDLE_DW_LLE ||                          \
     (defined HANDLE_DW_CFA && defined HANDLE_DW_CFA_PRED) ||                   \
     defined HANDLE_DW_APPLE_PROPERTY || defined HANDLE_DW_UT ||                \
     defined HANDLE_DWARF_SECTION || defined HANDLE_DW_IDX ||                   \
     defined HANDLE_DW_END)
 #error "Missing macro definition of HANDLE_DW*"
 #endif
 

 #ifndef HANDLE_DW_LNCT
 #define HANDLE_DW_LNCT(ID, NAME)
 #endif
 
 #ifndef HANDLE_DW_MACRO
 #define HANDLE_DW_MACRO(ID, NAME)
 #endif
 
+#ifndef HANDLE_MACRO_FLAGS
+#define HANDLE_MACRO_FLAGS(ID, NAME)
+#endif
+
 #ifndef HANDLE_DW_RLE
 #define HANDLE_DW_RLE(ID, NAME)
 #endif
 
 #ifndef HANDLE_DW_LLE
 #define HANDLE_DW_LLE(ID, NAME)
 #endif
 

 HANDLE_DW_MACRO(0x05, define_strp)
 HANDLE_DW_MACRO(0x06, undef_strp)
 HANDLE_DW_MACRO(0x07, import)
 HANDLE_DW_MACRO(0x08, define_sup)
 HANDLE_DW_MACRO(0x09, undef_sup)
 HANDLE_DW_MACRO(0x0a, import_sup)
 HANDLE_DW_MACRO(0x0b, define_strx)
 HANDLE_DW_MACRO(0x0c, undef_strx)
+// DWARF v5 Macro header flags
+HANDLE_MACRO_FLAGS(0x00, OFFSET_SIZE_32)
+HANDLE_MACRO_FLAGS(0x01, OFFSET_SIZE_64)
+HANDLE_MACRO_FLAGS(0x02, DEBUG_LINE_OFFSET)
+HANDLE_MACRO_FLAGS(0x03, OPCODE_OPERANDS_TABLE)
 
 // DWARF v5 Range List Entry encoding values.
 HANDLE_DW_RLE(0x00, end_of_list)
 HANDLE_DW_RLE(0x01, base_addressx)
 HANDLE_DW_RLE(0x02, startx_endx)
 HANDLE_DW_RLE(0x03, startx_length)
 HANDLE_DW_RLE(0x04, offset_pair)
 HANDLE_DW_RLE(0x05, base_address)

 #undef HANDLE_DW_ATE
 #undef HANDLE_DW_VIRTUALITY
 #undef HANDLE_DW_DEFAULTED
 #undef HANDLE_DW_CC
 #undef HANDLE_DW_LNS
 #undef HANDLE_DW_LNE
 #undef HANDLE_DW_LNCT
 #undef HANDLE_DW_MACRO
+#undef HANDLE_MACRO_FLAGS
 #undef HANDLE_DW_RLE
 #undef HANDLE_DW_LLE
 #undef HANDLE_DW_CFA
 #undef HANDLE_DW_CFA_PRED
 #undef HANDLE_DW_APPLE_PROPERTY
 #undef HANDLE_DW_UT
 #undef HANDLE_DWARF_SECTION
 #undef HANDLE_DW_IDX
 #undef HANDLE_DW_END

llvm/include/llvm/MC/MCObjectFileInfo.h

protected:
   MCSection *DwarfFrameSection = nullptr;
   MCSection *DwarfPubTypesSection = nullptr;
   const MCSection *DwarfDebugInlineSection = nullptr;
   MCSection *DwarfStrSection = nullptr;
   MCSection *DwarfLocSection = nullptr;
   MCSection *DwarfARangesSection = nullptr;
   MCSection *DwarfRangesSection = nullptr;
   MCSection *DwarfMacinfoSection = nullptr;
+  MCSection *DwarfMacroSection = nullptr;
   // The pubnames section is no longer generated by default.  The generation
   // can be enabled by a compiler flag.
   MCSection *DwarfPubNamesSection = nullptr;
 
   /// Accelerator table sections. DwarfDebugNamesSection is the DWARF v5
   /// accelerator table, while DwarfAccelNamesSection, DwarfAccelObjCSection,
   /// DwarfAccelNamespaceSection, DwarfAccelTypesSection are pre-DWARF v5
   /// extensions.
public:
   }
   MCSection *getDwarfStrSection() const { return DwarfStrSection; }
   MCSection *getDwarfLocSection() const { return DwarfLocSection; }
   MCSection *getDwarfARangesSection() const { return DwarfARangesSection; }
   MCSection *getDwarfRangesSection() const { return DwarfRangesSection; }
   MCSection *getDwarfRnglistsSection() const { return DwarfRnglistsSection; }
   MCSection *getDwarfLoclistsSection() const { return DwarfLoclistsSection; }
   MCSection *getDwarfMacinfoSection() const { return DwarfMacinfoSection; }
+  MCSection *getDwarfMacroSection() const { return DwarfMacroSection; }
 
   MCSection *getDwarfDebugNamesSection() const {
     return DwarfDebugNamesSection;
   }
   MCSection *getDwarfAccelNamesSection() const {
     return DwarfAccelNamesSection;
   }
   MCSection *getDwarfAccelObjCSection() const { return DwarfAccelObjCSection; }

llvm/lib/BinaryFormat/Dwarf.cpp

default:
     return StringRef();
 #define HANDLE_DW_LNE(ID, NAME)                                                \
   case DW_LNE_##NAME:                                                          \
     return "DW_LNE_" #NAME;
 #include "llvm/BinaryFormat/Dwarf.def"
   }
 }
 
+StringRef llvm::dwarf::MacroString(unsigned 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"
+  }
+}
+
+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::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";

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 (*Func)(unsigned Form));
   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

if (getDwarfVersion() >= 5) {
         if (!useSplitDwarf())
           U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_loclists_base,
                             DebugLocs.getSym(),
                             TLOF.getDwarfLoclistsSection()->getBeginSymbol());
       }
     }
 
     auto *CUNode = cast<DICompileUnit>(P.first);
-    // If compile Unit has macros, emit "DW_AT_macro_info" attribute.
+    // If compile Unit has macros, emit "DW_AT_macro_info/DW_AT_macros"
+    // attribute.
     if (CUNode->getMacros()) {
+      if (getDwarfVersion() >= 5) {
+        // FIXME: Add support for DWARFv5 DW_AT_macros attribute for split
+        // case.
+        if (!useSplitDwarf())
+          U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macros,
+                            U.getMacroLabelBegin(),
+                            TLOF.getDwarfMacroSection()->getBeginSymbol());
+      } else {
         if (useSplitDwarf())
-        TheCU.addSectionDelta(TheCU.getUnitDie(), dwarf::DW_AT_macro_info,
-                            U.getMacroLabelBegin(),
-                            TLOF.getDwarfMacinfoDWOSection()->getBeginSymbol());
+          TheCU.addSectionDelta(
+              TheCU.getUnitDie(), dwarf::DW_AT_macro_info,
         else
           U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
                             U.getMacroLabelBegin(),
                             TLOF.getDwarfMacinfoSection()->getBeginSymbol());
       }
     }
+    }
 
   // Emit all frontend-produced Skeleton CUs, i.e., Clang modules.
   for (auto *CUNode : MMI->getModule()->debug_compile_units())
     if (CUNode->getDWOId())
       getOrCreateDwarfCompileUnit(CUNode);
 
   // Compute DIE offsets and sizes.
   InfoHolder.computeSizeAndOffsets();
void DwarfDebug::endModule() {
   // conditionalized on !DisableDebugInfoPrinting and the presence of the
   // llvm.dbg.cu metadata node)
   if (!MMI->hasDebugInfo())
     return;
 
   // Finalize the debug info for the module.
   finalizeModuleInfo();
 
-  emitDebugStr();
 
   if (useSplitDwarf())
     // Emit debug_loc.dwo/debug_loclists.dwo section.
     emitDebugLocDWO();
   else
     // Emit debug_loc/debug_loclists section.
     emitDebugLoc();
 
void DwarfDebug::endModule() {
 
   // Emit info into a debug ranges section.
   emitDebugRanges();
 
   if (useSplitDwarf())
   // Emit info into a debug macinfo.dwo section.
     emitDebugMacinfoDWO();
   else
-  // Emit info into a debug macinfo section.
+    // Emit info into a debug macinfo/macro section.
     emitDebugMacinfo();
 
+  emitDebugStr();
+
   if (useSplitDwarf()) {
     emitDebugStrDWO();
     emitDebugInfoDWO();
     emitDebugAbbrevDWO();
     emitDebugLineDWO();
     emitDebugRangesDWO();
   }
 
emitDebugRangesImpl(Holder,
                           : Asm->getObjFileLowering().getDwarfRangesSection());
 }
 
 void DwarfDebug::emitDebugRangesDWO() {
   emitDebugRangesImpl(InfoHolder,
                       Asm->getObjFileLowering().getDwarfRnglistsDWOSection());
 }
 
+/// Emit the header of a DWARF 5 macro section.
+static void emitMacroHeader(AsmPrinter *Asm, const DwarfDebug &DD,
+                            const DwarfCompileUnit &CU) {
+  enum HeaderFlagMask {
+#define HANDLE_MACRO_FLAGS(ID, NAME) MACRO_FLAG_##NAME = ID,
+#include "llvm/BinaryFormat/Dwarf.def"
+  };
+  dwarf::FormParams DwarfParams;
+  uint8_t Flags = 0;
+  Asm->OutStreamer->AddComment("Macro information version");
+  Asm->emitInt16(5);
+  assert(DwarfParams.getDwarfOffsetByteSize() == 4 && "DWARF64 not supported!");
+  // We are setting Offset and line offset flags unconditionally here,
+  // since we're only supporting DWARF32 and line offset should be mostly
+  // present.
+  Flags |= MACRO_FLAG_OFFSET_SIZE_32 | MACRO_FLAG_DEBUG_LINE_OFFSET;
+  // FIXME: We are not setting opcode_operands_table_flag, since we're not
+  // emitting opcode_operands_table
+  Asm->OutStreamer->AddComment("Flags: 32 bit, lineptr present");
+  Asm->emitInt8(Flags);
+  Asm->OutStreamer->AddComment("lineptr");
+  if (DD.useSectionsAsReferences())
+    Asm->OutStreamer->EmitSymbolValue(
+        Asm->getObjFileLowering().getDwarfLineSection()->getBeginSymbol(), 4);
+  else
+    Asm->OutStreamer->EmitSymbolValue(
+        Asm->OutStreamer->getDwarfLineTableSymbol(CU.getUniqueID()), 4);
+}
+
 void DwarfDebug::handleMacroNodes(DIMacroNodeArray Nodes, DwarfCompileUnit &U) {
   for (auto *MN : Nodes) {
     if (auto *M = dyn_cast<DIMacro>(MN))
       emitMacro(*M);
     else if (auto *F = dyn_cast<DIMacroFile>(MN))
       emitMacroFile(*F, U);
     else
       llvm_unreachable("Unexpected DI type!");
   }
 }
 
 void DwarfDebug::emitMacro(DIMacro &M) {
-  Asm->EmitULEB128(M.getMacinfoType());
-  Asm->EmitULEB128(M.getLine());
   StringRef Name = M.getName();
   StringRef Value = M.getValue();
+  bool UseMacro = getDwarfVersion() >= 5;
+
+  if (UseMacro) {
+    unsigned Type = M.getMacinfoType() == dwarf::DW_MACINFO_define
+                        ? dwarf::DW_MACRO_define_strp
+                        : dwarf::DW_MACRO_undef_strp;
+    Asm->OutStreamer->AddComment(dwarf::MacroString(Type));
+    Asm->EmitULEB128(Type);
+    Asm->OutStreamer->AddComment("Line Number");
+    Asm->EmitULEB128(M.getLine());
+    Asm->OutStreamer->AddComment("Macro String");
+    Asm->OutStreamer->EmitSymbolValue(
+        this->InfoHolder.getStringPool()
+            .getEntry(*Asm, Name.str() + ' ' + Value.str())
+            .getSymbol(),
+        4);
+  } else {
+    Asm->OutStreamer->AddComment(dwarf::MacinfoString(M.getMacinfoType()));
+    Asm->EmitULEB128(M.getMacinfoType());
+    Asm->OutStreamer->AddComment("Line Number");
+    Asm->EmitULEB128(M.getLine());
+    Asm->OutStreamer->AddComment("Macro String");
     Asm->OutStreamer->EmitBytes(Name);
     if (!Value.empty()) {
       // There should be one space between macro name and macro value.
       Asm->emitInt8(' ');
+      Asm->OutStreamer->AddComment("Macro Value=" + Value);
       Asm->OutStreamer->EmitBytes(Value);
     }
     Asm->emitInt8('\0');
   }
+}
 
-void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
-  assert(F.getMacinfoType() == dwarf::DW_MACINFO_start_file);
-  Asm->EmitULEB128(dwarf::DW_MACINFO_start_file);
+void DwarfDebug::emitMacroFileImpl(DIMacroFile &F, DwarfCompileUnit &U,
+                                   unsigned StartFile, unsigned EndFile,
+                                   StringRef (*Func)(unsigned Form)) {
+
+  Asm->OutStreamer->AddComment(Func(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->EmitULEB128(dwarf::DW_MACINFO_end_file);
+  Asm->OutStreamer->AddComment(Func(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);
+  bool UseMacro = getDwarfVersion() >= 5;
+  if (UseMacro)
+    emitMacroFileImpl(F, U, dwarf::DW_MACRO_start_file,
+                      dwarf::DW_MACRO_end_file, dwarf::MacroString);
+  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();
     DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
     auto *CUNode = cast<DICompileUnit>(P.first);
     DIMacroNodeArray Macros = CUNode->getMacros();
     if (Macros.empty())
       continue;
     Asm->OutStreamer->SwitchSection(Section);
     Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin());
+    if (getDwarfVersion() >= 5)
+      emitMacroHeader(Asm, *this, U);
     handleMacroNodes(Macros, U);
     Asm->OutStreamer->AddComment("End Of Macro List Mark");
     Asm->emitInt8(0);
   }
 }
 
-/// Emit macros into a debug macinfo section.
+/// Emit macros into a debug macinfo/macro section.
 void DwarfDebug::emitDebugMacinfo() {
-  emitDebugMacinfoImpl(Asm->getObjFileLowering().getDwarfMacinfoSection());
+  auto &ObjLower = Asm->getObjFileLowering();
+  emitDebugMacinfoImpl(getDwarfVersion() >= 5
+                           ? ObjLower.getDwarfMacroSection()
+                           : ObjLower.getDwarfMacinfoSection());
 }
 
 void DwarfDebug::emitDebugMacinfoDWO() {
+  // FIXME: Add support for macro.dwo section.
+  if (getDwarfVersion() >= 5)
+    return;
   emitDebugMacinfoImpl(Asm->getObjFileLowering().getDwarfMacinfoDWOSection());
 }
 
 // DWARF5 Experimental Separate Dwarf emitters.
 
 void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
                                   std::unique_ptr<DwarfCompileUnit> NewU) {
 
   if (!CompilationDir.empty())
     NewU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
   addGnuPubAttributes(*NewU, Die);
 
   SkeletonHolder.addUnit(std::move(NewU));
 }
 
 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
 

llvm/lib/MC/MCObjectFileInfo.cpp

DwarfRangesSection =
       Ctx->getMachOSection("__DWARF", "__debug_ranges", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "debug_range");
   DwarfRnglistsSection =
       Ctx->getMachOSection("__DWARF", "__debug_rnglists", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "debug_range");
   DwarfMacinfoSection =
       Ctx->getMachOSection("__DWARF", "__debug_macinfo", MachO::S_ATTR_DEBUG,
                            SectionKind::getMetadata(), "debug_macinfo");
+  DwarfMacroSection =
+      Ctx->getMachOSection("__DWARF", "__debug_macro", MachO::S_ATTR_DEBUG,
+                           SectionKind::getMetadata(), "debug_macro");
   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,
DwarfStrSection =
                          ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, "");
   DwarfLocSection = Ctx->getELFSection(".debug_loc", DebugSecType, 0);
   DwarfARangesSection =
       Ctx->getELFSection(".debug_aranges", DebugSecType, 0);
   DwarfRangesSection =
       Ctx->getELFSection(".debug_ranges", DebugSecType, 0);
   DwarfMacinfoSection =
       Ctx->getELFSection(".debug_macinfo", DebugSecType, 0);
+  DwarfMacroSection = Ctx->getELFSection(".debug_macro", DebugSecType, 0);
 
   // DWARF5 Experimental Debug Info
 
   // Accelerator Tables
   DwarfDebugNamesSection =
       Ctx->getELFSection(".debug_names", ELF::SHT_PROGBITS, 0);
   DwarfAccelNamesSection =
       Ctx->getELFSection(".apple_names", ELF::SHT_PROGBITS, 0);
DwarfRangesSection = Ctx->getCOFFSection(
       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(), "debug_macinfo");
+  DwarfMacroSection = Ctx->getCOFFSection(
+      ".debug_macro",
+      COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+          COFF::IMAGE_SCN_MEM_READ,
+      SectionKind::getMetadata(), "debug_macro");
   DwarfMacinfoDWOSection = Ctx->getCOFFSection(
       ".debug_macinfo.dwo",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
           COFF::IMAGE_SCN_MEM_READ,
       SectionKind::getMetadata(), "debug_macinfo.dwo");
   DwarfInfoDWOSection = Ctx->getCOFFSection(
       ".debug_info.dwo",
       COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
DwarfLocSection =
       Ctx->getWasmSection(".debug_loc", SectionKind::getMetadata());
   DwarfAbbrevSection =
       Ctx->getWasmSection(".debug_abbrev", SectionKind::getMetadata());
   DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", SectionKind::getMetadata());
   DwarfRangesSection =
       Ctx->getWasmSection(".debug_ranges", SectionKind::getMetadata());
   DwarfMacinfoSection =
       Ctx->getWasmSection(".debug_macinfo", SectionKind::getMetadata());
+  DwarfMacroSection =
+      Ctx->getWasmSection(".debug_macro", SectionKind::getMetadata());
   DwarfAddrSection = Ctx->getWasmSection(".debug_addr", SectionKind::getMetadata());
   DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", SectionKind::getMetadata());
   DwarfTUIndexSection = Ctx->getWasmSection(".debug_tu_index", SectionKind::getMetadata());
   DwarfInfoSection =
       Ctx->getWasmSection(".debug_info", SectionKind::getMetadata());
   DwarfFrameSection = Ctx->getWasmSection(".debug_frame", SectionKind::getMetadata());
   DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", SectionKind::getMetadata());
   DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", SectionKind::getMetadata());

llvm/test/DebugInfo/MIR/X86/dbg-stack-value-range.mir

 # Verifies that "local1" stack location is ended at the end of the block (.Ltmp6).
 #
 # CHECK: .Ltmp4:
 # CHECK-NEXT:   #DEBUG_VALUE: foo:local1 <- [DW_OP_constu 4, DW_OP_minus, DW_OP_deref] $rbp
 # CHECK:        jmp     .LBB0_2
 # CHECK-NEXT: .Ltmp6:
 # CHECK: .Lfunc_end0:
 #
-# CHECK: .Linfo_string7:
-# CHECK-NEXT: .asciz  "local1"
-#
 # CHECK: .Ldebug_loc2:
 # CHECK-NEXT: .quad   .Ltmp1-.Lfunc_begin0
 # CHECK-NEXT: .quad   .Ltmp4-.Lfunc_begin0
 # CHECK-NEXT: .short  1                       # Loc expr size
 # CHECK-NEXT: .byte   94                      # super-register DW_OP_reg14
 # CHECK-NEXT: .quad   .Ltmp4-.Lfunc_begin0
 # CHECK-NEXT: .quad   .Ltmp6-.Lfunc_begin0
 # CHECK-NEXT: .short  2                       # Loc expr size
 # CHECK-NEXT: .byte   118                     # DW_OP_breg6
 # CHECK-NEXT: .byte   124                     # -4
 #
 # CHECK: .long   .Ldebug_loc2            # DW_AT_location
 # CHECK-NEXT: .long   .Linfo_string7          # DW_AT_name
-
-
+#
+# CHECK: .Linfo_string7:
+# CHECK-NEXT: .asciz  "local1"
 --- |
   ; ModuleID = 'dbg-stack-value-range.ll'
   source_filename = "dbg-stack-value-range.c"
   target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
   
   ; Function Attrs: nounwind uwtable
   define dso_local i32 @foo(i32 %X) local_unnamed_addr #0 !dbg !7 {

llvm/test/DebugInfo/X86/stringpool.ll

 ; RUN: llc -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s --check-prefix=LINUX
 ; RUN: llc -mtriple=x86_64-darwin < %s | FileCheck %s --check-prefix=DARWIN
 
 source_filename = "test/DebugInfo/X86/stringpool.ll"
 
 @yyyy = common global i32 0, align 4, !dbg !0
 
 !llvm.dbg.cu = !{!4}
 !llvm.module.flags = !{!7}
 
 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = !DIGlobalVariable(name: "yyyy", scope: null, file: !2, line: 1, type: !3, isLocal: false, isDefinition: true)
 !2 = !DIFile(filename: "z.c", directory: "/home/nicholas")
 !3 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !4 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 3.1 (trunk 143009)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5)
 !5 = !{}
-; Verify that "yyyy" ended up in the stringpool.
-; LINUX: .section .debug_str,"MS",@progbits,1
-; LINUX: yyyy
-; DARWIN: .section __DWARF,__debug_str,regular,debug
-; DARWIN: .asciz "yyyy" ## string offset=[[YYYY:[0-9]+]]
 
 ; Verify that we refer to 'yyyy' with a relocation.
 ; LINUX:      .long   .Linfo_string3          # DW_AT_name
 ; LINUX-NEXT: .long   {{[0-9]+}}              # DW_AT_type
 ; LINUX-NEXT:                                 # DW_AT_external
 ; LINUX-NEXT: .byte   1                       # DW_AT_decl_file
 ; LINUX-NEXT: .byte   1                       # DW_AT_decl_line
 ; LINUX-NEXT: .byte   9                       # DW_AT_location
 ; LINUX-NEXT: .byte   3
 ; LINUX-NEXT: .quad   yyyy
+; Verify that "yyyy" ended up in the stringpool.
+; LINUX: .section .debug_str,"MS",@progbits,1
+; LINUX: yyyy
 
 ; Verify that we refer to 'yyyy' with a direct offset.
-; DARWIN:             .long   [[YYYY]]
+; DARWIN: .section        __DWARF,__debug_info,regular,debug
+; DARWIN: DW_TAG_variable
+; DARWIN:             .long   [[YYYY:[0-9]+]]
 ; DARWIN-NEXT:        .long   {{[0-9]+}}              ## DW_AT_type
 ; DARWIN-NEXT:                                        ## DW_AT_external
 ; DARWIN-NEXT:        .byte   1                       ## DW_AT_decl_file
 ; DARWIN-NEXT:        .byte   1                       ## DW_AT_decl_line
 ; DARWIN-NEXT:        .byte   9                       ## DW_AT_location
 ; DARWIN-NEXT:        .byte   3
 ; DARWIN-NEXT:        .quad   _yyyy
+; DARWIN: .section __DWARF,__debug_str,regular,debug
+; DARWIN: .asciz "yyyy" ## string offset=[[YYYY]]
 !6 = !{!0}
 !7 = !{i32 1, !"Debug Info Version", i32 3}