[DWARF5] Added support for debug_macro section parsing and dumping in llvm-dwarfdump.

[SouraVX]

Summary

Summary:
This patch adds parsing and dumping DWARFv5 macro section in llvm-dwarfdump, it does not introduce any new switch. Existing "--debug-macro" can be used to dump macinfo/macro section.

[jhenderson]

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

2

Same comments apply in this test as in the previous one.

Also, use single or double dashes consistently for the entire llvm-mc call.

[SouraVX]

Something you may wish to consider is writing the tests as unit tests rather than using dwarfdump to test them, since the code is in a library. It may require a little extra legwork to set up initially (writing dwarf generator code, like there already is for debug info and debug line), but I think there is a decent payoff in return. It'll allow you to avoid the noise that some of these tests have.

Nice suggestion thanks!, but I think that should be taken as a separate exercise. what's your take on this?

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

479

Thanks! for the suggestion here. I've partially tried to address concern related to this also in this inline comment.

These three functions all look very similar..

874

Since these are mostly 5 liner functions handling their cases cleanly as needed, introducing one more function just to reduce 2-3 LOC doesn't sound good idea(personal opinion).
Plus problem in this entire patch(due to code shared by macro/macinfo) is that, you flip one thing and you'll endup modifying everything (handling macro/macinfo, parsing/dumping) just to make sure that existing functionality is not broken.

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

9

emission of DW_FORM_define_strp form is getting checked here. Is this what you're asking ?

31–40

Yes, If Flags in Macro header indicate debug_line_offset is present then it is needed. That's why here.

46

Yes, macinfo section represent this way, If accidentally removed would result in assmbler error.

56–64

Sorry this one is not needed, removed thanks!

[SouraVX]

Addressed review comments by @jhenderson. Thanks a lot for this!

[SouraVX]

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

12

I tried multiple times, but seems like this line is causing the test case to fail when using --strict-whitespace with FileCheck Even though indentation is correct(2 spaces) checked through normal dumping on stdout and by redirecting to a file.
So I temporarily removed --strict-whitespace option. Still digging will update here once done.

[SouraVX]

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

50

In editor it was looking normal *No extra space/character*. I'll check once more.

[SouraVX]

Added descriptive comments in test cases.

[SouraVX]

Addressed @jhenderson comments.
Thanks for this!

[SouraVX]

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

12

Added -strict-whitespace option. Thanks!

[SouraVX]

@ikudrin and @jhenderson I've tried to address most of your comments/concerns. Are you guys Okay with these changes?

[jhenderson]

In D73086#1916681, @SouraVX wrote:

Something you may wish to consider is writing the tests as unit tests rather than using dwarfdump to test them, since the code is in a library. It may require a little extra legwork to set up initially (writing dwarf generator code, like there already is for debug info and debug line), but I think there is a decent payoff in return. It'll allow you to avoid the noise that some of these tests have.

Nice suggestion thanks!, but I think that should be taken as a separate exercise. what's your take on this?

As it could simplify the tests for this, it might be better to do that upfront. You could then keep a basic test to show that llvm-dwarfdump can dump both kinds of sections, but the detail could be tested in the unit tests. I don't feel strongly about it however.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

32

Still missing a blank line between Version and the comment for flags.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

874

The flip side argument is that you'd have to modify 3 functions any time you wanted to change the functionality somehow. It's not really about the number of lines of code. I'm not sure sharing the code is that hard. See semi-pseudo code below.

template <typename DWARFDebugT, typename SectionT>
static Expected<const DWARFDebugT *> getDWARFDebugMacro(
           std::unique_ptr<DWARFDebugT> &MacroPtr,
           SectionT *MacroSec,
           bool LittleEndian,
           bool IsMacro,
           DataExtractor StringExtractor) {
  if (MacroPtr)
    return MacroPtr.get();
  DWARFDataExtractor Data(MacroSec, LittleEndian, 0);
  MacroPtr.reset(new DWARFDebugT());
  if (Error Err = MacroPtr->parse(StringExtractor, Data, IsMacro))
    return std::move(Err);
  return MacroPtr.get();
}

Expected<const DWARFDebugMacro *> DWARFContext::getDebugMacinfoDWO() {
  return getDWARFDebugMacro(MacinfoDWO,
                            DObj->getMacinfoDWOSection(),
                            isLittleEndian(),
                            /*IsMacro=*/false,
                            getStringExtractor());
}

...

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

55–64

I wasn't interested in the quotes. I wanted you to change the comment to match what I posted, so that it is good English!

128

Nit: "FIXME: Add..." (with space after the ':')

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

2–3

In new tests, I try to use '##' to distinguish comments from lit and FileCheck directives.

can dump debug_macro -> can dump both debug_macro
section -> sections
in a single object -> in the same object

5

This hasn't been done.

5

|\ -> | \ for readability

6

I'd add two extra spaces before llvm-dwarfdump to clearly show that it is a continuation of the previous line.

9

I was just confused by the DW_MACRO_define_strp causing an extra two spaces of indentation, that's all. It looks slightly broken when I read it with little prior knowledge of debug_macro sections.

31–40

Okay. I'd guess that you could delete most of the strings, right?

50

Is it using a tab instead of a space in the text. To me, I see:

.byte  1
.ascii  "DWARF_VERSION"

with the first '"' in the second line not lining up with the 1. I guess you've not written this by hand though, so if this is what the assembler produces, it's fine.

56–64

I was also actually referring to the extra strings. It looks like you've got several duplicates that could be deleted?

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

8

# CHECK:.debug_macro contents:

same below for the other CHECK: line.

llvm/test/DebugInfo/X86/unsupported-dwarf64-debug-macro-v5.s

2

Same comments in this test as elsewhere re '##', and line continuations.

3

unsupported case where the DWARF64 flag is present in the debug_macro section header.

7

No real need for strict-whitespace and match-full-lines in this test case. The formatting isn't really important.

llvm/test/DebugInfo/X86/unsupported-opcode_operands_table-debug-macro-v5.s

2

Same comments as in other test cases.

[ikudrin]

We are almost there.

I added comments only for one test file. Please, consider them thoroughly and apply similar adjustments to the other tests.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

85

I suppose it would be useful to add a comment that the value of 0 in Header.Version means that the parsed data is from a .debug_macinfo[.dwo] section and other fields in the Header are uninitialized in that case.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

870

If you call this method twice, and the first call returns an error, the second call will still return some partially parsed DWARFDebugMacro object. This is inconsistent. You should call Macro.reset() before returning an error.

The same for two other similar methods.

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

111

The variable is used only in DW_MACRO_define_strp/DW_MACRO_undef_strp cases. It does not need to preserve the value outside the handler. Thus, why not embrace the body of those cases in braces and move the variable there making it even more local?

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

5

I guess you do not need -dwarf-version=5. It affects the format of the generated .debug_line section, but the parser does not read it and the test does not check anything related to it.

25

You do not need to reference the real line table because it is not used in the parser/dumper. Just use 0 here. And fix the comment.

31–40

Only .Linfo_string3 is used. There are no references to other strings in the file, so they should be removed.

BTW, the comments for the strings are misleading, because all of them except .Linfo_string0 have different offsets than stated.

34

There should be an empty line before .section to improve readability.

43

In fact, this section may be removed because it is not used.

47

Please add comments for this section describing the values, the same way as that is done for .debug_macro.

49

In fact, this definition also does not affect the test and can be removed.

53–56

You may just use .asciz "DWARF_VERSION 4" instead. It is the same but more readable.

59–65

This second .debug_str and all three strings inside it are not needed. Please, remove them.

[SouraVX]

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

9

The spacing/indentation is part of dumping here, reflecting that this macro is defined under DW_MACRO_start_file file.

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

