[Debug-Info][XCOFF] support dwarf for XCOFF for assembly output

[shchenz]

Summary

This patch supports dwarf debugging info for XCOFF format when clang generates an assembly output. Object output will be handled in followup patches.

Since I can not get the assembly file been assembled, I verify the debug info by checking the assembly files.

I have done some testing in debugger on the AIX system, this patch works well for some cases at 32-bit XCOFF.

[hubert.reinterpretcast]

llvm/lib/MC/MCDwarf.cpp

483–485

Same replacement as elsewhere.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCAsmInfo.cpp

70

Use more conservative formatting from PPCELFMCAsmInfo.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2342–2343

Minor nit: add missing "the".

[shchenz]

Thanks for your comments @ikudrin and @hubert.reinterpretcast . I am still working on addressing your comments. I have posted D95931 and D95932.

I still need at least two patches to avoid the streamer type check in general code:
1: in lib/MC/MCDwarf.cpp, maybe we should also use emitDwarfUnitLength for debug line length;
2: in lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp, like Igor suggested, we may need to use MCTargetStreamer, not very sure for now.

[shchenz]

address @ikudrin and @hubert.reinterpretcast comments:
1: don't check streamer type in general codes.
2: use .set for debug line reference across sections.
3: group csect properties and make them optional when create a new xcoff section.
4: format fix.

[shchenz]

llvm/include/llvm/MC/MCSectionXCOFF.h

51–53

Good idea. I created one NFC patch D95931

llvm/include/llvm/MC/MCStreamer.h

1086

good catch.

llvm/lib/MC/MCDwarf.cpp

487

Thanks for your high-level comments. Indeed, checking the streamer type inside general debug code makes no sense. I have updated them according to your comments.

[shchenz]

1: rebase due to update in D95998

[MaskRay]

in assembly path

I was a bit confused by this term. You may just use MCAsmStreamer.

Hi, I have followed some part of the patch, mainly related to MCDwarfLineEntry::Make. Can you please explain a bit why .file/.loc cannot be used for assembler output?
If you have desire to implement .file/.loc for integrated assemblers, you will not need alternative paths to .file/.loc .
If you have other tools and they cannot consume .file/.loc, please make it clear.

llvm/include/llvm/MC/MCDwarf.h

176

Make it lowercase BTW.

314

Make it lowercase

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

405

The report_fatal_error only triggers if DwarfVersion < 3. I think the driver and llvm-mc should surface the error and essentially make this line unreachable: then due to whether we have an error subsequently, this report_fatal_error may not be needed.

llvm/lib/MC/MCAsmStreamer.cpp

1443

This can be combined with the previous if. The comment can be added below, along the lines of: For a new file, print a .file directive if the target supports it.

1469

Drop this line - which is untested.

Does XCOFF support DWARF v5? MCObjectFileInfo does not have them. The binary format seems to hard code some section type values.

1490

Make is a no-op here.

llvm/lib/MC/MCObjectFileInfo.cpp

914

/*MultiSymbolsAllowed=*/true or /* MultiSymbolsAllowed */ true

llvm/test/DebugInfo/XCOFF/empty.ll

172

Is .ascii or .asciz available?

[shchenz]

address @MaskRay comments

[shchenz]

In D95518#2553303, @MaskRay wrote:

in assembly path

I was a bit confused by this term. You may just use MCAsmStreamer.

Hi, I have followed some part of the patch, mainly related to MCDwarfLineEntry::Make. Can you please explain a bit why .file/.loc cannot be used for assembler output?
If you have desire to implement .file/.loc for integrated assemblers, you will not need alternative paths to .file/.loc .
If you have other tools and they cannot consume .file/.loc, please make it clear.

Yes, the reason we need to populate the .dwline section with raw data on AIX is AIX assembler does not support .file/.loc directives. But it should be easy to switch back to the .file/.loc way by modifying the flag value UsesDwarfFileAndLocDirectives.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

405

Could you help to point out the places that checks DWARF64 and dwarf version 3? As I tested, there is no error if I compile with clang -m64 -gdwarf-2 t.c on AIX without the new added report_fatal_error.

llvm/lib/MC/MCAsmStreamer.cpp

1469

Yes, currently the debug sections are hardcoded and it is not able to support DWARF v5. But we are going to (partly) support it in the near future. So I prefer to keep it here.

llvm/test/DebugInfo/XCOFF/empty.ll

172

These two directives are not supported by AIX assembler. https://www.ibm.com/support/knowledgecenter/ssw_aix_72/assembler/idalangref_pseudo_ops_oview.html

BTW, do we have any control option to use .ascii/.asciz

[shchenz]

1: rebase due to change in D94668

[shchenz]

1: rebase due to change in D95998

[jmorse]

Drive by comment,

Object output will be handled in followup patches.

[...]

Since I can not get the assembly file been assembled, I verify the debug info by checking the assembly files.

When support for object emission is added, please translate the empty.ll into an object + llvm-dwarfdump test. Testing the assembly output is fine for the short-term, but in the long term it causes a lot of needless test changes. The NVPTX debug-info tests are all assembly output, and they create an extra burden.

llvm/test/DebugInfo/XCOFF/empty.ll

19

NB: we usually delete any un-necessary attributes (normally all of them) for debug-info tests, as they're otherwise a needless maintenance burden.

[hubert.reinterpretcast]

In D95518#2556452, @jmorse wrote:

Drive by comment,

Object output will be handled in followup patches.

[...]

Since I can not get the assembly file been assembled, I verify the debug info by checking the assembly files.

I think this shifts the context of the quoted text. The second part of the quoted text says that we cannot use llvm-dwarfdump to test the assembly output because an assembler that reads the assembly is not available in all LLVM build environments. The quoted text is not meant to say that the checking of the assembly is a temporary situation only until object output is added.

When support for object emission is added, please translate the empty.ll into an object + llvm-dwarfdump test. Testing the assembly output is fine for the short-term, but in the long term it causes a lot of needless test changes. The NVPTX debug-info tests are all assembly output, and they create an extra burden.

The XCOFF object output for 64-bit is some ways off. Assembly output checking will be around for some time. In any case, the assembly output should not be completely untested.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

405

I agree the Clang driver at least should produce a friendly error message for this; however, there is not a closed set of users of LLVM as a library, so the report_fatal_error is still appropriate to have.

[shchenz]

1: update due to change in D95931
2: delete the function attributes in the test file

[shchenz]

Thanks for review @jmorse and thanks for explanation @hubert.reinterpretcast

Yes, we still have some work to do for object output for XCOFF 64-bit. So before that is done, we have to test the assembly output for debug infos.
Also yes, I plan to add llvm-dwarfdump test for the newly added empty.ll when I post the object output support for DWARF of XCOFF.

llvm/test/DebugInfo/XCOFF/empty.ll

19

Good idea. Thanks for reminder.

[shchenz]

1: update due to change in D96641 and D95931

[shchenz]

1: rebase due to change in parent patch D96409

[shchenz]

1: typo fix

[shchenz]

1: update due to change in D96409

[shchenz]

1: rebase
2: update due to change in D96409 & D95998

[shchenz]

1: update due to change in D96409 and D95998

[shchenz]

1: make sure what we end is the .text section

[shchenz]

gentle [e-mail]

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCContext.h

276–278

The formulation of the class should fundamentally ensure that the csects and debug sections do not happen to share the same key. I don't think we should rely on the particular numeric values for that.

286–293

Add a new constructor instead of making the existing one less specific.

295–302

Suggested corresponding update.

600–606

Use Optional with a suitable enumeration type.

llvm/include/llvm/MC/MCSectionXCOFF.h

38

Same comment re: using Optional.

44–48

This is the constructor used for csects.

62–67

Suggested corresponding change.

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCSectionXCOFF.h

109

Suggested corresponding change.

llvm/lib/MC/MCAsmStreamer.cpp

1435–1440

The comment only covers half the condition? That makes reading this confusing.

llvm/lib/MC/MCContext.cpp

686–690

Don't use the {} initialization for XCOFFSectionKey now that its constructors are more complicated.

llvm/lib/MC/MCSymbolXCOFF.cpp

16–18

This function (as named) is for csects. The assert should stay or some more extensive changes are needed.

30–32

This function (as named) is for csects. The assert should stay or some more extensive changes are needed.

[hubert.reinterpretcast]

llvm/test/DebugInfo/XCOFF/empty.ll

76–78

See comment about the size of the traceback table and the resulting alignment consequences.

277–279

Because the size of the traceback table is not a guaranteed to be a multiple of 4 (here it is 22 bytes), I think it may be more conservative to actually emit these labels immediately after the last code instruction (although it seems neither GCC nor XL on AIX do that). Alternatively (and GCC and XL both do so), padding should be emitted after the traceback table to maintain the alignment. @DiggerLin @jasonliu, if the second option (add padding) is chosen, I think it should be a separate patch that is a follow-up to the traceback table emission.

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCContext.h

600–606

It may make sense to add a getXCOFFDwarfSection function that forwards to this.

[hubert.reinterpretcast]

llvm/lib/MC/MCAsmStreamer.cpp

2352

I tried this patch with -ffunction-sections, and the assembly I get generates a duplicate definition of L...dwline:

	.byte	3
	.byte	1
	.byte	1
	.csect .main[PR],2
L..sec_end1:

	.dwsect 0x20000
L...dwline:
	.byte	0
	.byte	5
	.byte	2
	.vbyte	4, L..sec_end1
	.byte	0
	.byte	1
	.byte	1
L..debug_line_end0:

[shchenz]

address @hubert.reinterpretcast comments

[shchenz]

thanks for your review @hubert.reinterpretcast . See my inline reply.

llvm/include/llvm/MC/MCContext.h

600–606

hmm, I would let this function like this for now. There would be many redundant codes between getXCOFFDwarfSection and getXCOFFSection if we create a new getXCOFFDwarfSection. Let me know if you think it is profitable to add a new function. Maybe we need a big NFC patch for this change.

llvm/lib/MC/MCAsmStreamer.cpp

2352

Good catch. Fixed in the new update.

llvm/lib/MC/MCSymbolXCOFF.cpp

30–32

I have added a FIXME in the caller of setRepresentedCsect, I will fix this later in another patch.

llvm/test/DebugInfo/XCOFF/empty.ll

76–78

Can you help to point out which comments? Do you mean we will have a functionality issue if we don't align the text section?

[shchenz]

1: handle neighbouring .loc

[shchenz]

typo fix

[jasonliu]

llvm/include/llvm/MC/MCContext.h

600–606

I think what Hubert meant is to make a call to getXCOFFSection inside of getXCOFFDwarfSection so that you don't need to pass in so many default parameters when you just want to get the Dwarf Section. i.e. The getXCOFFDwarfSection signature could be

MCSectionXCOFF *
getXCOFFDwarfSection(StringRef Section, XCOFF::DwarfSectionSubtypeFlags DwarfSubtypeFlags, bool MultiSymbolsAllowed = true, const char *BeginSymName = nullptr);

llvm/lib/MC/MCContext.cpp

687–688

Use () to make it obvious that we are calling a constructor.

[hubert.reinterpretcast]

llvm/test/DebugInfo/XCOFF/empty.ll

76–78

I just meant that https://reviews.llvm.org/D95518?id=326625#inline-915279 applies here too. I'm not aware of a functionality issue with this.

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCSectionXCOFF.h

109

Minor nit: We've been using Dwarf for camelCase.

llvm/lib/MC/MCContext.cpp

679

Minor nit: We've been using Dwarf with PascalCase.

680–682

Minor comment: == works for this check.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1804–1812

@jasonliu, I'd like your analysis of how this interacts with explicit sections.

[shchenz]

1: format fixing

llvm/include/llvm/MC/MCContext.h

600–606

Thanks for the review @jasonliu

That would make the API more confusing in my opinion. For that case, we have getXCOFFDwarfSection and getXCOFFSection. DWARF section should also be an XCOFF section, so why can't we call getXCOFFSection directly for DWARF section? getXCOFFSection obviously already has a parameter for DWARF section?

I am a little in favor of the current implementation, if you guys insist, I will do it in another NFC patch.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1804–1812

explicit sections are generated when -fdata-sections is enabled? If so, I think debugging functionality should not be impacted. We only need to worry about the "text" section for debug line. For explicit sections functionality, I guess it should not be impacted too as we only add new labels, not data, like vbyte, byte

Anyway, your input is appreciated @jasonliu

llvm/test/DebugInfo/XCOFF/empty.ll

76–78

Ah, OK, I was thinking you were saying "comments" in llvm source code

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1804–1812

