[DebugInfo]: Support for debug_loclists.dwo section in llvm and llvm-dwarfdump.

[SouraVX]

Summary

This patch adds support for debug_loclists.dwo section in llvm and llvm-dwarfdump.
Also Fixes PR43622, PR43623.

[aprantl]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2504

This function looks like it may be more readable if it were organized like this:

if (getDwarfVersion() >= 5) {
  for (const auto &List : DebugLocs.getLists())
    ...
} else /* DWARF v2-4 */ {
  for (const auto &List : DebugLocs.getLists())
    ...
}

2521

Can you please make sure all comments are complete sentences ending in a .?

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1164–1169

This is a bit of a surprising/uncommon piece of code (using a conditional operator without using its result, and using the comma operator). Probably best to use more common constructs for this sort of situation.

I don't think there's any need to name the label differently (loclists_table_base/loclists_dwo_table_base) depending on dwo usage. Probably just keep it with a single/the same name always (loclists_table_base).

2483–2499

This function handles the pre-standard loclists format (which can't use some of the new/more compact encoding options available in DWARFv5 - as the comment inside the loop mentions)

It'd be better to reuse the emitDebugLoc() function (refactored to be able to use the appropriate .dwo section in some way (either add a function parameter, or choose the section based on whether Split DWARF is enabled, etc)) because it now has some advanced handling of choosing base address selection entries, etc.

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

96–98

I'm /guessing/ this is probably not compatible with DWP files (the DWARFUnit's "LocSectionData" is carefully populated from the DWP's cu_index - see DWARFUnit's ctor & try testing dumping of a DWP file (admittedly, there's no DWP tool that can produce a DWP file for DWARFv5 right now, so you'd have to hand-craft one/locally patch llvm-dwp).

llvm/test/DebugInfo/Inputs/dwarfdump-test-loclists-dwo.c

1–18 ↗

(On Diff #226538)

Probably easier/better to add extra RUN/check to test/DebugInfo/X86/sret.ll - see my changes in r374600: http://llvm.org/viewvc/llvm-project?view=revision&revision=374600

[SouraVX]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1164–1169

Yeah, I'll clean this up in next revision. basically I was only interested in creating symbol based on whether we are in split mode or not. So didn't bothered to check the result of ternary operator.

2483–2499

Hi @dblaikie, Thanks for reviewing this.
Primary reason why I added {loclists.dwo} code to this function is because --
top level bifurcation of emission is based on "split or not"--

if (useSplitDwarf())

  emitDebugLocDWO();   -- this handles both v4 and v5 loc and loclists format
else
  // Emit info into a debug loc section.
  emitDebugLoc(); -- as you, mentioned this only handles pre-standard loclist format.. So I choose to add it here.

Now your suggestion is to add the v5 loclist.dwo format to emitDebugLoc() function -- as it can handle v4 and v5 both ??
I think that also implies to make emission decision based on version of dwarf ??
sort of --

if (getDwarfVersion() == 4 && UseSplitDwarf())
    emitDebugLocDWO()   -- handles only v4 split mode
else ()
    emitDebugLoc() -- handles everything else -- v4 v5 and v5 + split

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

96–98

I haven't got a chance to look into details of llvm-dwp utility.
My Initial plan is to get loclist work in split mode, so that at least using LLDB{GDB is mostly broken for dwarf-5 compiled binaries} we can debug a binary compiled with -gdwarf-5 -gsplit-dwarf.
As of now LLDB is not able to handle loclists.dwo section. May be @labath can add more to this.

llvm/test/DebugInfo/Inputs/dwarfdump-test-loclists-dwo.c

1–18 ↗

(On Diff #226538)

Adding extra checks to test/DebugInfo/X86/sret.ll is fine.
Do you think, we should both of these files also. C source file and dwo check file ?

As I can see from my initial implementation based on your suggestion. test/DebugInfo/X86/sret.ll this suffice our needs here.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2483–2499

Eh, yeah, looks like that'd be inconsistent with the other section support.

looking at emitDebugRanges/emitDebugRangesDWO - I've refactored those in llvmorg-10-init-8906-g89b7f16204a - this should give a good basis on which to refactor emitDebugLoc/emitDebugLocDWO.

With the exception that the existing emitDebugLocDWO will need to be a special case (the curretn/old code) that doesn't exist in the debugRanges/RangesDWO code.

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

96–98

Yeah, maybe leave a FIXIT here about DWP support?

I think the whole thing needs a bit more deep surgery for more complete/general DWP support & such, out of scope for this change.

llvm/test/DebugInfo/Inputs/dwarfdump-test-loclists-dwo.c

1–18 ↗

(On Diff #226538)

Oh, sorry - a better test that's got source in there and everything, is llvm/test/CodeGen/X86/debug-loclists.ll

Yes, you could add a test that tests that with split DWARF (& them dumping loclists.dwo from the dwo file).

See llvm/test/DebugInfo/X86/cu-ranges.ll for the range list equivalent that tests both split and non-split forms.

[SouraVX]

Since D69672, D68271 are accepted and ready to land.
To avoid conflicts and save some rework, I'm considering rebasing my changes on top of D69672, once get merged.

[labath]

Sorry for the trouble, I should be able to land the other patches soon.

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

96–98

Yep, lldb does not support loclists.dwo (and its support for the non-dwo variant is somewhat dodgy as well). I am planning to address all of that by making lldb use the llvm classes for parsing (hence my other patches).

[SouraVX]

Revised to use new api's based on @labath and @dblaikie work, to emit loclists.dwo section.

[SouraVX]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1210–1211

In current implementation, emitDebugLocDWO() only handles -gdwarf-4 -gsplit-dwarf case.
Rest of the cases
-gdwarf-4, -gdwarf-5, -gdwarf-5 -gsplit-dwarf are handled by emitDebugLoc();.

[SouraVX]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1210–1211

I also have another implementation, which keeps above code uniform as in

if (useSplitDwarf())
  emitDebugLocDWO();
else
  emitDebugLoc();

But bloat's up a little emitDebugLocDWO() function. This is a bit cleaner but with one extra check in if.
Please share, your views on this and overall patch, and I shall incorporate changes.

[SouraVX]

Since DW_FORM_loclistx form is supported now.
I'm planning to revise this to accommodate DW_FORM_loclistx form.
Thank you for your patience.

[SouraVX]

Rebased and revised to adapt DW_FORM_loclistx.

[SouraVX]

Hi @labath @dblaikie , could you guys please have a look at this revised update. So that we all are on same we page as we progress. Pavel has done lot changes thanks a lot, I just wanted my work to be in sync with his work.
+ This patch doesn't take account of dwp files{Dwarf-5}. dwp prior{Dwarf-5} is intact.
+ Though I haven't look at this D70394 but their might be small conflict with this. But I'm happy to resolve that and address comments on this.
Thanks!

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

189–198

I wrote this as conditional, just to avoid breaking of DWP{Prior Dwarf-5} stuff .
Notably failure of loclists-dwp.ll . Since this test case doesn't address DWP{Dwarf-5}. We're good here.
Till we DWP{Dwarf-5} support.

[labath]

I've only looked at the consumption side, and it seems reasonable to me. The main thing I noticed is that it would be good to abstract the logic for computing the actual final offset in the loclists table somehow (I'm talking about the code that's presently in DWARFDie.cpp:dumpLocation). That's because the this logic will need to be repeated in the code which fetches the final resolved addresses programmatically (DWARFDie::getLocations in D70394). It also probably means that the code in that patch does not handle all of these cases correctly.

However, currently I don't know what's the best way to do that (and I don't even think it's you who needs to make that happen). Though, if you have any thoughts on this, I'd like to hear them.

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

190–199

I'd probably factor this so that just the DWARFDataExtractor is created in the conditional, and the creation of the loclists object is a separate statement.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2435–2452

I'm not sure I understand why this change is here - if I'm reading it right, the only difference between the two emitRangeList calls is "ShouldUseBaseAddress" - if that change is needed, perhaps it'd be better to have a single call that uses "!DD.useSplitDwarf()" as the "ShouldUseBaseAddress" parameter. But I don't think that's correct - base addresses should be used in split and non-split DWARF5, I think.

I believe base addresses should not be used in pre-DWARF5 split DWARF, but that codepath isn't using this function right now. (I think maybe it should, though)

2515–2518

What motivated this change? Perhaps this should be in a separate patch if there's a bug to fix here that's separate from the new loclist support being added?

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

511–512

Can probably remove this FIXME now.

529

Maybe in the IsDWO case just set it to "HeaderSize"?

Hmm, @aprantl @probinson - I can't find the wording in the DWARF5 spec about the use of loclists_base and rnglists_base in split units. It's unclear if these need to be specified in the split unit, or if they're assumed to be zero (or, technically, zero + sizeof(list header))? Currently LLVM doesn't generate a rnglists_base for split DWARFv5 units (I haven't checked the history on that change - but I might've had a hand in it) & this change is going to propagate that choice & do similarly for loclists_base.

GCC 8.1 at least doesn't seem to give us any hint there - since they don't use rnglists.dwo so far as I can tell (I induced a function-local range list and it was put in the .o rnglists section, there was no rnglists.dwo section)

In some ways it'd be tidier to emit it, of course - consistent between .o and .dwo, but also it'd likely be redundant/always have the same value in every .dwo file.

llvm/test/CodeGen/X86/debug-loclists.ll

5

Does this check need a different prefix, or can it use the same/default prefix? At a glance it looks like all the CHECKs are the same (& I think they should be) so maybe they can be reused.

llvm/test/DebugInfo/X86/dwarfdump-debug-loclists-dwo.test

1 ↗

(On Diff #230024)

What does this test that's different from the debug-loclists.ll?

This is a separate test for the parser only? We don't /always/ bother with that, but it's nice to have - if we're going to do that, the functionality should probably be committed in two separate patches - one with the parser functionality and its test, and then anotehr with the emission functionality and test.

Is there no existing llm-dwarfdump/parser test for loclists? (existing source example that could be reused, possibly existing CHECKs that could be reused (they may need some adaptation to be flexible enough to handle a .dwo file, where the addresses won't be able to be resolved, etc), even if a new object file would have to be committed to go with it)

[SouraVX]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2435–2452

Thanks for noting this. Yeah, I was previously of holding on opposite thought, then

base addresses should be used in split and non-split DWARF5

This seems fine, after referring back to Spec.

But bear with me for a moment, I'm noting one further glitch-- if we do pass
ShouldUseBaseAddress , I'm getting loclist entries like.
` 0x00000018:

DW_LLE_base_addressx   (0x0000000000000000)  -- coming in every pair with 0
DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000004): DW_OP_reg5 RDI
DW_LLE_offset_pair     (0x0000000000000004, 0x0000000000000018): DW_OP_reg3 RBX
DW_LLE_end_of_list     () `

I'm guessing base is not their for split ?? Any thought on this ??

2515–2518

Sure, will do this separately.

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

190–199

Thanks for suggestion, refactored code looks much cleaner.

511–512

Sure, Will do.

llvm/test/CodeGen/X86/debug-loclists.ll

5

I'll try to remove redundancy, but I guess some are needed specially when checking dump of debug_loclists.dwo section. -- that contains / uses different form then non-split case.

[SouraVX]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2435–2452

+ Surprisingly this DW_LLE_base_addressx doesn't pops up in non-split case, Not sure if this is fine.
+ For ShouldUseBaseAddress {false}, we're producing / emitting
DW_LLE_stratx_length while for {true} as mentioned above we're producing /emitting.
DW_LLE_offset_pair

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

529

Anyways it's getLocSectionBase() value is 0 .
Since, we've set it up that way above --

if (IsDWO)
       setLocSection(&Context.getDWARFObj().getLoclistsDWOSection(), 0);

Added this here just for readibility / uniformity sake.

[labath]

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

529

Does LocSectionBase have to be zero? Could set the LocSectionBase to sizeof(header) instead? (If the consensus is that DW_AT_loclists_base is not needed in dwo files -- which seems reasonable to me.)

That way, you wouldn't need to do the if(DWO) dance here and also in DWARFDie.cpp:dumpLocation. I think that would actually mostly address my earlier comment about having a "central" place to compute the final location section offset.

[SouraVX]

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

529

Does LocSectionBase have to be zero? Could set the LocSectionBase to sizeof(header) instead? (If the consensus is that DW_AT_loclists_base is not needed in dwo files -- which seems reasonable to me.)

Yes, as per Spec also. I also tried to hack DW_AT_loclists_base to place in .dwo file. that ends up in a backend error

Fatal Backend Error :A dwo section may not contain relocations

later, I re-read Spec to find the same, dwo section contain no relocation. this is also caused trouble, in another piece of my work, where I tried to insert

DW_AT_macinfo

in a dwo file.

[labath]

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

529

Fatal Backend Error :A dwo section may not contain relocations

If that's the only problem then presumably the relocation could be dispensed with by emitting the attribute value as a constant, or a label difference (distance from the start of the section) instead of a plain label (though I don't think that is necessary).

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2435–2452

But bear with me for a moment, I'm noting one further glitch-- if we do pass ShouldUseBaseAddress , I'm getting loclist entries like.
DW_LLE_base_addressx (0x0000000000000000) -- coming in every pair with 0

Yes, it's expected that dumping loclists.dwo would print zero (Or some other small numbers) in a base_addressx or startx_length - those are address pool indexes, not addresses. The addresses themselves are in the debug_addr section in the .o file, so llvm-dwarfdump (dumping the .dwo file) doesn't have access to them - so it prints out the raw entry parameters (address indexes, offsets, etc) rather than the "processed" values you see when dumping non-split DWARF.

It should do this in non-split DWARF too:

$ cat loc.cpp
int f1(int i, int j) {
  int x = 5;
  int y = 3;
  int r = i + j;
  int undef;
  x = undef;
  y = 4;
  return r;
}
void f2() {
}
blaikie@blaikie-linux2:~/dev/scratch$ clang++-tot -ffunction-sections -O3 loc.cpp -gdwarf-5 -c && llvm-dwarfdump-tot loc.o -debug-loclists -v
loc.o:  file format ELF64-x86-64

.debug_loclists contents:
0x00000000: locations list header: length = 0x00000035, version = 0x0005, addr_size = 0x08, seg_size = 0x00, 
offset_entry_count = 0x00000003
offsets: [
0x0000000c => 0x00000018
0x0000001d => 0x00000029
0x00000025 => 0x00000031
]
0x00000018: 
            DW_LLE_base_addressx   (0x0000000000000000)
            DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000003): DW_OP_consts +3, DW_OP_stack_value
            DW_LLE_offset_pair     (0x0000000000000003, 0x0000000000000004): DW_OP_consts +4, DW_OP_stack_value
            DW_LLE_end_of_list     ()

0x00000029: 
            DW_LLE_startx_length   (0x0000000000000000, 0x0000000000000003): DW_OP_consts +5, DW_OP_stack_value
            DW_LLE_end_of_list     ()

0x00000031: 
            DW_LLE_base_addressx   (0x0000000000000000)
            DW_LLE_offset_pair     (0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX
            DW_LLE_end_of_list     ()

Though if you compile without -ffunction-sections, the CU will have a relocated base address, and the loclists will not need to use base_addressx - they will instead use offset_pair and rely on the CU's base address.

In short: I would expect the loclists to be exactly the same in split and non-split cases. So I don't know why you're adding the "ShouldUseBaseAddress = false" part to the split case.

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

529

@labath - yeah, I like that idea of changing:

if (IsDWO)
     setLocSection(&Context.getDWARFObj().getLoclistsDWOSection(), 0);

to

if (IsDWO)
     setLocSection(&Context.getDWARFObj().getLoclistsDWOSection(), DWARFListTableHeader::getHeaderSize(Header.getFormat());

And then simplifying this:

uint64_t Offset =
        IsDWO ? HeaderSize + getLocSectionBase() : getLocSectionBase();

down to:

uint64_t Offset = getLocSectionBase();

@SouraVX - please make those changes. We'll continue here without loclists_base in the split unit & if that (& rnglists_base in split units) needs to be addressed, we'll do them in separate commits/discussions, so as to avoid conflating/complicating this review further.

llvm/test/CodeGen/X86/debug-loclists.ll

5

I believe these should be the same in split and non-split case (as discussed in the other thread about the implementation and use of ShouldUseBaseAddress) at which point these tests should be/can be simplified to use the same CHECKs for both split and non-split.

[SouraVX]

Addressed and incorporated suggestions by David, Pavel. Thanks for this.

• Cleaned up / refactored code.
• Removed following test /files - dwarfdump-test-loclists-dwo.c, dwarfdump-test-loclists-dwo.dwo, dwarfdump-debug-loclists-dwo.test
• Considering a separate patch for llvm-dwarfdump parser for loclists.dwo, using / based on above files.

[labath]

The consumption side looks good to me. I'll leave it to David to figure out the production and testing story..

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

92

revert the whitespace change too

[probinson]

Hmm, @aprantl @probinson - I can't find the wording in the DWARF5 spec about the use of loclists_base and rnglists_base in split units. It's unclear if these need to be specified in the split unit, or if they're assumed to be zero (or, technically, zero + sizeof(list header))? Currently LLVM doesn't generate a rnglists_base for split DWARFv5 units (I haven't checked the history on that change - but I might've had a hand in it) & this change is going to propagate that choice & do similarly for loclists_base.

If you look at Table F.1, p.395 in the DWARF 5 spec, it shows DW_AT_loclists_base/rnglists_base as used in conventional units but not skeleton/split units. Given that there's an index, I think the attribute itself would be superfluous.

[dblaikie]

In D69462#1755029, @probinson wrote:

Hmm, @aprantl @probinson - I can't find the wording in the DWARF5 spec about the use of loclists_base and rnglists_base in split units. It's unclear if these need to be specified in the split unit, or if they're assumed to be zero (or, technically, zero + sizeof(list header))? Currently LLVM doesn't generate a rnglists_base for split DWARFv5 units (I haven't checked the history on that change - but I might've had a hand in it) & this change is going to propagate that choice & do similarly for loclists_base.

If you look at Table F.1, p.395 in the DWARF 5 spec, it shows DW_AT_loclists_base/rnglists_base as used in conventional units but not skeleton/split units. Given that there's an index, I think the attribute itself would be superfluous.

Ah, perfect - thanks a bunch!

[dblaikie]

Close enough - I'll do some post-commit cleanup once this is in.

[dblaikie]

Do you have commit access, or do you need me to commit this for you?

[SouraVX]

In D69462#1757665, @dblaikie wrote:

Do you have commit access, or do you need me to commit this for you?

Thanks, I've committed this.

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

public:
   virtual const DWARFSection &getStrOffsetsSection() const { return Dummy; }
   virtual void
   forEachInfoDWOSections(function_ref<void(const DWARFSection &)> F) const {}
   virtual void
   forEachTypesDWOSections(function_ref<void(const DWARFSection &)> F) const {}
   virtual StringRef getAbbrevDWOSection() const { return ""; }
   virtual const DWARFSection &getLineDWOSection() const { return Dummy; }
   virtual const DWARFSection &getLocDWOSection() const { return Dummy; }
+  virtual const DWARFSection &getLoclistsDWOSection() const { return Dummy; }
   virtual StringRef getStrDWOSection() const { return ""; }
   virtual const DWARFSection &getStrOffsetsDWOSection() const {
     return Dummy;
   }
   virtual const DWARFSection &getRangesDWOSection() const { return Dummy; }
   virtual const DWARFSection &getRnglistsDWOSection() const { return Dummy; }
   virtual const DWARFSection &getAddrSection() const { return Dummy; }
   virtual const DWARFSection &getAppleNamesSection() const { return Dummy; }

llvm/include/llvm/MC/MCObjectFileInfo.h

protected:
   /// The DWARF v5 string offset and address table sections.
   MCSection *DwarfStrOffSection = nullptr;
   MCSection *DwarfAddrSection = nullptr;
   /// The DWARF v5 range list section.
   MCSection *DwarfRnglistsSection = nullptr;
   /// The DWARF v5 locations list section.
   MCSection *DwarfLoclistsSection = nullptr;
 
-  /// The DWARF v5 range list section for fission.
+  /// The DWARF v5 range and location list sections for fission.
   MCSection *DwarfRnglistsDWOSection = nullptr;
+  MCSection *DwarfLoclistsDWOSection = nullptr;
 
   // These are for Fission DWP files.
   MCSection *DwarfCUIndexSection = nullptr;
   MCSection *DwarfTUIndexSection = nullptr;
 
   /// Section for newer gnu pubnames.
   MCSection *DwarfGnuPubNamesSection = nullptr;
   /// Section for newer gnu pubtypes.
public:
   MCSection *getDwarfLineDWOSection() const { return DwarfLineDWOSection; }
   MCSection *getDwarfLocDWOSection() const { return DwarfLocDWOSection; }
   MCSection *getDwarfStrOffDWOSection() const { return DwarfStrOffDWOSection; }
   MCSection *getDwarfStrOffSection() const { return DwarfStrOffSection; }
   MCSection *getDwarfAddrSection() const { return DwarfAddrSection; }
   MCSection *getDwarfRnglistsDWOSection() const {
     return DwarfRnglistsDWOSection;
   }
+  MCSection *getDwarfLoclistsDWOSection() const {
+    return DwarfLoclistsDWOSection;
+  }
   MCSection *getDwarfCUIndexSection() const { return DwarfCUIndexSection; }
   MCSection *getDwarfTUIndexSection() const { return DwarfTUIndexSection; }
   MCSection *getDwarfSwiftASTSection() const { return DwarfSwiftASTSection; }
 
   MCSection *getCOFFDebugSymbolsSection() const {
     return COFFDebugSymbolsSection;
   }
   MCSection *getCOFFDebugTypesSection() const {

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

if (!AddrPool.isEmpty() &&
         (getDwarfVersion() >= 5 ||
          (SkCU && !TheCU.getUnitDie().children().empty())))
       U.addAddrTableBase();
 
     if (getDwarfVersion() >= 5) {
       if (U.hasRangeLists())
         U.addRnglistsBase();
 
-      if (!DebugLocs.getLists().empty() && !useSplitDwarf()) {
+      if (!DebugLocs.getLists().empty()) {
         DebugLocs.setSym(Asm->createTempSymbol("loclists_table_base"));
+        if (!useSplitDwarf())
           U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_loclists_base,
                             DebugLocs.getSym(),
                             TLOF.getDwarfLoclistsSection()->getBeginSymbol());
       }
     }
 
     auto *CUNode = cast<DICompileUnit>(P.first);
     // If compile Unit has macros, emit "DW_AT_macro_info" attribute.
     if (CUNode->getMacros())
       U.addSectionLabel(U.getUnitDie(), dwarf::DW_AT_macro_info,
                         U.getMacroLabelBegin(),
                         TLOF.getDwarfMacinfoSection()->getBeginSymbol());
   }
 
void DwarfDebug::endModule() {
   if (!MMI->hasDebugInfo())
     return;
 
   // Finalize the debug info for the module.
   finalizeModuleInfo();
 
   emitDebugStr();
 
   if (useSplitDwarf())
+    // Handles debug_loc.dwo / debug_loclists.dwo section emission
     emitDebugLocDWO();
   else
-    // Emit info into a debug loc section.
+    // Handles debug_loc / debug_loclists section emission
     emitDebugLoc();
 
   // Corresponding abbreviations into a abbrev section.
   emitAbbreviations();
 
   // Emit all the DIEs into a debug info section.
   emitDebugInfo();
 

 static MCSymbol *emitLoclistsTableHeader(AsmPrinter *Asm,
                                          const DwarfDebug &DD) {
   MCSymbol *TableStart = Asm->createTempSymbol("debug_loclist_table_start");
   MCSymbol *TableEnd = Asm->createTempSymbol("debug_loclist_table_end");
   emitListsTableHeaderStart(Asm, TableStart, TableEnd);
 
   const auto &DebugLocs = DD.getDebugLocs();
 
-  // FIXME: Generate the offsets table and use DW_FORM_loclistx with the
-  // DW_AT_loclists_base attribute. Until then set the number of offsets to 0.
   Asm->OutStreamer->AddComment("Offset entry count");
   Asm->emitInt32(DebugLocs.getLists().size());
   Asm->OutStreamer->EmitLabel(DebugLocs.getSym());
 
   for (const auto &List : DebugLocs.getLists())
     Asm->EmitLabelDifference(List.Label, DebugLocs.getSym(), 4);
 
   return TableEnd;
for (const auto *RS : P.second) {
         Asm->EmitLabelDifferenceAsULEB128(End, Begin);
       } else {
         Asm->OutStreamer->EmitSymbolValue(Begin, Size);
         Asm->OutStreamer->EmitSymbolValue(End, Size);
       }
       EmitPayload(*RS);
     }
   }
 
   if (UseDwarf5) {
     Asm->OutStreamer->AddComment(StringifyEnum(EndOfList));
     Asm->emitInt8(EndOfList);
   } else {
     // Terminate the list with two 0 values.
     Asm->OutStreamer->EmitIntValue(0, Size);
     Asm->OutStreamer->EmitIntValue(0, Size);
   }
 }
 
+// Handles emission of both debug_loclist / debug_loclist.dwo
 static void emitLocList(DwarfDebug &DD, AsmPrinter *Asm, const DebugLocStream::List &List) {
-  emitRangeList(
-      DD, Asm, List.Label, DD.getDebugLocs().getEntries(List), *List.CU,
-      dwarf::DW_LLE_base_addressx, dwarf::DW_LLE_offset_pair,
-      dwarf::DW_LLE_startx_length, dwarf::DW_LLE_end_of_list,
-      llvm::dwarf::LocListEncodingString,
+  emitRangeList(DD, Asm, List.Label, DD.getDebugLocs().getEntries(List),
+                *List.CU, dwarf::DW_LLE_base_addressx,
+                dwarf::DW_LLE_offset_pair, dwarf::DW_LLE_startx_length,
+                dwarf::DW_LLE_end_of_list, llvm::dwarf::LocListEncodingString,
                 /* ShouldUseBaseAddress */ true,
                 [&](const DebugLocStream::Entry &E) {
                   DD.emitDebugLocEntryLocation(E, List.CU);
                 });
 }
 
-// Emit locations into the .debug_loc/.debug_rnglists section.
+// Emit locations into the .debug_loc/.debug_loclists section.
 void DwarfDebug::emitDebugLoc() {
   if (DebugLocs.getLists().empty())
     return;
 
   MCSymbol *TableEnd = nullptr;
   if (getDwarfVersion() >= 5) {
+
     Asm->OutStreamer->SwitchSection(
         Asm->getObjFileLowering().getDwarfLoclistsSection());
+
     TableEnd = emitLoclistsTableHeader(Asm, *this);
   } else {
     Asm->OutStreamer->SwitchSection(
         Asm->getObjFileLowering().getDwarfLocSection());
   }
 
   for (const auto &List : DebugLocs.getLists())
     emitLocList(*this, Asm, List);
 
   if (TableEnd)
     Asm->OutStreamer->EmitLabel(TableEnd);
 }
 
+// Emit locations into the .debug_loc.dwo/.debug_loclists.dwo section.
 void DwarfDebug::emitDebugLocDWO() {
+  if (DebugLocs.getLists().empty())
+    return;
+
+  if (getDwarfVersion() >= 5) {
+    MCSymbol *TableEnd = nullptr;
+    Asm->OutStreamer->SwitchSection(
+        Asm->getObjFileLowering().getDwarfLoclistsDWOSection());
+    TableEnd = emitLoclistsTableHeader(Asm, *this);
+    for (const auto &List : DebugLocs.getLists())
+      emitLocList(*this, Asm, List);
+
+    if (TableEnd)
+      Asm->OutStreamer->EmitLabel(TableEnd);
+    return;
+  }
+
   for (const auto &List : DebugLocs.getLists()) {
     Asm->OutStreamer->SwitchSection(
         Asm->getObjFileLowering().getDwarfLocDWOSection());
     Asm->OutStreamer->EmitLabel(List.Label);
+
     for (const auto &Entry : DebugLocs.getEntries(List)) {
       // GDB only supports startx_length in pre-standard split-DWARF.
       // (in v5 standard loclists, it currently* /only/ supports base_address +
       // offset_pair, so the implementations can't really share much since they
       // need to use different representations)
       // * as of October 2018, at least
       // Ideally/in v5, this could use SectionLabels to reuse existing addresses
       // in the address pool to minimize object size/relocations.
       Asm->emitInt8(dwarf::DW_LLE_startx_length);
       unsigned idx = AddrPool.getIndex(Entry.Begin);
       Asm->EmitULEB128(idx);
       Asm->EmitLabelDifference(Entry.End, Entry.Begin, 4);
-
       emitDebugLocEntryLocation(Entry, List.CU);
     }
     Asm->emitInt8(dwarf::DW_LLE_end_of_list);
   }
 }
 
 struct ArangeSpan {
   const MCSymbol *Start, *End;
 };
 
 // Emit a debug aranges section, containing a CU lookup for any
 // address we can tie back to a CU.
 void DwarfDebug::emitDebugARanges() {

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

void DWARFContext::dump(
   if (const auto *Off =
           shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists,
                      DObj->getLoclistsSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(),
                             0);
     dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *Off);
   }
   if (const auto *Off =
+          shouldDump(ExplicitDWO, ".debug_loclists.dwo", DIDT_ID_DebugLoclists,
+                     DObj->getLoclistsDWOSection().Data)) {
+    DWARFDataExtractor Data(*DObj, DObj->getLoclistsDWOSection(),
+                            isLittleEndian(), 0);
+    dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *Off);
+  }
+
+  if (const auto *Off =
           shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
                      DObj->getLocDWOSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
                             4);
     DWARFDebugLoclists Loc(Data, /*Version=*/4);
     if (*Off) {
       uint64_t Offset = **Off;
       Loc.dumpLocationList(&Offset, OS,
class DWARFObjInMemory final : public DWARFObject {
 
   InfoSectionMap InfoSections;
   InfoSectionMap TypesSections;
   InfoSectionMap InfoDWOSections;
   InfoSectionMap TypesDWOSections;
 
   DWARFSectionMap LocSection;
   DWARFSectionMap LoclistsSection;
+  DWARFSectionMap LoclistsDWOSection;
   DWARFSectionMap LineSection;
   DWARFSectionMap RangesSection;
   DWARFSectionMap RnglistsSection;
   DWARFSectionMap StrOffsetsSection;
   DWARFSectionMap LineDWOSection;
   DWARFSectionMap FrameSection;
   DWARFSectionMap EHFrameSection;
   DWARFSectionMap LocDWOSection;
class DWARFObjInMemory final : public DWARFObject {
   DWARFSectionMap PubtypesSection;
   DWARFSectionMap GnuPubnamesSection;
   DWARFSectionMap GnuPubtypesSection;
 
   DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
     return StringSwitch<DWARFSectionMap *>(Name)
         .Case("debug_loc", &LocSection)
         .Case("debug_loclists", &LoclistsSection)
+        .Case("debug_loclists.dwo", &LoclistsDWOSection)
         .Case("debug_line", &LineSection)
         .Case("debug_frame", &FrameSection)
         .Case("eh_frame", &EHFrameSection)
         .Case("debug_str_offsets", &StrOffsetsSection)
         .Case("debug_ranges", &RangesSection)
         .Case("debug_rnglists", &RnglistsSection)
         .Case("debug_loc.dwo", &LocDWOSection)
         .Case("debug_line.dwo", &LineDWOSection)
const DWARFSection &getStrOffsetsDWOSection() const override {
     return StrOffsetsDWOSection;
   }
   const DWARFSection &getRangesDWOSection() const override {
     return RangesDWOSection;
   }
   const DWARFSection &getRnglistsDWOSection() const override {
     return RnglistsDWOSection;
   }
+  const DWARFSection &getLoclistsDWOSection() const override {
+    return LoclistsDWOSection;
+  }
   const DWARFSection &getAddrSection() const override { return AddrSection; }
   StringRef getCUIndexSection() const override { return CUIndexSection; }
   StringRef getGdbIndexSection() const override { return GdbIndexSection; }
   StringRef getTUIndexSection() const override { return TUIndexSection; }
 
   // DWARF v5
   const DWARFSection &getStrOffsetsSection() const override {
     return StrOffsetsSection;

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

if (FormValue.isFormClass(DWARFFormValue::FC_Block) ||
     return;
   }
 
   if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
     uint64_t Offset = *FormValue.getAsSectionOffset();
 
     if (FormValue.getForm() == DW_FORM_loclistx) {
       FormValue.dump(OS, DumpOpts);
+
       if (auto LoclistOffset = U->getLoclistOffset(Offset))
         Offset = *LoclistOffset + U->getLocSectionBase();
       else
         return;
     }
     U->getLocationTable().dumpLocationList(&Offset, OS, U->getBaseAddress(),
                                            MRI, U, DumpOpts, Indent);
     return;
   }
 
   FormValue.dump(OS, DumpOpts);
 }
 
 /// Dump the name encoded in the type tag.

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
   clear();
   if (IsDWO) {
     // If we are reading a package file, we need to adjust the location list
     // data based on the index entries.
     StringRef Data = LocSection->Data;
     if (auto *IndexEntry = Header.getIndexEntry())
       if (const auto *C = IndexEntry->getOffset(DW_SECT_LOC))
         Data = Data.substr(C->Offset, C->Length);
-    LocTable = std::make_unique<DWARFDebugLoclists>(
-        DWARFDataExtractor(Data, isLittleEndian, getAddressByteSize()),
-        Header.getVersion());
+
+    DWARFDataExtractor DWARFData =
+        Header.getVersion() >= 5
+            ? DWARFDataExtractor(Context.getDWARFObj(),
+                                 Context.getDWARFObj().getLoclistsDWOSection(),
+                                 isLittleEndian, getAddressByteSize())
+            : DWARFDataExtractor(Data, isLittleEndian, getAddressByteSize());
+    LocTable =
+        std::make_unique<DWARFDebugLoclists>(DWARFData, Header.getVersion());
+
   } else if (Header.getVersion() >= 5) {
     LocTable = std::make_unique<DWARFDebugLoclists>(
         DWARFDataExtractor(Context.getDWARFObj(),
                            Context.getDWARFObj().getLoclistsSection(),
                            isLittleEndian, getAddressByteSize()),
         Header.getVersion());
   } else {
     LocTable = std::make_unique<DWARFDebugLoc>(
         DWARFDataExtractor(Context.getDWARFObj(), *LocSection, isLittleEndian,
if (RangeSection->Data.size()) {
 
       RngListTable = TableOrError.get();
 
       // In a split dwarf unit, there is no DW_AT_rnglists_base attribute.
       // Adjust RangeSectionBase to point past the table header.
       if (IsDWO && RngListTable)
         RangeSectionBase = RngListTable->getHeaderSize();
     }
 
-    // FIXME: add loclists.dwo support
+    // In a split dwarf unit, there is no DW_AT_loclists_base attribute.
+    // Setting LocSectionBase to point past the table header.
+    if (IsDWO)
+      setLocSection(&Context.getDWARFObj().getLoclistsDWOSection(),
+                    DWARFListTableHeader::getHeaderSize(Header.getFormat()));
+    else
       setLocSection(&Context.getDWARFObj().getLoclistsSection(),
                     toSectionOffset(UnitDie.find(DW_AT_loclists_base), 0));
 
     if (LocSection->Data.size()) {
+      if (IsDWO)
+        LoclistTableHeader.emplace(".debug_loclists.dwo", "locations");
+      else
         LoclistTableHeader.emplace(".debug_loclists", "locations");
-      uint64_t Offset = LocSectionBase;
+
       uint64_t HeaderSize = DWARFListTableHeader::getHeaderSize(Header.getFormat());
+      uint64_t Offset = getLocSectionBase();
       DWARFDataExtractor Data(Context.getDWARFObj(), *LocSection,
                               isLittleEndian, getAddressByteSize());
       if (Offset < HeaderSize)
         return createStringError(errc::invalid_argument,
                                  "did not detect a valid"
                                  " list table with base = 0x%" PRIx64 "\n",
                                  Offset);
       Offset -= HeaderSize;
       if (Error E = LoclistTableHeader->extract(Data, &Offset))

llvm/lib/MC/MCObjectFileInfo.cpp

DwarfLineDWOSection =
       Ctx->getELFSection(".debug_line.dwo", DebugSecType, ELF::SHF_EXCLUDE);
   DwarfLocDWOSection =
       Ctx->getELFSection(".debug_loc.dwo", DebugSecType, ELF::SHF_EXCLUDE);
   DwarfStrOffDWOSection = Ctx->getELFSection(".debug_str_offsets.dwo",
                                              DebugSecType, ELF::SHF_EXCLUDE);
   DwarfRnglistsDWOSection =
       Ctx->getELFSection(".debug_rnglists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
 
+  DwarfLoclistsDWOSection =
+      Ctx->getELFSection(".debug_loclists.dwo", DebugSecType, ELF::SHF_EXCLUDE);
+
   // DWP Sections
   DwarfCUIndexSection =
       Ctx->getELFSection(".debug_cu_index", DebugSecType, 0);
   DwarfTUIndexSection =
       Ctx->getELFSection(".debug_tu_index", DebugSecType, 0);
 
   StackMapSection =
       Ctx->getELFSection(".llvm_stackmaps", ELF::SHT_PROGBITS, ELF::SHF_ALLOC);

llvm/test/CodeGen/X86/debug-loclists.ll

 ; RUN: llc -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t < %s
 ; RUN: llvm-dwarfdump -v -debug-info -debug-loclists %t | FileCheck %s
 
+; RUN: llc -dwarf-version=5 -split-dwarf-file=foo.dwo -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t < %s
+; RUN: llvm-dwarfdump -v -debug-info -debug-loclists %t | FileCheck %s --check-prefix=DWO
+
 ; CHECK:      DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x0) loclist = 0x00000018:
 ; CHECK-NEXT:     [0x0000000000000000, 0x0000000000000003) ".text._Z2f1ii": DW_OP_consts +3, DW_OP_stack_value
 ; CHECK-NEXT:     [0x0000000000000003, 0x0000000000000004) ".text._Z2f1ii": DW_OP_consts +4, DW_OP_stack_value)
 ; CHECK-NEXT:   DW_AT_name {{.*}} "y"
 
 ; CHECK:      DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x1) loclist = 0x00000029:
 ; CHECK-NEXT:     [0x0000000000000000, 0x0000000000000003) ".text._Z2f1ii": DW_OP_consts +5, DW_OP_stack_value)
 ; CHECK-NEXT:   DW_AT_name {{.*}} "x"
 
 ; CHECK:      DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x2) loclist = 0x00000031:
 ; CHECK-NEXT:     [0x0000000000000003, 0x0000000000000004) ".text._Z2f1ii": DW_OP_reg0 RAX)
 ; CHECK-NEXT:   DW_AT_name {{.*}} "r"
 
 ; CHECK:      .debug_loclists contents:
 ; CHECK-NEXT: 0x00000000: locations list header: length = 0x00000035, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
 
+; DWO:      .debug_loclists.dwo contents:
+; DWO-NEXT: 0x00000000: locations list header: length = 0x00000035, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
+
 ; CHECK-NEXT: offsets: [
 ; CHECK-NEXT: 0x0000000c => 0x00000018
 ; CHECK-NEXT: 0x0000001d => 0x00000029
 ; CHECK-NEXT: 0x00000025 => 0x00000031
 ; CHECK-NEXT: ]
 
 ; Don't use startx_length if there's more than one entry, because the shared
 ; base address will be useful for both the range that does start at the start of