8

Is spacing the you're concerned about here ?

[jhenderson]

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

8

Right. It allows easier reading of the line, because it lines up the actual content being checked with the rest of the content from the subsequent CHECK-NEXT lines.

[SouraVX]

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

53–56

Removing this since macinfo represent info in section itself not in debug_str so this is also un-necessary! Sorry for the confusion caused here.
+ Removing other- duplicate/un-necessary string after scrutinizing.

[SouraVX]

@jhenderson Thanks for sharing pseudo code!
I forgot to mention this thing in our last discussion of refactoring the code shared by macro/macinfo. macro and macinfo are represented differently(due to their contents) to be specific DWARFSection and StringRef explicitly as a result we can't share extract DWARFDataExtractor the using same way. --
DWARFDataExtractor Data(Macinfo, LittleEndian, 0); -- this only works for macinfo
for macro you also need DWARFObject
DWARFDataExtractor MacroData(*DObj, DObj->getMacroSection(), isLittleEndian(), 0); -- only works for macro section.
+ SectionT &MacroSection argument will be const llvm::DWARFSection& -- for macro case
and StringRef --for macinfo case.
code bloating a lot -- psuedo code not compilable, -- sort of need one more extra argument to fetch information from macinfo section (StringRef)

template<typename DWARFDebugT, typename SectionT>
static Expected<const DWARFDebugT*> getDWARFDebugMacro(
                const DWARFObject &DObj,
                std::unique_ptr<DWARFDebugT> &MacroPtr,
                SectionT &MacroSection,
                bool LittleEndian,
                bool IsMacro,
                DataExtractor StringExtractor) {
        if (MacroPtr)
           return MacroPtr.get();
        if (IsMacro) {
        DWARFDataExtractor MacroData(DObj, MacroSection, LittleEndian, 0);
            if (Error Err = MacroPtr->parse(StringExtractor, MacroData, IsMacro)) {
                    Macro.reset();
              return std::move(Err);
            }
        else {
        DWARFDataExtractor MacinfoData(MacroSection, LittleEndian, 0);
        MacroPtr.reset(new DWARFDebugT());
            if (Error Err = MacroPtr->parse(StringExtractor, MacinfoData, IsMacro)) {
                    Macro.reset();
              return std::move(Err);
            }
        return MacroPtr.get();

        }
        }
}

Do you still vote for this ? Please share!

[jhenderson]

This might be a legacy thing, but it looks like DWARFSection is just a wrapper around a StringRef. Could they all use StringRef (or DWARFSection), instead of having some use one and some use the other? That might require an additional change or two, but it seems pointless having the two types to me.

[SouraVX]

In D73086#1921504, @jhenderson wrote:

This might be a legacy thing, but it looks like DWARFSection is just a wrapper around a StringRef. Could they all use StringRef (or DWARFSection), instead of having some use one and some use the other? That might require an additional change or two, but it seems pointless having the two types to me.

The rationale behind putting some section as StringRef and some as DWARFSection is based on relocations macinfo doesn't have relocation macro does have relocations hence (I represented it that way).
DWARFDataExtractor also seems to have different handling(2 constructors) for both cases(relocation and normal cases).
Besides your suggestion to use one common thing(taking StringRef for this case) for both(macro/macinfo) will introduce inconsistency(might also introduce some bugs). Since their are already some sections str line_str and more represented as StringRef while others as DWARFSection.

[SouraVX]

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

8

To avoid same mistakes again, and avoiding confusion -- Following modification you're suggesting -

# CHECK:.debug_macro contents: -- CHECK pattern(1 leading space) in all test cases
should modified be modified with "2" leading spaces in all test cases i.e
# CHECK:debug_macro
and like wise in subsequent CHECK-NEXT ?

[SouraVX]

Addressed @ikudrin and @jhenderson comments!
Removed [WIP] from Title of the revision!

[SouraVX]

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

5

Done!

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

86

parsing a macinfo...
it self -> itself

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

870

This sort of change is exactly why I think we should avoid duplicating the logic in three places. It would have been easy to add it only in one place.

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

3

Still need to do "the same object" instead of "the single object".

3

I don't see a verbose case still?

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

8

Thanks, this bit looks fine now.

llvm/test/DebugInfo/X86/unsupported-opcode_operands_table-debug-macro-v5.s

3

where the opcode_operands_table

[SouraVX]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

86

Is it okay to keep it the way it self or something like "macinfo or macinfo.dwo section".
Since this also covers macinfo.dwo case also. ?

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

3

I think we don't need one "verbose" case, since there is no difference b/w both cases.

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

870

I'm investigating the opportunity you discussed/mentioned in last comment(Thanks for that!) If found with constructive cases, will push a patch or two for review.

[SouraVX]

Addressed nits comments by @jhenderson
Thanks for this!

[ikudrin]

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

39

Remove this .file line. I guess you may expect it to contribute the "File Numer" to this section, but that is not true. It has no influence on the content of this section.

In fact, the byte you described as "DW_MACINFO_define" is the actual file number. The next byte is that directive and the following byte is the line number for the entry. You should know that DW_MACINFO_define does not have an operand for file number.

I guess it would be better to use some different values for the file number and for the line number here to avoid that misinterpretation.

43

You may just use .asciz "DWARF_VERSION 4". It is the same. The fact that the macro string consists of the name, space, and value is not important for this test. And you have not divided the definition for "DWARF_VERSION 5" despite it follows the same rules.

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

32

Not needed for the test. Remove.

llvm/test/DebugInfo/X86/unsupported-dwarf64-debug-macro-v5.s

14

For the consistency, this should be .quad, not .long.

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

870

This sort of change is exactly why I think we should avoid duplicating the logic in three places. It would have been easy to add it only in one place.

Totally agree.

[SouraVX]

Addressed @ikudrin nits comments. Thanks for this!

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

870

I already had discussion with @jhenderson WRT to this in previous revision, highlighted some of the implications https://reviews.llvm.org/D73086#1921493
+ I'm separately investigating that.

[SouraVX]

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

43

And you have not divided the definition for "DWARF_VERSION 5" despite it follows the same rules.

Are you concerned regarding representation ??
DW_MACRO_define_strp forms requires the entire macro and definition(value) "DWARF_VERSION 5" to be kept as a string in debug_str section.
That's what I've done here. Am I missing something here ?

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

86

Sorry, macinfo[.dwo] was fine (I wanted to correct the like of 'a'). Feel free to reinstate that bit.

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

3

Does verbose mode dump at a different time for .debug_macro etc, like the .debug_line code does? If it does, we should probably still have it (but obviously it can share the same checks).

[SouraVX]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

86

Sure will do!

[SouraVX]

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

3

No, Verbose mode isn't part of macro/macinfo since the beginning. I think it's due to nature of it's contents.

[ikudrin]

I am mostly OK with the changes at the moment. Please reach the consent with @jhenderson about code duplication and other topics he mentioned.

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

43

Both strings, "DWARF_VERSION 4" and "DWARF_VERSION 5", are OK now.

48

Remove the comment "string offset=149". It is both useless and misleading. The real offset is 0.

[SouraVX]

In D73086#1926229, @ikudrin wrote:

I am mostly OK with the changes at the moment. Please reach the consent with @jhenderson about code duplication and other topics he mentioned.

Thanks for the consent @ikudrin!
@jhenderson, Are you okay with these changes?

[jhenderson]

In D73086#1926329, @SouraVX wrote:

In D73086#1926229, @ikudrin wrote:

I am mostly OK with the changes at the moment. Please reach the consent with @jhenderson about code duplication and other topics he mentioned.

Thanks for the consent @ikudrin!
@jhenderson, Are you okay with these changes?