It seems that we want to generate a section end label on every text csect here.
If that's the case, then it doesn't seem like we are generating them correctly when explicit section for text section is enabled. An example would be:

int bar() {return 1;}
int __attribute__((section ("explicit_main_sec"))) main() {
  return bar();
}

I don't see a L..sec_end for .text[PR].

A side note when I was trying things: it seems we have a subtle bug when we enables -function-sections and specify an explicit section for a function. We don't generate a label for the function entry point in this case, and we don't have the correct function entry point stored in the function descriptor section.
The bug is not related to this patch, and we need to fix it in another patch. But it affects how we want to construct a test case in this patch.

llvm/test/DebugInfo/XCOFF/empty.ll

3

We should add test for -ffunction-sections, and possible explicit sections as well.

52

It might not be big deal, but it seems we are generating an extra label for no reason?

[shchenz]

address @jasonliu comments:
1: handle explicit section
2: add more testcases

[shchenz]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1804–1812

Good catch. We need to generate section end symbol for the explicit section too. Fixed in the new patch.

I found one issue, not sure if it is the same one as you found:
for the case you given, if we compile it with -ffunction-sections, we will get some linking error:

> clang 4.c -ffunction-sections          
ld: 0711-317 ERROR: Undefined symbol: .main
ld: 0711-345 Use the -bloadmap or -bnoquiet option to obtain more information.
clang-13: error: linker command failed with exit code 8 (use -v to see invocation)

llvm/test/DebugInfo/XCOFF/empty.ll

52

Not sure, this should be also exist without -g.

[shchenz]

some simplify to the test case

[shchenz]

llvm/test/DebugInfo/XCOFF/empty.ll

52

Not sure, this should be also exist without -g.

What I mean is these two labels are caused by input to MC DWARF generation. The L..tmp2 is generated by a .loc directive. It will be used in dwlinesection. The L..tmp1 is generated for other usage., I have not checked into this yet. But I guess this should not be related for XCOFF DWARF.

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1804–1812

Yes, it's the same bug.
I feel the current way of handling end of text csect is not very robust.
A few more ways to break it:

int __attribute__((section ("explict_text_sec"))) foo() {
  return 1;
}
int bar2() {return 1;}
int __attribute__((section ("explict_text_sec"))) bar() {
  return bar2();
}

It seems when C++ exception handling is enabled, and eh instruments are generated, then we will not have the label L..sec_end on the correct location.
A sample program would be:

int foo(){
  try { throw 1;}
  catch(...) { return 1;}
  return 0;
}

[shchenz]

1: address comments

[shchenz]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1804–1812

issue 1 is indeed an issue. Fixed in the new patch. Now, I use a new method NOW. Use end symbol of .text section for all sections including any function sections or explicit sections.

issue 2 is as expected, we have to contain this inaccurate text end symbol, because we may generate other sections (maybe not for text, for example, eh, rodata sections) between functions, and we need an end symbol for all instructions in the current CU, so we have to add it in PPCAIXAsmPrinter::doFinalization() which runs after all functions being handled by AsmPrinter::runOnMachineFunction(). But this should not impact debugability as the inaccurate label only impact the last debug line entry in the current CU and this inaccurate label is out of any function, so before we reach this address in the debugger, we should jump to the caller of the last function in the section.

[jasonliu]

llvm/lib/MC/MCAsmStreamer.cpp

2318

I hope this FIXME is not going to stay here for long (and we will quickly have a patch to address this). As this is really a workaround here and it creates different behavior between object file generation and assembly generation which is undesirable.

2339

The assembly generated is hard for human to consume. It will be very difficult to debug if anything goes wrong between those lines. It would be great if we could use addComment to let people know what each of this byte means (It could be in a follow on patch if this is too much for this one).
Some of the existing dwarf code does not really have those comments because they were meant for object file generation only. But now, it might make sense to have those comments available.
Arguably, one could use some other tools to dump the assembled object file and figure out what each entry means. But those are extra steps and it requires time to map the dump output from object file to the original asm output.

2358

Should use dwarf::DW_LNS_extended_op instead of hardcoding 0?

2365–2368

We have the same 4 lines on these 3 blocks. Do we want to common them up?
Also, better yet, is it possible if we just use most of the logic from MCObjectStreamer::emitDwarfAdvanceLineAddr instead of making our own assembly version?
For example, put the common code that would work for both assembly and object file generation in a common function that could access by MCAsmStreamer and MCObjectStreamer. And in the override version of emitDwarfAdvanceLineAddr, we could call the common function and handle the differences between assembly and object file generation. Or, at least we want to see if we could reuse MCDwarfLineAddr::Emit which gets called in MCObjectStreamer::emitDwarfAdvanceLineAddr, instead of duplicating the logic here.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2344

I wonder if doFinalizationAtSectionEnd really has to be in MCStreamer. At least for this patch, it could just be a helper static function, or private member function of PPCAIXAsmPrinter or even a lambda here, and no other target actually needs it. We could always refactor it to a larger scope later when we find the need for it.

[jasonliu]

llvm/lib/MC/MCAsmStreamer.cpp

2141

This is more of a question for my own understanding: when do we need to call MCDwarfLineEntry::make?
It seems in MCObjectStreamer, we would also call MCDwarfLineEntry::make in emitValueImpl and emitBytes. Are those calls not necessary in the MCAsmStreamer counterpart?

[shchenz]

1: address @jasonliu comments

llvm/lib/MC/MCAsmStreamer.cpp

2318

I left this as a FIXME because I can not find an easy way to fix this. Why we need this function is because of the difference of the changeSection function of MCAsmStreamer and MCObjectStreamer. MCObjectStreamer will change the insert point to the section end, while MCAsmStreamer will add a new section start in the assembly output. The MCAsmStreamer current behavior is not what we need for debug lines, we can not add another .text section when we generate assembly for .dwline.
So if we want to have the same behavior for MCAsmStreamer and MCObjectStreamer, we must make sure that we know a function is a section end. So we can add a section end symbol in the function emitFunctionBodyEnd. But this seems hard due to explicit sections. When we handle a function in AsmPrinter pass, it is hard to know there are other functions(which will be handled later) that also belong to the same section unless a CU level analysis is performed to fetch this info.

2339

Please check the assembly generated now matching your expectation? Since the prologue of debug line is not newly generated by this patch, so I left it without comment to avoid many current cases fail.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2344

I know what you mean, but we must implement this based on MCStreamer. We only need this for MCAsmStreamer but not for MCObjectStreamer. Currently, there is no way to differentiate these two streamers. And we should not differentiate them, as it breaks the abstraction of MCSreamer.

[shchenz]

llvm/lib/MC/MCAsmStreamer.cpp

2141

I think the calling of MCDwarfLineEntry::make in MCObjectStreamer is for DW_LNS_advance_pc usage.
For MCAsmStreamer, we don't use DW_LNS_advance_pc, so we only need to add a line entry and a temp label where we generate a .loc directive.

[jasonliu]

llvm/lib/MC/MCAsmStreamer.cpp

2339

Thanks. It's much better for reading now.

2346

nit: AddComment for here too?

[jasonliu]

llvm/lib/MC/MCAsmStreamer.cpp

2318

I guess one way to do this for assembly would be:

1. collect all the seen text csects somehow into an array.
2. After all the text csects are emitted (doFinalization or emitEndOfAsmFile?), traverse (and switch to) each text csect in the array and emit the section end label for it.

I think in this way, you could make sure that the section end labels are indeed emitted to the section end.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

2344

You are right. Forgot about the fact that this is for assembly only.

[jasonliu]

llvm/test/DebugInfo/XCOFF/empty.ll

10

So I tried a simple program with this patch:

(gdb) list
1       int bar2() {return 1;}
2       int  main() {
3         int c = 10;
4         return bar2()+c;
5       }
(gdb) b 3
Breakpoint 1 at 0x100004d8: file /gsa/tlbgsa/home/j/a/jasonli/defect/XCOFF/main.c, line 3.
(gdb) r
Starting program: /gsa/tlbgsa-h1/06/jasonli/defect/XCOFF/main 

Breakpoint 1, main () at /gsa/tlbgsa/home/j/a/jasonli/defect/XCOFF/main.c:3
3         int c = 10;
(gdb) n
4         return bar2()+c;
(gdb) s
bar2 () at /gsa/tlbgsa/home/j/a/jasonli/defect/XCOFF/main.c:1
1       int bar2() {return 1;}
(gdb) n
0x100002fc in __start ()

It seems when we try the last "next", it skips the main function and goes directly into __start(). But gcc on AIX seems to be able to advance to main before goes to __start().

[jasonliu]

LGTM if the nit comment is addressed
There are two items that we need to follow up after this patch:

1. The corner case/bug in https://reviews.llvm.org/D95518#inline-919030
2. The possibility of addressing the FIXME for https://reviews.llvm.org/D95518#inline-918884

[shchenz]

1: add more comment

[shchenz]

@jasonliu Please see my inline comments for the corner case and the left FIXME. Thanks for your review.

llvm/lib/MC/MCAsmStreamer.cpp

2318

hmm, doing this in doFinalization for the explicit sections will be too late, just like the case we do this in dwarf line emission. We can not switch back to the previous section at the end of all text sections.

Collecting this info in doInitialization is a possible way. Before we run AsmPrinter::runOnMachineFunction() for any function, we go through all functions in the module and try to find out which function is the last one of a specific section.

But I am not sure that the function order (when we iterate them in the module ) is the same as the order they exist in the source file. We need more investigation here if we want to fix this later.

llvm/test/DebugInfo/XCOFF/empty.ll

10

Yeah, this is a difference between GCC and clang. We also get the same behavior for clang on Linux for this small case.

I think maybe clang's behavior is better than GCC. In the debugger, when we break a function name, we will always skip the function's prologue and stop after the prologue, so when we return back to a function at the address for a function's epilogue, should we just execute them and not stop there? If so, clang does the right thing, we don't stop at the function's epilogue and return to the function's caller.

[jasonliu]

llvm/lib/MC/MCAsmStreamer.cpp

2318

I'm not sure if I understand what you meant by we could not switch back to the previous section at the end of all text sections.
Assuming you have csects like this:

.csect main[PR]
xxx
.csect text[PR]
xxx
.csect main[PR]
xxx
.csect text[PR]
xxx

Then at finalization, we know no more text csect will be emitted. Then we could start emitting the end label for each of the csect above:

.csect main[PR]
.L..sec_end0
.csect text[PR]
.L..sec_end1

Then you could refer back to these labels in the dwarf sections. Those labels should give you the address of the end of that particular csect.
Wouldn't this work?

llvm/test/DebugInfo/XCOFF/empty.ll

10

I see. That's fine if this is just the behavior of clang. It's a corner case anyway.

[shchenz]

llvm/lib/MC/MCAsmStreamer.cpp

2318