You said you'd take a look at removing the duplication. Have you done that yet? That's what I'm waiting on.

[SouraVX]

You said you'd take a look at removing the duplication. Have you done that yet? That's what I'm waiting on.

Oh, Sorry! I think I mentioned that should be taken separately. https://reviews.llvm.org/D73086#1921509

[jhenderson]

In D73086#1926382, @SouraVX wrote:

You said you'd take a look at removing the duplication. Have you done that yet? That's what I'm waiting on.

Oh, Sorry! I think I mentioned that should be taken separately. https://reviews.llvm.org/D73086#1921509

If you want to do it separately, please do it before this patch. This patch makes the situation worse, which is obviously bad.

[SouraVX]

Refactored to remove code duplication.

Hi @jhenderson, @ikudrin, @dblaikie , I've refactored the dumping code to use a single getDWARFDebugMacro function for all dumping related to macro/macinfo. Thus removing all three redundant dumping functions getDebugMacro/Macinfo/MacinfoDWO . Resultant code looks cleaner/uniform.
@jhenderson I've briefly tried to work on https://reviews.llvm.org/D73086#1921509, hitting up multiple issues, Since this is not just macro/macinfo, a whole lot of sections are represented as DWARFSection and StringRef. This invites a huge rework.

[SouraVX]

Refactored static helper function(dumping macro/macinfo/macinfo.dwo) as a member function, making code more concise.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

295–297

Returning a pointer to the parameter seems unnecessarily confusing - just return Error instead of Expected - callers can use the MacroPtr they passed in instead of retrieving the same thing from the return value.

301

Prefer make_unique:

MacroPtr = std::make_unique<DWARFDebugMacro>();

302–308

This probably shouldn't be dynamically allocated either - if DWARFDataExtractor is move constructible, which I guess it should be, then:

DWARFDataExtractor Data = IsMacro ? DWARFDataExtractor(... ) : DWARFDataExtractor(...);

If DWARFDataExtractor can't be move constructible then Optional<DWARFDataExtractor> could be used:

Optional<DWARFDataExtractor> Data;
if (IsMacro)
  Data.emplace(...);
else
  Data.emplace(...);

310–311

This doesn't look like it needs to be dynamically allocated - could it just be:

DWARFDataExtractor DataDWO(Context.getDWARFObj().getMacinfoDWOSection(), IsLittleEndian, 0);

314

Rather than nulling out this pointer - use a local unique_ptr and assign to MacroPtr at the end if no errors have occurred. (safer than trying to remember/make sure all the failure paths undo the work)

[SouraVX]

Addressed refactoring comments by @dblaikie. Thanks for this!
-Returned type changed to Error.
-Since DWARFDataExtractor is move constructible, removed dynamic construction of objects.
-Instead of resetting ptr, used local unique_ptr this will get moved to MacroPtr in case of successful parsing.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

491

This (& similar elsewhere) should be written as "Macinfo->dump(OS)", the ".get()" is redundant.

@jhenderson - did you want to roll the error handling/dumping into the common code too? (looks like the "if/handle/else/dump" could go in the common function (& rename the function to parseAndDump or something) too?

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

491

Should we go ahead with this ?

[jhenderson]

Sorry, I've been quite busy with having about 15-20 different active reviews at once, some of which are not trivial in complexity. It may take me a couple of working days to respond to things.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

297–298

It might make the code nicer if IsDWO and IsMacro are folded into one small enum e.g. MacroSecType. You can then switch on that value, and it also avoids multiple boolean arguments, which are easy to get wrong.

314

It looks to me like @dblaikie wanted the MacroPtr = std::make_unique<DWARFDebugMacro>(); line to be replaced with auto Ptr = std::make_unique<DWARFDebugMacro>(); and only assign to MacroPtr at the end.

If there is an error, then MacroPtr will remain unchanged (i.e. unitialised). This is very similar to having a strong exception safety guarantee in concept, i.e. the state hasn't changed if there's an error.

491

Since this is all within the same library, we can put the recoverable error handler calls inside the function, and simplify the interface further.

@dblaikie's first comment about get though should also be addressed.

[SouraVX]

Addressed comments/suggestion by @jhenderson and @dblaikie. Thanks a lot for this!
-Removed both boolean types and introduced new helper enum MacroSecType. Now content parsing/dumping is based on this enum.
-Simplified interface further by moving Error handling inside function, renamed this function as parseAndDumpMacroMacinfo.

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

290–293

Dump -> dump a

and macinfo -> or macinfo

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

327–329

Comment indentation is slightly off. Might be worth reporting a warning in the case that this is hit?

489

I'm not particularly keen that dumping and parsing happen in the same function. It feels like those are two separate tasks that should be kept independent. Perhaps a small lambda near here instead would make sense to factor out the sequence "parse -> check not null -> dump"?

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

489

Are you suggesting something sort of -
parseMacroOrMacinfo handles parsing and error handling, this can be a member function instead of a lamba for uniformities sake.

if (shouldDump(Explicit, ".debug_macro", DIDT_ID_DebugMacro,
                  DObj->getMacroSection().Data)) {
     parseMacroOrMacinfo(Macro, OS, DumpOpts, /*IsLittleEndian=*/true,
                              dwarf::Macro);
     if (Macro)
     Macro->dump(OS);
   }

I'm okay with this too :)

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

489

Most of the other sections have a pattern of "get/parse" followed by "dump", often in one line, without the error check. I think we should follow that if possible (but with the error check, or possibly by initialising the pointer to some "default" empty section in the event of a failure). In other words, yes, esssentially what you suggested. In particular, this will allow the parsing code to be used and tested independently of the printing.

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

327–329

Before revising this patch, I want to have your opinion on this -
I'm considering removing this case MacroDWO instead of emitting a warning(I'm not against it). But since that part of code case(MacroDWO) will never be hit, since we don't do it explicitly in first place here --

if (shouldDump(Explicit, ".debug_macro.dwo", DIDT_ID_DebugMacro,
                 DObj->getMacroDWOSection()))
parseMacroOrMacinfo(MacroDWO, OS, DumpOpts, /*IsLittleEndian=*/true,
                              dwarf::MacroDWO);

And it's not needed atleast for this patch.
Should I go ahead remove this case and just leave a FIXME?

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

327–329

If the behaviour from prior to your patch is unchanged, I think that's fine to do from my point of view. I wouldn't want to see things regress though.

[SouraVX]

Addressed @jhenderson comments, Thanks a lot for this!

• Refactored the code based on comments.
• Empty case MacroDWO: is still there with FIXME, just for appeasing a build warning warning: enumeration value ‘MacroDWO’ not handled in switch [-Wswitch]
• No regression found after check-all.

FIXME: might still look a bit misplaced(couple of spaces), but clang-format is doing that.

[jhenderson]

LGTM, with one minor suggestion. It might make sense to get one of the other reviewers formal approval before landing this.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

327–329

I think the problem is that you've put the FIXME above the case statement, whereas it should be below it. If you move it to before the break, it'll look right, and it's probably the right place for it:

case dwarf::MacroDWO:
  // FIXME: Add support for debug_macro.dwo section.
  break;

[jhenderson]

In D73086#1940876, @jhenderson wrote:

It might make sense to get one of the other reviewers formal approval before landing this.

Given @ikudrin requested changes earlier, he'll need to approve it for this patch to move to "Approved" state officially, not that it matters that much.

[SouraVX]

In D73086#1940879, @jhenderson wrote:

In D73086#1940876, @jhenderson wrote:

It might make sense to get one of the other reviewers formal approval before landing this.

Given @ikudrin requested changes earlier, he'll need to approve it for this patch to move to "Approved" state officially, not that it matters that much.