Please keep in mind that there is no way to change the insert point for the assembly output. See MCAsmStreamer::changeSection() -> MCSectionXCOFF::PrintSwitchToSection(.

If we are in the position of the text end, for your example:

.csect main[PR]
xxx
.csect text[PR]
xxx

Assume .text is the end of all text sections, now we want to emit end symbol for section main.
Then we call switchSection(main), what we have now is generating another csect directive for main and then add the end label, so it becomes:

.csect main[PR]
xxx
.csect text[PR]
xxx
.csect main[PR]
L..sec_end    #for main

I think this is not what we expect, right? We expect:

.csect main[PR]
xxx
L..sec_end    #for main
.csect text[PR]
xxx

So we must do the section end lable adding when we just reach a section end.

FYI, MCObjectStreamer has the ability to change the insert point. See MCObjectStreamer::changeSectionImpl(

[jasonliu]

llvm/lib/MC/MCAsmStreamer.cpp

2318

So we must do the section end lable adding when we just reach a section end.

You don't have to.

.csect .text[PR]
    lwz 1,1
    lwz 2,2
.csect something[PR]
    lwz 3,3
.csect .text[PR]
end_label:
.csect .data[RW]
   .byte end_label

In this example, we switch back to .text section and emitted the section end label. And we print the end_label label at .data csect. And it correctly shows 8 in .data[rw] when you do the objdump of the assembled object file.

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// True if Dwarf2 output generally uses relocations for references to other
   /// .debug_* sections.
   bool DwarfUsesRelocationsAcrossSections = true;
 
   /// True if DWARF FDE symbol reference relocations should be replaced by an
   /// absolute difference.
   bool DwarfFDESymbolsUseAbsDiff = false;
 
+  /// True if the target supports generating the DWARF line table through using
+  /// the .loc/.file directives. Defaults to true.
+  bool UsesDwarfFileAndLocDirectives = true;
+
+  /// True if the target needs the DWARF section length in the header (if any)
+  /// of the DWARF section in the assembly file. Defaults to true.
+  bool DwarfSectionSizeRequired = true;
+
   /// True if dwarf register numbers are printed instead of symbolic register
   /// names in .cfi_* directives.  Defaults to false.
   bool DwarfRegNumForCFI = false;
 
   /// True if target uses parens to indicate the symbol variant instead of @.
   /// For example, foo(plt) instead of foo@plt.  Defaults to false.
   bool UseParensForSymbolVariant = false;
 
public:
 
   bool doDwarfFDESymbolsUseAbsDiff() const { return DwarfFDESymbolsUseAbsDiff; }
   bool useDwarfRegNumForCFI() const { return DwarfRegNumForCFI; }
   bool useParensForSymbolVariant() const { return UseParensForSymbolVariant; }
   bool supportsExtendedDwarfLocDirective() const {
     return SupportsExtendedDwarfLocDirective;
   }
 
+  bool usesDwarfFileAndLocDirectives() const {
+    return UsesDwarfFileAndLocDirectives;
+  }
+
+  bool needsDwarfSectionSizeInHeader() const {
+    return DwarfSectionSizeRequired;
+  }
+
   void addInitialFrameState(const MCCFIInstruction &Inst);
 
   const std::vector<MCCFIInstruction> &getInitialFrameState() const {
     return InitialFrameState;
   }
 
   void setBinutilsVersion(std::pair<int, int> Value) {
     BinutilsVersion = Value;

llvm/include/llvm/MC/MCContext.h

struct WasmSectionKey {
           return SectionName < Other.SectionName;
         if (GroupName != Other.GroupName)
           return GroupName < Other.GroupName;
         return UniqueID < Other.UniqueID;
       }
     };
 
     struct XCOFFSectionKey {
+      // Section name.
       std::string SectionName;
+      // Section property.
+      // For csect section, it is storage mapping class.
+      // For debug section, it is section type flags.
+      union {
         XCOFF::StorageMappingClass MappingClass;
+        XCOFF::DwarfSectionSubtypeFlags DwarfSubtypeFlags;
+      };
+      bool IsCsect;
 
       XCOFFSectionKey(StringRef SectionName,
                       XCOFF::StorageMappingClass MappingClass)
-          : SectionName(SectionName), MappingClass(MappingClass) {}
+          : SectionName(SectionName), MappingClass(MappingClass),
+            IsCsect(true) {}
+
+      XCOFFSectionKey(StringRef SectionName,
+                      XCOFF::DwarfSectionSubtypeFlags DwarfSubtypeFlags)
+          : SectionName(SectionName), DwarfSubtypeFlags(DwarfSubtypeFlags),
+            IsCsect(false) {}
 
       bool operator<(const XCOFFSectionKey &Other) const {
+        if (IsCsect && Other.IsCsect)
           return std::tie(SectionName, MappingClass) <
                  std::tie(Other.SectionName, Other.MappingClass);
+        if (IsCsect != Other.IsCsect)
+          return IsCsect;
+        return std::tie(SectionName, DwarfSubtypeFlags) <
+               std::tie(Other.SectionName, Other.DwarfSubtypeFlags);
       }
     };
 
     StringMap<MCSectionMachO *> MachOUniquingMap;
     std::map<ELFSectionKey, MCSectionELF *> ELFUniquingMap;
     std::map<COFFSectionKey, MCSectionCOFF *> COFFUniquingMap;
     std::map<WasmSectionKey, MCSectionWasm *> WasmUniquingMap;
     std::map<XCOFFSectionKey, MCSectionXCOFF *> XCOFFUniquingMap;
     StringMap<bool> RelSecNames;
public:
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                   const Twine &Group, unsigned UniqueID,
                                   const char *BeginSymName);
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                   const MCSymbolWasm *Group, unsigned UniqueID,
                                   const char *BeginSymName);
 
-    MCSectionXCOFF *
-    getXCOFFSection(StringRef Section, SectionKind K,
-                    Optional<XCOFF::CsectProperties> CsectProp = None,
-                    bool MultiSymbolsAllowed = false,
-                    const char *BeginSymName = nullptr);
+    MCSectionXCOFF *getXCOFFSection(
+        StringRef Section, SectionKind K,
+        bool MultiSymbolsAllowed = false, const char *BeginSymName = nullptr,
+        Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSubtypeFlags = None);
 
     // Create and save a copy of STI and return a reference to the copy.
     MCSubtargetInfo &getSubtargetCopy(const MCSubtargetInfo &STI);
 
     /// @}
 
     /// \name Dwarf Management
     /// @{
 

llvm/include/llvm/MC/MCDwarf.h

public:
   MCDwarfLineEntry(MCSymbol *label, const MCDwarfLoc loc)
       : MCDwarfLoc(loc), Label(label) {}
 
   MCSymbol *getLabel() const { return Label; }
 
   // This is called when an instruction is assembled into the specified
   // section and if there is information from the last .loc directive that
   // has yet to have a line entry made for it is made.
-  static void Make(MCObjectStreamer *MCOS, MCSection *Section);
+  static void make(MCStreamer *MCOS, MCSection *Section);
 };
 
 /// Instances of this class represent the line information for a compile
 /// unit where machine instructions have been assembled after seeing .loc
 /// directives.  This is the information used to build the dwarf line
 /// table for a section.
 class MCLineSection {
 public:

 };
 
 class MCDwarfLineTable {
   MCDwarfLineTableHeader Header;
   MCLineSection MCLineSections;
 
 public:
   // This emits the Dwarf file and the line tables for all Compile Units.
-  static void Emit(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params);
+  static void emit(MCStreamer *MCOS, MCDwarfLineTableParams Params);
 
   // This emits the Dwarf file and the line tables for a given Compile Unit.
-  void EmitCU(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params,
+  void emitCU(MCStreamer *MCOS, MCDwarfLineTableParams Params,
               Optional<MCDwarfLineStr> &LineStr) const;
 
   Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 Optional<MD5::MD5Result> Checksum,
                                 Optional<StringRef> Source,
                                 uint16_t DwarfVersion,
                                 unsigned FileNumber = 0);
   unsigned getFile(StringRef &Directory, StringRef &FileName,

llvm/include/llvm/MC/MCObjectStreamer.h

void emitCodeAlignment(unsigned ByteAlignment,
                          unsigned MaxBytesToEmit = 0) override;
   void emitValueToOffset(const MCExpr *Offset, unsigned char Value,
                          SMLoc Loc) override;
   void emitDwarfLocDirective(unsigned FileNo, unsigned Line, unsigned Column,
                              unsigned Flags, unsigned Isa,
                              unsigned Discriminator,
                              StringRef FileName) override;
   void emitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
-                                const MCSymbol *Label, unsigned PointerSize);
+                                const MCSymbol *Label,
+                                unsigned PointerSize) override;
   void emitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
                                  const MCSymbol *Label);
   void emitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
                           unsigned Column, bool PrologueEnd, bool IsStmt,
                           StringRef FileName, SMLoc Loc) override;
   void emitCVLinetableDirective(unsigned FunctionId, const MCSymbol *Begin,
                                 const MCSymbol *End) override;
   void emitCVInlineLinetableDirective(unsigned PrimaryFunctionId,

llvm/include/llvm/MC/MCSectionXCOFF.h

 //    contained in another XCOFF object file. External reference csects are not
 //    implemented yet.
 class MCSectionXCOFF final : public MCSection {
   friend class MCContext;
 
   Optional<XCOFF::CsectProperties> CsectProp;
   MCSymbolXCOFF *const QualName;
   StringRef SymbolTableName;
+  Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSubtypeFlags;
   bool MultiSymbolsAllowed;
   static constexpr unsigned DefaultAlignVal = 4;
 
   MCSectionXCOFF(StringRef Name, XCOFF::StorageMappingClass SMC,
                  XCOFF::SymbolType ST, SectionKind K, MCSymbolXCOFF *QualName,
                  MCSymbol *Begin, StringRef SymbolTableName,
                  bool MultiSymbolsAllowed)
       : MCSection(SV_XCOFF, Name, K, Begin),
         CsectProp(XCOFF::CsectProperties(SMC, ST)), QualName(QualName),
-        SymbolTableName(SymbolTableName),
+        SymbolTableName(SymbolTableName), DwarfSubtypeFlags(None),
         MultiSymbolsAllowed(MultiSymbolsAllowed) {
     assert(
         (ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM || ST == XCOFF::XTY_ER) &&
         "Invalid or unhandled type for csect.");
     assert(QualName != nullptr && "QualName is needed.");
+
     QualName->setRepresentedCsect(this);
     QualName->setStorageClass(XCOFF::C_HIDEXT);
     // A csect is 4 byte aligned by default, except for undefined symbol csects.
     if (ST != XCOFF::XTY_ER)
       setAlignment(Align(DefaultAlignVal));
   }
 
   MCSectionXCOFF(StringRef Name, SectionKind K, MCSymbolXCOFF *QualName,
+                 XCOFF::DwarfSectionSubtypeFlags DwarfSubtypeFlags,
                  MCSymbol *Begin, StringRef SymbolTableName,
                  bool MultiSymbolsAllowed)
       : MCSection(SV_XCOFF, Name, K, Begin), QualName(QualName),
-        SymbolTableName(SymbolTableName),
+        SymbolTableName(SymbolTableName), DwarfSubtypeFlags(DwarfSubtypeFlags),
         MultiSymbolsAllowed(MultiSymbolsAllowed) {
     assert(QualName != nullptr && "QualName is needed.");
 
     // FIXME: use a more meaningful name for non csect sections.
     QualName->setRepresentedCsect(this);
 
     // Set default alignment 4 for all non csect sections for now.
     // FIXME: set different alignments according to section types.
public:
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
   StringRef getSymbolTableName() const { return SymbolTableName; }
   bool isMultiSymbolsAllowed() const { return MultiSymbolsAllowed; }
   bool isCsect() const { return CsectProp.hasValue(); }
+  bool isDWARFSect() const { return DwarfSubtypeFlags.hasValue(); }
+  Optional<XCOFF::DwarfSectionSubtypeFlags> getDwarfSubtypeFlags() const {
+    return DwarfSubtypeFlags;
+  }
 };
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/MC/MCStreamer.h

public:
   /// Finish emission of machine code.
   void Finish(SMLoc EndLoc = SMLoc());
 
   virtual bool mayHaveInstructions(MCSection &Sec) const { return true; }
 
   /// Emit a special value of 0xffffffff if producing 64-bit debugging info.
   void maybeEmitDwarf64Mark();
 
   /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
   /// according to the settings.
   virtual void emitDwarfUnitLength(uint64_t Length, const Twine &Comment);
 
   /// Emit a unit length field. The actual format, DWARF32 or DWARF64, is chosen
   /// according to the settings.
   /// Return the end symbol generated inside, the caller needs to emit it.
   virtual MCSymbol *emitDwarfUnitLength(const Twine &Prefix,
                                         const Twine &Comment);
+
+  /// Emit the debug line start label.
+  virtual void emitDwarfLineStartLabel(MCSymbol *StartSym);
+
+  /// If targets does not support representing debug line section by .loc/.file
+  /// directives in assembly output, we need to populate debug line section with
+  /// raw debug line contents.
+  virtual void emitDwarfAdvanceLineAddr(int64_t LineDelta,
+                                        const MCSymbol *LastLabel,
+                                        const MCSymbol *Label,
+                                        unsigned PointerSize) {}
+
+  /// Do finalization for the streamer at the end of a section.
+  virtual void doFinalizationAtSectionEnd(MCSection *Section) {}
 };
 
 /// Create a dummy machine code streamer, which does nothing. This is useful for
 /// timing the assembler front end.
 MCStreamer *createNullStreamer(MCContext &Ctx);
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSTREAMER_H

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

DwarfDebug::DwarfDebug(AsmPrinter *A)
 
   unsigned DwarfVersionNumber = Asm->TM.Options.MCOptions.DwarfVersion;
   unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
                                     : MMI->getModule()->getDwarfVersion();
   // Use dwarf 4 by default if nothing is requested. For NVPTX, use dwarf 2.
   DwarfVersion =
       TT.isNVPTX() ? 2 : (DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION);
 
-  bool Dwarf64 =
-      (Asm->TM.Options.MCOptions.Dwarf64 || MMI->getModule()->isDwarf64()) &&
-      DwarfVersion >= 3 &&   // DWARF64 was introduced in DWARFv3.
-      TT.isArch64Bit() &&    // DWARF64 requires 64-bit relocations.
-      TT.isOSBinFormatELF(); // Support only ELF for now.
+  bool Dwarf64 = DwarfVersion >= 3 && // DWARF64 was introduced in DWARFv3.
+                 TT.isArch64Bit();    // DWARF64 requires 64-bit relocations.
+
+  // Support DWARF64
+  // 1: For ELF when requested.
+  // 2: For XCOFF64: the AIX assembler will fill in debug section lengths
+  //    according to the DWARF64 format for 64-bit assembly, so we must use
+  //    DWARF64 in the compiler too for 64-bit mode.
+  Dwarf64 &=
+      ((Asm->TM.Options.MCOptions.Dwarf64 || MMI->getModule()->isDwarf64()) &&
+       TT.isOSBinFormatELF()) ||
+      TT.isOSBinFormatXCOFF();
+
+  if (!Dwarf64 && TT.isArch64Bit() && TT.isOSBinFormatXCOFF())
+    report_fatal_error("XCOFF requires DWARF64 for 64-bit mode!");
 
   UseRangesSection = !NoDwarfRangesSection && !TT.isNVPTX();
 
   // Use sections as references. Force for NVPTX.
   if (DwarfSectionsAsReferences == Default)
     UseSectionsAsReferences = TT.isNVPTX();
   else
     UseSectionsAsReferences = DwarfSectionsAsReferences == Enable;

llvm/lib/MC/MCAsmInfoXCOFF.cpp

 
 MCAsmInfoXCOFF::MCAsmInfoXCOFF() {
   IsLittleEndian = false;
   HasVisibilityOnlyWithLinkage = true;
   PrivateGlobalPrefix = "L..";
   PrivateLabelPrefix = "L..";
   SupportsQuotedNames = false;
   UseDotAlignForAlignment = true;
+  UsesDwarfFileAndLocDirectives = false;
+  DwarfSectionSizeRequired = false;
   if (UseLEB128Directives == cl::BOU_UNSET)
     HasLEB128Directives = false;
   ZeroDirective = "\t.space\t";
   ZeroDirectiveSupportsNonZeroValue = false;
   AsciiDirective = nullptr; // not supported
   AscizDirective = nullptr; // not supported
   ByteListDirective = "\t.byte\t";
   CharacterLiteralSyntax = ACLS_SingleQuotePrefix;

llvm/lib/MC/MCAsmStreamer.cpp

public:
   void emitAddrsigSym(const MCSymbol *Sym) override;
 
   /// If this file is backed by an assembly streamer, this dumps the specified
   /// string in the output .s file. This capability is indicated by the
   /// hasRawTextSupport() predicate.
   void emitRawTextImpl(StringRef String) override;
 
   void finishImpl() override;
+
+  void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) override;
+
+  MCSymbol *emitDwarfUnitLength(const Twine &Prefix,
+                                const Twine &Comment) override;
+
+  void emitDwarfLineStartLabel(MCSymbol *StartSym) override;
+
+  void emitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
+                                const MCSymbol *Label,
+                                unsigned PointerSize) override;
+
+  void doFinalizationAtSectionEnd(MCSection *Section) override;
 };
 
 } // end anonymous namespace.
 
 void MCAsmStreamer::AddComment(const Twine &T, bool EOL) {
   if (!IsVerboseAsm) return;
 
   T.toVector(CommentToEmit);
Expected<unsigned> MCAsmStreamer::tryEmitDwarfFileDirective(
   MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
   unsigned NumFiles = Table.getMCDwarfFiles().size();
   Expected<unsigned> FileNoOrErr =
       Table.tryGetFile(Directory, Filename, Checksum, Source,
                        getContext().getDwarfVersion(), FileNo);
   if (!FileNoOrErr)
     return FileNoOrErr.takeError();
   FileNo = FileNoOrErr.get();
-  if (NumFiles == Table.getMCDwarfFiles().size())
+
+  // Return early if this file is already emitted before or if target doesn't
+  // support .file directive.
+  if (NumFiles == Table.getMCDwarfFiles().size() ||
+      !MAI->usesDwarfFileAndLocDirectives())
     return FileNo;
 
   SmallString<128> Str;
   raw_svector_ostream OS1(Str);
   printDwarfFileDirective(FileNo, Directory, Filename, Checksum, Source,
                           UseDwarfDirectory, OS1);
 
   if (MCTargetStreamer *TS = getTargetStreamer())
     TS->emitDwarfFileDirective(OS1.str());
   else
     emitRawText(OS1.str());
 
   return FileNo;
 }
 
 void MCAsmStreamer::emitDwarfFile0Directive(StringRef Directory,
                                             StringRef Filename,
                                             Optional<MD5::MD5Result> Checksum,
                                             Optional<StringRef> Source,
                                             unsigned CUID) {
   assert(CUID == 0);
   // .file 0 is new for DWARF v5.
   if (getContext().getDwarfVersion() < 5)
     return;
   // Inform MCDwarf about the root file.
   getContext().setMCLineTableRootFile(CUID, Directory, Filename, Checksum,
                                       Source);
 
+  // Target doesn't support .loc/.file directives, return early.
+  if (!MAI->usesDwarfFileAndLocDirectives())
+    return;
+
   SmallString<128> Str;
   raw_svector_ostream OS1(Str);
   printDwarfFileDirective(0, Directory, Filename, Checksum, Source,
                           UseDwarfDirectory, OS1);
 
   if (MCTargetStreamer *TS = getTargetStreamer())
     TS->emitDwarfFileDirective(OS1.str());
   else
     emitRawText(OS1.str());
 }
 
 void MCAsmStreamer::emitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                           unsigned Column, unsigned Flags,
                                           unsigned Isa, unsigned Discriminator,
                                           StringRef FileName) {
+  // If target doesn't support .loc/.file directive, we need to record the lines
+  // same way like we do in object mode.
+  if (!MAI->usesDwarfFileAndLocDirectives()) {
+    this->MCStreamer::emitDwarfLocDirective(FileNo, Line, Column, Flags, Isa,
+                                            Discriminator, FileName);
+    return;
+  }
+
   OS << "\t.loc\t" << FileNo << " " << Line << " " << Column;
   if (MAI->supportsExtendedDwarfLocDirective()) {
     if (Flags & DWARF2_FLAG_BASIC_BLOCK)
       OS << " basic_block";
     if (Flags & DWARF2_FLAG_PROLOGUE_END)
       OS << " prologue_end";
     if (Flags & DWARF2_FLAG_EPILOGUE_BEGIN)
       OS << " epilogue_begin";
void MCAsmStreamer::AddEncodingComment(const MCInst &Inst,
   }
 }
 
 void MCAsmStreamer::emitInstruction(const MCInst &Inst,
                                     const MCSubtargetInfo &STI) {
   assert(getCurrentSectionOnly() &&
          "Cannot emit contents before setting section!");
 
+  if (!MAI->usesDwarfFileAndLocDirectives())
+    // Now that a machine instruction has been assembled into this section, make
+    // a line entry for any .loc directive that has been seen.
+    MCDwarfLineEntry::make(this, getCurrentSectionOnly());
+
   // Show the encoding in a comment if we have a code emitter.
   AddEncodingComment(Inst, STI);
 
   // Show the MCInst if enabled.
   if (ShowInst) {
     Inst.dump_pretty(GetCommentOS(), InstPrinter.get(), "\n ");
     GetCommentOS() << "\n";
   }
void MCAsmStreamer::emitRawTextImpl(StringRef String) {
   EmitEOL();
 }
 
 void MCAsmStreamer::finishImpl() {
   // If we are generating dwarf for assembly source files dump out the sections.
   if (getContext().getGenDwarfForAssembly())
     MCGenDwarfInfo::Emit(this);
 
+  // Now it is time to emit debug line sections if target doesn't support .loc
+  // and .line directives.
+  if (!MAI->usesDwarfFileAndLocDirectives()) {
+    MCDwarfLineTable::emit(this, getAssembler().getDWARFLinetableParams());
+    return;
+  }
+
   // Emit the label for the line table, if requested - since the rest of the
   // line table will be defined by .loc/.file directives, and not emitted
   // directly, the label is the only work required here.
   const auto &Tables = getContext().getMCDwarfLineTables();
   if (!Tables.empty()) {
     assert(Tables.size() == 1 && "asm output only supports one line table");
     if (auto *Label = Tables.begin()->second.getLabel()) {
       SwitchSection(getContext().getObjectFileInfo()->getDwarfLineSection());
       emitLabel(Label);
     }
   }
 }
 
+void MCAsmStreamer::emitDwarfUnitLength(uint64_t Length, const Twine &Comment) {
+  // If the assembler on some target fills in the DWARF unit length, we
+  // don't want to emit the length in the compiler. For example, the AIX
+  // assembler requires the assembly file with the unit length omitted from
+  // the debug section headers. In such cases, any label we placed occurs
+  // after the implied length field. We need to adjust the reference here
+  // to account for the offset introduced by the inserted length field.
+  if (!MAI->needsDwarfSectionSizeInHeader())
+    return;
+  MCStreamer::emitDwarfUnitLength(Length, Comment);
+}
+
+MCSymbol *MCAsmStreamer::emitDwarfUnitLength(const Twine &Prefix,
+                                             const Twine &Comment) {
+  // If the assembler on some target fills in the DWARF unit length, we
+  // don't want to emit the length in the compiler. For example, the AIX
+  // assembler requires the assembly file with the unit length omitted from
+  // the debug section headers. In such cases, any label we placed occurs
+  // after the implied length field. We need to adjust the reference here
+  // to account for the offset introduced by the inserted length field.
+  if (!MAI->needsDwarfSectionSizeInHeader())
+    return getContext().createTempSymbol(Prefix + "_end");
+  return MCStreamer::emitDwarfUnitLength(Prefix, Comment);
+}
+
+void MCAsmStreamer::emitDwarfLineStartLabel(MCSymbol *StartSym) {
+  // If the assembler on some target fills in the DWARF unit length, we
+  // don't want to emit the length in the compiler. For example, the AIX
+  // assembler requires the assembly file with the unit length omitted from
+  // the debug section headers. In such cases, any label we placed occurs
+  // after the implied length field. We need to adjust the reference here
+  // to account for the offset introduced by the inserted length field.
+  MCContext &Ctx = getContext();
+  if (!MAI->needsDwarfSectionSizeInHeader()) {
+    MCSymbol *DebugLineSymTmp = Ctx.createTempSymbol("debug_line_");
+    // Emit the symbol which does not contain the unit length field.
+    emitLabel(DebugLineSymTmp);
+
+    // Adjust the outer reference to account for the offset introduced by the
+    // inserted length field.
+    unsigned LengthFieldSize =
+        dwarf::getUnitLengthFieldByteSize(Ctx.getDwarfFormat());
+    const MCExpr *EntrySize = MCConstantExpr::create(LengthFieldSize, Ctx);
+    const MCExpr *OuterSym = MCBinaryExpr::createSub(
+        MCSymbolRefExpr::create(DebugLineSymTmp, Ctx), EntrySize, Ctx);
+
+    emitAssignment(StartSym, OuterSym);
+    return;
+  }
+  MCStreamer::emitDwarfLineStartLabel(StartSym);
+}
+
+// Generate DWARF line sections for assembly mode without .loc/.file
+void MCAsmStreamer::emitDwarfAdvanceLineAddr(int64_t LineDelta,
+                                             const MCSymbol *LastLabel,
+                                             const MCSymbol *Label,
+                                             unsigned PointerSize) {
+  assert(!MAI->usesDwarfFileAndLocDirectives() &&
+         ".loc/.file don't need raw data in debug line section!");
+  if (!LastLabel) {
+    // Set to CU beginning.
+    emitIntValue(dwarf::DW_LNS_extended_op, 1);
+    emitULEB128IntValue(PointerSize + 1);
+    emitIntValue(dwarf::DW_LNE_set_address, 1);
+    emitSymbolValue(Label, PointerSize);
+
+    // Emit the sequence for the LineDelta (from 1) and a zero address delta.
+    MCDwarfLineAddr::Emit(this, MCDwarfLineTableParams(), LineDelta, 0);
+    return;
+  }
+
+  // INT64_MAX is a signal of the end of the section. Emit DW_LNE_end_sequence
+  // for the end of the section.
+  if (LineDelta == INT64_MAX) {
+    // Set new address to end label.
+    emitIntValue(dwarf::DW_LNS_extended_op, 1);
+    emitULEB128IntValue(PointerSize + 1);
+    emitIntValue(dwarf::DW_LNE_set_address, 1);
+    emitSymbolValue(Label, PointerSize);
+
+    emitIntValue(0, 1);
+    emitULEB128IntValue(1);
+    emitIntValue(dwarf::DW_LNE_end_sequence, 1);
+    return;
+  }
+
+  // Set new address to new label.
+  emitIntValue(dwarf::DW_LNS_extended_op, 1);
+  emitULEB128IntValue(PointerSize + 1);
+  emitIntValue(dwarf::DW_LNE_set_address, 1);
+  emitSymbolValue(Label, PointerSize);
+
+  // Advance line.
+  emitIntValue(dwarf::DW_LNS_advance_line, 1);
+  emitSLEB128IntValue(LineDelta);
+  emitIntValue(dwarf::DW_LNS_copy, 1);
+}
+
+void MCAsmStreamer::doFinalizationAtSectionEnd(MCSection *Section) {
+  // Emit section end. This is used to tell the debug line section where the end
+  // is for a text section if we don't use .loc to represent the debug line.
+  if (MAI->usesDwarfFileAndLocDirectives())
+    return;
+
+  SwitchSectionNoChange(Section);
+
+  MCSymbol *Sym = getCurrentSectionOnly()->getEndSymbol(getContext());
+
+  if (!Sym->isInSection())
+    emitLabel(Sym);
+}
+
 MCStreamer *llvm::createAsmStreamer(MCContext &Context,
                                     std::unique_ptr<formatted_raw_ostream> OS,
                                     bool isVerboseAsm, bool useDwarfDirectory,
                                     MCInstPrinter *IP,
                                     std::unique_ptr<MCCodeEmitter> &&CE,
                                     std::unique_ptr<MCAsmBackend> &&MAB,
                                     bool ShowInst) {
   return new MCAsmStreamer(Context, std::move(OS), isVerboseAsm,
                            useDwarfDirectory, IP, std::move(CE), std::move(MAB),
                            ShowInst);
 }

llvm/lib/MC/MCContext.cpp

MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
   auto *F = new MCDataFragment();
   Result->getFragmentList().insert(Result->begin(), F);
   F->setParent(Result);
   Begin->setFragment(F);
 
   return Result;
 }
 
-MCSectionXCOFF *
-MCContext::getXCOFFSection(StringRef Section, SectionKind Kind,
-                           Optional<XCOFF::CsectProperties> CsectProp,
-                           bool MultiSymbolsAllowed, const char *BeginSymName) {
+MCSectionXCOFF *MCContext::getXCOFFSection(
+    StringRef Section, SectionKind Kind,
+    Optional<XCOFF::CsectProperties> CsectProp, bool MultiSymbolsAllowed,
+    const char *BeginSymName,
+    Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSectionSubtypeFlags) {
+  bool IsDWARFSec = DwarfSectionSubtypeFlags.hasValue();
+  assert(((IsDWARFSec && !CsectProp.hasValue()) ||
+          (!IsDWARFSec && CsectProp.hasValue())) &&
+         "Invalid XCOFF section!");
+
   // Do the lookup. If we have a hit, return it.
-  // FIXME: handle the case for non-csect sections. Non-csect section has None
-  // CsectProp.
   auto IterBool = XCOFFUniquingMap.insert(std::make_pair(
-      XCOFFSectionKey{Section.str(), CsectProp->MappingClass}, nullptr));
+      IsDWARFSec
+          ? XCOFFSectionKey{Section.str(), DwarfSectionSubtypeFlags.getValue()}
+          : XCOFFSectionKey{Section.str(), CsectProp->MappingClass},
+      nullptr));
   auto &Entry = *IterBool.first;
   if (!IterBool.second) {
     MCSectionXCOFF *ExistedEntry = Entry.second;
     if (ExistedEntry->isMultiSymbolsAllowed() != MultiSymbolsAllowed)
       report_fatal_error("section's multiply symbols policy does not match");
 
     return ExistedEntry;
   }
 
   // Otherwise, return a new section.
   StringRef CachedName = Entry.first.SectionName;
-  MCSymbolXCOFF *QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol(
-      CachedName + "[" + XCOFF::getMappingClassString(CsectProp->MappingClass) +
-      "]"));
+  MCSymbolXCOFF *QualName = nullptr;
+  // Debug section don't have storage class attribute.
+  if (IsDWARFSec)
+    QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol(CachedName));
+  else
+    QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol(
+        CachedName + "[" +
+        XCOFF::getMappingClassString(CsectProp->MappingClass) + "]"));
 
   MCSymbol *Begin = nullptr;
   if (BeginSymName)
     Begin = createTempSymbol(BeginSymName, false);
 
   // QualName->getUnqualifiedName() and CachedName are the same except when
   // CachedName contains invalid character(s) such as '$' for an XCOFF symbol.