Thanks a lot @jhenderson, for investing time in this!
I'll land this after other reviewers @ikudrin and @dblaikie acceptance.

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

327–329

Sure Thanks!
I'll take care of that!

[ikudrin]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

479

I am not sure that Macro as an in-out parameter of a void method is the perfect design. It would be better if parseMacroOrMacinfo() would just return std::unique_ptr<DWARFDebugMacro>. The code here, in that case, will look like:

if (!Macro)
  Macro = parseMacroOrMacinfo(...);
if (Macro)
  Macro->dump(OS);

Much more clear, no?

485–486

Before the patch, isLittleEndian() was used, but now you always pass the constant true. Could you please elaborate, why the behavior has been changed?

[SouraVX]

Addressed comments by @ikudrin Thanks for this!
-made return type std_unique_ptr<DWARFDebugMacro>.
-littleEndian replaced and some cleanup.

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

479

Removed this

if (!Macro)  --this seemed redundant to me since during first parsing of section, this will always be NULL.
  Macro = parseMacroOrMacinfo(...);

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

485–486

Sorry, some how in effort to keeping the code concise this crept in. I've removed this since parseMacroMacinfo is a member function of DWARFContext.

[ikudrin]

llvm/include/llvm/BinaryFormat/Dwarf.h

75 ↗