-  MCSectionXCOFF *Result = new (XCOFFAllocator.Allocate()) MCSectionXCOFF(
-      QualName->getUnqualifiedName(), CsectProp->MappingClass, CsectProp->Type,
-      Kind, QualName, Begin, CachedName, MultiSymbolsAllowed);
+  MCSectionXCOFF *Result = nullptr;
+  if (IsDWARFSec)
+    Result = new (XCOFFAllocator.Allocate())
+        MCSectionXCOFF(QualName->getUnqualifiedName(), Kind, QualName,
+                       DwarfSectionSubtypeFlags.getValue(), Begin, CachedName,
+                       MultiSymbolsAllowed);
+  else
+    Result = new (XCOFFAllocator.Allocate())
+        MCSectionXCOFF(QualName->getUnqualifiedName(), CsectProp->MappingClass,
+                       CsectProp->Type, Kind, QualName, Begin, CachedName,
+                       MultiSymbolsAllowed);
+
   Entry.second = Result;
 
   auto *F = new MCDataFragment();
   Result->getFragmentList().insert(Result->begin(), F);
   F->setParent(Result);
 
   if (Begin)
     Begin->setFragment(F);

llvm/lib/MC/MCDwarf.cpp

static inline uint64_t ScaleAddrDelta(MCContext &Context, uint64_t AddrDelta) {
   return AddrDelta / MinInsnLength;
 }
 
 //
 // This is called when an instruction is assembled into the specified section
 // and if there is information from the last .loc directive that has yet to have
 // a line entry made for it is made.
 //
-void MCDwarfLineEntry::Make(MCObjectStreamer *MCOS, MCSection *Section) {
+void MCDwarfLineEntry::make(MCStreamer *MCOS, MCSection *Section) {
   if (!MCOS->getContext().getDwarfLocSeen())
     return;
 
   // Create a symbol at in the current section for use in the line entry.
   MCSymbol *LineSym = MCOS->getContext().createTempSymbol();
   // Set the value of the symbol to use for the MCDwarfLineEntry.
   MCOS->emitLabel(LineSym);
 
makeStartPlusIntExpr(MCContext &Ctx, const MCSymbol &Start, int IntVal) {
   return Res;
 }
 
 //
 // This emits the Dwarf line table for the specified section from the entries
 // in the LineSection.
 //
 static inline void emitDwarfLineTable(
-    MCObjectStreamer *MCOS, MCSection *Section,
+    MCStreamer *MCOS, MCSection *Section,
     const MCLineSection::MCDwarfLineEntryCollection &LineEntries) {
   unsigned FileNum = 1;
   unsigned LastLine = 1;
   unsigned Column = 0;
   unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
   unsigned Isa = 0;
   unsigned Discriminator = 0;
   MCSymbol *LastLabel = nullptr;
static inline void emitDwarfLineTable(
   const MCAsmInfo *AsmInfo = Ctx.getAsmInfo();
   MCOS->emitDwarfAdvanceLineAddr(INT64_MAX, LastLabel, SectionEnd,
                                  AsmInfo->getCodePointerSize());
 }
 
 //
 // This emits the Dwarf file and the line tables.
 //
-void MCDwarfLineTable::Emit(MCObjectStreamer *MCOS,
-                            MCDwarfLineTableParams Params) {
+void MCDwarfLineTable::emit(MCStreamer *MCOS, MCDwarfLineTableParams Params) {
   MCContext &context = MCOS->getContext();
 
   auto &LineTables = context.getMCDwarfLineTables();
 
   // Bail out early so we don't switch to the debug_line section needlessly and
   // in doing so create an unnecessary (if empty) section.
   if (LineTables.empty())
     return;
 
   // In a v5 non-split line table, put the strings in a separate section.
   Optional<MCDwarfLineStr> LineStr;
   if (context.getDwarfVersion() >= 5)
     LineStr = MCDwarfLineStr(context);
 
   // Switch to the section where the table will be emitted into.
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection());
 
   // Handle the rest of the Compile Units.
   for (const auto &CUIDTablePair : LineTables) {
-    CUIDTablePair.second.EmitCU(MCOS, Params, LineStr);
+    CUIDTablePair.second.emitCU(MCOS, Params, LineStr);
   }
 
   if (LineStr)
     LineStr->emitSection(MCOS);
 }
 
 void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params,
                                MCSection *Section) const {
MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                              ArrayRef<char> StandardOpcodeLengths,
                              Optional<MCDwarfLineStr> &LineStr) const {
   MCContext &context = MCOS->getContext();
 
   // Create a symbol at the beginning of the line table.
   MCSymbol *LineStartSym = Label;
   if (!LineStartSym)
     LineStartSym = context.createTempSymbol();
+
   // Set the value of the symbol, as we are at the start of the line table.
-  MCOS->emitLabel(LineStartSym);
+  MCOS->emitDwarfLineStartLabel(LineStartSym);
 
   unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(context.getDwarfFormat());
 
   MCSymbol *LineEndSym = MCOS->emitDwarfUnitLength("debug_line", "unit length");
 
   // Next 2 bytes is the Version.
   unsigned LineTableVersion = context.getDwarfVersion();
   MCOS->emitInt16(LineTableVersion);
 
   // In v5, we get address info next.
   if (LineTableVersion >= 5) {
     MCOS->emitInt8(context.getAsmInfo()->getCodePointerSize());
     MCOS->emitInt8(0); // Segment selector; same as EmitGenDwarfAranges.
   }
 
   MCSymbol *ProStartSym = context.createTempSymbol();
 
   // Create a symbol for the end of the prologue (to be set when we get there).
   MCSymbol *ProEndSym = context.createTempSymbol(); // Lprologue_end
 
MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
 
   // This is the end of the prologue, so set the value of the symbol at the
   // end of the prologue (that was used in a previous expression).
   MCOS->emitLabel(ProEndSym);
 
   return std::make_pair(LineStartSym, LineEndSym);
 }
 
-void MCDwarfLineTable::EmitCU(MCObjectStreamer *MCOS,
-                              MCDwarfLineTableParams Params,
+void MCDwarfLineTable::emitCU(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                               Optional<MCDwarfLineStr> &LineStr) const {
   MCSymbol *LineEndSym = Header.Emit(MCOS, Params, LineStr).second;
 
   // Put out the line tables.
   for (const auto &LineSec : MCLineSections.getMCLineEntries())
     emitDwarfLineTable(MCOS, LineSec.first, LineSec.second);
 
   // This is the end of the section, so set the value of the symbol at the end

llvm/lib/MC/MCObjectFileInfo.cpp

void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
   CompactUnwindSection = Ctx->getXCOFFSection(
       ".eh_info_table", SectionKind::getData(),
       XCOFF::CsectProperties(XCOFF::StorageMappingClass::XMC_RW,
                              XCOFF::XTY_SD));
 
   // DWARF sections for XCOFF are not csects. They are special STYP_DWARF
   // sections, and the individual DWARF sections are distinguished by their
   // section subtype.
-  // TODO: Populate the DWARF sections appropriately.
-  DwarfAbbrevSection = nullptr;   // SSUBTYP_DWABREV
-  DwarfInfoSection = nullptr;     // SSUBTYP_DWINFO
-  DwarfLineSection = nullptr;     // SSUBTYP_DWLINE
-  DwarfFrameSection = nullptr;    // SSUBTYP_DWFRAME
-  DwarfPubNamesSection = nullptr; // SSUBTYP_DWPBNMS
-  DwarfPubTypesSection = nullptr; // SSUBTYP_DWPBTYP
-  DwarfStrSection = nullptr;      // SSUBTYP_DWSTR
-  DwarfLocSection = nullptr;      // SSUBTYP_DWLOC
-  DwarfARangesSection = nullptr;  // SSUBTYP_DWARNGE
-  DwarfRangesSection = nullptr;   // SSUBTYP_DWRNGES
-  DwarfMacinfoSection = nullptr;  // SSUBTYP_DWMAC
+  DwarfAbbrevSection = Ctx->getXCOFFSection(
+      ".dwabrev", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwabrev", XCOFF::SSUBTYP_DWABREV);
+
+  DwarfInfoSection = Ctx->getXCOFFSection(
+      ".dwinfo", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwinfo", XCOFF::SSUBTYP_DWINFO);
+
+  DwarfLineSection = Ctx->getXCOFFSection(
+      ".dwline", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwline", XCOFF::SSUBTYP_DWLINE);
+
+  DwarfFrameSection = Ctx->getXCOFFSection(
+      ".dwframe", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwframe", XCOFF::SSUBTYP_DWFRAME);
+
+  DwarfPubNamesSection = Ctx->getXCOFFSection(
+      ".dwpbnms", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwpbnms", XCOFF::SSUBTYP_DWPBNMS);
+
+  DwarfPubTypesSection = Ctx->getXCOFFSection(
+      ".dwpbtyp", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwpbtyp", XCOFF::SSUBTYP_DWPBTYP);
+
+  DwarfStrSection = Ctx->getXCOFFSection(
+      ".dwstr", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwstr", XCOFF::SSUBTYP_DWSTR);
+
+  DwarfLocSection = Ctx->getXCOFFSection(
+      ".dwloc", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwloc", XCOFF::SSUBTYP_DWLOC);
+
+  DwarfARangesSection = Ctx->getXCOFFSection(
+      ".dwarnge", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwarnge", XCOFF::SSUBTYP_DWARNGE);
+
+  DwarfRangesSection = Ctx->getXCOFFSection(
+      ".dwrnges", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwrnges", XCOFF::SSUBTYP_DWRNGES);
+
+  DwarfMacinfoSection = Ctx->getXCOFFSection(
+      ".dwmac", SectionKind::getMetadata(), /* CsectProperties */ None,
+      /* MultiSymbolsAllowed */ true, ".dwmac", XCOFF::SSUBTYP_DWMAC);
 }
 
 void MCObjectFileInfo::InitMCObjectFileInfo(const Triple &TheTriple, bool PIC,
                                             MCContext &ctx,
                                             bool LargeCodeModel) {
   PositionIndependent = PIC;
   Ctx = &ctx;
 

llvm/lib/MC/MCObjectStreamer.cpp

 }
 
 void MCObjectStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
                                      SMLoc Loc) {
   MCStreamer::emitValueImpl(Value, Size, Loc);
   MCDataFragment *DF = getOrCreateDataFragment();
   flushPendingLabels(DF, DF->getContents().size());
 
-  MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
+  MCDwarfLineEntry::make(this, getCurrentSectionOnly());
 
   // Avoid fixups when possible.
   int64_t AbsValue;
   if (Value->evaluateAsAbsolute(AbsValue, getAssemblerPtr())) {
     if (!isUIntN(8 * Size, AbsValue) && !isIntN(8 * Size, AbsValue)) {
       getContext().reportError(
           Loc, "value evaluated as " + Twine(AbsValue) + " is out of range.");
       return;
void MCObjectStreamer::emitInstructionImpl(const MCInst &Inst,
                                            const MCSubtargetInfo &STI) {
   MCStreamer::emitInstruction(Inst, STI);
 
   MCSection *Sec = getCurrentSectionOnly();
   Sec->setHasInstructions(true);
 
   // Now that a machine instruction has been assembled into this section, make
   // a line entry for any .loc directive that has been seen.
-  MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
+  MCDwarfLineEntry::make(this, getCurrentSectionOnly());
 
   // If this instruction doesn't need relaxation, just emit it as data.
   MCAssembler &Assembler = getAssembler();
   MCAsmBackend &Backend = Assembler.getBackend();
   if (!(Backend.mayNeedRelaxation(Inst, STI) ||
         Backend.allowEnhancedRelaxation())) {
     emitInstToData(Inst, STI);
     return;

 
 void MCObjectStreamer::emitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                              unsigned Column, unsigned Flags,
                                              unsigned Isa,
                                              unsigned Discriminator,
                                              StringRef FileName) {
   // In case we see two .loc directives in a row, make sure the
   // first one gets a line entry.
-  MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
+  MCDwarfLineEntry::make(this, getCurrentSectionOnly());
 
   this->MCStreamer::emitDwarfLocDirective(FileNo, Line, Column, Flags, Isa,
                                           Discriminator, FileName);
 }
 
 static const MCExpr *buildSymbolDiff(MCObjectStreamer &OS, const MCSymbol *A,
                                      const MCSymbol *B) {
   MCContext &Context = OS.getContext();
void MCObjectStreamer::emitCVFileChecksumsDirective() {
   getContext().getCVContext().emitFileChecksums(*this);
 }
 
 void MCObjectStreamer::emitCVFileChecksumOffsetDirective(unsigned FileNo) {
   getContext().getCVContext().emitFileChecksumOffset(*this, FileNo);
 }
 
 void MCObjectStreamer::emitBytes(StringRef Data) {
-  MCDwarfLineEntry::Make(this, getCurrentSectionOnly());
+  MCDwarfLineEntry::make(this, getCurrentSectionOnly());
   MCDataFragment *DF = getOrCreateDataFragment();
   flushPendingLabels(DF, DF->getContents().size());
   DF->getContents().append(Data.begin(), Data.end());
 }
 
 void MCObjectStreamer::emitValueToAlignment(unsigned ByteAlignment,
                                             int64_t Value,
                                             unsigned ValueSize,

 void MCObjectStreamer::finishImpl() {
   getContext().RemapDebugPaths();
 
   // If we are generating dwarf for assembly source files dump out the sections.
   if (getContext().getGenDwarfForAssembly())
     MCGenDwarfInfo::Emit(this);
 
   // Dump out the dwarf file & directory tables and line tables.
-  MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
+  MCDwarfLineTable::emit(this, getAssembler().getDWARFLinetableParams());
 
   // Emit pseudo probes for the current module.
   MCPseudoProbeTable::emit(this);
 
   // Update any remaining pending labels with empty data fragments.
   flushPendingLabels();
 
   resolvePendingFixups();
   getAssembler().Finish();
 }

llvm/lib/MC/MCSectionXCOFF.cpp

 //===- lib/MC/MCSectionXCOFF.cpp - XCOFF Code Section Representation ------===//
 //
 // 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/MC/MCSectionXCOFF.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCExpr.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 MCSectionXCOFF::~MCSectionXCOFF() = default;
 
 void MCSectionXCOFF::printCsectDirective(raw_ostream &OS) const {
   OS << "\t.csect " << QualName->getName() << "," << Log2_32(getAlignment())
if (getKind().isBSSLocal() || getKind().isCommon()) {
     assert(getCSectType() == XCOFF::XTY_CM &&
            "wrong csect type for .bss csect");
     // Don't have to print a directive for switching to section for commons.
     // '.comm' and '.lcomm' directives for the variable will create the needed
     // csect.
     return;
   }
 
+  // XCOFF debug sections.
+  if (getKind().isMetadata() && isDWARFSect()) {
+    OS << "\n\t.dwsect "
+       << format("0x%" PRIx32, getDwarfSubtypeFlags().getValue()) << '\n';
+    OS << MAI.getPrivateLabelPrefix() << getName() << ':' << '\n';
+    return;
+  }
+
   report_fatal_error("Printing for this SectionKind is unimplemented.");
 }
 
 bool MCSectionXCOFF::UseCodeAlign() const { return getKind().isText(); }
 
 bool MCSectionXCOFF::isVirtualSection() const {
   assert(isCsect() && "Only csect section can be virtual!");
   return XCOFF::XTY_CM == CsectProp->Type;
 }

llvm/lib/MC/MCStreamer.cpp

MCSymbol *MCStreamer::emitDwarfUnitLength(const Twine &Prefix,
   emitAbsoluteSymbolDiff(
       Hi, Lo, dwarf::getDwarfOffsetByteSize(Context.getDwarfFormat()));
   // emit the begin symbol after we generate the length field.
   emitLabel(Lo);
   // Return the Hi symbol to the caller.
   return Hi;
 }
 
+void MCStreamer::emitDwarfLineStartLabel(MCSymbol *StartSym) {
+  // Set the value of the symbol, as we are at the start of the line table.
+  emitLabel(StartSym);
+}
+
 void MCStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
   visitUsedExpr(*Value);
   Symbol->setVariableValue(Value);
 
   MCTargetStreamer *TS = getTargetStreamer();
   if (TS)
     TS->emitAssignment(Symbol, Value);
 }

llvm/lib/MC/MCSymbolXCOFF.cpp

 //===- lib/MC/MCSymbolXCOFF.cpp - XCOFF Code Symbol Representation --------===//
 //
 // 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/MC/MCSectionXCOFF.h"
 
 using namespace llvm;
 
 MCSectionXCOFF *MCSymbolXCOFF::getRepresentedCsect() const {
   assert(RepresentedCsect &&
          "Trying to get csect representation of this symbol but none was set.");
-  assert(!getName().equals(getUnqualifiedName()) &&
-         "Symbol does not represent a csect; MCSectionXCOFF that represents "
-         "the symbol should not be (but is) set.");
   assert(getSymbolTableName().equals(RepresentedCsect->getSymbolTableName()) &&
          "SymbolTableNames need to be the same for this symbol and its csect "
          "representation.");
   return RepresentedCsect;
 }
 
 void MCSymbolXCOFF::setRepresentedCsect(MCSectionXCOFF *C) {
   assert(C && "Assigned csect should not be null.");
   assert((!RepresentedCsect || RepresentedCsect == C) &&
          "Trying to set a csect that doesn't match the one that this symbol is "
          "already mapped to.");
-  assert(!getName().equals(getUnqualifiedName()) &&
-         "Symbol does not represent a csect; can only set a MCSectionXCOFF "
-         "representation for a csect.");
   assert(getSymbolTableName().equals(C->getSymbolTableName()) &&
          "SymbolTableNames need to be the same for this symbol and its csect "
          "representation.");
   RepresentedCsect = C;
 }

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCAsmInfo.cpp

 
 PPCXCOFFMCAsmInfo::PPCXCOFFMCAsmInfo(bool Is64Bit, const Triple &T) {
   if (T.getArch() == Triple::ppc64le || T.getArch() == Triple::ppcle)
     report_fatal_error("XCOFF is not supported for little-endian targets");
   CodePointerSize = CalleeSaveStackSlotSize = Is64Bit ? 8 : 4;
 
   // A size of 8 is only supported by the assembler under 64-bit.
   Data64bitsDirective = Is64Bit ? "\t.vbyte\t8, " : nullptr;
+
+  // Debug Information
+  SupportsDebugInformation = true;
+
+  // Set up DWARF directives
+  MinInstAlignment = 4;
 }

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   FnDescSec->setAlignment(Align(Subtarget->isPPC64() ? 8 : 4));
 
   CurrentFnDescSym = FnDescSec->getQualNameSymbol();
 
   return AsmPrinter::SetupMachineFunction(MF);
 }
 
 void PPCAIXAsmPrinter::emitFunctionBodyEnd() {
+  // When -function-sections is enabled, generating function section end symbol
+  // to tell debug line section where is the end of current function section.
+  if (TM.getFunctionSections() && !MAI->usesDwarfFileAndLocDirectives() &&
+      MMI->hasDebugInfo())
+    OutStreamer->doFinalizationAtSectionEnd(MF->getSection());
 
-  if (!TM.getXCOFFTracebackTable())
-    return;
-
+  if (TM.getXCOFFTracebackTable())
     emitTracebackTable();
 }
 
 void PPCAIXAsmPrinter::emitTracebackTable() {
 
   // Create a symbol for the end of function.
   MCSymbol *FuncEnd = createTempSymbol(MF->getName());
   OutStreamer->emitLabel(FuncEnd);
 
   OutStreamer->AddComment("Traceback table begin");
case PPC::TAILBCTR8:
     if (MI->getOperand(0).isSymbol())
       report_fatal_error("Tail call for extern symbol not yet supported.");
     break;
   }
   return PPCAsmPrinter::emitInstruction(MI);
 }
 
 bool PPCAIXAsmPrinter::doFinalization(Module &M) {
+  // Do streamer related finalization for DWARF.
+  if (!MAI->usesDwarfFileAndLocDirectives() && MMI->hasDebugInfo())
+    OutStreamer->doFinalizationAtSectionEnd(
+        OutStreamer->getContext().getObjectFileInfo()->getTextSection());
+
   for (MCSymbol *Sym : ExtSymSDNodeSymbols)
     OutStreamer->emitSymbolAttribute(Sym, MCSA_Extern);
   return PPCAsmPrinter::doFinalization(M);
 }
 
 static unsigned mapToSinitPriority(int P) {
   if (P < 0 || P > 65535)
     report_fatal_error("invalid init priority");

llvm/test/DebugInfo/XCOFF/empty.ll

+
+; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | \
+; RUN:   FileCheck %s --check-prefix=ASM32
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | \
+; RUN:   FileCheck %s --check-prefix=ASM64
+
+source_filename = "1.c"
+target datalayout = "E-m:a-p:32:32-i64:64-n32"
+
+; Function Attrs: noinline nounwind optnone
+define i32 @main() #0 !dbg !8 {
+entry:
+  %retval = alloca i32, align 4
+  store i32 0, i32* %retval, align 4
+  ret i32 0, !dbg !12
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "1.c", directory: "debug")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 2}
+!6 = !{i32 7, !"PIC Level", i32 2}
+!7 = !{!"clang version 12.0.0"}
+!8 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 1, type: !9, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!11}
+!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!12 = !DILocation(line: 3, column: 3, scope: !8)
+
+; ASM32:   .csect .text[PR],2
+; ASM32-NEXT:   .file   "1.c"
+; ASM32-NEXT:   .globl  main[DS]                        # -- Begin function main
+; ASM32-NEXT:   .globl  .main
+; ASM32-NEXT:   .align  2
+; ASM32-NEXT:   .csect main[DS],2
+; ASM32-NEXT:   .vbyte  4, .main                        # @main
+; ASM32-NEXT:   .vbyte  4, TOC[TC0]
+; ASM32-NEXT:   .vbyte  4, 0
+; ASM32-NEXT:   .csect .text[PR],2
+; ASM32-NEXT:  .main:
+; ASM32-NEXT:  L..func_begin0:
+; ASM32-NEXT:  # %bb.0:                                # %entry
+; ASM32-NEXT:  L..tmp0:
+; ASM32-NEXT:   li 4, 0
+; ASM32-NEXT:  L..tmp1:
+; ASM32-NEXT:  L..tmp2:
+; ASM32-NEXT:   li 3, 0
+; ASM32-NEXT:   stw 4, -4(1)
+; ASM32-NEXT:   blr
+; ASM32-NEXT:  L..tmp3:
+; ASM32-NEXT:  L..main0:
+; ASM32-NEXT:   .vbyte  4, 0x00000000                   # Traceback table begin
+; ASM32-NEXT:   .byte   0x00                            # Version = 0
+; ASM32-NEXT:   .byte   0x09                            # Language = CPlusPlus
+; ASM32-NEXT:   .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
+; ASM32-NEXT:                                          # +HasTraceBackTableOffset, -IsInternalProcedure
+; ASM32-NEXT:                                          # -HasControlledStorage, -IsTOCless
+; ASM32-NEXT:                                          # -IsFloatingPointPresent
+; ASM32-NEXT:                                          # -IsFloatingPointOperationLogOrAbortEnabled
+; ASM32-NEXT:   .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
+; ASM32-NEXT:                                          # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
+; ASM32-NEXT:   .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+; ASM32-NEXT:   .byte   0x00                            # -HasVectorInfo, -HasExtensionTable, NumOfGPRsSaved = 0
+; ASM32-NEXT:   .byte   0x00                            # NumberOfFixedParms = 0
+; ASM32-NEXT:   .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
+; ASM32-NEXT:   .vbyte  4, L..main0-.main               # Function size
+; ASM32-NEXT:   .vbyte  2, 0x0004                       # Function name len = 4
+; ASM32-NEXT:   .byte   'm,'a,'i,'n                     # Function Name
+; ASM32-NEXT:  L..func_end0:
+; ASM32-NEXT:                                          # -- End function
+; ASM32-NEXT:  L..sec_end0:
+; ASM32:       .dwsect 0x60000
+; ASM32-NEXT:  L...dwabrev:
+; ASM32-NEXT:   .byte   1                               # Abbreviation Code
+; ASM32-NEXT:   .byte   17                              # DW_TAG_compile_unit
+; ASM32-NEXT:   .byte   1                               # DW_CHILDREN_yes
+; ASM32-NEXT:   .byte   37                              # DW_AT_producer
+; ASM32-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM32-NEXT:   .byte   19                              # DW_AT_language
+; ASM32-NEXT:   .byte   5                               # DW_FORM_data2
+; ASM32-NEXT:   .byte   3                               # DW_AT_name
+; ASM32-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM32-NEXT:   .byte   16                              # DW_AT_stmt_list
+; ASM32-NEXT:   .byte   23                              # DW_FORM_sec_offset
+; ASM32-NEXT:   .byte   27                              # DW_AT_comp_dir
+; ASM32-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM32-NEXT:   .byte   17                              # DW_AT_low_pc
+; ASM32-NEXT:   .byte   1                               # DW_FORM_addr
+; ASM32-NEXT:   .byte   18                              # DW_AT_high_pc
+; ASM32-NEXT:   .byte   6                               # DW_FORM_data4
+; ASM32-NEXT:   .byte   0                               # EOM(1)
+; ASM32-NEXT:   .byte   0                               # EOM(2)
+; ASM32-NEXT:   .byte   2                               # Abbreviation Code
+; ASM32-NEXT:   .byte   46                              # DW_TAG_subprogram
+; ASM32-NEXT:   .byte   0                               # DW_CHILDREN_no
+; ASM32-NEXT:   .byte   17                              # DW_AT_low_pc
+; ASM32-NEXT:   .byte   1                               # DW_FORM_addr
+; ASM32-NEXT:   .byte   18                              # DW_AT_high_pc
+; ASM32-NEXT:   .byte   6                               # DW_FORM_data4
+; ASM32-NEXT:   .byte   64                              # DW_AT_frame_base
+; ASM32-NEXT:   .byte   24                              # DW_FORM_exprloc
+; ASM32-NEXT:   .byte   3                               # DW_AT_name
+; ASM32-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM32-NEXT:   .byte   58                              # DW_AT_decl_file
+; ASM32-NEXT:   .byte   11                              # DW_FORM_data1
+; ASM32-NEXT:   .byte   59                              # DW_AT_decl_line
+; ASM32-NEXT:   .byte   11                              # DW_FORM_data1
+; ASM32-NEXT:   .byte   39                              # DW_AT_prototyped
+; ASM32-NEXT:   .byte   25                              # DW_FORM_flag_present
+; ASM32-NEXT:   .byte   73                              # DW_AT_type
+; ASM32-NEXT:   .byte   19                              # DW_FORM_ref4
+; ASM32-NEXT:   .byte   63                              # DW_AT_external
+; ASM32-NEXT:   .byte   25                              # DW_FORM_flag_present
+; ASM32-NEXT:   .byte   0                               # EOM(1)
+; ASM32-NEXT:   .byte   0                               # EOM(2)
+; ASM32-NEXT:   .byte   3                               # Abbreviation Code
+; ASM32-NEXT:   .byte   36                              # DW_TAG_base_type
+; ASM32-NEXT:   .byte   0                               # DW_CHILDREN_no
+; ASM32-NEXT:   .byte   3                               # DW_AT_name
+; ASM32-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM32-NEXT:   .byte   62                              # DW_AT_encoding
+; ASM32-NEXT:   .byte   11                              # DW_FORM_data1
+; ASM32-NEXT:   .byte   11                              # DW_AT_byte_size
+; ASM32-NEXT:   .byte   11                              # DW_FORM_data1
+; ASM32-NEXT:   .byte   0                               # EOM(1)
+; ASM32-NEXT:   .byte   0                               # EOM(2)
+; ASM32-NEXT:   .byte   0                               # EOM(3)
+; ASM32:        .dwsect 0x10000
+; ASM32-NEXT:  L...dwinfo:
+; ASM32-NEXT:  L..cu_begin0:
+; ASM32-NEXT:   .vbyte  2, 4                            # DWARF version number
+; ASM32-NEXT:   .vbyte  4, L...dwabrev                  # Offset Into Abbrev. Section
+; ASM32-NEXT:   .byte   4                               # Address Size (in bytes)
+; ASM32-NEXT:   .byte   1                               # Abbrev [1] 0xb:0x38 DW_TAG_compile_unit
+; ASM32-NEXT:   .vbyte  4, L..info_string0              # DW_AT_producer
+; ASM32-NEXT:   .vbyte  2, 12                           # DW_AT_language
+; ASM32-NEXT:   .vbyte  4, L..info_string1              # DW_AT_name
+; ASM32-NEXT:   .vbyte  4, L..line_table_start0         # DW_AT_stmt_list
+; ASM32-NEXT:   .vbyte  4, L..info_string2              # DW_AT_comp_dir
+; ASM32-NEXT:   .vbyte  4, L..func_begin0               # DW_AT_low_pc
+; ASM32-NEXT:   .vbyte  4, L..func_end0-L..func_begin0  # DW_AT_high_pc
+; ASM32-NEXT:   .byte   2                               # Abbrev [2] 0x26:0x15 DW_TAG_subprogram
+; ASM32-NEXT:   .vbyte  4, L..func_begin0               # DW_AT_low_pc
+; ASM32-NEXT:   .vbyte  4, L..func_end0-L..func_begin0  # DW_AT_high_pc
+; ASM32-NEXT:   .byte   1                               # DW_AT_frame_base
+; ASM32-NEXT:   .byte   81
+; ASM32-NEXT:   .vbyte  4, L..info_string3              # DW_AT_name
+; ASM32-NEXT:   .byte   1                               # DW_AT_decl_file
+; ASM32-NEXT:   .byte   1                               # DW_AT_decl_line
+; ASM32-NEXT:                                          # DW_AT_prototyped
+; ASM32-NEXT:   .vbyte  4, 59                           # DW_AT_type
+; ASM32-NEXT:                                          # DW_AT_external
+; ASM32-NEXT:   .byte   3                               # Abbrev [3] 0x3b:0x7 DW_TAG_base_type
+; ASM32-NEXT:   .vbyte  4, L..info_string4              # DW_AT_name
+; ASM32-NEXT:   .byte   5                               # DW_AT_encoding
+; ASM32-NEXT:   .byte   4                               # DW_AT_byte_size
+; ASM32-NEXT:   .byte   0                               # End Of Children Mark
+; ASM32-NEXT:  L..debug_info_end0:
+; ASM32:        .dwsect 0x70000
+; ASM32-NEXT:  L...dwstr:
+; ASM32-NEXT:  L..info_string0:
+; ASM32-NEXT:   .byte   'c,'l,'a,'n,'g,' ,'v,'e,'r,'s,'i,'o,'n,' ,'1,'2,'.,'0,'.,'0,0000 # string offset=0
+; ASM32-NEXT:  L..info_string1:
+; ASM32-NEXT:   .byte   '1,'.,'c,0000                   # string offset=21
+; ASM32-NEXT:  L..info_string2:
+; ASM32-NEXT:   .byte   'd,'e,'b,'u,'g,0000             # string offset=25
+; ASM32-NEXT:  L..info_string3:
+; ASM32-NEXT:   .byte   'm,'a,'i,'n,0000                # string offset=31
+; ASM32-NEXT:  L..info_string4:
+; ASM32-NEXT:   .byte   'i,'n,'t,0000                   # string offset=36
+; ASM32-NEXT:   .toc
+; ASM32:        .dwsect 0x20000
+; ASM32-NEXT:  L...dwline:
+; ASM32-NEXT:  L..debug_line_0:
+; ASM32-NEXT:  .set L..line_table_start0, L..debug_line_0-4
+; ASM32-NEXT:   .vbyte  2, 4
+; ASM32-NEXT:   .vbyte  4, L..tmp5-L..tmp4
+; ASM32-NEXT:  L..tmp4:
+; ASM32-NEXT:   .byte   4
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   -5
+; ASM32-NEXT:   .byte   14
+; ASM32-NEXT:   .byte   13
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   'd,'e,'b,'u,'g
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   '1,'.,'c
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:  L..tmp5:
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   5
+; ASM32-NEXT:   .byte   2
+; ASM32-NEXT:   .vbyte  4, L..tmp0
+; ASM32-NEXT:   .byte   19
+; ASM32-NEXT:   .byte   5
+; ASM32-NEXT:   .byte   3
+; ASM32-NEXT:   .byte   10
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   5
+; ASM32-NEXT:   .byte   2
+; ASM32-NEXT:   .vbyte  4, L..tmp2
+; ASM32-NEXT:   .byte   3
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   5
+; ASM32-NEXT:   .byte   2
+; ASM32-NEXT:   .vbyte  4, L..sec_end0
+; ASM32-NEXT:   .byte   0
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:   .byte   1
+; ASM32-NEXT:  L..debug_line_end0:
+
+; ASM64:        .csect .text[PR],2
+; ASM64-NEXT:   .file   "1.c"
+; ASM64-NEXT:   .globl  main[DS]                        # -- Begin function main
+; ASM64-NEXT:   .globl  .main
+; ASM64-NEXT:   .align  2
+; ASM64-NEXT:   .csect main[DS],3
+; ASM64-NEXT:   .vbyte  8, .main                        # @main
+; ASM64-NEXT:   .vbyte  8, TOC[TC0]
+; ASM64-NEXT:   .vbyte  8, 0
+; ASM64-NEXT:   .csect .text[PR],2
+; ASM64-NEXT:  .main:
+; ASM64-NEXT:  L..func_begin0:
+; ASM64-NEXT:  # %bb.0:                                # %entry
+; ASM64-NEXT:  L..tmp0:
+; ASM64-NEXT:   li 4, 0
+; ASM64-NEXT:  L..tmp1:
+; ASM64-NEXT:  L..tmp2:
+; ASM64-NEXT:   li 3, 0
+; ASM64-NEXT:   stw 4, -4(1)
+; ASM64-NEXT:   blr
+; ASM64-NEXT:  L..tmp3:
+; ASM64-NEXT:  L..main0:
+; ASM64-NEXT:   .vbyte  4, 0x00000000                   # Traceback table begin
+; ASM64-NEXT:   .byte   0x00                            # Version = 0
+; ASM64-NEXT:   .byte   0x09                            # Language = CPlusPlus
+; ASM64-NEXT:   .byte   0x20                            # -IsGlobaLinkage, -IsOutOfLineEpilogOrPrologue
+; ASM64-NEXT:                                          # +HasTraceBackTableOffset, -IsInternalProcedure
+; ASM64-NEXT:                                          # -HasControlledStorage, -IsTOCless
+; ASM64-NEXT:                                          # -IsFloatingPointPresent
+; ASM64-NEXT:                                          # -IsFloatingPointOperationLogOrAbortEnabled
+; ASM64-NEXT:   .byte   0x40                            # -IsInterruptHandler, +IsFunctionNamePresent, -IsAllocaUsed
+; ASM64-NEXT:                                          # OnConditionDirective = 0, -IsCRSaved, -IsLRSaved
+; ASM64-NEXT:   .byte   0x80                            # +IsBackChainStored, -IsFixup, NumOfFPRsSaved = 0
+; ASM64-NEXT:   .byte   0x00                            # -HasVectorInfo, -HasExtensionTable, NumOfGPRsSaved = 0
+; ASM64-NEXT:   .byte   0x00                            # NumberOfFixedParms = 0
+; ASM64-NEXT:   .byte   0x01                            # NumberOfFPParms = 0, +HasParmsOnStack
+; ASM64-NEXT:   .vbyte  4, L..main0-.main               # Function size
+; ASM64-NEXT:   .vbyte  2, 0x0004                       # Function name len = 4
+; ASM64-NEXT:   .byte   'm,'a,'i,'n                     # Function Name
+; ASM64-NEXT:  L..func_end0:
+; ASM64-NEXT:                                          # -- End function
+; ASM64-NEXT:  L..sec_end0:
+; ASM64:        .dwsect 0x60000
+; ASM64-NEXT:  L...dwabrev:
+; ASM64-NEXT:   .byte   1                               # Abbreviation Code
+; ASM64-NEXT:   .byte   17                              # DW_TAG_compile_unit
+; ASM64-NEXT:   .byte   1                               # DW_CHILDREN_yes
+; ASM64-NEXT:   .byte   37                              # DW_AT_producer
+; ASM64-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM64-NEXT:   .byte   19                              # DW_AT_language
+; ASM64-NEXT:   .byte   5                               # DW_FORM_data2
+; ASM64-NEXT:   .byte   3                               # DW_AT_name
+; ASM64-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM64-NEXT:   .byte   16                              # DW_AT_stmt_list
+; ASM64-NEXT:   .byte   23                              # DW_FORM_sec_offset
+; ASM64-NEXT:   .byte   27                              # DW_AT_comp_dir
+; ASM64-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM64-NEXT:   .byte   17                              # DW_AT_low_pc
+; ASM64-NEXT:   .byte   1                               # DW_FORM_addr
+; ASM64-NEXT:   .byte   18                              # DW_AT_high_pc
+; ASM64-NEXT:   .byte   6                               # DW_FORM_data4
+; ASM64-NEXT:   .byte   0                               # EOM(1)
+; ASM64-NEXT:   .byte   0                               # EOM(2)
+; ASM64-NEXT:   .byte   2                               # Abbreviation Code
+; ASM64-NEXT:   .byte   46                              # DW_TAG_subprogram
+; ASM64-NEXT:   .byte   0                               # DW_CHILDREN_no
+; ASM64-NEXT:   .byte   17                              # DW_AT_low_pc
+; ASM64-NEXT:   .byte   1                               # DW_FORM_addr
+; ASM64-NEXT:   .byte   18                              # DW_AT_high_pc
+; ASM64-NEXT:   .byte   6                               # DW_FORM_data4
+; ASM64-NEXT:   .byte   64                              # DW_AT_frame_base
+; ASM64-NEXT:   .byte   24                              # DW_FORM_exprloc
+; ASM64-NEXT:   .byte   3                               # DW_AT_name
+; ASM64-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM64-NEXT:   .byte   58                              # DW_AT_decl_file
+; ASM64-NEXT:   .byte   11                              # DW_FORM_data1
+; ASM64-NEXT:   .byte   59                              # DW_AT_decl_line
+; ASM64-NEXT:   .byte   11                              # DW_FORM_data1
+; ASM64-NEXT:   .byte   39                              # DW_AT_prototyped
+; ASM64-NEXT:   .byte   25                              # DW_FORM_flag_present
+; ASM64-NEXT:   .byte   73                              # DW_AT_type
+; ASM64-NEXT:   .byte   19                              # DW_FORM_ref4
+; ASM64-NEXT:   .byte   63                              # DW_AT_external
+; ASM64-NEXT:   .byte   25                              # DW_FORM_flag_present
+; ASM64-NEXT:   .byte   0                               # EOM(1)
+; ASM64-NEXT:   .byte   0                               # EOM(2)
+; ASM64-NEXT:   .byte   3                               # Abbreviation Code
+; ASM64-NEXT:   .byte   36                              # DW_TAG_base_type
+; ASM64-NEXT:   .byte   0                               # DW_CHILDREN_no
+; ASM64-NEXT:   .byte   3                               # DW_AT_name
+; ASM64-NEXT:   .byte   14                              # DW_FORM_strp
+; ASM64-NEXT:   .byte   62                              # DW_AT_encoding
+; ASM64-NEXT:   .byte   11                              # DW_FORM_data1
+; ASM64-NEXT:   .byte   11                              # DW_AT_byte_size
+; ASM64-NEXT:   .byte   11                              # DW_FORM_data1
+; ASM64-NEXT:   .byte   0                               # EOM(1)
+; ASM64-NEXT:   .byte   0                               # EOM(2)
+; ASM64-NEXT:   .byte   0                               # EOM(3)
+; ASM64:        .dwsect 0x10000
+; ASM64-NEXT:  L...dwinfo:
+; ASM64-NEXT:  L..cu_begin0:
+; ASM64-NEXT:   .vbyte  2, 4                            # DWARF version number
+; ASM64-NEXT:   .vbyte  8, L...dwabrev                  # Offset Into Abbrev. Section
+; ASM64-NEXT:   .byte   8                               # Address Size (in bytes)
+; ASM64-NEXT:   .byte   1                               # Abbrev [1] 0x17:0x58 DW_TAG_compile_unit
+; ASM64-NEXT:   .vbyte  8, L..info_string0              # DW_AT_producer
+; ASM64-NEXT:   .vbyte  2, 12                           # DW_AT_language
+; ASM64-NEXT:   .vbyte  8, L..info_string1              # DW_AT_name
+; ASM64-NEXT:   .vbyte  8, L..line_table_start0         # DW_AT_stmt_list
+; ASM64-NEXT:   .vbyte  8, L..info_string2              # DW_AT_comp_dir
+; ASM64-NEXT:   .vbyte  8, L..func_begin0               # DW_AT_low_pc
+; ASM64-NEXT:   .vbyte  4, L..func_end0-L..func_begin0  # DW_AT_high_pc
+; ASM64-NEXT:   .byte   2                               # Abbrev [2] 0x46:0x1d DW_TAG_subprogram
+; ASM64-NEXT:   .vbyte  8, L..func_begin0               # DW_AT_low_pc
+; ASM64-NEXT:   .vbyte  4, L..func_end0-L..func_begin0  # DW_AT_high_pc
+; ASM64-NEXT:   .byte   1                               # DW_AT_frame_base
+; ASM64-NEXT:   .byte   81
+; ASM64-NEXT:   .vbyte  8, L..info_string3              # DW_AT_name
+; ASM64-NEXT:   .byte   1                               # DW_AT_decl_file
+; ASM64-NEXT:   .byte   1                               # DW_AT_decl_line
+; ASM64-NEXT:                                          # DW_AT_prototyped
+; ASM64-NEXT:   .vbyte  4, 99                           # DW_AT_type
+; ASM64-NEXT:                                          # DW_AT_external
+; ASM64-NEXT:   .byte   3                               # Abbrev [3] 0x63:0xb DW_TAG_base_type
+; ASM64-NEXT:   .vbyte  8, L..info_string4              # DW_AT_name
+; ASM64-NEXT:   .byte   5                               # DW_AT_encoding
+; ASM64-NEXT:   .byte   4                               # DW_AT_byte_size
+; ASM64-NEXT:   .byte   0                               # End Of Children Mark
+; ASM64-NEXT:  L..debug_info_end0:
+; ASM64:        .dwsect 0x70000
+; ASM64-NEXT:  L...dwstr:
+; ASM64-NEXT:  L..info_string0:
+; ASM64-NEXT:   .byte   'c,'l,'a,'n,'g,' ,'v,'e,'r,'s,'i,'o,'n,' ,'1,'2,'.,'0,'.,'0,0000 # string offset=0
+; ASM64-NEXT:  L..info_string1:
+; ASM64-NEXT:   .byte   '1,'.,'c,0000                   # string offset=21
+; ASM64-NEXT:  L..info_string2:
+; ASM64-NEXT:   .byte   'd,'e,'b,'u,'g,0000             # string offset=25
+; ASM64-NEXT:  L..info_string3:
+; ASM64-NEXT:   .byte   'm,'a,'i,'n,0000                # string offset=31
+; ASM64-NEXT:  L..info_string4:
+; ASM64-NEXT:   .byte   'i,'n,'t,0000                   # string offset=36
+; ASM64-NEXT:   .toc
+; ASM64:        .dwsect 0x20000
+; ASM64-NEXT:  L...dwline:
+; ASM64-NEXT:  L..debug_line_0:
+; ASM64-NEXT:  .set L..line_table_start0, L..debug_line_0-12
+; ASM64-NEXT:   .vbyte  2, 4
+; ASM64-NEXT:   .vbyte  8, L..tmp5-L..tmp4
+; ASM64-NEXT:  L..tmp4:
+; ASM64-NEXT:   .byte   4
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   -5
+; ASM64-NEXT:   .byte   14
+; ASM64-NEXT:   .byte   13
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   'd,'e,'b,'u,'g
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   '1,'.,'c
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:  L..tmp5:
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   9
+; ASM64-NEXT:   .byte   2
+; ASM64-NEXT:   .vbyte  8, L..tmp0
+; ASM64-NEXT:   .byte   19
+; ASM64-NEXT:   .byte   5
+; ASM64-NEXT:   .byte   3
+; ASM64-NEXT:   .byte   10
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   9
+; ASM64-NEXT:   .byte   2
+; ASM64-NEXT:   .vbyte  8, L..tmp2
+; ASM64-NEXT:   .byte   3
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   9
+; ASM64-NEXT:   .byte   2
+; ASM64-NEXT:   .vbyte  8, L..sec_end0
+; ASM64-NEXT:   .byte   0
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:   .byte   1
+; ASM64-NEXT:  L..debug_line_end0:

llvm/test/DebugInfo/XCOFF/lit.local.cfg

+if not 'PowerPC' in config.root.targets:
+    config.unsupported = True