(On Diff #252858)

I guess that it is better to make this enum private inside DWARFContext.

You may also want to remove MACRODWO because it is used only for an empty ("TODO") case in parseMacroOrMacinfo(). Just remove that empty case and move the "TODO" comment to this enum.

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

276

Maybe I am missing something, but I cannot find the discussion where the removal of these public methods was approved.

getDebugMacinfo() and getDebugMacinfoDWO() should not be removed from the public interface. getDebugMacro() should be added. parseMacroOrMacinfo() should be private and be called from these methods.

[SouraVX]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

276

It was part of effort of removing the redundant code that @jhenderson and you were discussing about https://reviews.llvm.org/D73086#1927338

[SouraVX]

llvm/include/llvm/BinaryFormat/Dwarf.h

75 ↗

(On Diff #252858)

Thanks, I'll take care of that in next revision.

[SouraVX]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

276

@ikudrin While naming parseMacroMacinfo or getMacroMacinfo can still be debatable, but semantically this parseMacroMacinfo function is doing essentially the same thing which these 2 + 1(getDebugMacro) were doing i.e parsing the contents and returning to the caller for dumping the contents.

[ikudrin]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

276

Not exactly. Look from the perspective of a user of the DWARFContext class. Before the patch, they could just call Context->getDebugMacinfo(), but now they need to pass way more arguments, some of which are not that obvious (namely, DumpOpts) and others are references to a private member of DWARFContext (namely, MacroPtr). This is a significant degradation of the public interface of DWARFContext.

[SouraVX]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

276

Thanks for pointing this out! I've drafted a rough patch that does not degrade the existing public interface of DWARFContext and doesn't bloat the code too much.
Here's snippet from that, there will be 3 functions(getDebugMacro/Macinfo/MacinfoDWO) calling parseMacroOrMacinfo for doing the math associated with parsing and error handling.

std::unique_ptr<DWARFDebugMacro> DWARFContext::getDebugMacro() {
   return parseMacroOrMacinfo(Macro, getRecoverableErrorHandler(),
              MACRO);
}

In subsequent dumping code we'll just check for nullptr and dump accordingly.

Macro = getDebugMacro();
   if (Macro)
     Macro->dump(OS);

Could you please share your opinion on this!

[ikudrin]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

276

Almost. The getters should cache the result of parseMacroOrMacinfo() and return raw pointers because unique_ptr transfers ownership.

[SouraVX]

Addressed comments by @ikudrin Thanks for this!
-Replaced the return type to raw pointer. Now no un-necessary transfer of ownership involved here.
-Also changed parseMacroOrMacifo to return const DWARFDebugMacro*, in case of errors this will return nullptr. And subsequently checked while dumping.

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

111–113

Why did you change the naming style of this? LLVM coding standards say that enums should use the same naming scheme as types: https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly.

Also, why the = 1?

114–115

Use C++ style comments, and put this all on one line. Also add missing trailing full stop.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

300

ParseAndDump. This is a (callable) object, not a function.

[SouraVX]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

111–113

Ah Sorry, I renamed them this way, to avoid confusion of naming while calling
parseMacroOrMacinfo(Macro, getRecoverableErrorHandler(), MACRO);

I'll change this as per Coding Standard.

114–115

Ah, seems like clang-formatting is getting in way(maybe due to /**/ style comment), I'll correct it such that clang-format does't put a new line.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

300

Sorry, didn't get what you meant here ?

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

300

Is naming not conforming to standard are you referring here parseAndDump ?

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

300

Right. Lambdas are objects, not functions, and so should follow the variable naming scheme, not the function naming scheme.

[SouraVX]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

111–113

Just want to drop a forward note here since, naming enum also as Macro Macinfoand so forth was colliding with previous definition std::unique_ptr<DWARFDebugMacro> Macro;
error: Macro conflicts with a previous declaration Macro
So I've extended enum names as
MacroSection MacinfoSection MacinfoDwoSection.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

300

Thanks! done locally, we'll wait for @ikudrin before revising this.

[ikudrin]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

287

• Make parseMacroOrMacinfo() private.
• parseMacroOrMacinfo() should return a newly created std::unique_ptr<DWARFDebugMacro>.
• Remove the MacroPtr argument. Caching the result is the responsibility of getters.
• Remove the RecoverableErrorHandler argument. All getters pass the same value, and this method, being a non-static member of the same class, also has access to it.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

485–487

This might be simplified to

if (auto Macinfo = getDebugMacinfo())
  Macinfo->dump(OS);

862–863

The getters should look like

const DWARFDebugMacro *DWARFContext::getDebugMacinfo() {
  if (!Macinfo)
    Macinfo = parseMacroOrMacinfo(MACINFO);
  return Macinfo.get();
}

[SouraVX]

Addressed comments by @jhenderson and @ikudrin Thanks for this!

[ikudrin]

LGTM. Please wait for the comments from @jhenderson and @dblaikie.

[SouraVX]

In D73086#1949559, @ikudrin wrote:

LGTM. Please wait for the comments from @jhenderson and @dblaikie.

Thanks a lot for investing time in this, I'll wait for @jhenderson and @dblaikie. In meantime can you also share some final thoughts on D72828 Mostly it's already reviewed.

[jhenderson]

Latest version looks good to me too.

[SouraVX]

@dblaikie are you Okay with these changes ?

[dblaikie]

I think it's OK - best I can tell at this point, given all the review iterations/comments/etc. *fingers crossed*

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

class DWARFContext : public DIContext {
   std::unique_ptr<DWARFGdbIndex> GdbIndex;
   std::unique_ptr<DWARFUnitIndex> TUIndex;
   std::unique_ptr<DWARFDebugAbbrev> Abbrev;
   std::unique_ptr<DWARFDebugLoc> Loc;
   std::unique_ptr<DWARFDebugAranges> Aranges;
   std::unique_ptr<DWARFDebugLine> Line;
   std::unique_ptr<DWARFDebugFrame> DebugFrame;
   std::unique_ptr<DWARFDebugFrame> EHFrame;
+  std::unique_ptr<DWARFDebugMacro> Macro;
   std::unique_ptr<DWARFDebugMacro> Macinfo;
   std::unique_ptr<DWARFDebugNames> Names;
   std::unique_ptr<AppleAcceleratorTable> AppleNames;
   std::unique_ptr<AppleAcceleratorTable> AppleTypes;
   std::unique_ptr<AppleAcceleratorTable> AppleNamespaces;
   std::unique_ptr<AppleAcceleratorTable> AppleObjC;
 
   DWARFUnitVector DWOUnits;
class DWARFContext : public DIContext {
   /// and type units from the debug_types.dwo section (if necessary)
   /// and store them in DWOUnits.
   /// If \p Lazy is true, set up to parse but don't actually parse them.
   enum { EagerParse = false, LazyParse = true };
   void parseDWOUnits(bool Lazy = false);
 
   std::unique_ptr<const DWARFObject> DObj;
 
+  /// Helper enum to distinguish between macro[.dwo] and macinfo[.dwo]
+  /// section.
+  enum MacroSecType {
+    MacinfoSection,
+    MacinfoDwoSection,
+    MacroSection
+    // FIXME: Add support for.debug_macro.dwo section.
+  };
+
 public:
   DWARFContext(std::unique_ptr<const DWARFObject> DObj,
                std::string DWPName = "",
                std::function<void(Error)> RecoverableErrorHandler =
                    WithColor::defaultErrorHandler,
                std::function<void(Error)> WarningHandler =
                    WithColor::defaultWarningHandler);
   ~DWARFContext();
public:
   const DWARFDebugAranges *getDebugAranges();
 
   /// Get a pointer to the parsed frame information object.
   const DWARFDebugFrame *getDebugFrame();
 
   /// Get a pointer to the parsed eh frame information object.
   const DWARFDebugFrame *getEHFrame();
 
-  /// Get a pointer to the parsed DebugMacro object.
+  /// Get a pointer to the parsed DebugMacinfo information object.
   const DWARFDebugMacro *getDebugMacinfo();
 
-  /// Get a pointer to the parsed dwo DebugMacro object.
+  /// Get a pointer to the parsed DebugMacinfoDWO information object.
   const DWARFDebugMacro *getDebugMacinfoDWO();
 
+  /// Get a pointer to the parsed DebugMacro information object.
+  const DWARFDebugMacro *getDebugMacro();
+
   /// Get a reference to the parsed accelerator table object.
   const DWARFDebugNames &getDebugNames();
 
   /// Get a reference to the parsed accelerator table object.
   const AppleAcceleratorTable &getAppleNames();
 
   /// Get a reference to the parsed accelerator table object.
   const AppleAcceleratorTable &getAppleTypes();
public:
   /// TODO: refactor compile_units() to make this const.
   uint8_t getCUAddrSize();
 
   Triple::ArchType getArch() const {
     return getDWARFObj().getFile()->getArch();
   }
 
 private:
+  /// Parse a macro[.dwo] or macinfo[.dwo] section.
+  std::unique_ptr<DWARFDebugMacro>
+  parseMacroOrMacinfo(MacroSecType SectionType);
+
   /// Return the compile unit which contains instruction with provided
   /// address.
   /// TODO: change input parameter from "uint64_t Address"
   ///       into "SectionedAddress Address"
   DWARFCompileUnit *getCompileUnitForAddress(uint64_t Address);
   void addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram, DWARFDie Die,
                        std::vector<DILocal> &Result);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugMacro.h

 //===- DWARFDebugMacro.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARF_DWARFDEBUGMACRO_H
 #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGMACRO_H
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/DataExtractor.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/WithColor.h"
 #include <cstdint>
 
 namespace llvm {
 
 class raw_ostream;
 
 class DWARFDebugMacro {
+  /// DWARFv5 section 6.3.1 Macro Information Header.
+  enum HeaderFlagMask {
+#define HANDLE_MACRO_FLAG(ID, NAME) MACRO_##NAME = ID,
+#include "llvm/BinaryFormat/Dwarf.def"
+  };
+  struct MacroHeader {
+    /// Macro version information number.
+    uint16_t Version = 0;
+
+    /// The bits of the flags field are interpreted as a set of flags, some of
+    /// which may indicate that additional fields follow. The following flags,
+    /// beginning with the least significant bit, are defined:
+    /// offset_size_flag:
+    ///   If the offset_size_flag is zero, the header is for a 32-bit DWARF
+    ///   format macro section and all offsets are 4 bytes long; if it is one,
+    ///   the header is for a 64-bit DWARF format macro section and all offsets
+    ///   are 8 bytes long.
+    /// debug_line_offset_flag:
+    ///   If the debug_line_offset_flag is one, the debug_line_offset field (see
+    ///   below) is present. If zero, that field is omitted.
+    /// opcode_operands_table_flag:
+    ///   If the opcode_operands_table_flag is one, the opcode_operands_table
+    ///   field (see below) is present. If zero, that field is omitted.
+    uint8_t Flags;
+
+    /// debug_line_offset
+    ///   An offset in the .debug_line section of the beginning of the line
+    ///   number information in the containing compilation unit, encoded as a
+    ///   4-byte offset for a 32-bit DWARF format macro section and an 8-byte
+    ///   offset for a 64-bit DWARF format macro section.
+    uint64_t DebugLineOffset;
+
+    /// Print the macro header from the debug_macro section.
+    void dumpMacroHeader(raw_ostream &OS) const;
+
+    /// Parse the debug_macro header.
+    Error parseMacroHeader(DWARFDataExtractor Data, uint64_t *Offset);
+  };
+
   /// A single macro entry within a macro list.
   struct Entry {
     /// The type of the macro entry.
     uint32_t Type;
     union {
       /// The source line where the macro is defined.
       uint64_t Line;
       /// Vendor extension constant value.
       uint64_t ExtConstant;
     };
 
     union {
       /// The string (name, value) of the macro entry.
       const char *MacroStr;
       // An unsigned integer indicating the identity of the source file.
       uint64_t File;
       /// Vendor extension string.
       const char *ExtStr;
     };
   };
 
   struct MacroList {
+    // A value 0 in the `Header.Version` field indicates that we're parsing
+    // a macinfo[.dwo] section which doesn't have header itself, hence
+    // for that case other fields in the `Header` are uninitialized.
+    MacroHeader Header;
     SmallVector<Entry, 4> Macros;
     uint64_t Offset;
   };
 
   /// A list of all the macro entries in the debug_macinfo section.
   std::vector<MacroList> MacroLists;
 
 public:
   DWARFDebugMacro() = default;
 
-  /// Print the macro list found within the debug_macinfo section.
+  /// Print the macro list found within the debug_macinfo/debug_macro section.
   void dump(raw_ostream &OS) const;
 
-  /// Parse the debug_macinfo section accessible via the 'data' parameter.
-  void parse(DataExtractor data);
+  /// Parse the debug_macinfo/debug_macro section accessible via the 'Data'
+  /// parameter.
+  Error parse(DataExtractor StringExtractor, DWARFDataExtractor Data,
+              bool IsMacro);
 
   /// Return whether the section has any entries.
   bool empty() const { return MacroLists.empty(); }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGMACRO_H

llvm/include/llvm/DebugInfo/DWARF/DWARFObject.h

public:
   virtual StringRef getArangesSection() const { return ""; }
   virtual const DWARFSection &getFrameSection() const { return Dummy; }
   virtual const DWARFSection &getEHFrameSection() const { return Dummy; }
   virtual const DWARFSection &getLineSection() const { return Dummy; }
   virtual StringRef getLineStrSection() const { return ""; }
   virtual StringRef getStrSection() const { return ""; }
   virtual const DWARFSection &getRangesSection() const { return Dummy; }
   virtual const DWARFSection &getRnglistsSection() const { return Dummy; }
+  virtual const DWARFSection &getMacroSection() const { return Dummy; }
   virtual StringRef getMacinfoSection() const { return ""; }
   virtual StringRef getMacinfoDWOSection() const { return ""; }
   virtual const DWARFSection &getPubnamesSection() const { return Dummy; }
   virtual const DWARFSection &getPubtypesSection() const { return Dummy; }
   virtual const DWARFSection &getGnuPubnamesSection() const { return Dummy; }
   virtual const DWARFSection &getGnuPubtypesSection() const { return Dummy; }
   virtual const DWARFSection &getStrOffsetsSection() const { return Dummy; }
   virtual void

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
         break;
       Offset = TableOffset + Length;
     } else {
       Rnglists.dump(OS, LookupPooledAddress, DumpOpts);
     }
   }
 }
 
+std::unique_ptr<DWARFDebugMacro>
+DWARFContext::parseMacroOrMacinfo(MacroSecType SectionType) {
+  auto Macro = std::make_unique<DWARFDebugMacro>();
+  auto ParseAndDump = [&](DWARFDataExtractor &Data, bool IsMacro) {
+    if (Error Err = Macro->parse(getStringExtractor(), Data, IsMacro)) {
+      RecoverableErrorHandler(std::move(Err));
+      Macro = nullptr;
+    }
+  };
+  switch (SectionType) {
+  case MacinfoSection: {
+    DWARFDataExtractor Data(DObj->getMacinfoSection(), isLittleEndian(), 0);
+    ParseAndDump(Data, /*IsMacro=*/false);
+    break;
+  }
+  case MacinfoDwoSection: {
+    DWARFDataExtractor Data(DObj->getMacinfoDWOSection(), isLittleEndian(), 0);
+    ParseAndDump(Data, /*IsMacro=*/false);
+    break;
+  }
+  case MacroSection: {
+    DWARFDataExtractor Data(*DObj, DObj->getMacroSection(), isLittleEndian(),
+                            0);
+    ParseAndDump(Data, /*IsMacro=*/true);
+    break;
+  }
+  }
+  return std::move(Macro);
+}
+
 static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
                                 DWARFDataExtractor Data,
                                 const MCRegisterInfo *MRI,
                                 const DWARFObject &Obj,
                                 Optional<uint64_t> DumpOffset) {
   uint64_t Offset = 0;
 
   while (Data.isValidOffset(Offset)) {
     DWARFListTableHeader Header(".debug_loclists", "locations");
     if (Error E = Header.extract(Data, &Offset)) {
       DumpOpts.RecoverableErrorHandler(std::move(E));
       return;
     }
static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
   }
 }
 
 void DWARFContext::dump(
     raw_ostream &OS, DIDumpOptions DumpOpts,
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
   uint64_t DumpType = DumpOpts.DumpType;
 
   StringRef Extension = sys::path::extension(DObj->getFileName());
   bool IsDWO = (Extension == ".dwo") || (Extension == ".dwp");
 
   // Print UUID header.
   const auto *ObjFile = DObj->getFile();
   if (DumpType & DIDT_UUID)
     dumpUUID(OS, *ObjFile);
 
   // Print a header for each explicitly-requested section.
void DWARFContext::dump(
   if (const auto *Off = shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
                                    DObj->getFrameSection().Data))
     getDebugFrame()->dump(OS, getRegisterInfo(), *Off);
 
   if (const auto *Off = shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
                                    DObj->getEHFrameSection().Data))
     getEHFrame()->dump(OS, getRegisterInfo(), *Off);
 
+  if (shouldDump(Explicit, ".debug_macro", DIDT_ID_DebugMacro,
+                 DObj->getMacroSection().Data)) {
+    if (auto Macro = getDebugMacro())
+      Macro->dump(OS);
+  }
+
   if (shouldDump(Explicit, ".debug_macinfo", DIDT_ID_DebugMacro,
                  DObj->getMacinfoSection())) {
-    getDebugMacinfo()->dump(OS);
+    if (auto Macinfo = getDebugMacinfo())
+      Macinfo->dump(OS);
   }
 
   if (shouldDump(Explicit, ".debug_macinfo.dwo", DIDT_ID_DebugMacro,
                  DObj->getMacinfoDWOSection())) {
-    getDebugMacinfoDWO()->dump(OS);
+    if (auto MacinfoDWO = getDebugMacinfoDWO())
+      MacinfoDWO->dump(OS);
   }
 
   if (shouldDump(Explicit, ".debug_aranges", DIDT_ID_DebugAranges,
                  DObj->getArangesSection())) {
     uint64_t offset = 0;
     DWARFDataExtractor arangesData(DObj->getArangesSection(), isLittleEndian(),
                                    0);
     DWARFDebugArangeSet set;
if (EHFrame)
     return EHFrame.get();
 
   DWARFDataExtractor debugFrameData(*DObj, DObj->getEHFrameSection(),
                                     isLittleEndian(), DObj->getAddressSize());
   DebugFrame.reset(new DWARFDebugFrame(getArch(), true /* IsEH */));
   DebugFrame->parse(debugFrameData);
   return DebugFrame.get();
 }
 
-const DWARFDebugMacro *DWARFContext::getDebugMacinfoDWO() {
-  if (MacinfoDWO)
-    return MacinfoDWO.get();
-
-  DataExtractor MacinfoDWOData(DObj->getMacinfoDWOSection(), isLittleEndian(),
-                               0);
-  MacinfoDWO.reset(new DWARFDebugMacro());
-  MacinfoDWO->parse(MacinfoDWOData);
-  return MacinfoDWO.get();
+const DWARFDebugMacro *DWARFContext::getDebugMacro() {
+  if (!Macro)
+    Macro = parseMacroOrMacinfo(MacroSection);
+  return Macro.get();
 }
 
 const DWARFDebugMacro *DWARFContext::getDebugMacinfo() {
-  if (Macinfo)
-    return Macinfo.get();
+  if (!Macinfo)
+    Macinfo = parseMacroOrMacinfo(MacinfoSection);
+}
 
-  DataExtractor MacinfoData(DObj->getMacinfoSection(), isLittleEndian(), 0);
-  Macinfo.reset(new DWARFDebugMacro());
-  Macinfo->parse(MacinfoData);
-  return Macinfo.get();
+const DWARFDebugMacro *DWARFContext::getDebugMacinfoDWO() {
+  if (!MacinfoDWO)
+    MacinfoDWO = parseMacroOrMacinfo(MacinfoDwoSection);
+  return MacinfoDWO.get();
 }
 
 template <typename T>
 static T &getAccelTable(std::unique_ptr<T> &Cache, const DWARFObject &Obj,
                         const DWARFSection &Section, StringRef StringSection,
                         bool IsLittleEndian) {
   if (Cache)
     return *Cache;
   DWARFDataExtractor AccelSection(Obj, Section, IsLittleEndian, 0);
   DataExtractor StrData(StringSection, IsLittleEndian, 0);
   Cache.reset(new T(AccelSection, StrData));
class DWARFObjInMemory final : public DWARFObject {
   DWARFSectionMap AppleTypesSection;
   DWARFSectionMap AppleNamespacesSection;
   DWARFSectionMap AppleObjCSection;
   DWARFSectionMap NamesSection;
   DWARFSectionMap PubnamesSection;
   DWARFSectionMap PubtypesSection;
   DWARFSectionMap GnuPubnamesSection;
   DWARFSectionMap GnuPubtypesSection;
+  DWARFSectionMap MacroSection;
 
   DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
     return StringSwitch<DWARFSectionMap *>(Name)
         .Case("debug_loc", &LocSection)
         .Case("debug_loclists", &LoclistsSection)
         .Case("debug_loclists.dwo", &LoclistsDWOSection)
         .Case("debug_line", &LineSection)
         .Case("debug_frame", &FrameSection)
return StringSwitch<DWARFSectionMap *>(Name)
         .Case("debug_pubnames", &PubnamesSection)
         .Case("debug_pubtypes", &PubtypesSection)
         .Case("debug_gnu_pubnames", &GnuPubnamesSection)
         .Case("debug_gnu_pubtypes", &GnuPubtypesSection)
         .Case("apple_types", &AppleTypesSection)
         .Case("apple_namespaces", &AppleNamespacesSection)
         .Case("apple_namespac", &AppleNamespacesSection)
         .Case("apple_objc", &AppleObjCSection)
+        .Case("debug_macro", &MacroSection)
         .Default(nullptr);
   }
 
   StringRef AbbrevSection;
   StringRef ArangesSection;
   StringRef StrSection;
   StringRef MacinfoSection;
   StringRef MacinfoDWOSection;
const DWARFSection &getEHFrameSection() const override {
     return EHFrameSection;
   }
   const DWARFSection &getLineSection() const override { return LineSection; }
   StringRef getStrSection() const override { return StrSection; }
   const DWARFSection &getRangesSection() const override { return RangesSection; }
   const DWARFSection &getRnglistsSection() const override {
     return RnglistsSection;
   }
+  const DWARFSection &getMacroSection() const override { return MacroSection; }
   StringRef getMacinfoSection() const override { return MacinfoSection; }
   StringRef getMacinfoDWOSection() const override { return MacinfoDWOSection; }
   const DWARFSection &getPubnamesSection() const override { return PubnamesSection; }
   const DWARFSection &getPubtypesSection() const override { return PubtypesSection; }
   const DWARFSection &getGnuPubnamesSection() const override {
     return GnuPubnamesSection;
   }
   const DWARFSection &getGnuPubtypesSection() const override {

llvm/lib/DebugInfo/DWARF/DWARFDebugMacro.cpp

 //===- DWARFDebugMacro.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 
 using namespace llvm;
 using namespace dwarf;
 
+void DWARFDebugMacro::MacroHeader::dumpMacroHeader(raw_ostream &OS) const {
+  // FIXME: Add support for dumping opcode_operands_table
+  OS << format("macro header: version = 0x%04" PRIx16 ", flags = 0x%02" PRIx8,
+               Version, Flags);
+  if (Flags & MACRO_DEBUG_LINE_OFFSET)
+    OS << format(", debug_line_offset = 0x%04" PRIx64 "\n", DebugLineOffset);
+  else
+    OS << "\n";
+}
+
 void DWARFDebugMacro::dump(raw_ostream &OS) const {
   unsigned IndLevel = 0;
   for (const auto &Macros : MacroLists) {
     OS << format("0x%08" PRIx64 ":\n", Macros.Offset);
+    if (Macros.Header.Version >= 5)
+      Macros.Header.dumpMacroHeader(OS);
     for (const Entry &E : Macros.Macros) {
       // There should not be DW_MACINFO_end_file when IndLevel is Zero. However,
       // this check handles the case of corrupted ".debug_macinfo" section.
       if (IndLevel > 0)
         IndLevel -= (E.Type == DW_MACINFO_end_file);
       // Print indentation.
       for (unsigned I = 0; I < IndLevel; I++)
         OS << "  ";
       IndLevel += (E.Type == DW_MACINFO_start_file);
-
+      // Based on which version we are handling choose appropriate macro forms.
+      if (Macros.Header.Version >= 5)
+        WithColor(OS, HighlightColor::Macro).get() << MacroString(E.Type);
+      else
         WithColor(OS, HighlightColor::Macro).get() << MacinfoString(E.Type);
       switch (E.Type) {
       default:
-        // Got a corrupted ".debug_macinfo" section (invalid macinfo type).
+        // Got a corrupted ".debug_macinfo/.debug_macro" section (invalid
+        // macinfo type).
         break;
-      case DW_MACINFO_define:
-      case DW_MACINFO_undef:
+        // debug_macro and debug_macinfo share some common encodings.
+        // DW_MACRO_define     == DW_MACINFO_define
+        // DW_MACRO_undef      == DW_MACINFO_undef
+        // DW_MACRO_start_file == DW_MACINFO_start_file
+        // DW_MACRO_end_file   == DW_MACINFO_end_file
+        // For readability/uniformity we are using DW_MACRO_*.
+      case DW_MACRO_define:
+      case DW_MACRO_undef:
+      case DW_MACRO_define_strp:
+      case DW_MACRO_undef_strp:
         OS << " - lineno: " << E.Line;
         OS << " macro: " << E.MacroStr;
         break;
-      case DW_MACINFO_start_file:
+      case DW_MACRO_start_file:
         OS << " - lineno: " << E.Line;
         OS << " filenum: " << E.File;
         break;
-      case DW_MACINFO_end_file:
+      case DW_MACRO_end_file:
         break;
       case DW_MACINFO_vendor_ext:
         OS << " - constant: " << E.ExtConstant;
         OS << " string: " << E.ExtStr;
         break;
       }
       OS << "\n";
     }
   }
 }
 
-void DWARFDebugMacro::parse(DataExtractor data) {
+Error DWARFDebugMacro::parse(DataExtractor StringExtractor,
+                             DWARFDataExtractor Data, bool IsMacro) {
   uint64_t Offset = 0;
   MacroList *M = nullptr;
-  while (data.isValidOffset(Offset)) {
+  while (Data.isValidOffset(Offset)) {
     if (!M) {
       MacroLists.emplace_back();
       M = &MacroLists.back();
       M->Offset = Offset;
+      if (IsMacro) {
+        auto Err = M->Header.parseMacroHeader(Data, &Offset);
+        if (Err)
+          return std::move(Err);
+      }
     }
     // A macro list entry consists of:
     M->Macros.emplace_back();
     Entry &E = M->Macros.back();
     // 1. Macinfo type
-    E.Type = data.getULEB128(&Offset);
+    E.Type = Data.getULEB128(&Offset);
 
     if (E.Type == 0) {
-      // Reached end of a ".debug_macinfo" section contribution.
+      // Reached end of a ".debug_macinfo/debug_macro" section contribution.
       M = nullptr;
       continue;
     }
 
     switch (E.Type) {
     default:
       // Got a corrupted ".debug_macinfo" section (invalid macinfo type).
       // Push the corrupted entry to the list and halt parsing.
       E.Type = DW_MACINFO_invalid;
-      return;
-    case DW_MACINFO_define:
-    case DW_MACINFO_undef:
+      return Error::success();
+    // debug_macro and debug_macinfo share some common encodings.
+    // DW_MACRO_define     == DW_MACINFO_define
+    // DW_MACRO_undef      == DW_MACINFO_undef
+    // DW_MACRO_start_file == DW_MACINFO_start_file
+    // DW_MACRO_end_file   == DW_MACINFO_end_file
+    // For readibility/uniformity we are using DW_MACRO_*.
+    case DW_MACRO_define:
+    case DW_MACRO_undef:
       // 2. Source line
-      E.Line = data.getULEB128(&Offset);
+      E.Line = Data.getULEB128(&Offset);
       // 3. Macro string
-      E.MacroStr = data.getCStr(&Offset);
+      E.MacroStr = Data.getCStr(&Offset);
       break;
-    case DW_MACINFO_start_file:
+    case DW_MACRO_define_strp:
+    case DW_MACRO_undef_strp: {
+      uint64_t StrOffset = 0;
       // 2. Source line
-      E.Line = data.getULEB128(&Offset);
+      E.Line = Data.getULEB128(&Offset);
+      // 3. Macro string
+      // FIXME: Add support for DWARF64
+      StrOffset = Data.getRelocatedValue(/*OffsetSize=*/4, &Offset);
+      E.MacroStr = StringExtractor.getCStr(&StrOffset);
+      break;
+    }
+    case DW_MACRO_start_file:
+      // 2. Source line
+      E.Line = Data.getULEB128(&Offset);
       // 3. Source file id
-      E.File = data.getULEB128(&Offset);
+      E.File = Data.getULEB128(&Offset);
       break;
-    case DW_MACINFO_end_file:
+    case DW_MACRO_end_file:
       break;
     case DW_MACINFO_vendor_ext:
       // 2. Vendor extension constant
-      E.ExtConstant = data.getULEB128(&Offset);
+      E.ExtConstant = Data.getULEB128(&Offset);
       // 3. Vendor extension string
-      E.ExtStr = data.getCStr(&Offset);
+      E.ExtStr = Data.getCStr(&Offset);
       break;
     }
   }
+  return Error::success();
+}
+
+Error DWARFDebugMacro::MacroHeader::parseMacroHeader(DWARFDataExtractor Data,
+                                                     uint64_t *Offset) {
+  Version = Data.getU16(Offset);
+  uint8_t FlagData = Data.getU8(Offset);
+  // FIXME: Add support for DWARF64
+  if (FlagData & MACRO_OFFSET_SIZE)
+    return createStringError(errc::not_supported, "DWARF64 is not supported");
+
+  // FIXME: Add support for parsing opcode_operands_table
+  if (FlagData & MACRO_OPCODE_OPERANDS_TABLE)
+    return createStringError(errc::not_supported,
+                             "opcode_operands_table is not supported");
+  Flags = FlagData;
+  if (Flags & MACRO_DEBUG_LINE_OFFSET)
+    DebugLineOffset = Data.getU32(Offset);
+  return Error::success();
 }

llvm/test/DebugInfo/X86/debug-macro-macinfo.s

+## This test checks that llvm-dwarfdump can dump both debug_macro and debug_macinfo
+## sections present in the same object.
+
+# RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
+# RUN:   llvm-dwarfdump -debug-macro - | FileCheck -strict-whitespace -match-full-lines %s
+
+#      CHECK:.debug_macro contents:
+# CHECK-NEXT:0x00000000:
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
+# CHECK-NEXT:DW_MACRO_start_file - lineno: 0 filenum: 0
+# CHECK-NEXT:  DW_MACRO_define_strp - lineno: 1 macro: DWARF_VERSION 5
+# CHECK-NEXT:DW_MACRO_end_file
+
+#      CHECK:.debug_macinfo contents:
+# CHECK-NEXT:0x00000000:
+# CHECK-NEXT:DW_MACINFO_start_file - lineno: 0 filenum: 2
+# CHECK-NEXT:  DW_MACINFO_define - lineno: 6 macro: DWARF_VERSION 4
+# CHECK-NEXT:DW_MACINFO_end_file
+
+  .section  .debug_macro,"",@progbits
+.Lcu_macro_begin0:
+  .short  5                      # Macro information version
+  .byte 2                       # Flags: 32 bit, debug_line_offset present
+  .long 0                       # debug_line_offset
+  .byte 3                       # DW_MACRO_start_file
+  .byte 0                       # Line Number
+  .byte 0                       # File Number
+  .byte 5                       # DW_MACRO_define_strp
+  .byte 1                       # Line Number
+  .long .Linfo_string0          # Macro String
+  .byte 4                       # DW_MACRO_end_file
+  .byte 0                       # End Of Macro List Mark
+
+  .section  .debug_macinfo,"",@progbits
+.Lcu_macro_begin1:
+  .byte 3                       # DW_MACINFO_start_file
+  .byte 0                       # Line Number
+  .byte 2                       # File Number
+  .byte 1                       # DW_MACINFO_define
+  .byte 6                       # Line Number
+  .asciz  "DWARF_VERSION 4"      # Macro String
+  .byte 4                       # DW_MACINFO_end_file
+  .byte 0                       # End Of Macro List Mark
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "DWARF_VERSION 5"

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

+## This test checks llvm-dwarfdump can dump debug_macro section containing
+## multiple macro units.
+
+# RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
+# RUN:   llvm-dwarfdump -debug-macro - | FileCheck -strict-whitespace -match-full-lines %s
+
+#      CHECK:.debug_macro contents:
+# CHECK-NEXT:0x00000000:
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x02, debug_line_offset = 0x0000
+# CHECK-NEXT:DW_MACRO_start_file - lineno: 0 filenum: 0
+# CHECK-NEXT:  DW_MACRO_start_file - lineno: 1 filenum: 6
+# CHECK-NEXT:    DW_MACRO_define_strp - lineno: 1 macro: FOO 5
+# CHECK-NEXT:  DW_MACRO_end_file
+# CHECK-NEXT:  DW_MACRO_undef_strp - lineno: 8 macro: WORLD1
+# CHECK-NEXT:DW_MACRO_end_file
+
+#      CHECK:0x{{.*}}:
+# CHECK-NEXT:macro header: version = 0x0005, flags = 0x00
+# CHECK-NEXT:DW_MACRO_define_strp - lineno: 0 macro: WORLD 2
+
+  .section  .debug_macro,"",@progbits
+.Lcu_macro_begin0:
+  .short  5                      # Macro information version
+  .byte 2                       # Flags: 32 bit, debug_line_offset present
+  .long 0                       # debug_line_offset
+  .byte 3                       # DW_MACRO_start_file
+  .byte 0                       # Line Number
+  .byte 0                       # File Number
+  .byte 3                       # DW_MACRO_start_file
+  .byte 1                       # Line Number
+  .byte 6                       # File Number
+  .byte 5                       # DW_MACRO_define_strp
+  .byte 1                       # Line Number
+  .long .Linfo_string0          # Macro String
+  .byte 4                       # DW_MACRO_end_file
+  .byte 6                       # DW_MACRO_undef_strp
+  .byte 8                       # Line Number
+  .long .Linfo_string1          # Macro String
+  .byte 4                       # DW_MACRO_end_file
+  .byte 0                       # End Of Macro List Mark
+  .short  5                      # Macro information version
+  .byte 0                       # Flags: 32 bit
+  .byte 5                       # DW_MACRO_define_strp
+  .byte 0                       # Line Number
+  .long .Linfo_string2          # Macro String
+  .byte 0                       # End Of Macro List Mark
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "FOO 5"
+.Linfo_string1:
+  .asciz  "WORLD1"
+.Linfo_string2:
+  .asciz  "WORLD 2"

llvm/test/DebugInfo/X86/unsupported-dwarf64-debug-macro-v5.s

+## This test checks llvm-dwarfdump emits correct error diagnostics for the
+## unsupported case where DWARF64 flag is present in the debug_macro section header.
+
+# RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
+# RUN:   not llvm-dwarfdump -debug-macro - /dev/null 2>&1 | FileCheck %s
+
+# CHECK:error: DWARF64 is not supported
+
+  .section  .debug_macro,"",@progbits
+.Lcu_macro_begin0:
+  .short  5                      # Macro information version
+  .byte 3                       # Flags: 64 bit, debug_line_offset present
+  .quad 0                       # debug_line_offset

llvm/test/DebugInfo/X86/unsupported-opcode_operands_table-debug-macro-v5.s

+## This test checks llvm-dwarfdump emits correct error diagnostics for the
+## unsupported case where the opcode_operands_table flag is present in the
+## debug_macro section header.
+
+# RUN: llvm-mc -triple x86_64-unknown-linux -filetype=obj %s -o -| \
+# RUN:   not llvm-dwarfdump -debug-macro - /dev/null 2>&1 | FileCheck %s
+
+# CHECK:error: opcode_operands_table is not supported
+
+  .section  .debug_macro,"",@progbits
+.Lcu_macro_begin0:
+  .short  5                      # Macro information version
+  .byte 4                       # Flags: 32 bit, debug_line_offset absent, opcode_operands_table present