[WIP][LLD][ELF][DebugInfo] Remove obsolete debug info.

[avl]

Summary

This patch is the implementation for removing obsolete debug info:

http://lists.llvm.org/pipermail/llvm-dev/2019-September/135473.html

It uses DWARFLinker which contains code refactored out from dsymutil.

[grimar]

lld/ELF/LLDDwarfLinker.cpp

13

Is it a final version of the comment? I'd expect to habe more information here probably about what we exactly do.

[avl]

How many changes do you expect will be needed to make the feature work?

Hi, following is the approximate list of changes, which assumed to match with corresponding patches :

1. Do not create DWARFContext inplace. Use ObjFile<ELFT>::dwarf and "llvm::call_once(initDwarfLine, [this]() { initializeDwarf(); });" instead.

2. Patch DebugInfoDWARF library to have a possibility to replace the error handler. Someone could already pass own error handler for DWARFContext. But there are places where WithColor::error() is used directly:

void DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
if (Error e = tryExtractDIEsIfNeeded(CUDieOnly))
  WithColor::error() << toString(std::move(e));
}

Thus, it is necessary to have a possibility to replace ErrorHandler here.

3. Replace LLDDwarfObj with DWARFObjInMemory implementation while creating DWARFContext:

for (InputFile *file : objectFiles) {
  std::unique_ptr<ObjectFile> ObjectFile = createELFObjectFile(file.mb);

  std::unique_ptr<DWARFContext> DWARFContext::create (ObjectFile, nullptr, ErrorHandler));
}

4. Create an implementation for lld/ELF/LLDDwarfLinker.cpp::ObjFileAddressMap.

5. Create special kind of section - "DebugInputSection : public InputSection". To keep the result of debug info linking and to handle relocations.

6. add LLD`s implementation for DWARFLinker/DWARFLinker.h::DwarfEmitter, which would write the output of DWARFLinker into DebugInputSection.

[avl]

lld/ELF/CMakeLists.txt

35

The idea is that the file name matches the class name. The class name has LLD to be different from DWARFLinker from DWARFLinker library. If it looks redundant, then I would delete this prefix.

53

It is used because LLDDwarfLinker.cpp includes DWARFLinker.h, which includes "llvm/CodeGen/Die.h", which needs "llvm::DIEAbbrev::Profile(llvm::FoldingSetNodeID&)" which is in AsmPrinter.

probably it could be refactored out later.

lld/ELF/LLDDwarfLinker.cpp

13

Ok, I would put more detailed comment.

[avl]

I wonder if that is really important to split patches that much (this patch seems have no functionality at all?). It would be good to see at least some benefit, but perhaps
it is not that easy to do... Anyways:
Personally I'd probably prefer to see a full set of patches for the feature. A reviewer should be able to apply them and debug (if he/she wants to) probably.

Hi George,

I follow the idea is that small patches are easier to review and easier to integrate. That concrete patch does not have a functionality but it includes DWARLinker library, creates option and creates placeholders for the functionality. Which looks like a small amount of things that could be reviewed.

Creating full set of patches which could be any time applied to the upstream and to the each other is quite time consuming thing because of time for synchronization/merging/rebasing. As an alternative we could discuss main points of future patches[0]. And iteratively apply patches step by step. If that plan is not good - then OK, I would start to work on preparing full set of patches for that feature.

[0] following is the approximate list of changes, which assumed to match with corresponding patches :

1. Do not create DWARFContext inplace. Use ObjFile<ELFT>::dwarf and "llvm::call_once(initDwarfLine, [this]() { initializeDwarf(); });" instead.

2. Patch DebugInfoDWARF library to have a possibility to replace the error handler. Someone could already pass own error handler for DWARFContext. But there are places where WithColor::error() is used directly:

void DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
if (Error e = tryExtractDIEsIfNeeded(CUDieOnly))
  WithColor::error() << toString(std::move(e));
}

Thus, it is necessary to have a possibility to replace ErrorHandler here.

3. Replace LLDDwarfObj with DWARFObjInMemory implementation while creating DWARFContext:

for (InputFile *file : objectFiles) {
  std::unique_ptr<ObjectFile> ObjectFile = createELFObjectFile(file.mb);

  std::unique_ptr<DWARFContext> DWARFContext::create (ObjectFile, nullptr, ErrorHandler));
}

4. Create an implementation for lld/ELF/LLDDwarfLinker.cpp::ObjFileAddressMap.

5. Create special kind of section - "DebugInputSection : public InputSection". To keep the result of debug info linking and to handle relocations.

6. add LLD`s implementation for DWARFLinker/DWARFLinker.h::DwarfEmitter, which would write the output of DWARFLinker into DebugInputSection.

[avl]

addressed comments.

[avl]

marked the patch as WIP while preparing full set of patches for the feature.

[grimar]

A few comments from me.

lld/ELF/Config.h

170

Unsorted (shold be placed before gcSections + should be gcDebugInfo I think.

lld/ELF/Driver.cpp

2228

Looking at this piece I think that 915, 916 lines should just be:

config->gcDebuginfo = config->gcSections &&
      args.hasFlag(OPT_gc_debuginfo, OPT_no_gc_debuginfo, false);

Perhaps worth to report an error when we have --gc-debug info, but not --gc-sections, but I am not sure here.

lld/ELF/LLDDwarfLinker.cpp

67

We usually do not do such things in LLD. I.e. do not assert on options when the code is trivial like in your case:

if (config->gcSections && config->gcDebuginfo)
  linkDebugInfo<ELFT>();

84

Please do not use new. Is should be something like:

dwarfContexts.push_back(std::make_unique...

89

It would probably be a bit more natural to:

std::unique_ptr<DwarfLinkerObjFile> Obj = std::make_unique<DwarfLinkerObjFile>(
              file->getName(), dwarfObjFile, emptyWarnings);
Obj->Addresses = ;
debugInfoLinker.addObjectFile(*Obj);
objectsForLinking.push_back(std::move(Obj));

94

Addresses = std::make_unique<ObjFileAddressMap>();

lld/ELF/LLDDwarfLinker.h

18

I am not an expert in English, though would rewrite to something like:

// This function is used to remove an unused parts of debug data
// which belongs to garbage collected sections.

(I guess othes might have a better variant though).

lld/test/ELF/gc-debuginfo.s

7 ↗

(On Diff #243205)

No need to use that much asm:

llvm-mc /dev/null -o %t.o -filetype=obj -triple=aarch64-pc-linux

15 ↗

(On Diff #243205)

I'd add a test for -r --gc-debuginfo error too since you have this code.

[grimar]

In D74169#1863848, @avl wrote:

Creating full set of patches which could be any time applied to the upstream and to the each other is quite time consuming thing because of time for synchronization/merging/rebasing.

I do not think them needed to be in state "any time applied to the upstream".
"any time" is indeed too much.

Perhaps we could do something like the following: create a single large patch with all of features which can be applied. And upload it somewhere here as [not for commit].
Then reviewers should be able to review this single patch, but in case of questions they should be able to apply the huge patch to see how the whole feature works.
In this case you'll need to update one huge patch from time to time, e.g. rebase it from time to time after commits of smaller ones. And it should be much simpler.
How does it sound? (the same question for others).

[avl]

That is OK. The only thing is that I planned to integrate small fixes as soon as they are ready. So I do not have a full implementation at the moment. I will create a single large patch with all of the features sometime later as soon as it would be fully ready.

[MaskRay]

I agree with

if the additional complexity is not too much, and the new code is nicely isolated from existing code. I think I agree with you that linker is perhaps the best place to drop dead DWARF info.

(One thing I plan to work on is .debug_names accelerator table, which is similar to but more power than .gdb_index.)

On one side, I've heard thoughts that: (1) if we use -gsplit-dwarf, is .debug* garbage collection still valuable? (2) DWARFLinker can significantly increase link time. Can we move it to a post-link tool (dsymutil but for ELF)?
On the other side, I think this approach may be better than D54747 (reverted by rL360955) and may address the problem it tried to mitigate. Given the savings, we may bend our mind a bit and give more tolerance even if the additional complexity is more than not too much.

I am reluctant to let individual patches in before we can see the benefits, because they could easily turn out to be insufficient and cause churns. There is still possibility that we find --gc-debuginfo not suitable on the linker side and may want to do it in a post-link tool.

[dblaikie]

In D74169#1878422, @MaskRay wrote:

I agree with

if the additional complexity is not too much, and the new code is nicely isolated from existing code. I think I agree with you that linker is perhaps the best place to drop dead DWARF info.

(One thing I plan to work on is .debug_names accelerator table, which is similar to but more power than .gdb_index.)

On one side, I've heard thoughts that:
(1) if we use -gsplit-dwarf, is .debug* garbage collection still valuable?

For users using -gsplit-dwarf, linker garbage collection provides zero value. But not everyone does, there are reasons to use one or the other in different situations.

(2) DWARFLinker can significantly increase link time. Can we move it to a post-link tool (dsymutil but for ELF)?

Presumably that'd take significantly longer and use more memory and disk space overall - but, yes, it would get you a running executable sooner. (/somewhat/ like the tradeoff of using .dwo files directly, compared to linking them into a .dwp - dwo files are ready sooner, but take up more space, etc, but dwp takes time to make - good for archival purposes)

But (2) I think is unclear to me - I'd like to know how much more time/memory it takes, if it does take more (it probably will take more) - given that it should produce significantly less output (& at Google at least, output is memory usage - since we write to a memory mapped file (though we use Split DWARF in most places where size/memory usage matters, so this solution isn't immediately relevant there).

(& this also might be reusable/good foundation for DWARF aware linking in llvm-dwp, for what it's worth (again, not clear what the tradeoffs will be like in terms of memory/cpu overhead, output size savings, etc))

On the other side, I think this approach may be better than D54747 (reverted by rL360955) and may address the problem it tried to mitigate. Given the savings, we may bend our mind a bit and give more tolerance even if the additional complexity is more than not too much.

I am reluctant to let individual patches in before we can see the benefits, because they could easily turn out to be insufficient and cause churns. There is still possibility that we find --gc-debuginfo not suitable on the linker side and may want to do it in a post-link tool.

lld/ELF/LLDDwarfLinker.cpp

75–76

Probably should be using make_uniqeu<DWARFContext> too, rather than "unique_ptr(new DWARFContext"?

(& a couple of other opportunities to use make_unique in this code below)

[avl]

On one side, I've heard thoughts that:
 (1) if we use -gsplit-dwarf, is .debug* garbage collection still valuable?

For users using -gsplit-dwarf, linker garbage collection provides zero value. But not everyone does, there are reasons to use one or the other in different situations.

also, as an theoretical alternative - probably we might want to implement -gsplit-dwarf so that it include only used part of debug info. i.e. that which referenced after garbage collection. As the result size of all .dwo files would be smaller.

(2) DWARFLinker can significantly increase link time. Can we move it to a post-link tool (dsymutil but for ELF)?

Presumably that'd take significantly longer and use more memory and disk space overall - but, yes, it would get you a running executable sooner. (/somewhat/ like the tradeoff of using .dwo files directly, compared to linking them into a .dwp - dwo files are ready sooner, but take up more space, etc, but dwp takes time to make - good for archival purposes)

But (2) I think is unclear to me - I'd like to know how much more time/memory it takes,

I am preparing the full patch for that feature, so that it would be possible to estimate these values: how much more time/memory it takes.

[dblaikie]

In D74169#1883671, @avl wrote:

On one side, I've heard thoughts that:
 (1) if we use -gsplit-dwarf, is .debug* garbage collection still valuable?

For users using -gsplit-dwarf, linker garbage collection provides zero value. But not everyone does, there are reasons to use one or the other in different situations.

also, as an theoretical alternative - probably we might want to implement -gsplit-dwarf so that it include only used part of debug info. i.e. that which referenced after garbage collection. As the result size of all .dwo files would be smaller.

That's not possible - the .dwo files are produced during compilation time, before the linker has done any garbage collection.

(currently even when building the dwp file from dwo files it's not possible to strip the dead debug info - since there's no feedback from the linker that reaches the dwp tool (dwp and linking might be done in parallel on different machines, for instance) - but it'd be possible to implement something more like dsymutil where the linker generates a side-file address mapping/details of the garbage collection and then that is fed into the dwp tool (this would delay running the dwp tool though))

[avl]

That's not possible - the .dwo files are produced during compilation time, before the linker has done any garbage collection.

(currently even when building the dwp file from dwo files it's not possible to strip the dead debug info - since there's no feedback from the linker that reaches the dwp tool (dwp and linking might be done in parallel on different machines, for instance) - but it'd be possible to implement something more like dsymutil where the linker generates a side-file address mapping/details of the garbage collection and then that is fed into the dwp tool (this would delay running the dwp tool though))

Right. That is not possible in current scheme. Though we could probably change the scheme(if it would be considered beneficial). One alternative is what you were talking about - dsymutil/dwp tool which would take linker report and .dwo files and produce optimized .dwo files. Another alternative is that .dwo files could be optimized during linking time using the same scheme like current proposal. This proposal would take unoptimized .debug* sections of binary and generate optimized contents of destination .debug* sections during linking. Generally, It is possible to take unoptimized .dwo files and make them optimized.

I do not suggest to do it now. That is just possible alternative which could probably be considered if current proposal would show good results.

Another thing, is that this patch could be useful for -gsplit-dwarf even without optimizing .dwo files.
It could skip DW_TAG_skeleton_unit related to deleted code. So that Skeleton file do not have overlapped address ranges like this :

0x00000014: DW_TAG_skeleton_unit
              DW_AT_dwo_name    ("split1.dwo")
              DW_AT_low_pc      (0x0000000000000000)   <<< not assigned because of deleted code
              DW_AT_high_pc     (0x0000000000000008)
              DW_AT_addr_base   (0x00000008)

0x00000034: DW_TAG_skeleton_unit
              DW_AT_dwo_name    ("split2.dwo")
              DW_AT_low_pc      (0x0000000000000000)   <<< not assigned because of deleted code
              DW_AT_high_pc     (0x0000000000000008)
              DW_AT_addr_base   (0x00000008)

[clayborg]

I created dsymutil when at Apple, which has now been taken over by llvm-dsymutil. So a few thoughts on general DWARF linking and optimization:

As dsymutil links the DWARF it sees, it does indeed have a linker map of all final addresses for any addresses in each .o file. dsymutil will go through all DIEs within a CU and mark the ones that should be kept by starting with the compile unit DIE, then each DIE referred to the by the final link map (DW_TAG_subprogram, global or static DW_TAG_variable), that had a mapping in the linked executable will be marked as needing to be kept along with all child DIEs and all DIEs that these child DIEs refer to. You will run into many DIEs over and over, but as soon as you run into one that is already marked as needing to be kept, you can avoid recursing into that DIE again, so it never really gets out of hand to do this pass. One thing to be careful of: enumerations. A lot of code uses enums, but they don't use the enum type when that enumeration defines bit masks, so you might end up with code that doesn't refer to an enum type with any variables (they just use a signed or unsigned integer as the variable type), but it is sometimes still a good idea to keep these types around. We had issue where we were dead stripping these types and the enum weren't available in the debug info.

The other thing that dsymutil does to reduce file size, and the most valuable part of size reduction, is it uses ODR to only emit types one time when possible. If you have 100 .o files with std::string inside of them, you can often emit a single copy and change any future .o files references to their local copy, to use a DW_FORM_ref_addr form to refer to the first definition that was emitted. Enabling this allows us to trim debug info size by 75%. Dsymutil uses a method where it figures out the decl file and line for a type and the DW_AT_byte_size, along with a few other checks, to quickly unique types in C++ code. There is some trickiness here where compiler generated constructors and destructors may appear in one type and not in another, so there is some code to make sure there is a DIE within the type refer to, but overall this works really well and is pretty cheap to implement.

Line tables are fully relinked as well and all line entries for addresses that were stripped are removed. This can be tricky because often times the line tables are emitted as one large stream with no DW_LNE_end_sequence opcode at the end of each function address range. New DW_LNE_end_sequence opcodes need to be inserted when optimizing line tables so that you don't end up with an invalid line table where addresses don't increase within a sequence. Adding the new DW_LNE_end_sequence opcode terminates the sequence and allows the next line entries to change addresses to a lower address than the previous DW_LNE_end_sequence line entry.

dsymutil adds accelerator tables, in DWARF5 format or the Apple format, that are calculated by traversing the new DWARF once it is created. This means you don't end up with 100 accelerators tables concatenated together like linkers do now. I am keenly interested in this feature so we can prove that having the accelerator tables helps debugging speeds. Proving the accelerator tables help will help us get toolchains to integrate the accelerator tables into their builds. Having it start off as a separate post production step is a great way to help people figure out if they want to adopt them.

Having all of this re-linking code in a DWARFLinker library llvm/lib/DebugInfo/DWARF would be great. We have many tools at Facebook that are relinking DWARF, and not doing a very good job. If we had a library that would allow people to re-link their DWARF, either linking .o file DWARF into a main executable, or having an optimization pass that runs on fully linked libraries that might do function outlining or block re-use optimizations, then we can ensure the final DWARF is in great shape.

One last point is to have a flag that enabled DWARF verification. This can be run before the GC operation to ensure the incoming DWARF is in good shape and again after any modifications, to ensure the DWARF is still valid.

[dblaikie]

In D74169#1887739, @clayborg wrote:

I created dsymutil when at Apple, which has now been taken over by llvm-dsymutil. So a few thoughts on general DWARF linking and optimization:

As dsymutil links the DWARF it sees, it does indeed have a linker map of all final addresses for any addresses in each .o file. dsymutil will go through all DIEs within a CU and mark the ones that should be kept by starting with the compile unit DIE, then each DIE referred to the by the final link map (DW_TAG_subprogram, global or static DW_TAG_variable), that had a mapping in the linked executable will be marked as needing to be kept along with all child DIEs and all DIEs that these child DIEs refer to. You will run into many DIEs over and over, but as soon as you run into one that is already marked as needing to be kept, you can avoid recursing into that DIE again, so it never really gets out of hand to do this pass. One thing to be careful of: enumerations. A lot of code uses enums, but they don't use the enum type when that enumeration defines bit masks, so you might end up with code that doesn't refer to an enum type with any variables (they just use a signed or unsigned integer as the variable type), but it is sometimes still a good idea to keep these types around. We had issue where we were dead stripping these types and the enum weren't available in the debug info.

The other thing that dsymutil does to reduce file size, and the most valuable part of size reduction, is it uses ODR to only emit types one time when possible. If you have 100 .o files with std::string inside of them, you can often emit a single copy and change any future .o files references to their local copy, to use a DW_FORM_ref_addr form to refer to the first definition that was emitted. Enabling this allows us to trim debug info size by 75%. Dsymutil uses a method where it figures out the decl file and line for a type and the DW_AT_byte_size, along with a few other checks, to quickly unique types in C++ code. There is some trickiness here where compiler generated constructors and destructors may appear in one type and not in another, so there is some code to make sure there is a DIE within the type refer to, but overall this works really well and is pretty cheap to implement.

Line tables are fully relinked as well and all line entries for addresses that were stripped are removed. This can be tricky because often times the line tables are emitted as one large stream with no DW_LNE_end_sequence opcode at the end of each function address range. New DW_LNE_end_sequence opcodes need to be inserted when optimizing line tables so that you don't end up with an invalid line table where addresses don't increase within a sequence. Adding the new DW_LNE_end_sequence opcode terminates the sequence and allows the next line entries to change addresses to a lower address than the previous DW_LNE_end_sequence line entry.

dsymutil adds accelerator tables, in DWARF5 format or the Apple format, that are calculated by traversing the new DWARF once it is created. This means you don't end up with 100 accelerators tables concatenated together like linkers do now. I am keenly interested in this feature so we can prove that having the accelerator tables helps debugging speeds. Proving the accelerator tables help will help us get toolchains to integrate the accelerator tables into their builds. Having it start off as a separate post production step is a great way to help people figure out if they want to adopt them.

lld already supports gdb_index & there's plans to add debug_names support in the near future (~6 months).

Having all of this re-linking code in a DWARFLinker library llvm/lib/DebugInfo/DWARF would be great. We have many tools at Facebook that are relinking DWARF, and not doing a very good job. If we had a library that would allow people to re-link their DWARF, either linking .o file DWARF into a main executable, or having an optimization pass that runs on fully linked libraries that might do function outlining or block re-use optimizations, then we can ensure the final DWARF is in great shape.

I believe all the functionality in llvm-dsymutil related to DWARF linking that implements the features you described above (llvm-dsymutil was initially implemented with bug-for-bug compatibility with Apple dsymutil for safety and since then I think a few of those bugs have been fixed/improvements have been made) & that code is now/already in the llvm/lib/DWARFLinker library so it can be reused in lld for this effort (apologies if I'm preaching to the choir/being redundant here) & any others you might have in mind. No doubt there's probably some refactoring to do to improve its reusability as the integration with lld & other situations is done.

[clayborg]

In D74169#1887764, @dblaikie wrote:

In D74169#1887739, @clayborg wrote:

I created dsymutil when at Apple, which has now been taken over by llvm-dsymutil. So a few thoughts on general DWARF linking and optimization:

As dsymutil links the DWARF it sees, it does indeed have a linker map of all final addresses for any addresses in each .o file. dsymutil will go through all DIEs within a CU and mark the ones that should be kept by starting with the compile unit DIE, then each DIE referred to the by the final link map (DW_TAG_subprogram, global or static DW_TAG_variable), that had a mapping in the linked executable will be marked as needing to be kept along with all child DIEs and all DIEs that these child DIEs refer to. You will run into many DIEs over and over, but as soon as you run into one that is already marked as needing to be kept, you can avoid recursing into that DIE again, so it never really gets out of hand to do this pass. One thing to be careful of: enumerations. A lot of code uses enums, but they don't use the enum type when that enumeration defines bit masks, so you might end up with code that doesn't refer to an enum type with any variables (they just use a signed or unsigned integer as the variable type), but it is sometimes still a good idea to keep these types around. We had issue where we were dead stripping these types and the enum weren't available in the debug info.

The other thing that dsymutil does to reduce file size, and the most valuable part of size reduction, is it uses ODR to only emit types one time when possible. If you have 100 .o files with std::string inside of them, you can often emit a single copy and change any future .o files references to their local copy, to use a DW_FORM_ref_addr form to refer to the first definition that was emitted. Enabling this allows us to trim debug info size by 75%. Dsymutil uses a method where it figures out the decl file and line for a type and the DW_AT_byte_size, along with a few other checks, to quickly unique types in C++ code. There is some trickiness here where compiler generated constructors and destructors may appear in one type and not in another, so there is some code to make sure there is a DIE within the type refer to, but overall this works really well and is pretty cheap to implement.

Line tables are fully relinked as well and all line entries for addresses that were stripped are removed. This can be tricky because often times the line tables are emitted as one large stream with no DW_LNE_end_sequence opcode at the end of each function address range. New DW_LNE_end_sequence opcodes need to be inserted when optimizing line tables so that you don't end up with an invalid line table where addresses don't increase within a sequence. Adding the new DW_LNE_end_sequence opcode terminates the sequence and allows the next line entries to change addresses to a lower address than the previous DW_LNE_end_sequence line entry.

dsymutil adds accelerator tables, in DWARF5 format or the Apple format, that are calculated by traversing the new DWARF once it is created. This means you don't end up with 100 accelerators tables concatenated together like linkers do now. I am keenly interested in this feature so we can prove that having the accelerator tables helps debugging speeds. Proving the accelerator tables help will help us get toolchains to integrate the accelerator tables into their builds. Having it start off as a separate post production step is a great way to help people figure out if they want to adopt them.

lld already supports gdb_index & there's plans to add debug_names support in the near future (~6 months).

Does it support adding the GDB index after the fact on an already linked binary, or just at normal link time? I want to add a GSYM option to LLD at some point too. Can replace -gline-tables-only in many cases.

Having all of this re-linking code in a DWARFLinker library llvm/lib/DebugInfo/DWARF would be great. We have many tools at Facebook that are relinking DWARF, and not doing a very good job. If we had a library that would allow people to re-link their DWARF, either linking .o file DWARF into a main executable, or having an optimization pass that runs on fully linked libraries that might do function outlining or block re-use optimizations, then we can ensure the final DWARF is in great shape.

I believe all the functionality in llvm-dsymutil related to DWARF linking that implements the features you described above (llvm-dsymutil was initially implemented with bug-for-bug compatibility with Apple dsymutil for safety and since then I think a few of those bugs have been fixed/improvements have been made) & that code is now/already in the llvm/lib/DWARFLinker library so it can be reused in lld for this effort (apologies if I'm preaching to the choir/being redundant here) & any others you might have in mind. No doubt there's probably some refactoring to do to improve its reusability as the integration with lld & other situations is done.

That is great to hear! Sorry I haven't looked around at that code in a while, but glad to hear it is all ready to go.

[dblaikie]

In D74169#1887791, @clayborg wrote:

In D74169#1887764, @dblaikie wrote:

lld already supports gdb_index & there's plans to add debug_names support in the near future (~6 months).

Does it support adding the GDB index after the fact on an already linked binary, or just at normal link time? I want to add a GSYM option to LLD at some point too. Can replace -gline-tables-only in many cases.

I don't think there's been any effort to add it as a post-processing step, no. I believe it can be built either from parsed DWARF or from debug_gnu_pubnames - in either case, at link time. I mean, it'd be probably quite practical to extend it to be able to be done as a standalone/post-processing step.

For the sake of object and linked executable size, I suspect we might end up trying to move the indexing out of the object files/linked executable - perhaps putting the names either in a third file, or in the .dwo files and generating an index from them instead of from the objects. Not sure. Some further experimentation expected there.

[clayborg]

In D74169#1887799, @dblaikie wrote:

In D74169#1887791, @clayborg wrote:

In D74169#1887764, @dblaikie wrote:

lld already supports gdb_index & there's plans to add debug_names support in the near future (~6 months).

Does it support adding the GDB index after the fact on an already linked binary, or just at normal link time? I want to add a GSYM option to LLD at some point too. Can replace -gline-tables-only in many cases.

I don't think there's been any effort to add it as a post-processing step, no. I believe it can be built either from parsed DWARF or from debug_gnu_pubnames - in either case, at link time.

is debug_gnu_pubnames a new section that is now complete? The old .debug_pub* sections only contained globally visible things which means all debuggers would ignore this section. If accelerator tables were made from incomplete sources that will mean debuggers will have to question if .debug_names is complete or not.

I mean, it'd be probably quite practical to extend it to be able to be done as a standalone/post-processing step.

That would be great. As accelerator tables evolve and get updated, it would be nice to have a path to update older accelerator tables to newer more complete versions.

For the sake of object and linked executable size, I suspect we might end up trying to move the indexing out of the object files/linked executable - perhaps putting the names either in a third file, or in the .dwo files and generating an index from them instead of from the objects. Not sure. Some further experimentation expected there.

That is fine too. We make a dwarf linking tool that can link all of the .dwo files back into a normal DWARF file like with dsymutil and .o files on mac. That allows people to get the benefits of the .dwo performance improvements for the edit/compile /debug cycle and then link it into a minimal and optimized DWARF, using contribution from this patch and others to come that optimize the DWARF, for permanent storage on build servers.

[smeenai]

In D74169#1887799, @dblaikie wrote:

In D74169#1887791, @clayborg wrote:

In D74169#1887764, @dblaikie wrote:

lld already supports gdb_index & there's plans to add debug_names support in the near future (~6 months).

Does it support adding the GDB index after the fact on an already linked binary, or just at normal link time? I want to add a GSYM option to LLD at some point too. Can replace -gline-tables-only in many cases.

I don't think there's been any effort to add it as a post-processing step, no. I believe it can be built either from parsed DWARF or from debug_gnu_pubnames - in either case, at link time. I mean, it'd be probably quite practical to extend it to be able to be done as a standalone/post-processing step.

Note that such post-processing is probably more suited to llvm-objcopy than lld, though of course they can use the same underlying LLVM library.

[dblaikie]

In D74169#1888386, @clayborg wrote:

In D74169#1887799, @dblaikie wrote:

In D74169#1887791, @clayborg wrote:

In D74169#1887764, @dblaikie wrote:

lld already supports gdb_index & there's plans to add debug_names support in the near future (~6 months).

Does it support adding the GDB index after the fact on an already linked binary, or just at normal link time? I want to add a GSYM option to LLD at some point too. Can replace -gline-tables-only in many cases.

I don't think there's been any effort to add it as a post-processing step, no. I believe it can be built either from parsed DWARF or from debug_gnu_pubnames - in either case, at link time.

is debug_gnu_pubnames a new section that is now complete? The old .debug_pub* sections only contained globally visible things which means all debuggers would ignore this section. If accelerator tables were made from incomplete sources that will mean debuggers will have to question if .debug_names is complete or not.

It's "complete" in the sense that it's whatever GDB wanted and created a contract that GCC (& Clang/LLVM as best we know/have done so far) agree too, so GDB can rely on things being present/not present in some sense.

That's why debug_gnu_pubnames existed - because of, as you say, the underspecified nature of (or unreliable implementation of) debug_pubnames.

I believe debug_names semantics have been more strictly specified regarding what names will be there and what names will not.

I mean, it'd be probably quite practical to extend it to be able to be done as a standalone/post-processing step.

That would be great. As accelerator tables evolve and get updated, it would be nice to have a path to update older accelerator tables to newer more complete versions.

For the sake of object and linked executable size, I suspect we might end up trying to move the indexing out of the object files/linked executable - perhaps putting the names either in a third file, or in the .dwo files and generating an index from them instead of from the objects. Not sure. Some further experimentation expected there.

That is fine too. We make a dwarf linking tool that can link all of the .dwo files back into a normal DWARF file like with dsymutil and .o files on mac.

That's already done - DWP ( https://gcc.gnu.org/wiki/DebugFissionDWP ). But for an interactive scenario over a distributed filesystem shipping the whole linked DWP file back to the user for access by the debugger is a bit unfortunate/slow. Good for archival purposes, as you say - but it's still a bit of an open question as to what to do for interactive users if object file/linked executable size is a major concern - either generating a third file with just the index parts (so building the full index can be done in parallel/distributed separately from the link) or doing an index-only link of the .dwo files (not super great - still means a bottleneck of shipping all the .dwo files to one build machine, etc)...

That allows people to get the benefits of the .dwo performance improvements for the edit/compile /debug cycle and then link it into a minimal and optimized DWARF, using contribution from this patch and others to come that optimize the DWARF, for permanent storage on build servers.

[clayborg]

In D74169#1889749, @dblaikie wrote:

In D74169#1888386, @clayborg wrote:

In D74169#1887799, @dblaikie wrote:

In D74169#1887791, @clayborg wrote:

In D74169#1887764, @dblaikie wrote:

lld already supports gdb_index & there's plans to add debug_names support in the near future (~6 months).

Does it support adding the GDB index after the fact on an already linked binary, or just at normal link time? I want to add a GSYM option to LLD at some point too. Can replace -gline-tables-only in many cases.

I don't think there's been any effort to add it as a post-processing step, no. I believe it can be built either from parsed DWARF or from debug_gnu_pubnames - in either case, at link time.

is debug_gnu_pubnames a new section that is now complete? The old .debug_pub* sections only contained globally visible things which means all debuggers would ignore this section. If accelerator tables were made from incomplete sources that will mean debuggers will have to question if .debug_names is complete or not.

It's "complete" in the sense that it's whatever GDB wanted and created a contract that GCC (& Clang/LLVM as best we know/have done so far) agree too, so GDB can rely on things being present/not present in some sense.

That's why debug_gnu_pubnames existed - because of, as you say, the underspecified nature of (or unreliable implementation of) debug_pubnames.

Perfect, that is what I was hoping for.

I believe debug_names semantics have been more strictly specified regarding what names will be there and what names will not.

Yes, it indeed fully specifies what is needed. Thanks for the info.

I mean, it'd be probably quite practical to extend it to be able to be done as a standalone/post-processing step.

That would be great. As accelerator tables evolve and get updated, it would be nice to have a path to update older accelerator tables to newer more complete versions.

For the sake of object and linked executable size, I suspect we might end up trying to move the indexing out of the object files/linked executable - perhaps putting the names either in a third file, or in the .dwo files and generating an index from them instead of from the objects. Not sure. Some further experimentation expected there.

That is fine too. We make a dwarf linking tool that can link all of the .dwo files back into a normal DWARF file like with dsymutil and .o files on mac.

That's already done - DWP ( https://gcc.gnu.org/wiki/DebugFissionDWP ). But for an interactive scenario over a distributed filesystem shipping the whole linked DWP file back to the user for access by the debugger is a bit unfortunate/slow. Good for archival purposes, as you say - but it's still a bit of an open question as to what to do for interactive users if object file/linked executable size is a major concern - either generating a third file with just the index parts (so building the full index can be done in parallel/distributed separately from the link) or doing an index-only link of the .dwo files (not super great - still means a bottleneck of shipping all the .dwo files to one build machine, etc)...

For the linking, I was more thinking of converting the DWP format back into vanilla DWARF with no DWO/DWP artifacts (skeleton DIEs etc) or any other redirections (string table offsets, address tables, etc). Not sure if this would reduce the DWARF size of all of the DWO/DWP instrstructure was all removed?

[dblaikie]

I mean, it'd be probably quite practical to extend it to be able to be done as a standalone/post-processing step.

That would be great. As accelerator tables evolve and get updated, it would be nice to have a path to update older accelerator tables to newer more complete versions.

For the sake of object and linked executable size, I suspect we might end up trying to move the indexing out of the object files/linked executable - perhaps putting the names either in a third file, or in the .dwo files and generating an index from them instead of from the objects. Not sure. Some further experimentation expected there.

That is fine too. We make a dwarf linking tool that can link all of the .dwo files back into a normal DWARF file like with dsymutil and .o files on mac.

That's already done - DWP ( https://gcc.gnu.org/wiki/DebugFissionDWP ). But for an interactive scenario over a distributed filesystem shipping the whole linked DWP file back to the user for access by the debugger is a bit unfortunate/slow. Good for archival purposes, as you say - but it's still a bit of an open question as to what to do for interactive users if object file/linked executable size is a major concern - either generating a third file with just the index parts (so building the full index can be done in parallel/distributed separately from the link) or doing an index-only link of the .dwo files (not super great - still means a bottleneck of shipping all the .dwo files to one build machine, etc)...

For the linking, I was more thinking of converting the DWP format back into vanilla DWARF with no DWO/DWP artifacts (skeleton DIEs etc) or any other redirections (string table offsets, address tables, etc). Not sure if this would reduce the DWARF size of all of the DWO/DWP instrstructure was all removed?

Ah, sorry, I see what you mean. Well, the offsets systems in some cases save total size even once linked (eg: having a single 64 bit address with two short uleb indexes compared to two 64 bit addresses - even once the binary is linked and there's no extra bytes of relocation records for that address/addresses) & these features are no longer Split DWARF specific - Clang/LLVM generates almost (entirely, maybe?) all these constructs the same way with split or unsplit DWARF when emitting DWARFv5.

Might save a bit - certainly something someone could experiment with as improvements to DWARFLinker - for dsymutil, lld, and maybe dwp in the future.

(one of the cheap ones that'd be neat to see would be debug_rnglists optimization - wouldn't need to parse DWARF DIEs, etc, would be an entirely local optimization - may be useful for PROPELLER (~= -fbasic-block-sections) - because of the indirection in debug_rnglists (though the rnglist header's offset table) you could totally rewrite range lists to coalesce any contiguous ranges that end up together & rewriting the offsets in the offset table - though this optimization would benefit from being in both lld and dsymutil I think - not applicable to dwp unless address information is passed from the linker like dsymutil)

[avl]

@ruiu, @grimar, @MaskRay

While working on "remove obsolete debug info in lld" patch
I need to generate the DWARF section contents. dsymutil
uses AsmPrinter to create DWARF. Thus to create things
in the same way, I need to add AsmPrinter library and targets libraries:

--- a/lld/ELF/CMakeLists.txt
+++ b/lld/ELF/CMakeLists.txt
@@ -59,6 +59,10 @@ add_lld_library(lldELF
   Option
   Passes
   Support
+  AllTargetsCodeGens
+  AllTargetsDescs
+  AllTargetsInfos
+  AsmPrinter

Would it be OK to add these libraries to lld code ?

If that is not OK, then alternative solution would be to refactor
DWARF generation code to remove dependence on AsmPrinter and friends.

[grimar]

In D74169#1928711, @avl wrote:

@ruiu, @grimar, @MaskRay

While working on "remove obsolete debug info in lld" patch
I need to generate the DWARF section contents. dsymutil
uses AsmPrinter to create DWARF. Thus to create things
in the same way, I need to add AsmPrinter library and targets libraries:

--- a/lld/ELF/CMakeLists.txt
+++ b/lld/ELF/CMakeLists.txt
@@ -59,6 +59,10 @@ add_lld_library(lldELF
   Option
   Passes
   Support
+  AllTargetsCodeGens
+  AllTargetsDescs
+  AllTargetsInfos
+  AsmPrinter

Would it be OK to add these libraries to lld code ?

If that is not OK, then alternative solution would be to refactor
DWARF generation code to remove dependence on AsmPrinter and friends.

Honestly I just do not know the answer, but it sounds to me that we can add them, and do
the refactoring you are proposing after whole functionality is done. (i.e. remove them later if it will be possible/reasonable).

[MaskRay]

In D74169#1930688, @grimar wrote:

In D74169#1928711, @avl wrote:

@ruiu, @grimar, @MaskRay

While working on "remove obsolete debug info in lld" patch
I need to generate the DWARF section contents. dsymutil
uses AsmPrinter to create DWARF. Thus to create things
in the same way, I need to add AsmPrinter library and targets libraries:

--- a/lld/ELF/CMakeLists.txt
+++ b/lld/ELF/CMakeLists.txt
@@ -59,6 +59,10 @@ add_lld_library(lldELF
   Option
   Passes
   Support
+  AllTargetsCodeGens
+  AllTargetsDescs
+  AllTargetsInfos
+  AsmPrinter

Would it be OK to add these libraries to lld code ?

If that is not OK, then alternative solution would be to refactor
DWARF generation code to remove dependence on AsmPrinter and friends.

Honestly I just do not know the answer, but it sounds to me that we can add them, and do
the refactoring you are proposing after whole functionality is done. (i.e. remove them later if it will be possible/reasonable).

Honestly I don't know, either. I echo most of comments on https://reviews.llvm.org/D74169#1880922 For -gsplit-dwarf or -gsplit-dwarf=single users, garbage collection of debug info can provide hardly any benefit. For non -gsplit-dwarf use cases, I am concerned whether the pros (avoid an intermediate file/avoid a post-processing step) overweight cons (time/memory/lld size). The link time/memory may increase significantly. I wonder whether the peak memory usage can increase to 2x given our experience https://reviews.llvm.org/D74773#1920751

I am also curious to learn how much + AllTargetsCodeGens + AllTargetsDescs + AllTargetsInfos + AsmPrinter can increase the size of lld executable in a -DBUILD_SHARED_LIBS=off build.

Doing a full DWARF rewriting can save intermediate files. But if the memory/time trade-off is not that appealing, a standalone tool (which can have more configuration options) may be more suitable. That said, we may need some prototype to verify these theories.

How much do we sacrifice in link speed/peak memory usage/lld executable size in return for X% of .debug_* size saving?

[avl]

I am also curious to learn how much + AllTargetsCodeGens + AllTargetsDescs + AllTargetsInfos + AsmPrinter can increase the size of lld executable in a -DBUILD_SHARED_LIBS=off build.

Currently, it has zero effect because of --gc-sections.

I asked about using AsmPrinter in lld to check whether there is a fundamental limitation for that.
So far, I understood that the answer depends on the final results of the implementation.

Doing a full DWARF rewriting can save intermediate files. But if the memory/time trade-off is not that appealing, a standalone tool (which can have more configuration options) may be more suitable. That said, we may need some prototype to verify these theories.

I am currently working on that prototype.

How much do we sacrifice in link speed/peak memory usage/lld executable size in return for X% of .debug_* size saving?

When the prototype is ready, it would be possible to evaluate memory/time results.

I did another prototype(not based on dsymutil, though with a very similar idea) D67469.
Its results are in llvm thread http://lists.llvm.org/pipermail/llvm-dev/2019-September/135068.html.

[avl]

This version is a full patch implementing "remove obsolete debug info from lld" functionality.
As it was requested, It is presented as a full patch, which could be applied to the current code
base and evaluated. Some parts of that patch are already presented for review - D77169, D76085.
I am going to add tests for this patch and to address comments. Performance results would be presented in a separate message.

Limitations: it does not support DWARF5, modules, -fdebug-types-section, type units, .debug_types, multiple .debug_info sections.

Testing: it passes check-all lit testing. It is able to compile llvm code base. llvm-dwarfdump --verify shows zero errors for clang built by lld from this patch.

[dblaikie]

In D74169#1960135, @avl wrote:

This version is a full patch implementing "remove obsolete debug info from lld" functionality.
As it was requested, It is presented as a full patch, which could be applied to the current code
base and evaluated. Some parts of that patch are already presented for review - D77169, D76085.
I am going to add tests for this patch and to address comments. Performance results would be presented in a separate message.

Limitations: it does not support DWARF5, modules, -fdebug-types-section, type units, .debug_types, multiple .debug_info sections.

Not so much reason to support type units ("-fdebug-types-section/type units/.debug_types section/multiple .debug_info sections" all essentially describe the same thing). Since type units add object size overhead to reduced linked size in the face of a DWARF-agnostic/ignorant linker. If you have a DWARF aware linker, you'd probably avoid using type units so you could have smaller object files too.

Does it support multipe compile units in a single section in an object file (ala LTO/ThinLTO)?

Testing: it passes check-all lit testing. It is able to compile llvm code base. llvm-dwarfdump --verify shows zero errors for clang built by lld from this patch.

Do you have memory usage/compile time numbers for linking various programs with/without this feature?

[avl]

Size/Performance/Memory results:

lld binary size with this patch(SHARED_LIBS=OFF) - 49925kb.
lld binary size without this patch(SHARED_LIBS=OFF) - 49699kb.

Performance results for building whole LLVM:

--------------------------------------------------------------------------
|   |       CL options                | LLVM bin size  | LLVM build time |   
--------------------------------------------------------------------------
| A | (default set of options*)       |  100.0%(18.0GB)|  100.0%(75m15s) |
|   |                                 |                |                 |
| B | A +gc-debuginfo(**) +NoOdr=false|    54%(9,7GB)  |  124.0%(93m33s) |
|   |                                 |                |                 |
| C | A +gc-debuginfo +NoOdr=false    |    43%(7,7GB)  |  107.0%(80m26s) |
|   |   +fdebug-types-section(***)    |                |                 |
--------------------------------------------------------------------------

Performance results of lld for building single clang binary:

---------------------------------------------------------------------------------
|   |       CL options             | Clang size   | link time | run-time memory |
---------------------------------------------------------------------------------
| A | (default set of options*)    | 100.0%(1,4GB)| 100%(49s) |   (100%)9.3GB   |
|   |                              |              |           |                 |
| B | A +gc-debuginfo +NoOdr=false | 56.0%(0.78GB)| 296%(145s)|   (153%)14.2GB  |
|   |                              |              |           |                 |
| C | A +gc-debuginfo +NoOdr=true  | 86.0%(1.2GB) | 380%(186s)|   (161%)15GB    |
|   |                              |              |           |                 |
| D | A +gc-debuginfo +NoOdr=false | 42.0%(0.59GB)| 133%(65s) |   (113%)10.5GB  |
|   |   +fdebug-types-section(***) |              |           |                 |
---------------------------------------------------------------------------------

(*)
LLVM_TARGETS_TO_BUILD=X86;AArch64
LLVM_ENABLE_PROJECTS=clang;lld
LLVM_ENABLE_LLD=ON
CMAKE_CXX_FLAGS=--ffunction-sections
CMAKE_C_FLAGS=--ffunction-sections
CMAKE_CXX_FLAGS_DEBUG=-g
CMAKE_C_FLAGS_DEBUG=-g
CMAKE_EXE_LINKER_FLAGS=--Wl,--gc-sections
CMAKE_MODULE_LINKER_FLAGS=-Wl,--gc-sections
CMAKE_SHARED_LINKER_FLAGS=-Wl,--gc-sections

(**)

• gc-debuginfo - removes obsolete debug info. implemented by this patch.
• NoOdr - mode of DWARFLinker which switches on/off types deduplication. there is no command line option to switch it on/off.
• fdebug-types-section - deduplicates types using comdat sections.

(***) fdebug-types-section is not supported by dsymutil/DWARFLinker.
Thus presented results do not show real data.
But these numbers could be taken as an estimation for future results
when DWARF5/-fdebug-types-section would be supported by dsymutil/DWARFLinker.

(****) HW configuration:

OS Ubuntu 18.04
CPU Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz
RAM 32018 MiB
Storage SSD

[avl]

Not so much reason to support type units ("-fdebug-types-section/type units/.debug_types section/multiple .debug_info sections" all essentially describe the same thing). Since type units add object size overhead to reduced linked size in the face of a DWARF-agnostic/ignorant linker. If you have a DWARF aware linker, you'd probably avoid using type units so you could have smaller object files too.

It seems to me type units are useful for the current scheme. They increase the size of type reference(8 bytes vs 4 bytes) and introduce type unit header, but they avoid duplication. All references inside the object file point to the single type description - thus, object files have only one type's description instead of multiple copies. The effect of de-duplication is higher than the introduced increase.

DWARF aware linker does not reduce the size of object files. It reduces the size of binary, whereas type units allow decreasing object file.

I think DWARF aware linker could help to get even more size reduction. If instead of type units, there would be another structure - something like "bag of DWARF"(bag of types). You mentioned this idea in http://lists.llvm.org/pipermail/llvm-dev/2019-September/135262.html. "bag of DWARF" would allow to have single type description in object file for type and to have 4-bytes references. DWARF aware linker could merge "bag of DWARF" from various object files. (similar to the current process when linker merges comdat sections. But joining "bag of DWARF" is a more complicated process than selecting one section from the set of comdat sections)

Does it support multipe compile units in a single section in an object file (ala LTO/ThinLTO)?

it should but I did not check it yet. I would check and post results here.

[dblaikie]

In D74169#1960444, @avl wrote:

Not so much reason to support type units ("-fdebug-types-section/type units/.debug_types section/multiple .debug_info sections" all essentially describe the same thing). Since type units add object size overhead to reduced linked size in the face of a DWARF-agnostic/ignorant linker. If you have a DWARF aware linker, you'd probably avoid using type units so you could have smaller object files too.

It seems to me type units are useful for the current scheme. They increase the size of type reference(8 bytes vs 4 bytes) and introduce type unit header, but they avoid duplication. All references inside the object file point to the single type description - thus, object files have only one type's description instead of multiple copies. The effect of de-duplication is higher than the introduced increase.

DWARF aware linker does not reduce the size of object files. It reduces the size of binary, whereas type units allow decreasing object file.

To the best of my knowledge (as the person who implemented type unit support in LLVM... ) type units never reduce the size of object files - they only increase it.

There is no type duplication, so far as I know, in LLVM's object files even without type units - one definition of the type is emitted and all the rest of the DWARF references that type. With type units that type is just the skeleton (DW_AT_declaration and DW_AT_signature), without type units that type is the full definition, without the indirection to the type unit.

Are there particular examples of type duplication within a single object file you have in mind? I'd be super curious to see them - might be some bugs that need fixing.

I think DWARF aware linker could help to get even more size reduction. If instead of type units, there would be another structure - something like "bag of DWARF"(bag of types). You mentioned this idea in http://lists.llvm.org/pipermail/llvm-dev/2019-September/135262.html. "bag of DWARF" would allow to have single type description in object file for type and to have 4-bytes references. DWARF aware linker could merge "bag of DWARF" from various object files. (similar to the current process when linker merges comdat sections. But joining "bag of DWARF" is a more complicated process than selecting one section from the set of comdat sections)

Bag of DWARF doesn't seem like it'd help in a situation where you know you're going to use a DWARF-aware linker (just put all the DWARF in the CU as normal & know the DWARF-aware linker will introduce cross-CU references as needed as things are deduplicated). The idea for Bag of DWARF was with a DWARF agnostic linker you could reference more than one DIE from in a type unit (or a compile unit) to reduce a bunch of the duplication/overhead that type units introduce (eg: when defining a member function of a type unit, you currently have to duplicate the member function's declaration in the CU that references the TU, because you can't refer to that subprogram declaration DIE in the TU - only the type itself).

Does it support multipe compile units in a single section in an object file (ala LTO/ThinLTO)?

it should but I did not check it yet. I would check and post results here.

[clayborg]

Nice! Another thing I have been seeing a lot of is when functions are coalesced and many .o files have the same function that gets linked to the same location. We end up with many duplicate DWARF DIEs in the final executable since the linker will just link all of the DWARF for each function over and over (.debug_info and .debug_line content). I found this when making GSYM files from the DWARF and noticing that I had hundreds of duplicate entries that matched exactly. This would be a great follow up patch for --gc-debuginfo

[dblaikie]

(***) fdebug-types-section is not supported by dsymutil/DWARFLinker.
Thus presented results do not show real data.
But these numbers could be taken as an estimation for future results
when DWARF5/-fdebug-types-section would be supported by dsymutil/DWARFLinker.

Sorry, sort of duplicating the other thread of conversation we're having on this review - I don't believe type units would help dsymutil/DWARFLinker - nor that this data would be representative of potential improvements. Could you describe how these numbers would be representative of potential improvements? What benefit would type units provide to DWARF-aware linking?

[dblaikie]

In D74169#1960503, @clayborg wrote:

Nice! Another thing I have been seeing a lot of is when functions are coalesced and many .o files have the same function that gets linked to the same location. We end up with many duplicate DWARF DIEs in the final executable since the linker will just link all of the DWARF for each function over and over (.debug_info and .debug_line content). I found this when making GSYM files from the DWARF and noticing that I had hundreds of duplicate entries that matched exactly. This would be a great follow up patch for --gc-debuginfo

Given this is built on top of the DWARFLinker used for llvm-dsymutil which, I believe, already strips out those duplicate descriptions - hopefully that's already included in the functionality under review? But good to check/ask - @avl does this patch already do the good things for duplicate (or dropped) function sections?

(eg: "inline void f1() { } void f2() { f1(); }" + "inline void f1() { } void f2(); int main() { f1(); f2(); }" compiled and linked at -O0 the DWARF would usually contain two descriptions of 'f1', but ideally with a DWARF aware linker it'd contain only one description of 'f1'. Similarly: "void f1() { } void f2() { }" + "void f2(); int main() { f2(); }" compiled and linked with -ffunction-sections -Wl,-gc-sections would normally contain a DWARF description of "f1" but no code for f1, and a DWARF aware linker would strip out the DWARF description of 'f1' here)

[clayborg]

In D74169#1960444, @avl wrote:

Not so much reason to support type units ("-fdebug-types-section/type units/.debug_types section/multiple .debug_info sections" all essentially describe the same thing). Since type units add object size overhead to reduced linked size in the face of a DWARF-agnostic/ignorant linker. If you have a DWARF aware linker, you'd probably avoid using type units so you could have smaller object files too.

It seems to me type units are useful for the current scheme. They increase the size of type reference(8 bytes vs 4 bytes) and introduce type unit header, but they avoid duplication. All references inside the object file point to the single type description - thus, object files have only one type's description instead of multiple copies. The effect of de-duplication is higher than the introduced increase.

.debug_types could be much more efficient if we stop duplicating the decl context just so we can refer to a type. Right now if you have a variable, it will point to a CU local type, which duplicates the containing namespaces and class/struct/union decl contexts. So the overhead of .debug_types is a bit higher. It would be great if we could just refer directly to the type from .debug_types in the DW_TAG_variable and other DIEs that have DW_AT_type attributes.

Also, .debug_types is only there for struct, unions, classes and a few other types. When you have a typedef like "std::string::size_type", or a typedef inside of the std::string, it may or may not appear in the .debug_types definition, but no one can point to those types because the way .debug_types is currently defined, only one type can be referred to within a type unit. The results is that any code wanting to use of one these types must duplicate the entire decl context (namespace "std", class "basic_string<>", typedef "size_type") just so a variable can point to the DWARF.

I mention this because I think letting --gc-debuginfo do its thing with ODR type uniquing leaves the DWARF in a better state: type info for one class isn't strewn across a bunch of .o files, or having large swaths of the type duplicated all over the place. So if we have type uniquing, I would keep .debug_types out of it.

We could move to make .debug_types more useful. Right now a type unit has a single type signature that people can refer to and a single offset within the type unit for the type that people will extract. If we got a DWARF specification change in, we could make it so a single type unit has N signatures and N offsets to types within the type unit. This would allow people to directly reference contained types that are not class, structs or unions, like typedefs. But that requires a DWARF spec change.

DWARF aware linker does not reduce the size of object files. It reduces the size of binary, whereas type units allow decreasing object file.

Are object files not actually bigger when using .debug_types? All the duplicated decl context junk in the DWARF is not efficient. I would be surprised if type units make .o files smaller. There is nothing to unique within a single .o file and the type units should only make things bigger.

I think DWARF aware linker could help to get even more size reduction. If instead of type units, there would be another structure - something like "bag of DWARF"(bag of types). You mentioned this idea in http://lists.llvm.org/pipermail/llvm-dev/2019-September/135262.html. "bag of DWARF" would allow to have single type description in object file for type and to have 4-bytes references. DWARF aware linker could merge "bag of DWARF" from various object files. (similar to the current process when linker merges comdat sections. But joining "bag of DWARF" is a more complicated process than selecting one section from the set of comdat sections)

Right now the ODR type uniquing does this, but it doesn't split the types out into their own compile units. The first time you see a type, you emit it and remember it. All other uses of this type and up using a DW_FORM_ref_addr which is 32 bits to refer to the first emitted type. So the ODR already does this. What it doesn't do is split types out into unique compile units based on their DW_AT_decl_file. If we did, you can slowly combine all DWARF that was defined in header files into DW_TAG_compile_unit DIEs with only types from those files. Then the DWARF would be really clean. The main issue with this approach is that it means you have to make all DWARF in memory to that things can lazily be added to each of these bags (compile units with types in them) since you might end up adding more types to each compile unit. With the current ODR support we can parse the .o files one at a time, and refer to things we have already emitted easily and we don't need to keep everything around so we can add things to the "bags".

The downside of the dsymutil ODR technique, is many times you types that have implicitly added methods (default constructor, assignment operators, move constructors) that are only present if the user used them in their source file. So you might end up with many definitions of "class A", but some have the copy constructor in the DWARF (it was created by the compiler for types where the compiler can create them) and others that don't. So we sometimes have to emit the type multiple times when you have a DW_TAG_subprogram that refers to these implicitly created functions. But overall the approach works well for how easy it is to implement.

I am all for creating compile units and adding all of the types declared in that file to them and having the DWARF be even cleaner though!

[clayborg]

In D74169#1960551, @dblaikie wrote:

In D74169#1960503, @clayborg wrote:

Nice! Another thing I have been seeing a lot of is when functions are coalesced and many .o files have the same function that gets linked to the same location. We end up with many duplicate DWARF DIEs in the final executable since the linker will just link all of the DWARF for each function over and over (.debug_info and .debug_line content). I found this when making GSYM files from the DWARF and noticing that I had hundreds of duplicate entries that matched exactly. This would be a great follow up patch for --gc-debuginfo

Given this is built on top of the DWARFLinker used for llvm-dsymutil which, I believe, already strips out those duplicate descriptions - hopefully that's already included in the functionality under review? But good to check/ask - @avl does this patch already do the good things for duplicate (or dropped) function sections?

(eg: "inline void f1() { } void f2() { f1(); }" + "inline void f1() { } void f2(); int main() { f1(); f2(); }" compiled and linked at -O0 the DWARF would usually contain two descriptions of 'f1', but ideally with a DWARF aware linker it'd contain only one description of 'f1'. Similarly: "void f1() { } void f2() { }" + "void f2(); int main() { f2(); }" compiled and linked with -ffunction-sections -Wl,-gc-sections would normally contain a DWARF description of "f1" but no code for f1, and a DWARF aware linker would strip out the DWARF description of 'f1' here)

dsymutil's ODR does unique the types and only emit one copy. See my comment on implicit methods as one thing that can cause multiple copies of a type to be emitted.

[avl]

But good to check/ask - @avl does this patch already do the good things for duplicate (or dropped) function sections?
(eg: "inline void f1() { } void f2() { f1(); }" + "inline void f1() { } void f2(); int main() { f1(); f2(); }" compiled and linked at -O0 the DWARF would usually contain two descriptions of 'f1', but ideally with a DWARF aware linker it'd contain only one description of 'f1'. Similarly: "void f1() { } void f2() { }" + "void f2(); int main() { f2(); }" compiled and linked with -ffunction-sections -Wl,-gc-sections would normally contain a DWARF description of "f1" but no code for f1, and a DWARF aware linker would strip out the DWARF description of 'f1' here)

right. It generates one copy:

$cat test1.cpp

inline void f1() { } void f2(); int main() { f1(); f2(); }

$cat test2.cpp

inline void f1() { } void f2() { f1(); }

$ clang++ test1.cpp test2.cpp -O0 -g -ffunction-sections -fuse-ld=lld -Wl,--gc-sections; llvm-dwarfdump -a a.out | grep "\"f1\""
                DW_AT_name	("f1")
                DW_AT_name	("f1")
0x00000098: "f1"

$ clang++ test1.cpp test2.cpp -O0 -g -ffunction-sections -fuse-ld=lld -Wl,--gc-sections,--gc-debuginfo; llvm-dwarfdump -a a.out | grep "\"f1\""
                DW_AT_name	("f1")
0x0000008b: "f1"

[avl]

To the best of my knowledge (as the person who implemented type unit support in LLVM... ) type units never reduce the size of object files - they only increase it.

There is no type duplication, so far as I know, in LLVM's object files even without type units - one definition of the type is emitted and all the rest of the DWARF references that type. With type units that type is just the skeleton (DW_AT_declaration and DW_AT_signature), without type units that type is the full definition, without the indirection to the type unit.

Are there particular examples of type duplication within a single object file you have in mind? I'd be super curious to see them - might be some bugs that need fixing.

Sorry. I need to stop writing letters in the late evening.
type units make object files bigger. Thus, type units could not be used for reducing object files.

Mainly I am talking about two things:

1 -fdebug-types-section allows processing debug info faster.

dsymutil/DWARFLinker performance heavily depends on the size of input DWARF.
The more DWARF to parse, the more time the linking process would take.
Time to parse whole DWARF with ODR type deduplication(+gc-debuginfo +NoOdr=false) for clang is:

296%(145s)

Resulting DWARF is accurate: no type duplications, no extra bytes needed for type units. But it's processing time: 145s.

Time to parse in case -fdebug-types-section for clang is:
(most of types are in .debug_types section and ignored currently, thus
only .debug_info/.debug_line/.debug_ranges/.debug_loc are parsed)

133%(65s)

This difference is because not necessary to parse type information.
Comdat sections are quickly resolved by the linker based on section id.
Comparing hash id instead of analyzing context makes it work much faster.

So separating type info from the whole DWARF allows to noticeable speedup the debug info linking.
DWARFLinker will speedup debug info processing in the current scheme by supporting type units(-fdebug-types-section).
It looks like, linking time would be close to 133%(65s).

2 Something like "bag of dies" could avoid increasing size of data(created by type units).

This idea is not for the current state. This is a possible DWARF format change.

The linker processes comdat sections with type units quickly because it does not parse contents.
It uses the hash id to compare and either keep either decline the section.
Adding hash id makes processing faster, but it requires type units.

To reduce size of type units it is possible to implement "bag of dies" idea.
Something like this https://reviews.llvm.org/P8164 (global type table/bag of dies - means something similar).
But how "bag of dies" from different object files would be merged ? When single type is put in single
section - it could be merged per type basis. The similar approach for "bag of dies"
would introduce type duplication(the same types could be used in various "bag of dies").

DWARFLinker could be used for merging "bag of dies" instead of lld linker.
It would merge incoming "bag of dies" into single output "bag of dies".
To avoid heavy parsing and context analyzing DWARFLinker
could use solution similar to comdat solution - whether current die should be put into
resulting "bag of dies" would be decided by compare hash id(DW_AT_signature).

It looks like this solution would allow having a minimal size and fast processing.

Bag of DWARF doesn't seem like it'd help in a situation where you know you're going to use a DWARF-aware linker (just put all the DWARF in the CU as normal & know the DWARF-aware linker will introduce cross-CU references as needed as things are deduplicated). The idea for Bag of DWARF was with a DWARF agnostic linker you could reference more than one DIE from in a type unit (or a compile unit) to reduce a bunch of the duplication/overhead that type units introduce (eg: when defining a member function of a type unit, you currently have to duplicate the member function's declaration in the CU that references the TU, because you can't refer to that subprogram declaration DIE in the TU - only the type itself).

right, DWARF-aware linker doing de-duplication using ODR does not need "Bag of DWARF".
But doing de-duplication using ODR works slower than doing de-duplication for types marked with hash.
To add hash to the type it is necessary to put it into "Bag of DWARF".

It seems that Bag of DWARF used with DWARF agnostic linker would have a problem of type duplication.
"Bag of DWARF" from several object files could have duplicated types.
I think DWARF-aware linker is necessary to deduplicate "Bags of DWARF".

We could move to make .debug_types more useful. Right now a type unit has a single type signature that people can refer to and a single offset within the type unit for the type that people will extract. If we got a DWARF specification change in, we could make it so a single type unit has N signatures and N offsets to types within the type unit. This would allow people to directly reference contained types that are not class, structs or unions, like typedefs. But that requires a DWARF spec change.

yes. that is exactly what I am talking about. using type hash with elements of that type unit(bag of dies) would allow to speedup types de-duplication.

[dblaikie]

Rather than replying point-by-point, since I think the conversation has got a bit jumbled up - and maybe it's all best left to a separate thread than in this review... but:

The initial idea for bag-of-dwarf was to allow a type unit to expose more than one DIE (so CUs could reference nested types, member functions, parameters, etc). Also potentially to let CUs export entities that are known to have one home & that other DWARF might want to reference (this is a bit more of a stretch - but you could imagine a type with a strong vtable, no point putting it in a type unit, so you put it in the CU - but you could, if you wanted, still expose the type and its member functions as referenceable DIEs that could be referenced from other CUs rather than by having to redeclare (though not define) the entity in that other CU - inter-object-file-DIE references).

I see your point somewhat about how type units could integrate with DWARF-aware linking, but perhaps only in a very specific way - At least as LLVM emits type units, the types should always be identical (the type unit should never contain implicit special members or member function template instantiations, etc) & the variable component of a type (those implicit special members, etc) only ever appear on the declaration of the type that references to the type unit. If you knew that was the kind of input you were getting, you could rely on every type unit being identical (well, with GCC you can rely on each type unit being identical, but the same ODR type might be in multiple distinct type units because it uses exact hashing of the type unit contents, and the contents varies with implicit special members, etc)... Anyway, if you could rely on the type units for a given ODR type being identical or at least equivalent (no implicit special members, etc) - you could just use the first one you saw, drop the rest, and any new members you see can just be attached to a type declaration the way Clang does them today... hmm - I guess that'd work with GCC's output too, just ignoring any duplicate type units even though they aren't quite equivalent - they'd be no worse than Clang's type units. (Clang's never contain any of the special members, GCC's contain the used one - so if your type unit ended up being an arbitrarily chosen one from GCC, it wouldn't be any worse than CLang's - it'd just have some, but not all, the special members, member function templates, etc)

Hmm, I guess no reason you couldn't do this without type units though - maybe - depending on how debuggers handle it. Maybe they aren't good with member function declarations in type declarations if those type declarations aren't referencing type units....

eg: existing debug info with type units can look something like this:

DW_TAG_compile_unit
  DW_TAG_structure_type // DIE: t1.1
    DW_AT_name "t1"
    DW_AT_signature 0x42
    DW_AT_declaration true
  DW_TAG_variable
    DW_AT_type // -> DIE t1.1
DW_TAG_compile_unit
  DW_TAG_structure_type // DIE: t1.2
    DW_AT_name "t1"
    DW_AT_signature 0x42
    DW_AT_declaration true
    DW_TAG_subprogram // DIE: t1::t1
      DW_AT_name "t1"
      DW_AT_declaration
      DW_AT_artificial true
  DW_TAG_subprogram
    DW_AT_specification // -> DIE t1::t1
    // etc... 
  DW_TAG_variable
    DW_AT_type // -> DIE t1.2

type unit, signature 0x42, type offset -> DIE t1.tu
DW_TAG_type_unit
  DW_TAG_structure_type // DIE: t1.tu
    DW_AT_name "t1"
    // line/file/column/size/etc... 
    // let's say there are no explicit members, for the sake of simplicity


Then, without type units you could emit something very similar
DW_TAG_compile_unit
  DW_TAG_structure_type // DIE: t1.1
    DW_AT_name "t1"
    // line/file/column/size/etc... 
  DW_TAG_variable
    DW_AT_type // -> DIE t1.1
DW_TAG_compile_unit
  DW_TAG_structure_type // DIE: t1.2
    DW_AT_name "t1"
    DW_AT_signature 0x42
    DW_AT_declaration true
    DW_TAG_subprogram // DIE: t1::t1
      DW_AT_name "t1"
      DW_AT_declaration
      DW_AT_artificial true
  DW_TAG_subprogram
    DW_AT_specification // -> DIE t1::t1
    // etc... 
  DW_TAG_variable
    DW_AT_type // -> DIE t1.2

ie: don't go back and try to make t1.1 complete/merge all the contents, just tack things on to CU-local declarations whenever you come across a new member that has a definition in this translation unit. (ie: when the linker keeps the code for t1::t1 alive, then keep the subprogram definition alive, which keeps the subprogram declaration alive, which keeps the t1.2 declaration alive - but otherwise skip it and refer to t1.1 directly (or, in a first approximation, just always keep the declaration - but I guess dsymutil already has the smarts to strip the local type definition out entirely (does it use a declaration to reduce encoding length if there's lots of references to a type? Probably not, I guess))

This sort of complex design discussion probably merits some in person or video chat discussions or at least lengthy design discussion on llvm-dev.

[jhenderson]

One drive-by request/question: have you done any measurements of the impact on debuggers? In other words, does it improve/make worse the time it takes them to load the debug data?

[avl]

@dblaikie

This sort of complex design discussion probably merits some in person or video chat discussions or at least lengthy design discussion on llvm-dev.

Agreed. I think it would be better to dicuss it through email and extend it to llvm-dev later. I would start that email thread.

[avl]

One drive-by request/question: have you done any measurements of the impact on debuggers? In other words, does it improve/make worse the time it takes them to load the debug data?

no, I have not done yet. I would do and post results here.

[grimar]

I've put a few first general comments and suggestions inline.

side note: I've noticed you have a build time 75m15s, what looks to me too much for your configuration. Do you know about "-DLLVM_OPTIMIZED_TABLEGEN=1"? It should give an instant significant boost.

lld/ELF/DWARF.cpp

61

Doesn't seem you really need to know the number of sections?
Hence you can use DenseSet<StringRef> seen; (btw, 'seen' is the common name for sets used in a few similar situations in LLD code).

82

sec.Name.size() > 0 -> !sec.empty()

270

Comments should be started from an uppercase letter: check -> Check.
(applies here and for other comments)

275

Seems this assumes that relocations are sorted by r_offset? This is probably a wrong assumpting.
We have the code, for example, which uses the same thing (and perhaps could be reused somehow, not sure):

// Returns the index of the first relocation that points to a region between
// Begin and Begin+Size.
template <class IntTy, class RelTy>
static unsigned getReloc(IntTy begin, IntTy size, const ArrayRef<RelTy> &rels,
                         unsigned &relocI) {
  // Start search from RelocI for fast access. That works because the
  // relocations are sorted in .eh_frame.
  for (unsigned n = rels.size(); relocI < n; ++relocI) {
    const RelTy &rel = rels[relocI];
    if (rel.r_offset < begin)
      continue;

But it says that relocations are sorted in .eh_frame and I believe it is true,
but generally there is no requirement in ELF specification about that relocations must be sorted by offset I think.

292

Why exactly R_ABS/is it important? (Perhaps needs a comment).

lld/ELF/DWARF.h

93

Where it is used? I\ve not found it in this patch.

132

Is it used somewhere outside the template <class ELFT> LLDDwarfObj<ELFT>::LLDDwarfObj(ObjFile<ELFT> *obj) ?
Can it be a local variable?

lld/ELF/Driver.cpp

359

You do not need to have curly bracers around a single code line (the rule to look around to see the style often works good).

lld/ELF/InputSection.h

127

Why it is needed to store this bit? The code calls isDebugSection, is there something wrong with the current approach?

lld/ELF/LLDDwarfLinker.cpp

59

It should be InputSectionBase.

60

I'd suggest something shorter, like secToIndex

65

Prefer ++foo over foo++.

66

btw, what is so wrong with the following version?

for (InputSectionBase *sec : objFile->getSections())
  sectionIndexesMap[sec] = curIdx++;

(i.e. I probably see no issue with the case when sec == nullptr, as the code below handes this case anyways).

75

Continue early?

if (!sec || !sec->isLive() || !sectionIndexesMap.count(sec))
  continue;

104

We often call such things ret. Up to you.

141

This could be a single line, no need toadd an addend later.

144

Why this assert is useful? What scenario did you have in mind?

146

I think you can just inline Value.

194

An excessive empty line.

195

This comment needs expanding I think. "Estimation" is something that usually sounds tricky and requires an explanation of your algorithm implemented.

197

Don't use auto when the type is not obvious.

200

No need to have curly bracers here.

[grimar]

lld/ELF/LLDDwarfLinker.cpp

231

foo.size() > 0 -> !foo.empty() when foo is StringRef

257

emptyWarnings is unused. Is it OK? You can inline it if so.

267

Map what to what?

272

The way you work with Expected<> is incorrect. It might fail on error with LLVM_ENABLE_ABI_BREAKING_CHECKS=1.
You need to handle the error or to ignore it explicitly. E.g.:

Expected<GlobPattern> pat = GlobPattern::create(arg);
if (!pat) {
  error("--undefined-glob: " + toString(pat.takeError()));
  return;
}

284

Don't use auto here.

293

StringRef() -> ""

But I think it can be just:

for (auto &sec : outputSections)
  if (isDebugSection(sec->name))
    sec->setDebugData(sectionsMap.lookup(sec->name));

lld/ELF/Options.td

226

When you add an LLD option, you should also update the documentation (lld/docs/ld.lld.1)

lld/ELF/OutputSections.cpp

338

Needs a comment.

lld/ELF/OutputSections.h

128

Did you consider to use llvm::Optional<StringRef>?

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

461

You do not need to use else after return:

if (Map.getTriple().isOSDarwin() && !Map.getBinaryPath().empty() &&
    Options.FileType == OutputFileType::Object)
  return MachOUtils::generateDsymCompanion(
      Map, Options.Translator, *Streamer->getAsmPrinter().OutStreamer,
      OutFile);
return Streamer->finish(), true;

462

Something is wrong with this line. , true is a part of something else it seems.

[avl]

lld/ELF/DWARF.cpp

61

There should be three states here(seen, not seen, seen more than once). DWARFFormValue::dumpAddressSection() needs this to properly dump die address. If name seen more than once it prints section index.

// Print section index if name is not unique.
if (!SecRef.IsNameUnique)
  OS << format(" [%" PRIu64 "]", SectionIndex);

275

right. It assumes that relocations are sorted by r_offset.
It is sorted in scanRelocs(). But I missed that it is sorted not for all types of sections.
Would fix it , Thanks!

lld/ELF/DWARF.h

93

It is used at DWARFFormValue::dumpAddressSection(). When address is dumped, DWARFObject could be asked for section names(LLDDwarfObj is a child of DWARFObject). It could happen when Verbose mode is set for DWARFLinker.

132

Yes, it could be used outside of LLDDwarfObj() constructor. When DWARFObject::getSectionNames() is called the sectionNames is used.
One such place is DWARFFormValue::dumpAddressSection().

lld/ELF/InputSection.h

127

To not do string compare in every usage. i.e. that bit is set in the constructor and at every usage place is checked. Otherwise, it would be necessary to compare strings at every usage place.

lld/ELF/LLDDwarfLinker.cpp

66

The idea was to not put error data into sectionIndexesMap. sec is indeed checked later for nullptr.
But it looks like not putting wrong data is better approach than relying on following checks.

144

To check that relocation passed to the handler is from baseOffset, baseOffset + data.size() range.
i.e. to check that enumerateRelocations works correctly and pass proper relocations to the handler.

257

it is used only in std::make_unique<DwarfFile>.

If emptyWarnings is used inline then it`s constructor would be called for each ObjectFile. Probably we could rely on compiler here...

267

Would add comment.

[grimar]

Few more comments. They are mostly to give a feedback about the code style, I have not look deep into how it works yet.

lld/ELF/DWARF.cpp

29

I'd call it sectionNumber, having Map in the name here is not useful.

58

To avoid nesting, you can use an early continue:

if (!sec) {
  sectionNames.push_back({"", true});
  continue;
}
...

61

Ah, sorry, I've misread the code slightly, I did not notice the codition is sectionAmountMap[sec.Name] > 1 and not sectionAmountMap[sec.Name] > 0.

82

It is better to avoid using operator[] in situations like this, because
it is not const, when a sec.Name is not found it creates a new map entry. This is not what you want here,
you can use lookup().

lld/ELF/InputSection.h

127

Yeah, but did you measure numbers, i.e. is there a visible benefit? The code in this diff still calls isDebugSection in many places. It looks like a premature optimization to me and/or something that could probably be moved to another patch (which could change all call sites at once).

lld/ELF/LLDDwarfLinker.cpp

207

I think the returned type of this lambda can be deduced:

[](StringRef S) { return S; }

219

This 2 lambdas looks similar. Also you have 2 more below.
It seems you could do something like the following?

auto ReportWarn = [] [&](const Twine &msg, StringRef ctx, const DWARFDie *) {
if (!context.empty())
  warn(ctx+ ": " + msg);
else
  warn(msg);
};

DwarfStreamer outStreamer(..., ReportWarn, ReportWarn);

257

I'd inline to make the code shorter/cleaner. It doesn't look as hot path, so no need to optimize it until a benefit is proven.

[avl]

lld/ELF/DWARF.cpp

275

@grimar @ruiu It looks like it was considered safe to rely on sorted order of relocations - D36079. What do you think ?

[grimar]

lld/ELF/DWARF.cpp

275

I do not know. ELF specification does not says they must be. Perhaps we can at least check this with std::is_sorted.
I see lld/Wasm does it:

ArrayRef<WasmRelocation> relocs = section->Relocations;
assert(std::is_sorted(relocs.begin(), relocs.end(),
                      [](const WasmRelocation &r1, const WasmRelocation &r2) {
                        return r1.Offset < r2.Offset;
                      }));

assert will not help in release build though.
Perhaps other people can comment on this, as you see my concern about D36079 was not answered that time it seems.

[avl]

lld/ELF/DWARF.cpp

275

I see. I also did not find any reference to documentation which mentioned that relocations must be sorted(nor ELF file specification, nor DWARF specification).

[grimar]

lld/ELF/DWARF.cpp

275

I found it was answered actually:
http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20170731/474875.html
Then it is OK I think.

[avl]

addressed comments:

added test for -flto case.
resolved style issues.

I did not change isDebug bit yet. would make it with separate review.

[avl]

@jhenderson

One drive-by request/question: have you done any measurements of the impact on debuggers? In other words, does it improve/make worse the time it takes them to load the debug data?

loading times for debuggers:

no gc-debuginfo case:
gdb 8.1 clang11 1,4G: loading time 56 sec used memory 2166872kb
lldb 8.0 clang11 1,4G: loading time 7.5 sec used memory 1508860kb

gc-debuginfo case:
gdb 8.1 clang11 783M: loading time 51 sec used memory 1741552kb
lldb 8.1 clang11 783M: loading time 4 sec used memory 842980kb

Overall result: gc-debuginfo makes loading time shorter and reduces memory usage for debuggers,

[dblaikie]

In D74169#1972348, @avl wrote:

@jhenderson

One drive-by request/question: have you done any measurements of the impact on debuggers? In other words, does it improve/make worse the time it takes them to load the debug data?

loading times for debuggers:

no gc-debuginfo case:
gdb 8.1 clang11 1,4G: loading time 56 sec used memory 2166872kb
lldb 8.0 clang11 1,4G: loading time 7.5 sec used memory 1508860kb

gc-debuginfo case:
gdb 8.1 clang11 783M: loading time 51 sec used memory 1741552kb
lldb 8.1 clang11 783M: loading time 4 sec used memory 842980kb

Overall result: gc-debuginfo makes loading time shorter and reduces memory usage for debuggers,

Might be worth comparing with -gdb-index too (though not sure if gdb-index will be immediately compatible with the DWARF aware linking, so a difficult comparison - but even comparing "gdb-index without DWARF-aware linking V DWARF-aware linking without gdb-index", etc)

[avl]

Might be worth comparing with -gdb-index too (though not sure if gdb-index will be immediately compatible with the DWARF aware linking, so a difficult comparison - but even comparing "gdb-index without DWARF-aware linking V DWARF-aware linking without gdb-index", etc)

here are the results for clang binary:

-------------------------------------------------------------
|     Options    | Run-time, sec | Used Memory, kb |  Size  |
-------------------------------------------------------------
|                |     35.58     |     9403596     |  1,4G  |
-------------------------------------------------------------
|  gc-debuginfo  |    109.15     |    14275444     |  783M  |
-------------------------------------------------------------
|  gc-debuginfo  |    130.63     |    14394700     |  797M  |
|   gdb-index    |               |                 |        |
-------------------------------------------------------------
|   gdb-index    |     52.88     |     9524976     |  1.5G  | 
-------------------------------------------------------------

I did not check whether gdb-index is compatible with DWARF aware linking output.

There probably exists the room for optimization of gdb-index(related to the strategy of DWARF context creation).
As it was mentioned in https://reviews.llvm.org/D74773#1920751 simple caching of DWARF context results in an 8% performance increase and 20% memory usage increase.
It is probably worth implementing some smart strategy(reference counting?) that will keep DWARF context while there are users of it and release it when it is not expected to be used(so that it does not hold all DWARF contexts forever).

[dblaikie]

In D74169#1974097, @avl wrote:

Might be worth comparing with -gdb-index too (though not sure if gdb-index will be immediately compatible with the DWARF aware linking, so a difficult comparison - but even comparing "gdb-index without DWARF-aware linking V DWARF-aware linking without gdb-index", etc)

here are the results for clang binary:

-------------------------------------------------------------
|     Options    | Run-time, sec | Used Memory, kb |  Size  |
-------------------------------------------------------------
|                |     35.58     |     9403596     |  1,4G  |
-------------------------------------------------------------
|  gc-debuginfo  |    109.15     |    14275444     |  783M  |
-------------------------------------------------------------
|  gc-debuginfo  |    130.63     |    14394700     |  797M  |
|   gdb-index    |               |                 |        |
-------------------------------------------------------------
|   gdb-index    |     52.88     |     9524976     |  1.5G  | 
-------------------------------------------------------------

Ah, sorry, I meant specifically related to the gdb startup time point you made earlier about DWARF-aware linking improving startup time. It'd be useful to measure startup time with a gdb-index for comparison. (I'm guessing the time in the above chart is linking time, rather than GDB startup time)

I did not check whether gdb-index is compatible with DWARF aware linking output.

There probably exists the room for optimization of gdb-index(related to the strategy of DWARF context creation).
As it was mentioned in https://reviews.llvm.org/D74773#1920751 simple caching of DWARF context results in an 8% performance increase and 20% memory usage increase.
It is probably worth implementing some smart strategy(reference counting?) that will keep DWARF context while there are users of it and release it when it is not expected to be used(so that it does not hold all DWARF contexts forever).

[avl]

Ah, sorry, I meant specifically related to the gdb startup time point you made earlier about DWARF-aware linking improving startup time. It'd be useful to measure startup time with a gdb-index for comparison. (I'm guessing the time in the above chart is linking time, rather than GDB startup time)

right, these are linking times. here is start-up times:

-------------------------------------------------------------------
 Debugger     |     Options    | load-time, sec | Used Memory, kb |
-------------------------------------------------------------------
| gdb 8.1     |                |      47,79     |     2168172     |
-------------------------------------------------------------------
| gdb 8.1     |    gdb-index   |       3.04     |      555408     |
-------------------------------------------------------------------
| gdb 8.1     |  gc-debuginfo  |      44,8      |     1740876     |
-------------------------------------------------------------------
| gdb 8.1     |    gdb-index   |       3.7      |      555340     |
|             |  gc-debuginfo  |                |                 |
-------------------------------------------------------------------
| lldb 8      |                |       6,29     |     1511052     |
-------------------------------------------------------------------
| lldb 8      |    gdb-index   |       6,22     |     1523516     |
-------------------------------------------------------------------
| lldb 8      |  gc-debuginfo  |       3,32     |      843600     |
-------------------------------------------------------------------
| lldb 8      |    gdb-index   |       3.6      |      858532     |
|             |  gc-debuginfo  |                |                 |
-------------------------------------------------------------------

though gdb-index+gc-debuginfo times could be meaningless.

[dblaikie]

In D74169#1974622, @avl wrote:

Ah, sorry, I meant specifically related to the gdb startup time point you made earlier about DWARF-aware linking improving startup time. It'd be useful to measure startup time with a gdb-index for comparison. (I'm guessing the time in the above chart is linking time, rather than GDB startup time)

right, these are linking times. here is start-up times:

-------------------------------------------------------------------
 Debugger     |     Options    | load-time, sec | Used Memory, kb |
-------------------------------------------------------------------
| gdb 8.1     |                |      47,79     |     2168172     |
-------------------------------------------------------------------
| gdb 8.1     |    gdb-index   |       3.04     |      555408     |
-------------------------------------------------------------------
| gdb 8.1     |  gc-debuginfo  |      44,8      |     1740876     |
-------------------------------------------------------------------
| gdb 8.1     |    gdb-index   |       3.7      |      555340     |
|             |  gc-debuginfo  |                |                 |
-------------------------------------------------------------------
| lldb 8      |                |       6,29     |     1511052     |
-------------------------------------------------------------------
| lldb 8      |    gdb-index   |       6,22     |     1523516     |
-------------------------------------------------------------------
| lldb 8      |  gc-debuginfo  |       3,32     |      843600     |
-------------------------------------------------------------------
| lldb 8      |    gdb-index   |       3.6      |      858532     |
|             |  gc-debuginfo  |                |                 |
-------------------------------------------------------------------

though gdb-index+gc-debuginfo times could be meaningless.

Thanks! (yeah, the gdb-index + lldb times aren't relevant either, lldb uses a different kind of accelerated access (one that's only supported on the MachO debug info distribution model currently - but I believe someone's working on/plans to work on DWARFv5 debug_names support))

[avl]

Thanks! (yeah, the gdb-index + lldb times aren't relevant either, lldb uses a different kind of accelerated access (one that's only supported on the MachO debug info distribution model currently - but I believe someone's working on/plans to work on DWARFv5 debug_names support))

dsymutil supports DWARFv5 debug_names table generation. So if --gc-debuginfo specified then debug_names would be generated. This patch has a minor bug with it. I would update it.

[avl]

added test for flto case.(which shows that -flto=thin does not work currently).
added option --debug-names, which enable generation of debug_names table.

[avl]

This implementation does not work for -flto=thin case. That is the same problem like in D54747: https://reviews.llvm.org/D54747#1503720.

[avl]

rebased.

[avl]

Re-measured size/performance results:

A: --function-sections --gc-sections
B: --function-sections --gc-sections --gc-debuginfo
C: --function-sections --gc-sections --fdebug-types-section
D: --function-sections --gc-sections --gsplit-dwarf
E: --function-sections --gc-sections --fdebug-types-section --gc-debuginfo
(last case does not produce valid DWARF currently)

LLVM code base:
--------------------------------------------------------------
| Options |    build time   |    bin size   |    lib size    | 
--------------------------------------------------------------
|    A    |    66min(100%)  |   18.0G(100%) |  16.0G(100.0%) |
--------------------------------------------------------------
|    B    |    81min(123%)  |    9.7G( 54%) |  13.0G( 81.0%) |
--------------------------------------------------------------
|    C    |    58min( 87%)  |   12.0G( 67%) |  15.0G( 93.5%) |
--------------------------------------------------------------
|    D    |    58min( 87%)  |   12.0G( 67%) |   8.7G( 54.0%) |
--------------------------------------------------------------
|    E    |    68min(103%)  |    7.6G( 42%) |  14.0G( 87.5%) |
--------------------------------------------------------------


Clang binary:
--------------------------------------------------------------
| Options |       size     |     link time   |  used memory  |
--------------------------------------------------------------
|    A    |    1.50G(100%) |   26.7sec(100%) |  9191MB(100%) |
--------------------------------------------------------------
|    B    |    0.76G( 50%) |  107.4sec(402%) | 13361MB(145%) |
--------------------------------------------------------------
|    C    |    0.82G( 54%) |   18.3sec( 68%) |  8300MB( 90%) |
--------------------------------------------------------------
|    D    |    0.96G( 64%) |    7.6sec( 28%) |  4255MB( 46%) |
--------------------------------------------------------------
|    E    |    0.58G( 45%) |   58.5sec(219%) | 10317MB(112%) |
--------------------------------------------------------------


lldb loading time:
---------------------------------------------
| Options |       time     |   used memory  |
---------------------------------------------
|    A    |  6.32sec(100%) |  1475MB(100%)  |
---------------------------------------------
|    B    |  3.49sec( 55%) |   825MB( 56%)  |
---------------------------------------------
|    C    |  3.65sec( 58%) |   875MB( 59%)  |
---------------------------------------------
|    D    |  4.12sec( 65%) |  1017MB( 69%)  |
---------------------------------------------
|    E    |  3.95sec( 63%) |   628MB( 43%)  |
---------------------------------------------

[benesch]

Just an excited observer, but wanted to drop some statistics of my own, in case they're helpful.

I have a Rust project (Materialize) that compiles down into a ~800MB (!) binary by default. The weight is almost entirely debug info; .text is less than 5% of its size. This is evidently an artifact of how Rust codegen units are much, much larger than your average C/C++ codegen units and so the toolchain relies heavily on the linker for dead code elimination. Of course that dead code elimination doesn't currently apply to the debug info. This diff is exactly what's needed to solve the problem, as far as I can tell. (There's an upstream issue about this that led me here: https://github.com/rust-lang/rust/issues/56068.)

Without --gc-debuginfo:

# Link time: 10.486s
benesch@gibbon:~/materialize$ bloaty target/release/materialized -n 10
    FILE SIZE        VM SIZE    
 --------------  -------------- 
  24.5%   194Mi   0.0%       0    .debug_info
  24.1%   191Mi   0.0%       0    .debug_loc
  13.8%   109Mi   0.0%       0    .debug_pubtypes
  10.1%  79.9Mi   0.0%       0    .debug_pubnames
   8.8%  70.0Mi   0.0%       0    .debug_str
   8.3%  66.3Mi   0.0%       0    .debug_ranges
   4.4%  35.3Mi   0.0%       0    .debug_line
   3.1%  24.8Mi  66.3%  24.8Mi    .text
   1.8%  14.4Mi  25.1%  9.39Mi    [41 Others]
   0.6%  4.79Mi   0.0%       0    .strtab
   0.4%  3.22Mi   8.6%  3.22Mi    .eh_frame
 100.0%   793Mi 100.0%  37.4Mi    TOTAL

With --gc-debuginfo:

# Link time: 249.855s
benesch@gibbon:~/materialize$ bloaty target/release/materialized -n 10
    FILE SIZE        VM SIZE    
 --------------  -------------- 
  37.9%   115Mi   0.0%       0    .debug_info
  17.9%  54.7Mi   0.0%       0    .debug_str
  12.0%  36.7Mi   0.0%       0    .debug_ranges
  11.2%  34.4Mi   0.0%       0    .debug_loc
   8.1%  24.8Mi  66.3%  24.8Mi    .text
   6.6%  20.1Mi   0.0%       0    .debug_line
   2.7%  8.15Mi  19.3%  7.23Mi    [35 Others]
   1.6%  4.79Mi   0.0%       0    .strtab
   1.1%  3.22Mi   8.6%  3.22Mi    .eh_frame
   1.0%  2.99Mi   0.0%       0    .symtab
   0.0%       0   5.8%  2.16Mi    .bss
 100.0%   305Mi 100.0%  37.4Mi    TOTAL

So hugely successful in reducing the size of the debug info! The new binary is 40% of the size of the original. Some of that savings is from omitting debug_pubtypes and debug_pubnames, which is easy enough to strip without this patch, but there is also a substantial reduction in debug_info and debug_loc—a much larger reduction than dbz is able to provide.

Unfortunately there is also a massive blowup in link times, from 10s to 250s. That's a 25x increase, much larger than the link time increase for Clang described above, which was about 4x.

[dblaikie]

In D74169#1990180, @benesch wrote:

Just an excited observer, but wanted to drop some statistics of my own, in case they're helpful.

I have a Rust project (Materialize) that compiles down into a ~800MB (!) binary by default. The weight is almost entirely debug info; .text is less than 5% of its size. This is evidently an artifact of how Rust codegen units are much, much larger than your average C/C++ codegen units and so the toolchain relies heavily on the linker for dead code elimination.

Out of curiosity is there any work in the direction of fragmenting these modules/objects further to reduce this & other negative side effects of that situation?

Of course that dead code elimination doesn't currently apply to the debug info. This diff is exactly what's needed to solve the problem, as far as I can tell. (There's an upstream issue about this that led me here: https://github.com/rust-lang/rust/issues/56068.)

Without --gc-debuginfo:

# Link time: 10.486s
benesch@gibbon:~/materialize$ bloaty target/release/materialized -n 10
    FILE SIZE        VM SIZE    
 --------------  -------------- 
  24.5%   194Mi   0.0%       0    .debug_info
  24.1%   191Mi   0.0%       0    .debug_loc
  13.8%   109Mi   0.0%       0    .debug_pubtypes
  10.1%  79.9Mi   0.0%       0    .debug_pubnames
   8.8%  70.0Mi   0.0%       0    .debug_str
   8.3%  66.3Mi   0.0%       0    .debug_ranges
   4.4%  35.3Mi   0.0%       0    .debug_line
   3.1%  24.8Mi  66.3%  24.8Mi    .text
   1.8%  14.4Mi  25.1%  9.39Mi    [41 Others]
   0.6%  4.79Mi   0.0%       0    .strtab
   0.4%  3.22Mi   8.6%  3.22Mi    .eh_frame
 100.0%   793Mi 100.0%  37.4Mi    TOTAL

With --gc-debuginfo:

# Link time: 249.855s
benesch@gibbon:~/materialize$ bloaty target/release/materialized -n 10
    FILE SIZE        VM SIZE    
 --------------  -------------- 
  37.9%   115Mi   0.0%       0    .debug_info
  17.9%  54.7Mi   0.0%       0    .debug_str
  12.0%  36.7Mi   0.0%       0    .debug_ranges
  11.2%  34.4Mi   0.0%       0    .debug_loc
   8.1%  24.8Mi  66.3%  24.8Mi    .text
   6.6%  20.1Mi   0.0%       0    .debug_line
   2.7%  8.15Mi  19.3%  7.23Mi    [35 Others]
   1.6%  4.79Mi   0.0%       0    .strtab
   1.1%  3.22Mi   8.6%  3.22Mi    .eh_frame
   1.0%  2.99Mi   0.0%       0    .symtab
   0.0%       0   5.8%  2.16Mi    .bss
 100.0%   305Mi 100.0%  37.4Mi    TOTAL

So hugely successful in reducing the size of the debug info! The new binary is 40% of the size of the original. Some of that savings is from omitting debug_pubtypes and debug_pubnames, which is easy enough to strip without this patch, but there is also a substantial reduction in debug_info and debug_loc—a much larger reduction than dbz is able to provide.

Unfortunately there is also a massive blowup in link times, from 10s to 250s. That's a 25x increase, much larger than the link time increase for Clang described above, which was about 4x.

[benesch]

Out of curiosity is there any work in the direction of fragmenting these modules/objects further to reduce this & other negative side effects of that situation?

I'm afraid I have no idea. Nothing I'm aware of, but I'm not a rustc dev. Perhaps @rocallahan knows. I'll ask on the Rust Zulip, too.

[avl]

allowed multi-threaded execution.

[avl]

@benesch Thank you for the interest in this patch and the statistics data.

Unfortunately there is also a massive blowup in link times, from 10s to 250s. That's a 25x increase, much larger than the link time increase for Clang described above, which was about 4x.

Excuse me. It looks like my reported statistic is not very accurate. I would re-measure it and re-submit.
There are two things here: first is that reported numbers are for the patch, which I did not update(because of some bug). And another is that calculations are not accurate. I have just updated the patch. Following is what I got for clang:

/usr/bin/time -f "%E %M" bin/clang-11
0:11.62 9509308

/usr/bin/time -f "%E %M" bin/clang-11 --gc-debuginfo
1:15.16 15346672

i.e. it is about 6.5x, not 25x. I would also check the numbers for the updated patch and for your materialize project. Probably, it might be quite close since .text section takes 7.5% of entire binary in clang.
Thank you.

The new binary is 40% of the size of the original. Some of that savings is from omitting debug_pubtypes and debug_pubnames, which is easy enough to strip without this patch

The reason why debug_pubtypes and debug_pubnames were stripped, is that the current patch uses already existed dsymutil code, which does not generate debug_pubtypes and debug_pubnames. This patch changes debug info. Thus it removes other debug info tables, which it does not support(since they most probably would contain no relevant data). Supporting all these tables(as well as DWARF5) is a future task for the DWARFLinker.

[avl]

Re-measured size/performance results once more. These results are for 12-cores machine. Actually, the more cores the bigger difference between --gc-debuginfo/--no-gc-debuginfo cases.

A: --function-sections --gc-sections
B: --function-sections --gc-sections --gc-debuginfo
C: --function-sections --gc-sections --fdebug-types-section
D: --function-sections --gc-sections --gsplit-dwarf
E: --function-sections --gc-sections --gc-debuginfo --compress-debug-sections=zlib
F: --function-sections --gc-sections --fdebug-types-section --gc-debuginfo
(last case does not produce valid DWARF currently)

LLVM code base:
--------------------------------------------------------------
| Options |    build time   |    bin size   |    lib size    | 
--------------------------------------------------------------
|    A    |    54min(100%)  |   19.0G(100%) |  15.0G(100.0%) |
--------------------------------------------------------------
|    B    |    65min(120%)  |    9.7G( 51%) |  12.0G( 80.0%) |
--------------------------------------------------------------
|    C    |    53min( 98%)  |   12.0G( 63%) |  15.0G(100.0%) |
--------------------------------------------------------------
|    D    |    52min( 96%)  |   12.0G( 63%) |   8.2G( 55.0%) |
--------------------------------------------------------------
|    E    |    64min(118%)  |    5.3G( 28%) |  12.0G( 80.0%) |
--------------------------------------------------------------
|    F    |    57min(105%)  |    7.6G( 40%) |  14.0G( 93.0%) |
--------------------------------------------------------------


Clang binary:
-------------------------------------------------------------
| Options |      size      |     link time  |  used memory  |
-------------------------------------------------------------
|    A    |    1.50G(100%) |    9sec(100%)  |  9307MB(100%) |
-------------------------------------------------------------
|    B    |    0.76G( 50%) |   72sec(800%)  | 15055MB(161%) |
-------------------------------------------------------------
|    C    |    0.82G( 54%) |    8sec( 89%)  |  8402MB( 90%) |
-------------------------------------------------------------
|    D    |    0.96G( 64%) |    6sec( 67%)  |  4273MB( 46%) |
-------------------------------------------------------------
|    E    |    0.43G( 29%) |   80sec(889%)  | 15000MB(161%) |
-------------------------------------------------------------
|    F    |    0.58G( 39%) |   30sec(334%)  | 10890MB(117%) |
-------------------------------------------------------------


lldb loading time:
--------------------------------------------
| Options |      time     |   used memory  |
--------------------------------------------
|    A    |  6.4sec(100%) |  1495MB(100%)  |
--------------------------------------------
|    B    |  4.0sec( 63%) |   826MB( 55%)  |
--------------------------------------------
|    C    |  3.7sec( 58%) |   877MB( 59%)  |
--------------------------------------------
|    D    |  4.3sec( 67%) |  1023MB( 69%)  |
--------------------------------------------
|    E    |  2.1sec( 33%) |   478MB( 32%)  |
--------------------------------------------
|    F    |  2.7sec( 42%) |   631MB( 43%)  |
--------------------------------------------

[avl]

rebased. added tests.

[avl]

@ruiu @grimar @MaskRay @dblaikie @clayborg

What do you think about that patch ? Whether it is generally OK to start integration? If it is OK then I would divide the patch to smaller patches and start to integrate.

I think it is worth integrating: it has a small impact on existing lld code(most implementation is in separate library DWARFLinker. Only lld/ELF/DWARF.* and lld/ELF/LLDDwarfLinker.* are noticeably affected). --gc-debuginfo is off by default so it would not affect most of the users. Only those who explicitly specified --gc-debuginfo would use that functionality. The patch noticeably reduces the size of debug info. It also resolves"overlapping address ranges" problem. Upcoming optimizations could minimize the performance reduction.

[avl]

rebased. improved execution time for 5%.

[ayermolo]

@avl Would it be possible to rebase this on latest, or is this diff abandoned?

[avl]

rebased.

[avl]

@ayermolo Hi Alexander, I rebased on latest but did not check whether current size/performance numbers match with reported previously.

[ayermolo]

lld/ELF/LLDDwarfLinker.cpp

81

The RangesTy is defined as a map with uint64_t
using RangesTy = std::map<uint64_t, ObjFileAddressRange>;

Not sure I follow how this works. Am I missing some c++ thing? This fails to compile with clang.

223

There is no AccelTableKind::None, did you mean AccelTableKind::Default?

enum class AccelTableKind {

Apple,   ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
Dwarf,   ///< DWARF v5 .debug_names.
Default, ///< Dwarf for DWARF5 or later, Apple otherwise.

};

[avl]

lld/ELF/LLDDwarfLinker.cpp

81

The RangesTy is defined as a map with object::SectionedAddress.

/// Map LowPC to AddressHighPC.
using RangesTy = std::map<object::SectionedAddress, AddressHighPC>;

It looks like your local source files are in inconsistent state. This patch was build successfully by pre-merge build bot.

223

It is added by this patch at line 29 of llvm/include/llvm/DWARFLinker/DWARFLinker.h.

llvm/include/llvm/DWARFLinker/DWARFLinker.h

29

Here is the place where AccelTableKind::None is defined.

[avl]

rebased, added command-line option --gc-debuginfo-no-odr.

debuginfo-tests/CMakeLists.txt

 
 set(DEBUGINFO_TEST_DEPS
   clang
   FileCheck
   count
   llvm-config
   llvm-objdump
   check-gdb-llvm-support
+  llvm-dwarfdump
   not
   )
 
 if ("mlir" IN_LIST LLVM_ENABLE_PROJECTS)
   add_llvm_executable(check-gdb-mlir-support
         llvm-prettyprinters/gdb/mlir-support.cpp
   )
   target_include_directories(check-gdb-mlir-support PRIVATE ${LLVM_EXTERNAL_MLIR_SOURCE_DIR}/include)
if(TARGET safestack)
     list(APPEND DEBUGINFO_TEST_DEPS safestack)
   endif()
 endif()
 # Many dexter tests depend on lldb.
 if("lldb" IN_LIST LLVM_ENABLE_PROJECTS)
   list(APPEND DEBUGINFO_TEST_DEPS lldb lldb-server)
 endif()
 
-# The Windows builder scripts pass -fuse-ld=lld.
-if (WIN32)
+if (NOT APPLE)
   set(DEBUGINFO_TEST_DEPS ${DEBUGINFO_TEST_DEPS} lld)
 endif()
 
 if (NOT DEFINED Python3_EXECUTABLE)
   message(FATAL_ERROR "Cannot run debuginfo-tests without python 3")
 endif()
 
 configure_lit_site_cfg(

debuginfo-tests/dwarflinker/Inputs/empty-main.cpp

+int main ( void ) {
+  return 0;
+}

debuginfo-tests/dwarflinker/Inputs/full-main.cpp

+#include <stdio.h>
+int mod1_f1(int);
+int mod2_f1(const char*);
+int mod1_not_used(int p1);
+int mod2_not_used(int p1);
+int main ( void ) {
+  int res = mod1_f1(1);
+  res += mod2_f1("hello");
+  res += mod1_not_used(res);
+  res += mod2_not_used(res);
+  printf("\n %d", res);
+  return 0;
+}

debuginfo-tests/dwarflinker/Inputs/gc-debuginfo-main-lto.cpp

+#include <stdio.h>
+
+int mod1_f1(int);
+int mod2_f1(const char*);
+
+int main(void) {
+  int v1 = mod1_f1(3);
+  int v2 = mod2_f1("hello");
+
+  for (int idx = 0; idx < 3; idx++) {
+    printf("%d", v1+idx);
+    printf("%d", v2+idx);
+  }
+
+  return 0;
+}

debuginfo-tests/dwarflinker/Inputs/gc-debuginfo-main.c

+#include <stdio.h>
+
+int mod1_f1(int);
+int mod2_f1(int);
+
+__attribute__((optnone)) void func(int p) {
+  printf("\n%d", p);
+}
+
+__attribute__((optnone)) int main(void) {
+  int v1 = mod1_f1(3);
+  int v2 = mod2_f1(5);
+
+  for (int idx = 0; idx < 3; idx++)
+    func(v1 * idx + v2);
+
+  return 0;
+}

debuginfo-tests/dwarflinker/Inputs/gc-debuginfo-mod1-lto.cpp

+__attribute__((optnone)) int mod1_f1(int p1) { return p1 + 10; }
+
+__attribute__((optnone)) int mod1_not_used(int p1) {
+  return p1+100;
+}

debuginfo-tests/dwarflinker/Inputs/gc-debuginfo-mod1.c

+int mod1_f1(int p1) { return p1 + 10; }
+
+int mod1_not_used(int p1) {
+  int r = 0;
+  for (int i = 0; i < p1; i++)
+    r++;
+  return r;
+}

debuginfo-tests/dwarflinker/Inputs/gc-debuginfo-mod2-lto.cpp

+
+class S {
+  public:
+__attribute__((optnone))  S(const char* str) {
+    l = 0;
+    while (!*str)
+      l++;
+  }
+
+__attribute__((optnone))  int Length() {
+    return l;
+  }
+
+  int l = 0;
+};
+
+__attribute__((optnone)) int mod2_f1(const char* n) {
+  return S(n).Length();
+}
+
+__attribute__((optnone)) int mod2_not_used ( int p1) {
+  return p1+100;
+}

debuginfo-tests/dwarflinker/Inputs/gc-debuginfo-mod2.c

+
+int mod2_f1(int p1) { return p1 + 10; }
+
+int mod2_not_used(int p1) {
+  int r = 0;
+  for (int i = 0; i < p1; i++)
+    r++;
+
+  return r;
+}

debuginfo-tests/dwarflinker/Inputs/odr-foo.cpp

+#include "struct.h"
+
+__attribute__((optnone)) int foo ( S p ) {
+  return p.a1 + p.a2;
+}

debuginfo-tests/dwarflinker/Inputs/odr-main.cpp

+#include "struct.h"
+int foo(S);
+
+int main ( void ) {
+  S s; s.a1 = 2; s.a2 = 5;
+
+  return foo(s);
+}

debuginfo-tests/dwarflinker/Inputs/struct.h

+struct S {
+  int a1;
+  int a2;
+};

debuginfo-tests/dwarflinker/empty.cpp

+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O %p/Inputs/empty-main.cpp -c -o %t.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O %p/Inputs/gc-debuginfo-mod1-lto.cpp -c -o %t1.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O %p/Inputs/gc-debuginfo-mod2-lto.cpp -c -o %t2.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -O -fuse-ld=lld \
+// RUN: -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o %t2.o -o %t3.out
+// RUN: llvm-dwarfdump -a %t3.out | FileCheck %s
+// RUN: llvm-dwarfdump --verify %t3.out | FileCheck %s --check-prefix=VERIFY
+
+// UNSUPPORTED: system-darwin
+
+// This test checks that --gc-debuginfo removes unused debug info.
+// It checks that debug info related to all functions from
+// gc-debuginfo-mod1-lto.cpp and gc-debuginfo-mod2-lto.cpp is not
+// put into resulting binary
+
+CHECK: .debug_info contents:
+CHECK:      DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}empty-main.cpp")
+CHECK:      DW_AT_stmt_list   (0x[[MAIN_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_low_pc      (0x[[LOWPC_ADDR:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_high_pc     (0x[[HIGHPC_ADDR:[0-9A-Fa-f]+]])
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc      (0x[[LOWPC_ADDR]])
+CHECK:      DW_AT_high_pc     (0x[[HIGHPC_ADDR]])
+CHECK:      DW_AT_name      ("main")
+CHECK-NOT:  DW_TAG_subprogram
+CHECK:      NULL
+CHECK:      .eh_frame contents:
+CHECK:      .debug_line contents:
+CHECK:      debug_line[0x[[MAIN_STMT_LIST]]
+CHECK:      Address
+CHECK:      0x{{0*}}[[LOWPC_ADDR]]
+CHECK:      0x{{0*}}[[HIGHPC_ADDR]]
+CHECK-NOT:  mod1_f1
+CHECK-NOT:  mod2_f1
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK-NOT:  .debug_ranges contents:
+
+VERIFY: Verifying
+VERIFY: No errors.

debuginfo-tests/dwarflinker/full.cpp

+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O %p/Inputs/full-main.cpp -c -o %t.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O %p/Inputs/gc-debuginfo-mod1-lto.cpp -c -o %t1.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O %p/Inputs/gc-debuginfo-mod2-lto.cpp -c -o %t2.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -O -fuse-ld=lld \
+// RUN: -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o %t2.o -o %t3.out
+// RUN: llvm-dwarfdump -a %t3.out | FileCheck %s
+// RUN: llvm-dwarfdump --verify %t3.out | FileCheck %s --check-prefix=VERIFY
+
+// UNSUPPORTED: system-darwin
+
+// This test checks that --gc-debuginfo does not remove debug info.
+// (Because there is no code deleted by --gc-sections).
+// It checks that debug info related to all functions from
+// gc-debuginfo-mod1-lto.cpp and gc-debuginfo-mod2-lto.cpp is put
+// into resulting binary
+
+CHECK: .debug_info contents:
+CHECK:      DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}full-main.cpp")
+CHECK:      DW_AT_stmt_list   (0x[[MAIN_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_low_pc      (0x[[LOWPC_ADDR:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_high_pc     (0x[[HIGHPC_ADDR:[0-9A-Fa-f]+]])
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc      (0x[[LOWPC_ADDR]])
+CHECK:      DW_AT_high_pc     (0x[[HIGHPC_ADDR]])
+CHECK:      DW_AT_name      ("main")
+CHECK:      DW_TAG_variable
+CHECK:      DW_AT_location
+CHECK:      DW_AT_name    ("res")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name      ("mod1_f1")
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name      ("mod2_f1")
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name      ("mod1_not_used")
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name      ("mod2_not_used")
+CHECK:      DW_TAG_formal_parameter
+CHECK:      NULL
+CHECK:      NULL
+
+CHECK:      DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}gc-debuginfo-mod1-lto.cpp")
+CHECK:      DW_AT_stmt_list   (0x[[MOD1_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_ranges
+CHECK:      [0x{{0*}}[[MOD1_ADDR:[0-9A-Fa-f]+]],
+CHECK:      [0x{{0*}}[[MOD1_NON_USED_ADDR:[0-9A-Fa-f]+]],
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MOD1_ADDR]]
+CHECK:      DW_AT_name      ("mod1_f1")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MOD1_NON_USED_ADDR]]
+CHECK:      DW_AT_name      ("mod1_not_used")
+CHECK:      NULL
+CHECK:      NULL
+
+CHECK:      DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}gc-debuginfo-mod2-lto.cpp")
+CHECK:      DW_AT_stmt_list   (0x[[MOD2_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_ranges
+CHECK:      [0x{{0*}}[[MOD2_ADDR:[0-9A-Fa-f]+]],
+CHECK:      [0x{{0*}}[[MOD2_S_ADDR:[0-9A-Fa-f]+]],
+CHECK:      [0x{{0*}}[[MOD2_LENGTH_ADDR:[0-9A-Fa-f]+]],
+CHECK:      [0x{{0*}}[[MOD2_NON_USED_ADDR:[0-9A-Fa-f]+]],
+CHECK:      DW_TAG_class_type
+CHECK:      DW_AT_name      ("S")
+CHECK:      DW_TAG_member
+CHECK:      DW_AT_name    ("l")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name    ("S")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name    ("Length")
+CHECK:      NULL
+CHECK:      NULL
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MOD2_ADDR]]
+CHECK:      DW_AT_name      ("mod2_f1")
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_AT_name    ("n")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MOD2_S_ADDR]]
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_AT_name    ("this")
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_AT_name    ("str")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MOD2_LENGTH_ADDR]]
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_AT_name    ("this")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MOD2_NON_USED_ADDR]]
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_AT_name    ("p1")
+CHECK:      NULL
+
+CHECK:      .debug_loc contents:
+
+CHECK:      .eh_frame contents:
+
+CHECK:      .debug_line contents:
+CHECK:      debug_line[0x[[MAIN_STMT_LIST]]]
+CHECK:      Address
+CHECK:      0x{{0*}}[[LOWPC_ADDR]]
+CHECK:      debug_line[0x[[MOD1_STMT_LIST]]]
+CHECK:      Address
+CHECK:      0x{{0*}}[[MOD1_ADDR]]
+CHECK:      0x{{0*}}[[MOD1_NON_USED_ADDR]]
+CHECK:      debug_line[0x[[MOD2_STMT_LIST]]]
+CHECK:      Address
+CHECK:      0x{{0*}}[[MOD2_ADDR]]
+CHECK:      0x{{0*}}[[MOD2_S_ADDR]]
+CHECK:      0x{{0*}}[[MOD2_LENGTH_ADDR]]
+CHECK:      0x{{0*}}[[MOD2_NON_USED_ADDR]]
+
+CHECK:      .debug_str contents:
+CHECK:      "main"
+CHECK:      "res"
+CHECK:      "mod1_f1"
+CHECK:      "mod2_f1"
+CHECK:      "mod1_not_used"
+CHECK:      "mod2_not_used"
+CHECK:      "S"
+CHECK:      "Length"
+CHECK:      "this"
+
+CHECK:      .debug_ranges contents:
+
+
+VERIFY: Verifying
+VERIFY: No errors.

debuginfo-tests/dwarflinker/gc-debuginfo-lto.cpp

+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O -flto %p/Inputs/gc-debuginfo-main-lto.cpp -c -o %t.o
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O -flto %p/Inputs/gc-debuginfo-mod1-lto.cpp -c -o %t1.o
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O -flto %p/Inputs/gc-debuginfo-mod2-lto.cpp -c -o %t2.o
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -O -fuse-ld=lld \
+// RUN: -flto -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o %t2.o -o %t3.out
+// RUN: llvm-dwarfdump -a %t3.out | FileCheck %s
+// RUN: llvm-dwarfdump --verify %t3.out | FileCheck %s --check-prefix=VERIFY
+
+// UNSUPPORTED: system-darwin
+
+// This test checks that --gc-debuginfo removes unused debug info
+// correctly in case -flto. After -flto there would be single .debug_info
+// section containing all compile units. The test checks that dwarflinker
+// correctly processes several compilation units placed into single
+// .debug info section. The test checks that debug info related
+// to mod1_not_used() and mod2_not_used() functions
+// is deleted from resulting .debug* tables.
+
+CHECK: .debug_info contents:
+CHECK:      0x0000000b: DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}gc-debuginfo-main-lto.cpp")
+CHECK:      DW_AT_stmt_list   (0x[[MAIN_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MAIN_LPC:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_high_pc   (0x{{0*}}[[MAIN_HPC:[0-9A-Fa-f]+]])
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MAIN_LPC]])
+CHECK:      DW_AT_high_pc   (0x{{0*}}[[MAIN_HPC]])
+CHECK:      DW_AT_name      ("main")
+CHECK:      DW_TAG_variable
+CHECK:      DW_AT_location
+CHECK:      DW_AT_name    ("v1")
+CHECK:      DW_TAG_variable
+CHECK:      DW_AT_location
+CHECK:      DW_AT_name    ("v2")
+CHECK:      DW_TAG_variable
+CHECK:      DW_AT_location
+CHECK:      DW_AT_name  ("idx")
+CHECK:      DW_TAG_GNU_call_site
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MOD1_VAL:[0-9A-Fa-f]+]])
+CHECK:      DW_TAG_GNU_call_site
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MOD2_VAL:[0-9A-Fa-f]+]])
+CHECK:      Compile Unit
+CHECK_NOT: 0x0000000b
+CHECK:      DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}gc-debuginfo-mod2-lto.cpp")
+CHECK:      DW_AT_stmt_list   (0x{{0*}}[[MOD2_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_ranges      (0x{{0*}}[[RANGE_LIST_MOD2:[0-9A-Fa-f]+]]
+CHECK-NEXT: 0x{{0*}}[[MOD2_VAL_ADDR:[0-9A-Fa-f]+]], 0x{{[0-9a-zA-Z]*}}
+CHECK-NEXT: 0x{{0*}}[[MOD2_LENGTH_ADDR:[0-9A-Fa-f]+]], 0x{{[0-9a-zA-Z]*}}
+CHECK-NEXT: 0x{{0*}}[[MOD2_CONSTR_ADDR:[0-9A-Fa-f]+]], 0x{{[0-9a-zA-Z]*}}
+CHECK:      DW_TAG_class_type
+CHECK:      DW_AT_name      ("S")
+CHECK:      DW_TAG_member
+CHECK:      DW_AT_name    ("l")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name    ("S")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name    ("Length")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc (0x{{0*}}[[MOD2_VAL_ADDR]])
+CHECK:      DW_AT_name      ("mod2_f1")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc (0x{{0*}}[[MOD2_LENGTH_ADDR]])
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc (0x{{0*}}[[MOD2_CONSTR_ADDR]])
+CHECK:      Compile Unit
+CHECK_NOT: 0x0000000b
+CHECK:      DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}gc-debuginfo-mod1-lto.cpp")
+CHECK:      DW_AT_stmt_list   (0x{{0*}}[[MOD1_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MOD1_LPC:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_high_pc   (0x{{0*}}[[MOD1_HPC:[0-9A-Fa-f]+]])
+CHECK:      .debug_loc contents
+CHECK: .debug_line contents:
+CHECK: debug_line[0x[[MAIN_STMT_LIST]]]
+CHECK: Address
+CHECK: 0x{{0*}}[[MAIN_LPC]]
+CHECK: debug_line[0x{{0*}}[[MOD2_STMT_LIST]]]
+CHECK: Address
+CHECK: 0x{{0*}}[[MOD2_VAL_ADDR]]
+CHECK: 0x{{0*}}[[MOD2_LENGTH_ADDR]]
+CHECK: 0x{{0*}}[[MOD2_CONSTR_ADDR]]
+CHECK: debug_line[0x{{0*}}[[MOD1_STMT_LIST]]]
+CHECK: Address
+CHECK: 0x{{0*}}[[MOD1_LPC]]
+
+CHECK:      .debug_str contents
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK:      .debug_ranges contents:
+
+VERIFY: Verifying
+VERIFY: No errors.

debuginfo-tests/dwarflinker/gc-debuginfo.c

+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -fno-inline -O %p/Inputs/gc-debuginfo-main.c -c -o %t.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -fno-inline -O %p/Inputs/gc-debuginfo-mod1.c -c -o %t1.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -fno-inline -O %p/Inputs/gc-debuginfo-mod2.c -c -o %t2.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -O -fuse-ld=lld \
+// RUN: -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o %t2.o -o %t3.out
+// RUN: llvm-dwarfdump -a %t3.out | FileCheck %s
+// RUN: llvm-dwarfdump --verify %t3.out | FileCheck %s --check-prefix=VERIFY
+
+// UNSUPPORTED: system-darwin
+
+// This test checks that --gc-debuginfo removes unused debug info.
+// It checks that debug info related to mod1_not_used() and
+// mod2_not_used() functions is deleted from resulting .debug*
+// tables. .debug_loc table should be empty since mod1_f1()
+// and mod2_f1() functions do not refer to .debug_loc.
+
+CHECK: .debug_info contents:
+CHECK:      DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}gc-debuginfo-main.c")
+CHECK:      DW_AT_stmt_list   (0x[[MAIN_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_ranges      (0x00000000
+CHECK-NEXT: [0x{{0*}}[[MAIN_ADDR:[0-9A-Fa-f]+]], 0x{{[0-9a-zA-Z]*}})
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[MAIN_ADDR]])
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK:      DW_AT_name      ("main")
+CHECK:      DW_TAG_subprogram
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK:      DW_AT_name      ("mod1_f1")
+CHECK:      DW_TAG_subprogram
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK:      DW_AT_name      ("mod2_f1")
+CHECK:      Compile Unit
+CHECK:      DW_TAG_compile_unit
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK:      DW_AT_name ("{{.*}}gc-debuginfo-mod1.c")
+CHECK:      DW_AT_stmt_list   (0x{{0*}}[[MOD1_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_ranges      (0x{{0*}}[[RANGE_LIST_MOD1:[0-9A-Fa-f]+]]
+CHECK-NEXT: [0x{{0*}}[[GET_MOD1_ADDR:[0-9A-Fa-f]+]], 0x{{[0-9a-zA-Z]*}}))
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[GET_MOD1_ADDR]]
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK:      DW_AT_name      ("mod1_f1")
+CHECK:      Compile Unit
+CHECK:      DW_TAG_compile_unit
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK:      DW_AT_name ("{{.*}}gc-debuginfo-mod2.c")
+CHECK:      DW_AT_stmt_list   (0x{{0*}}[[MOD2_STMT_LIST:[0-9A-Fa-f]+]])
+CHECK:      DW_AT_ranges      (0x{{0*}}[[RANGE_LIST_MOD2:[0-9A-Fa-f]+]]
+CHECK-NEXT: [0x[[GET_MOD2_ADDR:[0-9A-Fa-f]+]], 0x{{[0-9a-zA-Z]*}}))
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_low_pc    (0x{{0*}}[[GET_MOD2_ADDR]]
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK:      DW_AT_name      ("mod2_f1")
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+CHECK:      NULL
+
+CHECK-NOT: .debug_loc contents:
+
+CHECK: .debug_line contents:
+CHECK: debug_line[0x[[MAIN_STMT_LIST]]]
+CHECK: Address
+CHECK: 0x{{0*}}[[MAIN_ADDR:[0-9A-Fa-f]+]]
+CHECK: debug_line[0x{{0*}}[[MOD1_STMT_LIST]]]
+CHECK: Address
+CHECK: 0x{{0*}}[[GET_MOD1_ADDR:[0-9A-Fa-f]+]]
+CHECK: debug_line[0x{{0*}}[[MOD2_STMT_LIST]]]
+CHECK: Address
+CHECK: 0x{{0*}}[[GET_MOD2_ADDR:[0-9A-Fa-f]+]]
+
+
+CHECK: .debug_str contents:
+CHECK-NOT:  mod1_not_used
+CHECK-NOT:  mod2_not_used
+
+CHECK: .debug_ranges contents:
+CHECK: 00000000 0000000000000000 {{[0-9a-zA-Z]*}}
+CHECK: 00000000 <End of list>
+CHECK: {{0*}}[[RANGE_LIST_MOD1]] 0000000000000000 {{[0-9a-zA-Z]*}}
+CHECK: {{0*}}[[RANGE_LIST_MOD1]] <End of list>
+CHECK: {{0*}}[[RANGE_LIST_MOD2]] 0000000000000000 {{[0-9a-zA-Z]*}}
+CHECK: {{0*}}[[RANGE_LIST_MOD2]] <End of list>
+
+VERIFY: Verifying
+VERIFY: No errors.

debuginfo-tests/dwarflinker/odr.cpp

+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -fno-inline -O %p/Inputs/odr-main.cpp -c -o %t.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -fno-inline -O %p/Inputs/odr-foo.cpp -c -o %t1.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -O -fuse-ld=lld \
+// RUN: -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o -o %t2.out
+// RUN: llvm-dwarfdump -a %t2.out | FileCheck %s
+// RUN: llvm-dwarfdump --verify %t2.out | FileCheck %s --check-prefix=VERIFY
+
+// UNSUPPORTED: system-darwin
+
+// This test checks that --gc-debuginfo properly implements
+// One Definition Rule. It checks that debug info related to struct S
+// presented only once(in first compilation unit). And that second
+// compilation unit references definition from the first compilation unit.
+
+CHECK: .debug_info contents:
+CHECK:      DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}odr-main.cpp")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name      ("main")
+CHECK:      DW_TAG_variable
+CHECK:      DW_AT_name    ("s")
+CHECK:      DW_AT_type    (0x{{0*}}[[STRUCT_OFFSET:[0-9A-Fa-f]+]]
+CHECK:      NULL
+CHECK:      NULL
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name      ("foo")
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_AT_type    (0x{{0*}}[[STRUCT_OFFSET]]
+CHECK:      0x{{0*}}[[STRUCT_OFFSET:[0-9A-Fa-f]+]]: DW_TAG_structure_type
+CHECK:      DW_AT_name      ("S")
+CHECK:      DW_TAG_member
+CHECK:      DW_AT_name    ("a1")
+CHECK:      DW_AT_name    ("a2")
+CHECK:      NULL
+CHECK:      NULL
+CHECK:      DW_TAG_compile_unit
+CHECK:      DW_AT_name ("{{.*}}odr-foo.cpp")
+CHECK:      DW_TAG_subprogram
+CHECK:      DW_AT_name      ("foo")
+CHECK:      DW_TAG_formal_parameter
+CHECK:      DW_AT_name    ("p")
+CHECK:      DW_AT_type    (0x{{0*}}[[STRUCT_OFFSET]]
+CHECK:      NULL
+
+VERIFY: Verifying
+VERIFY: No errors.

debuginfo-tests/llgdb-tests/dwarflinker/Inputs/debuginfo-modules.h

+struct Foo {
+  int x, y;
+};
+inline int foo() {
+  volatile Foo var;
+  var.x = 13;
+  var.y = 42;
+  return var.x + var.y;
+}

debuginfo-tests/llgdb-tests/dwarflinker/Inputs/debuginfo-modules.modulemap

+module foo {
+header "debuginfo-modules.h"
+}

debuginfo-tests/llgdb-tests/dwarflinker/Inputs/gc-debuginfo-mod1-lto.cpp

+struct S {
+  int a1;
+  int a2;
+};
+int mod1_func(void) {
+  volatile S var;
+  var.a1 = 100; var.a2 = 200;
+  return var.a1 + var.a2;
+}

debuginfo-tests/llgdb-tests/dwarflinker/Inputs/gc-debuginfo-mod1.c

+int mod1_f1(int p1) {
+  int r = 0;
+  for (int i = 0; i < p1; i++)
+    r++;
+
+  return r;
+}
+
+int mod1_not_used(int p1) { return p1 + 10; }

debuginfo-tests/llgdb-tests/dwarflinker/Inputs/gc-debuginfo-mod2.c

+int mod2_f1(int p1) {
+  int r = 0;
+  for (int i = 0; i < p1; i++)
+    r += p1;
+
+  return r;
+}
+
+int mod2_not_used(int p1) { return p1 + 10; }

debuginfo-tests/llgdb-tests/dwarflinker/Inputs/inline-foo.c

+#include <stdio.h>
+int foo(int p1) {
+  int r = 10;
+  for (int i = 0; i < p1; i++) {
+    r++;
+    printf("\n r %d i %d p1 %d", r, i, p1 );
+  }
+  return r;
+}

debuginfo-tests/llgdb-tests/dwarflinker/debuginfo-modules.cpp

+// RUN: %clang -cc1 -debug-info-kind=limited -dwarf-version=4 -fmodules-debuginfo \
+// RUN: -x c++ -fmodules  -emit-module -fmodule-name=foo \
+// RUN: %p/Inputs/debuginfo-modules.modulemap -o %t.pch
+// RUN: %clang -cc1 -debug-info-kind=limited -dwarf-version=4 %s \
+// RUN: -fmodules -fmodule-file=%t.pch  -emit-obj -o %t2.o
+// RUN: %clang -cc1 -debug-info-kind=limited -dwarf-version=4 \
+// RUN: -x ast %t.pch -fmodules -emit-obj -o %t3.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -O1 -fno-inline \
+// RUN: -fuse-ld=lld -Wl,--gc-sections,--gc-debuginfo %t2.o %t3.o -o %t3.out
+// RUN: %test_debuginfo %s %t3.out
+
+//XFAIL:*
+
+// UNSUPPORTED: system-darwin
+
+// This test checks that debug information for -fmodules-debuginfo is
+// valid after --gc-debuginfo done. It generates debuginfo module %t.pch
+// , object file for debuginfo-modules.cpp and object file for %t.pch
+// and finally links output. Resulting output should contain debug info from
+// %t.pch. i.e. "p var" debbugger command should print proper values
+// (x = 13, y = 42)
+
+#include "Inputs/debuginfo-modules.h"
+int main() { return foo(); }
+
+// DEBUGGER: break foo
+// CHECK: foo ()
+// DEBUGGER: r
+// DEBUGGER: n
+// DEBUGGER: n
+// DEBUGGER: p var
+// CHECK: x = 13, y = 42

debuginfo-tests/llgdb-tests/dwarflinker/gc-debuginfo-lto.cpp

+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O2 %s -c -o %t.o
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O2 %p/Inputs/gc-debuginfo-mod1-lto.cpp -c -o %t1.o
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -O2 \
+// RUN: -fuse-ld=lld -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o -o %t3.out
+// RUN: %test_debuginfo %s %t3.out
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O2 -flto %s -c -o %t.o
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O2 -flto %p/Inputs/gc-debuginfo-mod1-lto.cpp -c -o %t1.o
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -O2 -flto \
+// RUN: -fuse-ld=lld -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o -o %t3.out
+// RUN: %test_debuginfo %s %t3.out
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O2 -flto=thin %s -c -o %t.o
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O2 -flto=thin %p/Inputs/gc-debuginfo-mod1-lto.cpp -c -o %t1.o
+// RUN: %clang++ %target_itanium_abi_host_triple -gdwarf-4 -O2 -flto=thin \
+// RUN: -fuse-ld=lld -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o -o %t3.out
+// RUN: %test_debuginfo %s %t3.out
+
+// XFAIL:*
+
+// UNSUPPORTED: system-darwin
+
+// This test checks that debug info for mod1_func() function is properly
+// preserved. Specifically, it should print proper values for var variable.
+// Check that non-lto, full-lto, thin-lto modes are work correctly.
+
+int mod1_func(void);
+int main(void) {
+  return mod1_func();
+}
+
+// DEBUGGER: b gc-debuginfo-mod1-lto.cpp:8
+// DEBUGGER: r
+// DEBUGGER: p var
+// CHECK: return var.a1 + var.a2
+// CHECK: a1 = 100, a2 = 200

debuginfo-tests/llgdb-tests/dwarflinker/gc-debuginfo.c

+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O1 -fno-inline %s -c -o %t.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O1 -fno-inline %p/Inputs/gc-debuginfo-mod1.c -c -o %t1.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O1 -fno-inline %p/Inputs/gc-debuginfo-mod2.c -c -o %t2.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -O1 -fno-inline \
+// RUN: -fuse-ld=lld -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o %t2.o -o %t3.out
+// RUN: %test_debuginfo %s %t3.out
+
+// UNSUPPORTED: system-darwin
+
+// This test checks that location lists are valid after --gc-debuginfo done.
+// It steps into getModule1Value() and getModule2Value()(located in different
+// object files) and prints values of internal variable result. It should
+// print proper values if location lists are correct.
+
+#include <stdio.h>
+
+int mod1_f1();
+int mod2_f1();
+
+__attribute__((optnone)) void func(int p) {
+  printf("\n %d", p);
+}
+
+int main(void) {
+  func(mod1_f1(1));
+
+  func(mod2_f1(2));
+
+  return 0;
+}
+
+// DEBUGGER: break main
+// CHECK: gc-debuginfo.c
+// DEBUGGER: r
+// DEBUGGER: s
+// CHECK: mod1_f1 (p1=1)
+// DEBUGGER: s
+// DEBUGGER: p r
+// CHECK: = 1
+// DEBUGGER: n
+// DEBUGGER: s
+// CHECK: mod2_f1 (p1=2)
+// DEBUGGER: s
+// DEBUGGER: p r
+// CHECK: = 4
+// DEBUGGER: n
+// CHECK: return 0

debuginfo-tests/llgdb-tests/dwarflinker/inline.c

+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O -flto=full %s -c -o %t.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -ffunction-sections \
+// RUN: -O -flto=full %p/Inputs/inline-foo.c -c -o %t1.o
+// RUN: %clang %target_itanium_abi_host_triple -gdwarf-4 -O -flto=full \
+// RUN: -fuse-ld=lld -Wl,--gc-sections,--gc-debuginfo %t.o %t1.o -o %t3.out
+// RUN: %test_debuginfo %s %t3.out
+
+// UNSUPPORTED: system-darwin
+
+// This test checks that debug info for inlined function is properly preserved
+// when --gc-debuginfo is used. It is compiled with -flto=full, so that function
+// foo would be inlined. It checks that debugger shows local variables and
+// function name of inlined routine correctly.
+
+#include <stdio.h>
+
+int foo(int );
+
+int main(void) {
+  return foo(3);
+}
+
+// DEBUGGER: b foo
+// CHECK: inline-foo.c
+// DEBUGGER: r
+// DEBUGGER: si
+// CHECK: in foo
+// DEBUGGER: info locals
+// CHECK: i = 0
+// CHECK: r = 11
+// DEBUGGER: info address main
+// CHECK: Symbol "main" is a function
+// DEBUGGER: info address foo
+// CHECK: Symbol "foo" is a function

lld/Common/DWARF.cpp

for (const auto &entry : cu->dies()) {
       unsigned line = dwarf::toUnsigned(die.find(dwarf::DW_AT_decl_line), 0);
 
       // Here we want to take the variable name to add it into variableLoc.
       // Variable can have regular and linkage name associated. At first, we try
       // to get linkage name as it can be different, for example when we have
       // two variables in different namespaces of the same object. Use common
       // name otherwise, but handle the case when it also absent in case if the
       // input object file lacks some debug info.
-      StringRef name =
-          dwarf::toString(die.find(dwarf::DW_AT_linkage_name),
-                          dwarf::toString(die.find(dwarf::DW_AT_name), ""));
+      StringRef name = dwarf::toString(
+          die.find({dwarf::DW_AT_linkage_name, dwarf::DW_AT_name}), "");
       if (!name.empty())
         variableLoc.insert({name, {lt, file, line}});
     }
   }
 }
 
 // Returns the pair of file name and line number describing location of data
 // object (variable, array, etc) definition.

lld/ELF/CMakeLists.txt

add_lld_library(lldELF
   DriverUtils.cpp
   EhFrame.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp
   LinkerScript.cpp
   MapFile.cpp
+  LLDDwarfLinker.cpp
   MarkLive.cpp
   OutputSections.cpp
   Relocations.cpp
   ScriptLexer.cpp
   ScriptParser.cpp
   SymbolTable.cpp
   Symbols.cpp
   SyntheticSections.cpp
   Target.cpp
   Thunks.cpp
   Writer.cpp
 
   LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   BinaryFormat
   BitWriter
   Core
   DebugInfoDWARF
+  DWARFLinker
+  AsmPrinter
   Demangle
   LTO
   MC
   Object
   Option
   Passes
   Support
+  AllTargetsCodeGens
+  AllTargetsDescs
+  AllTargetsInfos
 
   LINK_LIBS
   lldCommon
   ${LLVM_PTHREAD_LIB}
 
   DEPENDS
   ELFOptionsTableGen
   intrinsics_gen
   )

lld/ELF/Config.h

struct Configuration {
   bool asNeeded = false;
   bool bsymbolic;
   bool bsymbolicFunctions;
   bool callGraphProfileSort;
   bool checkSections;
   bool compressDebugSections;
   bool cref;
   std::vector<std::pair<llvm::GlobPattern, uint64_t>> deadRelocInNonAlloc;
+  bool debugNames;
   bool defineCommon;
   bool demangle = true;
   bool dependentLibraries;
   bool disableVerify;
   bool ehFrameHdr;
   bool emitLLVM;
   bool emitRelocs;
   bool enableNewDtags;
   bool executeOnly;
   bool exportDynamic;
   bool fixCortexA53Errata843419;
   bool fixCortexA8;
   bool formatBinary = false;
+  bool gcDebugInfo;
+  bool gcDebugInfoNoOdr = false;
   bool gcSections;
   bool gdbIndex;
   bool gnuHash = false;
   bool gnuUnique;
   bool hasDynSymTab;
   bool ignoreDataAddressEquality;
   bool ignoreFunctionAddressEquality;
   bool ltoCSProfileGenerate;
   bool ltoDebugPassManager;
   bool ltoEmitAsm;

lld/ELF/DWARF.h

 //===- DWARF.h -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===-------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_DWARF_H
 #define LLD_ELF_DWARF_H
 
 #include "InputFiles.h"
+#include "Relocations.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf {
 
 class InputSection;
 
 struct LLDDWARFSection final : public llvm::DWARFSection {
   InputSectionBase *sec = nullptr;
+
+  /// Index into relocations array of the next relocation to consider.
+  mutable uint64_t nextEnumReloc = 0;
+  mutable uint64_t nextDwarfObjReloc = 0;
 };
 
 template <class ELFT> class LLDDwarfObj final : public llvm::DWARFObject {
 public:
   explicit LLDDwarfObj(ObjFile<ELFT> *obj);
 
   void forEachInfoSections(
       llvm::function_ref<void(const llvm::DWARFSection &)> f) const override {
public:
   const LLDDWARFSection &getGnuPubnamesSection() const override {
     return gnuPubnamesSection;
   }
 
   const LLDDWARFSection &getGnuPubtypesSection() const override {
     return gnuPubtypesSection;
   }
 
+  const llvm::DWARFSection &getLocSection() const override {
+    return locSection;
+  }
+
   StringRef getFileName() const override { return ""; }
   StringRef getAbbrevSection() const override { return abbrevSection; }
   StringRef getStrSection() const override { return strSection; }
   StringRef getLineStrSection() const override { return lineStrSection; }
 
   bool isLittleEndian() const override {
     return ELFT::TargetEndianness == llvm::support::little;
   }
 
   llvm::Optional<llvm::RelocAddrEntry> find(const llvm::DWARFSection &sec,
                                             uint64_t pos) const override;
 
+  ArrayRef<llvm::SectionName> getSectionNames() const override {
+    return sectionNames;
+  }
+
+  /// This function calls specified handler for all relocations
+  /// pointing to live section and located from "startPos" till "endPos"
+  /// for the section "s".
+  void enumerateRelocations(
+      const llvm::DWARFSection &s, uint64_t startPos, uint64_t endPos,
+      llvm::function_ref<void(Relocation rel, const InputSectionBase *sec)>
+          relHandler) const;
+
 private:
   template <class RelTy>
-  llvm::Optional<llvm::RelocAddrEntry> findAux(const InputSectionBase &sec,
-                                               uint64_t pos,
-                                               ArrayRef<RelTy> rels) const;
+  llvm::Optional<llvm::RelocAddrEntry>
+  findAux(const InputSectionBase &sec, uint64_t &nextDwarfObjReloc,
+          uint64_t pos, ArrayRef<RelTy> rels) const;
+
+  template <class RelTy>
+  void enumerateRelocations(
+      const LLDDWARFSection &sec, ArrayRef<RelTy> rels, uint64_t startPos,
+      uint64_t endPos,
+      llvm::function_ref<void(Relocation rel, const InputSectionBase *sec)>
+          relHandler) const;
 
   LLDDWARFSection gnuPubnamesSection;
   LLDDWARFSection gnuPubtypesSection;
   LLDDWARFSection infoSection;
   LLDDWARFSection loclistsSection;
   LLDDWARFSection rangesSection;
   LLDDWARFSection rnglistsSection;
   LLDDWARFSection strOffsetsSection;
   LLDDWARFSection lineSection;
   LLDDWARFSection addrSection;
+  LLDDWARFSection locSection;
   StringRef abbrevSection;
   StringRef strSection;
   StringRef lineStrSection;
+
+  std::vector<llvm::SectionName> sectionNames;
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/DWARF.cpp

 // https://sourceware.org/gdb/onlinedocs/gdb/Index-Section-Format.html.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARF.h"
 #include "Symbols.h"
 #include "Target.h"
 #include "lld/Common/Memory.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
-#include "llvm/Object/ELFObjectFile.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace lld;
 using namespace lld::elf;
 
 template <class ELFT> LLDDwarfObj<ELFT>::LLDDwarfObj(ObjFile<ELFT> *obj) {
   // Get the ELF sections to retrieve sh_flags. See the SHF_GROUP comment below.
   ArrayRef<typename ELFT::Shdr> objSections =
       CHECK(obj->getObj().sections(), obj);
+  StringMap<unsigned> sectionNumber;
   assert(objSections.size() == obj->getSections().size());
   for (auto it : llvm::enumerate(obj->getSections())) {
     InputSectionBase *sec = it.value();
-    if (!sec)
+    if (!sec) {
+      sectionNames.push_back({"", true});
       continue;
+    }
+    sectionNames.push_back({sec->name, true});
+    sectionNumber[sec->name]++;
 
     if (LLDDWARFSection *m =
             StringSwitch<LLDDWARFSection *>(sec->name)
                 .Case(".debug_addr", &addrSection)
                 .Case(".debug_gnu_pubnames", &gnuPubnamesSection)
                 .Case(".debug_gnu_pubtypes", &gnuPubtypesSection)
                 .Case(".debug_loclists", &loclistsSection)
                 .Case(".debug_ranges", &rangesSection)
                 .Case(".debug_rnglists", &rnglistsSection)
                 .Case(".debug_str_offsets", &strOffsetsSection)
                 .Case(".debug_line", &lineSection)
+                .Case(".debug_loc", &locSection)
                 .Default(nullptr)) {
       m->Data = toStringRef(sec->data());
       m->sec = sec;
       continue;
     }
 
     if (sec->name == ".debug_abbrev")
       abbrevSection = toStringRef(sec->data());
     else if (sec->name == ".debug_str")
       strSection = toStringRef(sec->data());
     else if (sec->name == ".debug_line_str")
       lineStrSection = toStringRef(sec->data());
     else if (sec->name == ".debug_info" &&
              !(objSections[it.index()].sh_flags & ELF::SHF_GROUP)) {
       // In DWARF v5, -fdebug-types-section places type units in .debug_info
       // sections in COMDAT groups. They are not compile units and thus should
       // be ignored for .gdb_index/diagnostics purposes.
       //
       // We use a simple heuristic: the compile unit does not have the SHF_GROUP
       // flag. If we place compile units in COMDAT groups in the future, we may
       // need to perform a lightweight parsing. We drop the SHF_GROUP flag when
       // the InputSection was created, so we need to retrieve sh_flags from the
       // associated ELF section header.
       infoSection.Data = toStringRef(sec->data());
       infoSection.sec = sec;
     }
   }
+  for (SectionName &sec : sectionNames)
+    if (!sec.Name.empty() && sectionNumber.lookup(sec.Name) > 1)
+      sec.IsNameUnique = false;
 }
 
 namespace {
 template <class RelTy> struct LLDRelocationResolver {
   // In the ELF ABIs, S sepresents the value of the symbol in the relocation
   // entry. For Rela, the addend is stored as part of the relocation entry.
   static uint64_t resolve(object::RelocationRef ref, uint64_t s,
                           uint64_t /* A */) {
     return s + ref.getRawDataRefImpl().p;
   }
 };
 
 template <class ELFT> struct LLDRelocationResolver<Elf_Rel_Impl<ELFT, false>> {
   // For Rel, the addend A is supplied by the caller.
   static uint64_t resolve(object::RelocationRef /*Ref*/, uint64_t s,
                           uint64_t a) {
     return s + a;
   }
 };
 } // namespace
 
+template <class RelTy>
+const RelTy *findReloc(const RelTy *rel, ArrayRef<RelTy> rels, uint64_t pos) {
+  // When dwarf->compile_units() is processed most of relocations are
+  // accessed sequentally. It is very often that next relocation is close
+  // to previous one. Searching for the next 4 relocations covers 90% cases.
+  const RelTy *end = std::min(rel + 4, rels.end());
+  for (; rel < end; ++rel)
+    if (rel->r_offset == pos)
+      return rel;
+
+  rel = partition_point(rels, [=](const RelTy &a) { return a.r_offset < pos; });
+
+  if (rel == rels.end() || rel->r_offset != pos)
+    return nullptr;
+
+  return rel;
+}
+
 // Find if there is a relocation at Pos in Sec.  The code is a bit
 // more complicated than usual because we need to pass a section index
 // to llvm since it has no idea about InputSection.
 template <class ELFT>
 template <class RelTy>
 Optional<RelocAddrEntry>
-LLDDwarfObj<ELFT>::findAux(const InputSectionBase &sec, uint64_t pos,
+LLDDwarfObj<ELFT>::findAux(const InputSectionBase &sec,
+                           uint64_t &nextDwarfObjReloc, uint64_t pos,
                            ArrayRef<RelTy> rels) const {
-  auto it =
-      partition_point(rels, [=](const RelTy &a) { return a.r_offset < pos; });
-  if (it == rels.end() || it->r_offset != pos)
+  const RelTy *rel = findReloc(rels.begin() + nextDwarfObjReloc, rels, pos);
+
+  if (!rel)
     return None;
-  const RelTy &rel = *it;
+
+  nextDwarfObjReloc = rel - rels.begin() + 1;
 
   const ObjFile<ELFT> *file = sec.getFile<ELFT>();
-  uint32_t symIndex = rel.getSymbol(config->isMips64EL);
+  uint32_t symIndex = rel->getSymbol(config->isMips64EL);
   const typename ELFT::Sym &sym = file->template getELFSyms<ELFT>()[symIndex];
   uint32_t secIndex = file->getSectionIndex(sym);
 
   // An undefined symbol may be a symbol defined in a discarded section. We
   // shall still resolve it. This is important for --gdb-index: the end address
   // offset of an entry in .debug_ranges is relocated. If it is not resolved,
   // its zero value will terminate the decoding of .debug_ranges prematurely.
-  Symbol &s = file->getRelocTargetSym(rel);
+  Symbol &s = file->getRelocTargetSym(*rel);
   uint64_t val = 0;
   if (auto *dr = dyn_cast<Defined>(&s))
     val = dr->value;
 
   DataRefImpl d;
-  d.p = getAddend<ELFT>(rel);
+  d.p = getAddend<ELFT>(*rel);
   return RelocAddrEntry{secIndex, RelocationRef(d, nullptr),
                         val,      Optional<object::RelocationRef>(),
                         0,        LLDRelocationResolver<RelTy>::resolve};
 }
 
 template <class ELFT>
 Optional<RelocAddrEntry> LLDDwarfObj<ELFT>::find(const llvm::DWARFSection &s,
                                                  uint64_t pos) const {
   auto &sec = static_cast<const LLDDWARFSection &>(s);
   if (sec.sec->areRelocsRela)
-    return findAux(*sec.sec, pos, sec.sec->template relas<ELFT>());
-  return findAux(*sec.sec, pos, sec.sec->template rels<ELFT>());
+    return findAux(*sec.sec, sec.nextDwarfObjReloc, pos,
+                   sec.sec->template relas<ELFT>());
+  return findAux(*sec.sec, sec.nextDwarfObjReloc, pos,
+                 sec.sec->template rels<ELFT>());
+}
+
+// This function calls specified handler for all relocations
+// pointing to live section and located from "startPos" till "endPos"
+// for the section "s".
+template <class ELFT>
+void LLDDwarfObj<ELFT>::enumerateRelocations(
+    const llvm::DWARFSection &s, uint64_t startPos, uint64_t endPos,
+    llvm::function_ref<void(Relocation rel, const InputSectionBase *sec)>
+        relHandler) const {
+  auto &sec = static_cast<const LLDDWARFSection &>(s);
+  if (sec.sec->areRelocsRela)
+    enumerateRelocations(sec, sec.sec->template relas<ELFT>(), startPos, endPos,
+                         relHandler);
+  else
+    enumerateRelocations(sec, sec.sec->template rels<ELFT>(), startPos, endPos,
+                         relHandler);
+}
+
+// This function calls specified handler for all relocations pointing
+// to live section and located from "startPos" till "endPos" from section
+// relocations(rels).
+// Assumption: "startPos"/"endPos" are always specified in increasing
+// order(i.e. "enumerateRelocations" are always called with "startPos"/"endPos"
+// having greater value than in previous call). "rels" contains
+// relocations sorted on r_offset basis.
+template <class ELFT>
+template <class RelTy>
+void LLDDwarfObj<ELFT>::enumerateRelocations(
+    const LLDDWARFSection &sec, ArrayRef<RelTy> rels, uint64_t startPos,
+    uint64_t endPos,
+    llvm::function_ref<void(Relocation rel, const InputSectionBase *sec)>
+        relHandler) const {
+  // Check if there are no more relocations.
+  if (sec.nextEnumReloc >= rels.size())
+    return;
+
+  // Skip relocations, started from nextReloc until relocPos < startPos.
+  uint64_t relocPos = rels[sec.nextEnumReloc].r_offset;
+  while (relocPos < startPos && sec.nextEnumReloc < rels.size() - 1)
+    relocPos = rels[++sec.nextEnumReloc].r_offset;
+
+  // Enumerate relocations in range [startPos, endPos).
+  const ObjFile<ELFT> *file = sec.sec->getFile<ELFT>();
+  while (relocPos >= startPos && relocPos < endPos) {
+    const RelTy &rel = rels[sec.nextEnumReloc];
+    const typename ELFT::Sym &sym =
+        file->template getELFSyms<ELFT>()[rel.getSymbol(config->isMips64EL)];
+    uint32_t secIndex = file->getSectionIndex(sym);
+
+    InputSectionBase *referencedSection = file->getSections()[secIndex];
+
+    // Check whether relocation points to live section.
+    if (referencedSection && referencedSection->isLive()) {
+      // Create architecture neutral relocation representation.
+      // Later we will fully calculate destination value, thus
+      // we do not need any expression. Set R_ABS then.
+      Relocation reloc = {R_ABS, rel.getType(config->isMips64EL), rel.r_offset,
+                          getAddend<ELFT>(rel), &file->getRelocTargetSym(rel)};
+
+      relHandler(reloc, referencedSection);
+    }
+
+    if (++sec.nextEnumReloc >= rels.size())
+      break;
+
+    relocPos = rels[sec.nextEnumReloc].r_offset;
+  }
 }
 
 template class elf::LLDDwarfObj<ELF32LE>;
 template class elf::LLDDwarfObj<ELF32BE>;
 template class elf::LLDDwarfObj<ELF64LE>;
 template class elf::LLDDwarfObj<ELF64BE>;

lld/ELF/Driver.cpp

 
 // This function is called on startup. We need this for LTO since
 // LTO calls LLVM functions to compile bitcode files to native code.
 // Technically this can be delayed until we read bitcode files, but
 // we don't bother to do lazily because the initialization is fast.
 static void initLLVM() {
   InitializeAllTargets();
   InitializeAllTargetMCs();
+  InitializeAllTargetInfos();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 }
 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions() {
   // The MIPS ABI as of 2016 does not support the GNU-style symbol lookup
if (config->strip == StripPolicy::All && config->emitRelocs)
     error("--strip-all and --emit-relocs may not be used together");
 
   if (config->zText && config->zIfuncNoplt)
     error("-z text and -z ifunc-noplt may not be used together");
 
   if (config->relocatable) {
     if (config->shared)
       error("-r and -shared may not be used together");
+    if (config->gcDebugInfo)
+      error("-r and --gc-debuginfo may not be used together");
     if (config->gdbIndex)
       error("-r and --gdb-index may not be used together");
     if (config->icf != ICFLevel::None)
       error("-r and --icf may not be used together");
     if (config->pie)
       error("-r and -pie may not be used together");
     if (config->exportDynamic)
       error("-r and --export-dynamic may not be used together");
   }
 
+  if (config->gcDebugInfo && !config->gcSections)
+    error("--gc-debuginfo may not be used without --gc-sections");
+
+  if (config->gcDebugInfoNoOdr && !config->gcSections)
+    error("--gc-debuginfo-noodr may not be used without --gc-sections");
+
+  if (!config->gcDebugInfo && config->debugNames)
+    error("--debug-names may not be used without --gc-debuginfo");
+
   if (config->executeOnly) {
     if (config->emachine != EM_AARCH64)
       error("-execute-only is only supported on AArch64 targets");
 
     if (config->singleRoRx && !script->hasSectionsCommand)
       error("-execute-only and -no-rosegment cannot be used together");
   }
 
config->checkSections =
       args.hasFlag(OPT_check_sections, OPT_no_check_sections, true);
   config->chroot = args.getLastArgValue(OPT_chroot);
   config->compressDebugSections = getCompressDebugSections(args);
   config->cref = args.hasFlag(OPT_cref, OPT_no_cref, false);
   config->defineCommon = args.hasFlag(OPT_define_common, OPT_no_define_common,
                                       !args.hasArg(OPT_relocatable));
   config->optimizeBBJumps =
       args.hasFlag(OPT_optimize_bb_jumps, OPT_no_optimize_bb_jumps, false);
+  config->debugNames = args.hasFlag(OPT_debug_names, OPT_no_debug_names, false);
   config->demangle = args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   config->dependencyFile = args.getLastArgValue(OPT_dependency_file);
   config->dependentLibraries = args.hasFlag(OPT_dependent_libraries, OPT_no_dependent_libraries, true);
   config->disableVerify = args.hasArg(OPT_disable_verify);
   config->discard = getDiscard(args);
   config->dwoDir = args.getLastArgValue(OPT_plugin_opt_dwo_dir_eq);
   config->dynamicLinker = getDynamicLinker(args);
   config->ehFrameHdr =
config->exportDynamic =
       args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, false);
   config->filterList = args::getStrings(args, OPT_filter);
   config->fini = args.getLastArgValue(OPT_fini, "_fini");
   config->fixCortexA53Errata843419 = args.hasArg(OPT_fix_cortex_a53_843419) &&
                                      !args.hasArg(OPT_relocatable);
   config->fixCortexA8 =
       args.hasArg(OPT_fix_cortex_a8) && !args.hasArg(OPT_relocatable);
   config->gcSections = args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, false);
+  config->gcDebugInfo =
+      args.hasFlag(OPT_gc_debuginfo, OPT_no_gc_debuginfo, false);
+  config->gcDebugInfoNoOdr =
+      args.hasFlag(OPT_gc_debuginfo_noodr, OPT_no_gc_debuginfo_noodr, false);
   config->gnuUnique = args.hasFlag(OPT_gnu_unique, OPT_no_gnu_unique, true);
   config->gdbIndex = args.hasFlag(OPT_gdb_index, OPT_no_gdb_index, false);
   config->icf = getICF(args);
   config->ignoreDataAddressEquality =
       args.hasArg(OPT_ignore_data_address_equality);
   config->ignoreFunctionAddressEquality =
       args.hasArg(OPT_ignore_function_address_equality);
   config->init = args.getLastArgValue(OPT_init, "_init");
if (s->type == SHT_LLVM_SYMPART) {
       return true;
     }
 
     // We do not want to emit debug sections if --strip-all
     // or -strip-debug are given.
     if (config->strip == StripPolicy::None)
       return false;
 
-    if (isDebugSection(*s))
+    if (isDebugSection(s->name))
       return true;
     if (auto *isec = dyn_cast<InputSection>(s))
       if (InputSectionBase *rel = isec->getRelocatedSection())
-        if (isDebugSection(*rel))
+        if (isDebugSection(rel->name))
           return true;
 
     return false;
   });
 
   // Since we now have a complete set of input files, we can create
   // a .d file to record build dependencies.
   if (!config->dependencyFile.empty())
template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
   replaceCommonSymbols();
 
   // Split SHF_MERGE and .eh_frame sections into pieces in preparation for garbage collection.
   splitSections<ELFT>();
 
   // Garbage collection and removal of shared symbols from unused shared objects.
   markLive<ELFT>();
   demoteSharedSymbols();
 
   // Make copies of any input sections that need to be copied into each
   // partition.
   copySectionsIntoPartitions();
 
   // Create synthesized sections such as .got and .plt. This is called before
   // processSectionCommands() so that they can be placed by SECTIONS commands.
   createSyntheticSections<ELFT>();
 
   // Some input sections that are used for exception handling need to be moved
   // into synthetic sections. Do that now so that they aren't assigned to

lld/ELF/InputSection.h

public:
   unsigned areRelocsRela : 1;
   const void *firstRelocation = nullptr;
 
   // The file which contains this section. Its dynamic type is always
   // ObjFile<ELFT>, but in order to avoid ELFT, we use InputFile as
   // its static type.
   InputFile *file;
 
   template <class ELFT> ObjFile<ELFT> *getFile() const {
     return cast_or_null<ObjFile<ELFT>>(file);
   }
 
   // If basic block sections are enabled, many code sections could end up with
   // one or two jump instructions at the end that could be relaxed to a smaller
   // instruction. The members below help trimming the trailing jump instruction
   // and shrinking a section.
   unsigned bytesDropped = 0;

 
 private:
   template <class ELFT, class RelTy>
   void copyRelocations(uint8_t *buf, llvm::ArrayRef<RelTy> rels);
 
   template <class ELFT> void copyShtGroup(uint8_t *buf);
 };
 
-inline bool isDebugSection(const InputSectionBase &sec) {
-  return sec.name.startswith(".debug") || sec.name.startswith(".zdebug");
+inline bool isDebugSection(StringRef name) {
+  return name.startswith(".debug") || name.startswith(".zdebug");
 }
 
 // The list of all input sections.
 extern std::vector<InputSectionBase *> inputSections;
 
 // The set of TOC entries (.toc + addend) for which we should not apply
 // toc-indirect to toc-relative relaxation. const Symbol * refers to the
 // STT_SECTION symbol associated to the .toc input section.
 extern llvm::DenseSet<std::pair<const Symbol *, uint64_t>> ppc64noTocRelax;
 
 } // namespace elf
 
 std::string toString(const elf::InputSectionBase *);
 } // namespace lld
 
 #endif

lld/ELF/InputSection.cpp

if (sym.type == STT_SECTION) {
       // avoid having to parse and recreate .eh_frame, we just replace any
       // relocation in it pointing to discarded sections with R_*_NONE, which
       // hopefully creates a frame that is ignored at runtime. Also, don't warn
       // on .gcc_except_table and debug sections.
       //
       // See the comment in maybeReportUndefined for PPC32 .got2 and PPC64 .toc
       auto *d = dyn_cast<Defined>(&sym);
       if (!d) {
-        if (!isDebugSection(*sec) && sec->name != ".eh_frame" &&
+        if (!isDebugSection(sec->name) && sec->name != ".eh_frame" &&
             sec->name != ".gcc_except_table" && sec->name != ".got2" &&
             sec->name != ".toc") {
           uint32_t secIdx = cast<Undefined>(sym).discardedSecIdx;
           Elf_Shdr_Impl<ELFT> sec =
               CHECK(file->getObj().sections(), file)[secIdx];
           warn("relocation refers to a discarded section: " +
                CHECK(file->getObj().getSectionName(sec), file) +
                "\n>>> referenced by " + getObjMsg(p->r_offset));

 // an example. Relocations in non-alloc sections are much easier to
 // handle than in allocated sections because it will never need complex
 // treatment such as GOT or PLT (because at runtime no one refers them).
 // So, we handle relocations for non-alloc sections directly in this
 // function as a performance optimization.
 template <class ELFT, class RelTy>
 void InputSection::relocateNonAlloc(uint8_t *buf, ArrayRef<RelTy> rels) {
   const unsigned bits = sizeof(typename ELFT::uint) * 8;
-  const bool isDebug = isDebugSection(*this);
+  const bool isDebug = isDebugSection(name);
   const bool isDebugLocOrRanges =
       isDebug && (name == ".debug_loc" || name == ".debug_ranges");
   const bool isDebugLine = isDebug && name == ".debug_line";
   Optional<uint64_t> tombstone;
   for (const auto &patAndValue : llvm::reverse(config->deadRelocInNonAlloc))
     if (patAndValue.first.match(this->name)) {
       tombstone = patAndValue.second;
       break;

lld/ELF/LLDDwarfLinker.h

+//===- LLDDwarfLinker.h -----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_ELF_LLDDWARFLINKER_H
+#define LLD_ELF_LLDDWARFLINKER_H
+
+#include "Writer.h"
+#include "llvm/ADT/SmallString.h"
+
+namespace lld {
+namespace elf {
+
+// This function is used to remove an unused parts of debug data
+// which belongs to garbage collected sections. It writes linked
+// debug info into specified outDebugInfoBytes container and links
+// output sections to their appropriate portions of debug info from
+// outDebugInfoBytes.
+template <class ELFT> void linkDebugInfo(DebugDataBits &outDebugInfoBytes);
+
+} // namespace elf
+} // namespace lld
+
+#endif // LLD_ELF_LLDDWARFLINKER_H

lld/ELF/LLDDwarfLinker.cpp

+//===- LLDDwarfLinker.cpp -------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements --gc-debuginfo functionality:
+//
+// When the linker does garbage collection, a lot of abandoned debug info
+// is left behind. To remove such abandoned debug info LLDDwarfLinker analyzes
+// relocations and removes debug info related to deleted sections.
+//
+// The process of linking debug info is based on liveness information created by
+// markLive<ELFT>(). AddressesMap::getValidAddressRanges() creates a list
+// of address ranges which points into live sections. DWARFLinker searches
+// for 'root DIEs' related to live address ranges and calls cloneDIE()
+// recursively. Cloned dies are passed to DWARFStreamer through DwarfEmitter
+// interface. DWARFStreamer writes data into plain memory container.
+// Corresponding sections of that container are linked with output sections.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LLDDwarfLinker.h"
+#include "DWARF.h"
+#include "InputFiles.h"
+#include "InputSection.h"
+#include "OutputSections.h"
+#include "Symbols.h"
+#include "Target.h"
+#include "lld/Common/DWARF.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/DWARFLinker/DWARFLinker.h"
+#include "llvm/DWARFLinker/DWARFStreamer.h"
+#include "llvm/Object/ELF.h"
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Support/Parallel.h"
+#include "llvm/Support/SmallVectorMemoryBuffer.h"
+#include "llvm/Target/TargetLoweringObjectFile.h"
+
+using namespace llvm;
+using namespace llvm::ELF;
+using namespace llvm::object;
+
+namespace lld {
+namespace elf {
+
+template <class ELFT> class ObjFileAddressMap : public AddressesMap {
+public:
+  ObjFileAddressMap(DWARFCache &dwarf, ObjFile<ELFT> *objFile)
+      : dwarf(dwarf), objFile(objFile),
+        dwarfObj(static_cast<const LLDDwarfObj<ELFT> &>(
+            dwarf.getContext()->getDWARFObj())) {
+
+    // Create map InputSectionBase -> SectionIndex.
+    DenseMap<InputSectionBase *, uint64_t> secToIndex;
+    uint64_t curIdx = 0;
+    for (InputSectionBase *sec : objFile->getSections()) {
+      if (sec)
+        secToIndex[sec] = curIdx;
+      ++curIdx;
+    }
+
+    // Discover live address ranges.
+    for (const Symbol *symbol : objFile->symbols) {
+      if (symbol->isFunc() || symbol->isObject()) {
+        if (symbol->kind() == Symbol::DefinedKind) {
+          InputSectionBase *sec =
+              cast<InputSectionBase>(cast<Defined>(*symbol).section);
+
+          if (!sec || !sec->isLive() || !secToIndex.count(sec))
+            continue;
+
+          hasValidRelocations = true;
+
+          SymbolAddresses addr = getSymbolAddresses(symbol, sec);
+          addressRanges[{addr.objectAddress, secToIndex[sec]}] = {
+              addr.objectAddress + symbol->getSize(),
+              (int64_t)addr.inputSectionAddress};
+        }
+      }
+    }
+  }
+
+  bool hasValidRelocs(bool resetRelocsPtr = true) override {
+    // TODO: Support the case multiplue .debug_info sections.
+    // TODO: HasValidRelocs should receive section
+    // TODO: which should be examined.
+    if (resetRelocsPtr)
+      dwarfObj.forEachInfoSections([&](const llvm::DWARFSection &sec) {
+        auto &debugInfoSec = static_cast<const LLDDWARFSection &>(sec);
+        debugInfoSec.nextEnumReloc = 0;
+      });
+
+    return hasValidRelocations;
+  }
+
+  bool hasValidRelocationAt(uint64_t startOffset, uint64_t endOffset,
+                            CompileUnit::DIEInfo &info) override {
+
+    bool ret = false;
+
+    // TODO: Support the case multiplue .debug_info sections.
+    // TODO: HasValidRelocationAt should receive section
+    // TODO: which should be examined.
+    dwarfObj.forEachInfoSections([&](const llvm::DWARFSection &sec) {
+      dwarfObj.enumerateRelocations(
+          sec, startOffset, endOffset,
+          [&](Relocation rel, const InputSectionBase *sec) {
+            if (!ret) {
+              if (!isDebugSection(sec->name)) {
+                info.AddrAdjust =
+                    getSymbolAddresses(rel.sym, sec).inputSectionAddress;
+                info.InDebugMap = true;
+                ret = true;
+              }
+            }
+          });
+    });
+
+    return ret;
+  }
+
+  bool applyValidRelocs(MutableArrayRef<char> data, uint64_t baseOffset,
+                        bool) override {
+    bool ret = false;
+
+    // TODO: Support the case multiplue .debug_info sections.
+    // TODO: ApplyValidRelocs should receive section
+    // TODO: which should be examined.
+    dwarfObj.forEachInfoSections([&](const llvm::DWARFSection &sec) {
+      dwarfObj.enumerateRelocations(
+          sec, baseOffset, baseOffset + data.size(),
+          [&](Relocation rel, const InputSectionBase *sec) {
+            SymbolAddresses Addr = getSymbolAddresses(rel.sym, sec);
+            assert(rel.offset - baseOffset < data.size());
+
+            // Apply relocation.
+            getTarget()->relocate(
+                (uint8_t *)(data.data() + rel.offset - baseOffset), rel,
+                Addr.inputSectionAddress + Addr.objectAddress + rel.addend);
+            ret = true;
+          });
+    });
+
+    return ret;
+  }
+
+  RangesTy &getValidAddressRanges() override { return addressRanges; };
+
+  void clear() override { addressRanges.clear(); }
+
+private:
+  struct SymbolAddresses {
+    uint64_t objectAddress = 0;
+    uint64_t inputSectionAddress = 0;
+  };
+
+  // Returns object address(symbol value) and address of input section.
+  SymbolAddresses
+  getSymbolAddresses(const Symbol *sym,
+                     const InputSectionBase *referencedSection) {
+    SymbolAddresses result;
+
+    if (sym && sym->kind() == Symbol::DefinedKind) {
+      auto &definedSym = cast<Defined>(*sym);
+
+      result.objectAddress = definedSym.value;
+
+      if (referencedSection && !isDebugSection(referencedSection->name)) {
+        result.inputSectionAddress =
+            referencedSection->getVA(definedSym.value) - definedSym.value;
+      }
+    }
+
+    return result;
+  }
+
+  RangesTy addressRanges;
+  DWARFCache &dwarf;
+  ObjFile<ELFT> *objFile;
+  const LLDDwarfObj<ELFT> &dwarfObj;
+  bool hasValidRelocations = false;
+};
+
+// This function is used to remove an unused parts of debug data
+// which belongs to garbage collected sections.
+template <class ELFT> void linkDebugInfo(DebugDataBits &outDebugInfoBytes) {
+  // Calculate estimated size of resulting debug info.
+  // It would reserve half of original debug info size.
+  // That is average ratio of debug info size decreasing.
+  uint64_t estimatedSize = 0;
+  for (const InputSectionBase *sec : inputSections)
+    if (isDebugSection(sec->name) && sec->isLive())
+      estimatedSize += sec->getSize() * 0.5f;
+  outDebugInfoBytes.reserve(estimatedSize);
+
+  auto ReportWarn = [&](const Twine &message, StringRef context,
+                        const DWARFDie *) {
+    if (context.empty())
+      warn(message);
+    else
+      warn(context + ": " + message);
+  };
+
+  // Create output streamer.
+  raw_svector_ostream stream(outDebugInfoBytes);
+  DwarfStreamer outStreamer(OutputFileType::Object, stream,
+                            [](StringRef input) { return input; }, false,
+                            ReportWarn, ReportWarn);
+  if (!outStreamer.init(Triple(sys::getProcessTriple())))
+    return;
+
+  // Create DWARF linker.
+  DWARFLinker debugInfoLinker(&outStreamer, DwarfLinkerClient::LLD);
+
+  debugInfoLinker.setEstimatedObjfilesAmount(objectFiles.size());
+  debugInfoLinker.setAccelTableKind(config->debugNames ? AccelTableKind::Dwarf
+                                                       : AccelTableKind::None);
+  debugInfoLinker.setErrorHandler(ReportWarn);
+  debugInfoLinker.setWarningHandler(ReportWarn);
+  debugInfoLinker.setNumThreads(llvm::parallel::strategy.ThreadsRequested);
+  debugInfoLinker.setNoODR(config->gcDebugInfoNoOdr);
+
+  std::vector<std::unique_ptr<DWARFFile>> objectsForLinking(objectFiles.size());
+  std::vector<std::unique_ptr<AddressesMap>> addresssMapForLinking(
+      objectFiles.size());
+  std::vector<std::string> emptyWarnings;
+
+  // Add object files to the DWARFLinker.
+  parallelForEachN(0, objectFiles.size(), [&](size_t i) {
+    if (ObjFile<ELFT> *obj = cast<ObjFile<ELFT>>(objectFiles[i])) {
+      addresssMapForLinking[i] =
+          std::make_unique<ObjFileAddressMap<ELFT>>(*obj->getDwarf(), obj);
+
+      objectsForLinking[i] = std::make_unique<DWARFFile>(
+          objectFiles[i]->getName(), obj->getDwarf()->getContext(),
+          addresssMapForLinking[i].get(), emptyWarnings);
+    }
+  });
+
+  for (size_t i = 0; i < objectFiles.size(); i++)
+    debugInfoLinker.addObjectFile(*objectsForLinking[i]);
+
+  // Link debug info.
+  debugInfoLinker.link();
+  outStreamer.finish();
+
+  if (outDebugInfoBytes.empty())
+    return;
+
+  // Create sections map: Section Name -> Section Bits.
+  // outDebugInfoBytes contains elf file with all
+  // generated debug sections. We create a map here to assign
+  // section bits to output section later.
+  DenseMap<StringRef, StringRef> sectionsMap;
+  if (Expected<ELFObjectFile<ELFT>> MemFile =
+          ELFObjectFile<ELFT>::create({outDebugInfoBytes, ""})) {
+    for (const SectionRef &Sec : MemFile->sections()) {
+      if (Expected<StringRef> name = Sec.getName()) {
+        if (!isDebugSection(*name))
+          continue;
+
+        if (Expected<StringRef> contents = Sec.getContents())
+          sectionsMap[*name] = *contents;
+        else
+          sectionsMap[*name] = "";
+      } else {
+        warn("Empty section name inside generated debug info");
+        return;
+      }
+    }
+  } else {
+    warn("Generated debug info is broken");
+    return;
+  }
+
+  // Set linked debug info to corresponding output section.
+  for (OutputSection *sec : outputSections)
+    if (isDebugSection(sec->name))
+      sec->setDebugData(sectionsMap.lookup(sec->name));
+}
+
+template void linkDebugInfo<ELF32LE>(DebugDataBits &);
+template void linkDebugInfo<ELF32BE>(DebugDataBits &);
+template void linkDebugInfo<ELF64LE>(DebugDataBits &);
+template void linkDebugInfo<ELF64BE>(DebugDataBits &);
+
+} // namespace elf
+} // namespace lld

lld/ELF/Options.td

 def color_diagnostics_eq: J<"color-diagnostics=">,
   HelpText<"Use colors in diagnostics">,
   MetaVarName<"[auto,always,never]">;
 
 defm cref: B<"cref",
     "Output cross reference table",
     "Do not output cross reference table">;
 
+defm debug_names: B<"debug-names",
+    "Enable .debug_names table generation",
+    "Disable .debug_names table generation (default)">;
+
 defm define_common: B<"define-common",
     "Assign space to common symbols",
     "Do not assign space to common symbols">;
 
 defm demangle: B<"demangle",
     "Demangle symbol names (default)",
     "Do not demangle symbol names">;
 

 
 defm format: Eq<"format", "Change the input format of the inputs following this option">,
   MetaVarName<"[default,elf,binary]">;
 
 defm gc_sections: B<"gc-sections",
     "Enable garbage collection of unused sections",
     "Disable garbage collection of unused sections (default)">;
 
+defm gc_debuginfo: B<"gc-debuginfo",
+    "Enable garbage collection of unused debug information",
+    "Disable garbage collection of unused debug information (default)">;
+
+defm gc_debuginfo_noodr: B<"gc-debuginfo-no-odr",
+    "Disable ODR types de-duplication",
+    "Enable ODR types de-duplication (default)">;
+
 defm gdb_index: BB<"gdb-index",
     "Generate .gdb_index section",
     "Do not generate .gdb_index section (default)">;
 
 defm gnu_unique: BB<"gnu-unique",
   "Enable STB_GNU_UNIQUE symbol binding (default)",
   "Disable STB_GNU_UNIQUE symbol binding">;
 

lld/ELF/OutputSections.h

public:
   void finalize();
   template <class ELFT> void writeTo(uint8_t *buf);
   template <class ELFT> void maybeCompress();
 
   void sort(llvm::function_ref<int(InputSectionBase *s)> order);
   void sortInitFini();
   void sortCtorsDtors();
 
+  void setDebugData(StringRef data) {
+    debugData = data;
+    size = data.size();
+  }
+
+  bool hasDebugData(void) const { return debugData.hasValue(); }
+
 private:
   // Used for implementation of --compress-debug-sections option.
   std::vector<uint8_t> zDebugHeader;
   llvm::SmallVector<char, 1> compressedData;
 
   std::array<uint8_t, 4> getFiller();
+
+  // Used for assign debug data generated by DWARFLinker
+  // for concrete output section.
+  llvm::Optional<StringRef> debugData;
 };
 
 int getPriority(StringRef s);
 
 InputSection *getFirstInputSection(const OutputSection *os);
 std::vector<InputSection *> getInputSections(const OutputSection *os);
 
 // All output sections that are handled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them

lld/ELF/OutputSections.cpp

template <class ELFT> void OutputSection::writeTo(uint8_t *buf) {
   // just write it down.
   if (!compressedData.empty()) {
     memcpy(buf, zDebugHeader.data(), zDebugHeader.size());
     memcpy(buf + zDebugHeader.size(), compressedData.data(),
            compressedData.size());
     return;
   }
 
+  // If there are data generated by dwarflinker just write it down.
+  if (hasDebugData()) {
+    memcpy(buf, debugData->data(), debugData->size());
+    return;
+  }
+
   // Write leading padding.
   std::vector<InputSection *> sections = getInputSections(this);
   std::array<uint8_t, 4> filler = getFiller();
   bool nonZeroFiller = read32(filler.data()) != 0;
   if (nonZeroFiller)
     fill(buf, sections.empty() ? size : sections[0]->outSecOff, filler);
 
   parallelForEachN(0, sections.size(), [&](size_t i) {

lld/ELF/Relocations.cpp

 static void scanRelocs(InputSectionBase &sec, ArrayRef<RelTy> rels) {
   OffsetGetter getOffset(sec);
 
   // Not all relocations end up in Sec.Relocations, but a lot do.
   sec.relocations.reserve(rels.size());
 
   for (auto i = rels.begin(), end = rels.end(); i != end;)
     scanReloc<ELFT>(sec, getOffset, i, rels.begin(), end);
-
   // Sort relocations by offset for more efficient searching for
   // R_RISCV_PCREL_HI20 and R_PPC64_ADDR64.
   if (config->emachine == EM_RISCV ||
       (config->emachine == EM_PPC64 && sec.name == ".toc"))
     llvm::stable_sort(sec.relocations,
                       [](const Relocation &lhs, const Relocation &rhs) {
                         return lhs.offset < rhs.offset;
                       });

lld/ELF/SyntheticSections.h

private:
   std::vector<GdbChunk> chunks;
 
   // A symbol table for this .gdb_index section.
   std::vector<GdbSymbol> symbols;
 
   size_t size;
 };
 
+/// DebugSection is used to keep data generated by DWARFLinker.
+class DebugSection final : public SyntheticSection {
+public:
+  DebugSection(StringRef name);
+  template <typename ELFT> static DebugSection *create(StringRef name);
+
+  void writeTo(uint8_t *) override {}
+  size_t getSize() const override { return 0; }
+  bool isNeeded() const override { return true; }
+};
+
 // --eh-frame-hdr option tells linker to construct a header for all the
 // .eh_frame sections. This header is placed to a section named .eh_frame_hdr
 // and also to a PT_GNU_EH_FRAME segment.
 // At runtime the unwinder then can find all the PT_GNU_EH_FRAME segments by
 // calling dl_iterate_phdr.
 // This section contains a lookup table for quick binary search of FDEs.
 // Detailed info about internals can be found in Ian Lance Taylor's blog:
 // http://www.airs.com/blog/archives/460 (".eh_frame")

lld/ELF/SyntheticSections.cpp

for (uint32_t val : sym.cuVector) {
       write32le(buf, val);
       buf += 4;
     }
   }
 }
 
 bool GdbIndexSection::isNeeded() const { return !chunks.empty(); }
 
+DebugSection::DebugSection(StringRef name)
+    : SyntheticSection(0, SHT_PROGBITS, 1, name) {}
+
+template <class ELFT> DebugSection *DebugSection::create(StringRef name) {
+  return make<DebugSection>(name);
+}
+
 EhFrameHeader::EhFrameHeader()
     : SyntheticSection(SHF_ALLOC, SHT_PROGBITS, 4, ".eh_frame_hdr") {}
 
 void EhFrameHeader::writeTo(uint8_t *buf) {
   // Unlike most sections, the EhFrameHeader section is written while writing
   // another section, namely EhFrameSection, which calls the write() function
   // below from its writeTo() function. This is necessary because the contents
   // of EhFrameHeader depend on the relocated contents of EhFrameSection and we
void PartitionIndexSection::writeTo(uint8_t *buf) {
   }
 }
 
 InStruct elf::in;
 
 std::vector<Partition> elf::partitions;
 Partition *elf::mainPart;
 
+template DebugSection *DebugSection::create<ELF32LE>(StringRef);
+template DebugSection *DebugSection::create<ELF32BE>(StringRef);
+template DebugSection *DebugSection::create<ELF64LE>(StringRef);
+template DebugSection *DebugSection::create<ELF64BE>(StringRef);
+
 template GdbIndexSection *GdbIndexSection::create<ELF32LE>();
 template GdbIndexSection *GdbIndexSection::create<ELF32BE>();
 template GdbIndexSection *GdbIndexSection::create<ELF64LE>();
 template GdbIndexSection *GdbIndexSection::create<ELF64BE>();
 
 template void elf::splitSections<ELF32LE>();
 template void elf::splitSections<ELF32BE>();
 template void elf::splitSections<ELF64LE>();

lld/ELF/Writer.h

 class InputFile;
 class OutputSection;
 class InputSectionBase;
 void copySectionsIntoPartitions();
 template <class ELFT> void createSyntheticSections();
 void combineEhSections();
 template <class ELFT> void writeResult();
 
+using DebugDataBits = SmallString<4096>;
+
 // This describes a program header entry.
 // Each contains type, access flags and range of output sections that will be
 // placed in it.
 struct PhdrEntry {
   PhdrEntry(unsigned type, unsigned flags)
       : p_align(type == llvm::ELF::PT_LOAD ? config->maxPageSize : 0),
         p_type(type), p_flags(flags) {}
   void add(OutputSection *sec);

lld/ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "AArch64ErrataFix.h"
 #include "ARMErrataFix.h"
 #include "CallGraphSort.h"
 #include "Config.h"
+#include "LLDDwarfLinker.h"
 #include "LinkerScript.h"
 #include "MapFile.h"
 #include "OutputSections.h"
 #include "Relocations.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
private:
   void openFile();
   void writeTrapInstr();
   void writeHeader();
   void writeSections();
   void writeSectionsBinary();
   void writeBuildId();
 
   std::unique_ptr<FileOutputBuffer> &buffer;
+  DebugDataBits debugInfoBytes;
 
   void addRelIpltSymbols();
   void addStartEndSymbols();
   void addStartStopSymbols(OutputSection *sec);
 
   uint64_t fileSize;
   uint64_t sectionHeaderOff;
 };
if (target->gotBaseSymInGotPlt)
       in.gotPlt->hasGotPltOffRel = true;
     else
       in.got->hasGotOffRel = true;
   }
 
   if (config->gdbIndex)
     add(GdbIndexSection::create<ELFT>());
 
+  if (config->debugNames)
+    add(DebugSection::create<ELFT>(".debug_names"));
+
   // We always need to add rel[a].plt to output if it has entries.
   // Even for static linking it can contain R_[*]_IRELATIVE relocations.
   in.relaPlt = make<RelocationSection<ELFT>>(
       config->isRela ? ".rela.plt" : ".rel.plt", /*sort=*/false);
   add(in.relaPlt);
 
   // The relaIplt immediately follows .rel[a].dyn to ensure that the IRelative
   // relocations are processed last by the dynamic loader. We cannot place the
template <class ELFT> void Writer<ELFT>::run() {
   // completes section contents. For example, we need to add strings
   // to the string table, and add entries to .got and .plt.
   // finalizeSections does that.
   finalizeSections();
   checkExecuteOnly();
   if (errorCount())
     return;
 
+  // If -gc-debuginfo specified remove unused debug data.
+  if (config->gcDebugInfo)
+    linkDebugInfo<ELFT>(debugInfoBytes);
+
   // If -compressed-debug-sections is specified, we need to compress
   // .debug_* sections. Do it right now because it changes the size of
   // output sections.
   for (OutputSection *sec : outputSections)
     sec->maybeCompress<ELFT>();
 
   if (script->hasSectionsCommand)
     script->allocateHeaders(mainPart->phdrs);

 void Writer<ELFT>::forEachRelSec(
     llvm::function_ref<void(InputSectionBase &)> fn) {
   // Scan all relocations. Each relocation goes through a series
   // of tests to determine if it needs special treatment, such as
   // creating GOT, PLT, copy relocations, etc.
   // Note that relocations for non-alloc sections are directly
   // processed by InputSection::relocateNonAlloc.
   for (InputSectionBase *isec : inputSections)
-    if (isec->isLive() && isa<InputSection>(isec) && (isec->flags & SHF_ALLOC))
+    if (isec->isLive() && isa<InputSection>(isec) &&
+        ((isec->flags & SHF_ALLOC)))
       fn(*isec);
   for (Partition &part : partitions) {
     for (EhInputSection *es : part.ehFrame->sections)
       fn(*es);
     if (part.armExidx && part.armExidx->isLive())
       for (InputSection *ex : part.armExidx->exidxSections)
         fn(*ex);
   }

lld/docs/ld.lld.1

 .It Fl -defsym Ns = Ns Ar symbol Ns = Ns Ar expression
 Define a symbol alias.
 .Ar expression
 may be another symbol or a linker script expression.
 For example,
 .Ql --defsym=foo=bar
 or
 .Ql --defsym=foo=bar+0x100 .
+.It Fl -debug-names
+Enable .debug_names table generation.
 .It Fl -demangle
 Demangle symbol names.
 .It Fl -disable-new-dtags
 Disable new dynamic tags.
 .It Fl -discard-all , Fl x
 Delete all local symbols.
 .It Fl -discard-locals , Fl X
 Delete temporary local symbols.

 may be one of
 .Cm binary ,
 .Cm elf ,
 and
 .Cm default .
 .Cm default
 is a synonym for
 .Cm elf .
+.It Fl -gc-debuginfo
+Enable removing obsolete debug info.
 .It Fl -gc-sections
 Enable garbage collection of unused sections.
 .It Fl -gdb-index
 Generate
 .Li .gdb_index
 section.
 .It Fl -hash-style Ns = Ns Ar value
 Specify hash style.

 Do not allow unresolved references in shared libraries.
 This option is enabled by default when linking an executable.
 .It Fl -no-as-needed
 Always set
 .Dv DT_NEEDED
 for shared libraries.
 .It Fl -no-color-diagnostics
 Do not use colors in diagnostics.
+.It Fl -no-debug-names
+Disable .debug_names table generation.
 .It Fl -no-define-common
 Do not assign space to common symbols.
 .It Fl -no-demangle
 Do not demangle symbol names.
 .It Fl -no-dynamic-linker
 Inhibit output of an
 .Li .interp
 section.
+.It Fl -no-gc-debuginfo
+Disable removing obsolete debug info.
 .It Fl -no-gc-sections
 Disable garbage collection of unused sections.
 .It Fl -no-gnu-unique
 Disable STB_GNU_UNIQUE symbol binding.
 .It Fl -no-merge-exidx-entries
 Disable merging .ARM.exidx entries.
 .It Fl -no-nmagic
 Page align sections.

lld/test/ELF/gc-debuginfo-cl-errors.s

+# REQUIRES: x86
+
+# RUN: echo '.global _start; .global main;  _start: jmp main; main: ' \
+# RUN:   | llvm-mc --filetype=obj --triple=x86_64-unknown-linux - -o %t.o
+
+# RUN: not ld.lld -r --gc-debuginfo %t.o -o /dev/null 2>&1 \
+# RUN:   | FileCheck --check-prefix=RELOC %s
+
+# RUN: not ld.lld --gc-debuginfo %t.o -o /dev/null 2>&1 \
+# RUN:   | FileCheck --check-prefix=GCSEC %s
+
+## This test checks that proper error message is displayed
+## if --gc-debuginfo command line flag is used incorrectly.
+
+# RELOC: error: -r and --gc-debuginfo may not be used together
+# GCSEC: error: --gc-debuginfo may not be used without --gc-sections

lld/test/ELF/gc-debuginfo.test

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+# RUN: ld.lld %t.o -o %t.default --gc-sections --gc-debuginfo
+# RUN: llvm-readelf --sections %t.default | FileCheck %s
+
+## This is a test for --gc-debuginfo feature.
+## It contains .debug_info section which references
+## .text.foo section. .text.foo would be deleted by --gc-sections.
+## --gc-debuginfo should generate zero sized .debug_info section
+## in such case.
+
+# CHECK: Section Headers:
+# CHECK:   [Nr] Name        Type     Address          Off              Size
+# CHECK:   [ 2] .debug_info PROGBITS {{[0-9a-fA-F]*}} {{[0-9a-fA-F]*}} 000000
+
+.section .text.foo,"axG",@progbits,foo
+.globl foo
+.Lfunc_begin0:
+foo:
+  ret
+.Lfunc_end0:
+
+.section .debug_abbrev,"",@progbits
+  .byte   1       # Abbreviation Code
+  .byte   17      # DW_TAG_compile_unit
+  .byte   1       # DW_CHILDREN_yes
+  .byte   17      # DW_AT_low_pc
+  .byte   1       # DW_FORM_addr
+  .byte   18      # DW_AT_high_pc
+  .byte   6       # DW_FORM_data4
+  .byte   0       # EOM(1)
+  .byte   0       # EOM(2)
+  .byte   2       # Abbreviation Code
+  .byte   46      # DW_TAG_subprogram
+  .byte   0       # DW_CHILDREN_no
+  .byte   3       # DW_AT_name
+  .byte   8       # DW_FORM_string
+  .byte   0       # EOM(1)
+  .byte   0       # EOM(2)
+  .byte   0
+
+.section .debug_info,"",@progbits
+.Lcu_begin0:
+  .long   .Lcu_end0 - .Lcu_begin0 - 4
+  .short  4              # DWARF version number
+  .long   0              # Offset Into Abbrev. Section
+  .byte   4              # Address Size
+.Ldie0:
+  .byte   1              # Abbrev [1] DW_TAG_compile_unit
+  .quad   .Lfunc_begin0  # DW_AT_low_pc
+  .long   .Lfunc_end0 - .Lfunc_begin0 # DW_AT_high_pc
+  .byte   2              # Abbrev [2] DW_TAG_subprogram
+  .asciz  "foo"          # DW_AT_name
+  .byte   0
+.Lcu_end0:

llvm/include/llvm/DWARFLinker/DWARFLinker.h

 
 enum class DwarfLinkerClient { Dsymutil, LLD, General };
 
 /// The kind of accelerator tables we should emit.
 enum class AccelTableKind {
   Apple,   ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
   Dwarf,   ///< DWARF v5 .debug_names.
   Default, ///< Dwarf for DWARF5 or later, Apple otherwise.
+  None,    ///< do not generate accelerator tables.
 };
 
 /// Partial address range. Besides an offset, only the
 /// HighPC is stored. The structure is stored in a map where the LowPC is the
 /// key.
-struct ObjFileAddressRange {
+struct AddressHighPC {
   /// Function HighPC.
-  uint64_t HighPC;
+  uint64_t HighPC = 0;
   /// Offset to apply to the linked address.
   /// should be 0 for not-linked object file.
-  int64_t Offset;
-
-  ObjFileAddressRange(uint64_t EndPC, int64_t Offset)
-      : HighPC(EndPC), Offset(Offset) {}
-
-  ObjFileAddressRange() : HighPC(0), Offset(0) {}
+  int64_t Offset = 0;
 };
 
-/// Map LowPC to ObjFileAddressRange.
-using RangesTy = std::map<uint64_t, ObjFileAddressRange>;
+/// Map LowPC to AddressHighPC.
+using RangesTy = std::map<object::SectionedAddress, AddressHighPC>;
 
 /// AddressesMap represents information about valid addresses used
 /// by debug information. Valid addresses are those which points to
 /// live code sections. i.e. relocations for these addresses point
 /// into sections which would be/are placed into resulting binary.
 class AddressesMap {
 public:
   virtual ~AddressesMap();
 
-  /// Returns true if represented addresses are from linked file.
-  /// Returns false if represented addresses are from not-linked
-  /// object file.
-  virtual bool areRelocationsResolved() const = 0;
-
   /// Checks that there are valid relocations against a .debug_info
   /// section. Reset current relocation pointer if neccessary.
   virtual bool hasValidRelocs(bool ResetRelocsPtr = true) = 0;
 
   /// Checks that there is a relocation against .debug_info
   /// table between \p StartOffset and \p NextOffset.
   ///
   /// This function must be called with offsets in strictly ascending

llvm/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h

 #include "llvm/CodeGen/DIE.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Support/DataExtractor.h"
 
 namespace llvm {
 
 class DeclContext;
 
+template <> struct DenseMapInfo<object::SectionedAddress> {
+  static object::SectionedAddress getEmptyKey();
+
+  static object::SectionedAddress getTombstoneKey();
+
+  static unsigned getHashValue(const object::SectionedAddress &val);
+
+  static bool isEqual(const object::SectionedAddress &lhs,
+                      const object::SectionedAddress &rhs);
+};
+
 template <typename KeyT, typename ValT>
 using HalfOpenIntervalMap =
     IntervalMap<KeyT, ValT, IntervalMapImpl::NodeSizer<KeyT, ValT>::LeafSize,
                 IntervalMapHalfOpenInfo<KeyT>>;
 
-using FunctionIntervals = HalfOpenIntervalMap<uint64_t, int64_t>;
+using FunctionIntervals =
+    HalfOpenIntervalMap<object::SectionedAddress, int64_t>;
 
 // FIXME: Delete this structure.
 struct PatchLocation {
   DIE::value_iterator I;
 
   PatchLocation() = default;
   PatchLocation(DIE::value_iterator I) : I(I) {}
 
struct DIEInfo {
     /// Does DIE transitively refer an incomplete decl?
     bool Incomplete : 1;
   };
 
   CompileUnit(DWARFUnit &OrigUnit, unsigned ID, bool CanUseODR,
               StringRef ClangModuleName)
       : OrigUnit(OrigUnit), ID(ID), Ranges(RangeAlloc),
         ClangModuleName(ClangModuleName) {
+
     Info.resize(OrigUnit.getNumDIEs());
 
     auto CUDie = OrigUnit.getUnitDIE(false);
     if (!CUDie) {
       HasODR = false;
       return;
     }
     if (auto Lang = dwarf::toUnsigned(CUDie.find(dwarf::DW_AT_language)))
public:
   const DIEInfo &getInfo(unsigned Idx) const { return Info[Idx]; }
 
   uint64_t getStartOffset() const { return StartOffset; }
   uint64_t getNextUnitOffset() const { return NextUnitOffset; }
   void setStartOffset(uint64_t DebugInfoSize) { StartOffset = DebugInfoSize; }
 
   uint64_t getLowPc() const { return LowPc; }
   uint64_t getHighPc() const { return HighPc; }
-  bool hasLabelAt(uint64_t Addr) const { return Labels.count(Addr); }
+  bool hasLabelAt(object::SectionedAddress Addr) const {
+    return Labels.count(Addr);
+  }
 
   Optional<PatchLocation> getUnitRangesAttribute() const {
     return UnitRangeAttribute;
   }
 
   const FunctionIntervals &getFunctionRanges() const { return Ranges; }
 
   const std::vector<PatchLocation> &getRangesAttributes() const {
public:
   void noteForwardReference(DIE *Die, const CompileUnit *RefUnit,
                             DeclContext *Ctxt, PatchLocation Attr);
 
   /// Apply all fixups recorded by noteForwardReference().
   void fixupForwardReferences();
 
   /// Add the low_pc of a label that is relocated by applying
   /// offset \p PCOffset.
-  void addLabelLowPc(uint64_t LabelLowPc, int64_t PcOffset);
+  void addLabelLowPc(object::SectionedAddress LabelLowPc, int64_t PcOffset);
 
   /// Add a function range [\p LowPC, \p HighPC) that is relocated by applying
   /// offset \p PCOffset.
-  void addFunctionRange(uint64_t LowPC, uint64_t HighPC, int64_t PCOffset);
+  void addFunctionRange(object::SectionedAddress LowPC,
+                        object::SectionedAddress HighPC, int64_t PCOffset);
 
   /// Keep track of a DW_AT_range attribute that we will need to patch up later.
   void noteRangeAttribute(const DIE &Die, PatchLocation Attr);
 
   /// Keep track of a location attribute pointing to a location list in the
   /// debug_loc section.
   void noteLocationAttribute(PatchLocation Attr, int64_t PcOffset);
 
private:
   FunctionIntervals::Allocator RangeAlloc;
 
   /// The ranges in that interval map are the PC ranges for
   /// functions in this unit, associated with the PC offset to apply
   /// to the addresses to get the linked address.
   FunctionIntervals Ranges;
 
   /// The DW_AT_low_pc of each DW_TAG_label.
-  SmallDenseMap<uint64_t, uint64_t, 1> Labels;
+  SmallDenseMap<object::SectionedAddress, int64_t, 1> Labels;
 
   /// DW_AT_ranges attributes to patch after we have gathered
   /// all the unit's function addresses.
   /// @{
   std::vector<PatchLocation> RangeAttributes;
   Optional<PatchLocation> UnitRangeAttribute;
   /// @}
 

llvm/include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h

 //===- DWARFAbbreviationDeclaration.h ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFABBREVIATIONDECLARATION_H
 #define LLVM_DEBUGINFO_DWARFABBREVIATIONDECLARATION_H
 
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Support/DataExtractor.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

class DWARFUnit {
   /// The compile unit debug information entry items.
   std::vector<DWARFDebugInfoEntry> DieArray;
 
   /// Map from range's start address to end address and corresponding DIE.
   /// IntervalMap does not support range removal, as a result, we use the
   /// std::map::upper_bound for address range lookup.
   std::map<uint64_t, std::pair<uint64_t, DWARFDie>> AddrDieMap;
 
+  Optional<uint64_t> StmtListOffset;
+  const char *CompilationDir = nullptr;
+
   using die_iterator_range =
       iterator_range<std::vector<DWARFDebugInfoEntry>::iterator>;
 
   std::shared_ptr<DWARFUnit> DWO;
 
   uint32_t getDIEIndex(const DWARFDebugInfoEntry *Die) {
     auto First = DieArray.data();
     assert(Die >= First && Die < First + DieArray.size());
public:
 
   DWARFDie getNonSkeletonUnitDIE(bool ExtractUnitDIEOnly = true) {
     parseDWO();
     if (DWO)
       return DWO->getUnitDIE(ExtractUnitDIEOnly);
     return getUnitDIE(ExtractUnitDIEOnly);
   }
 
+  Optional<uint64_t> getStmtListOffset();
+
   const char *getCompilationDir();
+
   Optional<uint64_t> getDWOId() {
     extractDIEsIfNeeded(/*CUDieOnly*/ true);
     return getHeader().getDWOId();
   }
   void setDWOId(uint64_t NewID) { Header.setDWOId(NewID); }
 
   /// Return a vector of address ranges resulting from a (possibly encoded)
   /// range list starting at a given offset in the appropriate ranges section.

llvm/include/llvm/MC/MCAsmInfo.h

return ExceptionsType == ExceptionHandling::WinEH &&
            (WinEHEncodingType != WinEH::EncodingType::Invalid &&
             WinEHEncodingType != WinEH::EncodingType::X86);
   }
 
   bool doesDwarfUseRelocationsAcrossSections() const {
     return DwarfUsesRelocationsAcrossSections;
   }
 
+  void
+  setDwarfUseRelocationsAcrossSections(bool UsesRelocationsAcrossSections) {
+    DwarfUsesRelocationsAcrossSections = UsesRelocationsAcrossSections;
+  }
+
   bool doDwarfFDESymbolsUseAbsDiff() const { return DwarfFDESymbolsUseAbsDiff; }
   bool useDwarfRegNumForCFI() const { return DwarfRegNumForCFI; }
   bool useParensForSymbolVariant() const { return UseParensForSymbolVariant; }
   bool supportsExtendedDwarfLocDirective() const {
     return SupportsExtendedDwarfLocDirective;
   }
 
   void addInitialFrameState(const MCCFIInstruction &Inst);

llvm/include/llvm/Object/ObjectFile.h

 };
 
 inline bool operator<(const SectionedAddress &LHS,
                       const SectionedAddress &RHS) {
   return std::tie(LHS.SectionIndex, LHS.Address) <
          std::tie(RHS.SectionIndex, RHS.Address);
 }
 
+inline bool operator<=(const SectionedAddress &LHS,
+                       const SectionedAddress &RHS) {
+  return std::tie(LHS.SectionIndex, LHS.Address) <=
+         std::tie(RHS.SectionIndex, RHS.Address);
+}
+
 inline bool operator==(const SectionedAddress &LHS,
                        const SectionedAddress &RHS) {
   return std::tie(LHS.SectionIndex, LHS.Address) ==
          std::tie(RHS.SectionIndex, RHS.Address);
 }
 
+inline bool operator!=(const SectionedAddress &LHS,
+                       const SectionedAddress &RHS) {
+  return std::tie(LHS.SectionIndex, LHS.Address) !=
+         std::tie(RHS.SectionIndex, RHS.Address);
+}
+
 raw_ostream &operator<<(raw_ostream &OS, const SectionedAddress &Addr);
 
 /// This is a value type class that represents a single symbol in the list of
 /// symbols in the object file.
 class SymbolRef : public BasicSymbolRef {
   friend class SectionRef;
 
 public:

llvm/lib/DWARFLinker/DWARFLinker.cpp

if (!LowPcIdx)
     return Flags;
 
   uint64_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
   DWARFUnit &OrigUnit = Unit.getOrigUnit();
   uint64_t LowPcOffset, LowPcEndOffset;
   std::tie(LowPcOffset, LowPcEndOffset) =
       getAttributeOffsets(Abbrev, *LowPcIdx, Offset, OrigUnit);
 
-  auto LowPc = dwarf::toAddress(DIE.find(dwarf::DW_AT_low_pc));
+  auto LowPc = dwarf::toSectionedAddress(DIE.find(dwarf::DW_AT_low_pc));
   assert(LowPc.hasValue() && "low_pc attribute is not an address.");
   if (!LowPc ||
       !RelocMgr.hasValidRelocationAt(LowPcOffset, LowPcEndOffset, MyInfo))
     return Flags;
 
   if (Options.Verbose) {
     outs() << "Keeping subprogram DIE:";
     DIDumpOptions DumpOpts;
     DumpOpts.ChildRecurseDepth = 0;
     DumpOpts.Verbose = Options.Verbose;
     DIE.dump(outs(), 8 /* Indent */, DumpOpts);
   }
 
   if (DIE.getTag() == dwarf::DW_TAG_label) {
     if (Unit.hasLabelAt(*LowPc))
       return Flags;
     // FIXME: dsymutil-classic compat. dsymutil-classic doesn't consider labels
     // that don't fall into the CU's aranges. This is wrong IMO. Debug info
     // generation bugs aside, this is really wrong in the case of labels, where
     // a label marking the end of a function will have a PC == CU's high_pc.
     if (dwarf::toAddress(OrigUnit.getUnitDIE().find(dwarf::DW_AT_high_pc))
-            .getValueOr(UINT64_MAX) <= LowPc)
+            .getValueOr(UINT64_MAX) <= LowPc->Address)
       return Flags;
     Unit.addLabelLowPc(*LowPc, MyInfo.AddrAdjust);
     return Flags | TF_Keep;
   }
 
   Flags |= TF_Keep;
 
-  Optional<uint64_t> HighPc = DIE.getHighPC(*LowPc);
+  Optional<uint64_t> HighPc = DIE.getHighPC(LowPc->Address);
   if (!HighPc) {
     reportWarning("Function without high_pc. Range will be discarded.\n", File,
                   &DIE);
     return Flags;
   }
 
   // Replace the debug map range with a more accurate one.
-  Ranges[*LowPc] = ObjFileAddressRange(*HighPc, MyInfo.AddrAdjust);
-  Unit.addFunctionRange(*LowPc, *HighPc, MyInfo.AddrAdjust);
+  Ranges[*LowPc] = {*HighPc, MyInfo.AddrAdjust};
+  Unit.addFunctionRange(*LowPc, {*HighPc, LowPc->SectionIndex},
+                        MyInfo.AddrAdjust);
   return Flags;
 }
 
 /// Check if a DIE should be kept.
 /// \returns updated TraversalFlags.
 unsigned DWARFLinker::shouldKeepDIE(AddressesMap &RelocMgr, RangesTy &Ranges,
                                     const DWARFDie &DIE, const DWARFFile &File,
                                     CompileUnit &Unit,
if (auto RefDie =
       // be necessary and could be advantageously replaced by
       // ReferencedCU->hasODR() && CU.hasODR().
       //
       // FIXME: compatibility with dsymutil-classic. There is no
       // reason not to unique ref_addr references.
       if (AttrSpec.Form != dwarf::DW_FORM_ref_addr && (UseOdr || IsModuleRef) &&
           Info.Ctxt &&
           Info.Ctxt != ReferencedCU->getInfo(Info.ParentIdx).Ctxt &&
-          Info.Ctxt->getCanonicalDIEOffset() && isODRAttribute(AttrSpec.Attr))
+          Info.Ctxt->getCanonicalDIEOffset() && isODRAttribute(AttrSpec.Attr)) {
         continue;
+      }
 
       // Keep a module forward declaration if there is no definition.
       if (!(isODRAttribute(AttrSpec.Attr) && Info.Ctxt &&
             Info.Ctxt->getCanonicalDIEOffset()))
         Info.Prune = false;
       ReferencedDIEs.emplace_back(RefDie, *ReferencedCU);
     }
   }

 }
 
 unsigned DWARFLinker::DIECloner::cloneStringAttribute(
     DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     const DWARFUnit &U, OffsetsStringPool &StringPool, AttributesInfo &Info) {
   // Switch everything to out of line strings.
   const char *String = *Val.getAsCString();
   auto StringEntry = StringPool.getEntry(String);
-
   // Update attributes info.
   if (AttrSpec.Attr == dwarf::DW_AT_name)
     Info.Name = StringEntry;
   else if (AttrSpec.Attr == dwarf::DW_AT_MIPS_linkage_name ||
            AttrSpec.Attr == dwarf::DW_AT_linkage_name)
     Info.MangledName = StringEntry;
 
   Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_strp,
                DIEInteger(StringEntry.getOffset()));
-
   return 4;
 }
 
 unsigned DWARFLinker::DIECloner::cloneDieReferenceAttribute(
     DIE &Die, const DWARFDie &InputDIE, AttributeSpec AttrSpec,
     unsigned AttrSize, const DWARFFormValue &Val, const DWARFFile &File,
     CompileUnit &Unit) {
   const DWARFUnit &U = Unit.getOrigUnit();
if (Die.getTag() == dwarf::DW_TAG_inlined_subroutine ||
       // relocated because it happens to match the low_pc of the
       // enclosing subprogram. To prevent issues with that, always use
       // the low_pc from the input DIE if relocations have been applied.
       Addr = (Info.OrigLowPc != std::numeric_limits<uint64_t>::max()
                   ? Info.OrigLowPc
                   : Addr) +
              Info.PCOffset;
     else if (Die.getTag() == dwarf::DW_TAG_compile_unit) {
-      Addr = Unit.getLowPc();
-      if (Addr == std::numeric_limits<uint64_t>::max())
+      const auto &pc = Unit.getLowPc();
+
+      if (pc != std::numeric_limits<uint64_t>::max())
+        Addr = pc;
+      else
         return 0;
     }
     Info.HasLowPc = true;
   } else if (AttrSpec.Attr == dwarf::DW_AT_high_pc) {
     if (Die.getTag() == dwarf::DW_TAG_compile_unit) {
-      if (uint64_t HighPc = Unit.getHighPc())
-        Addr = HighPc;
-      else
-        return 0;
+      Addr = Unit.getHighPc();
     } else
       // If we have a high_pc recorded for the input DIE, use
       // it. Otherwise (when no relocations where applied) just use the
       // one we just decoded.
       Addr = (Info.OrigHighPc ? Info.OrigHighPc : Addr) + Info.PCOffset;
   } else if (AttrSpec.Attr == dwarf::DW_AT_call_return_pc) {
     // Relocate a return PC address within a call site entry.
     if (Die.getTag() == dwarf::DW_TAG_call_site)
if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
       Info.IsDeclaration = true;
     Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                  dwarf::Form(AttrSpec.Form), DIEInteger(Value));
     return AttrSize;
   }
 
   if (AttrSpec.Attr == dwarf::DW_AT_high_pc &&
       Die.getTag() == dwarf::DW_TAG_compile_unit) {
-    if (Unit.getLowPc() == -1ULL)
-      return 0;
+    if (Unit.getLowPc() != std::numeric_limits<uint64_t>::max())
       // Dwarf >= 4 high_pc is an size, not an address.
       Value = Unit.getHighPc() - Unit.getLowPc();
+    else
+      return 0;
   } else if (AttrSpec.Form == dwarf::DW_FORM_sec_offset)
     Value = *Val.getAsSectionOffset();
   else if (AttrSpec.Form == dwarf::DW_FORM_sdata)
     Value = *Val.getAsSignedConstant();
   else if (auto OptionalValue = Val.getAsUnsignedConstant())
     Value = *OptionalValue;
   else {
     Linker.reportWarning(
DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
                                       DIE *Die) {
   DWARFUnit &U = Unit.getOrigUnit();
   unsigned Idx = U.getDIEIndex(InputDIE);
   CompileUnit::DIEInfo &Info = Unit.getInfo(Idx);
 
   // Should the DIE appear in the output?
   if (!Unit.getInfo(Idx).Keep)
     return nullptr;
-
   uint64_t Offset = InputDIE.getOffset();
   assert(!(Die && Info.Clone) && "Can't supply a DIE and a cloned DIE");
   if (!Die) {
     // The DIE might have been already created by a forward reference
     // (see cloneDieReferenceAttribute()).
     if (!Info.Clone)
       Info.Clone = DIE::get(DIEAlloc, dwarf::Tag(InputDIE.getTag()));
     Die = Info.Clone;
DIE *DWARFLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
   // We could copy the data only if we need to apply a relocation to it. After
   // testing, it seems there is no performance downside to doing the copy
   // unconditionally, and it makes the code simpler.
   SmallString<40> DIECopy(Data.getData().substr(Offset, NextOffset - Offset));
   Data =
       DWARFDataExtractor(DIECopy, Data.isLittleEndian(), Data.getAddressSize());
 
   // Modify the copy with relocated addresses.
-  if (ObjFile.Addresses->areRelocationsResolved() &&
-      ObjFile.Addresses->applyValidRelocs(DIECopy, Offset,
+  if (ObjFile.Addresses->applyValidRelocs(DIECopy, Offset,
                                           Data.isLittleEndian())) {
     // If we applied relocations, we store the value of high_pc that was
     // potentially stored in the input DIE. If high_pc is an address
     // (Dwarf version == 2), then it might have been relocated to a
     // totally unrelated value (because the end address in the object
     // file might be start address of another function which got moved
     // independently by the linker). The computation of the actual
     // high_pc value is done in cloneAddressAttribute().
if (LLVM_LIKELY(!Update) &&
         Copied = true;
       }
       continue;
     }
 
     DWARFFormValue Val(AttrSpec.Form);
     uint64_t AttrSize = Offset;
     Val.extractValue(Data, &Offset, U.getFormParams(), &U);
-    AttrSize = Offset - AttrSize;
 
+    AttrSize = Offset - AttrSize;
     OutOffset += cloneAttribute(*Die, InputDIE, File, Unit, StringPool, Val,
                                 AttrSpec, AttrSize, AttrInfo, IsLittleEndian);
   }
 
   // Look for accelerator entries.
   uint16_t Tag = InputDIE.getTag();
   // FIXME: This is slightly wrong. An inline_subroutine without a
   // low_pc, but with AT_ranges might be interesting to get into the
void DWARFLinker::patchRangesForUnit(const CompileUnit &Unit,
   const auto &FunctionRanges = Unit.getFunctionRanges();
   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
   DWARFDataExtractor RangeExtractor(OrigDwarf.getDWARFObj(),
                                     OrigDwarf.getDWARFObj().getRangesSection(),
                                     OrigDwarf.isLittleEndian(), AddressSize);
   auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
   DWARFUnit &OrigUnit = Unit.getOrigUnit();
   auto OrigUnitDie = OrigUnit.getUnitDIE(false);
-  uint64_t OrigLowPc =
-      dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc), -1ULL);
+  uint64_t OrigLowPc = dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc),
+                                        std::numeric_limits<uint64_t>::max());
   // Ranges addresses are based on the unit's low_pc. Compute the
   // offset we need to apply to adapt to the new unit's low_pc.
   int64_t UnitPcOffset = 0;
-  if (OrigLowPc != -1ULL)
+  if (OrigLowPc != std::numeric_limits<uint64_t>::max())
     UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
 
   for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
     uint64_t Offset = RangeAttribute.get();
     RangeAttribute.set(TheDwarfEmitter->getRangesSectionSize());
     if (Error E = RangeList.extract(RangeExtractor, &Offset)) {
       llvm::consumeError(std::move(E));
       reportWarning("invalid range list ignored.", File);
       RangeList.clear();
     }
     const auto &Entries = RangeList.getEntries();
     if (!Entries.empty()) {
       const DWARFDebugRangeList::RangeListEntry &First = Entries.front();
 
       if (CurrRange == InvalidRange ||
-          First.StartAddress + OrigLowPc < CurrRange.start() ||
-          First.StartAddress + OrigLowPc >= CurrRange.stop()) {
-        CurrRange = FunctionRanges.find(First.StartAddress + OrigLowPc);
-        if (CurrRange == InvalidRange ||
-            CurrRange.start() > First.StartAddress + OrigLowPc) {
+          First.SectionIndex != CurrRange.start().SectionIndex ||
+          First.StartAddress + OrigLowPc < CurrRange.start().Address ||
+          First.StartAddress + OrigLowPc >= CurrRange.stop().Address) {
+        CurrRange = FunctionRanges.find(
+            {First.StartAddress + OrigLowPc, First.SectionIndex});
+        if (CurrRange == InvalidRange || CurrRange == FunctionRanges.end() ||
+            CurrRange.start().SectionIndex != First.SectionIndex ||
+            CurrRange.start().Address > First.StartAddress + OrigLowPc) {
           reportWarning("no mapping for range.", File);
           continue;
         }
       }
     }
-
     TheDwarfEmitter->emitRangesEntries(UnitPcOffset, OrigLowPc, CurrRange,
                                        Entries, AddressSize);
   }
 }
 
 /// Generate the debug_aranges entries for \p Unit and if the
 /// unit has a DW_AT_ranges attribute, also emit the debug_ranges
 /// contribution for this attribute.
void DWARFLinker::patchLineTableForUnit(CompileUnit &Unit,
   // Iterate over the object file line info and extract the sequences
   // that correspond to linked functions.
   for (auto &Row : LineTable.Rows) {
     // Check whether we stepped out of the range. The range is
     // half-open, but consider accept the end address of the range if
     // it is marked as end_sequence in the input (because in that
     // case, the relocation offset is accurate and that entry won't
     // serve as the start of another function).
-    if (CurrRange == InvalidRange || Row.Address.Address < CurrRange.start() ||
-        Row.Address.Address > CurrRange.stop() ||
-        (Row.Address.Address == CurrRange.stop() && !Row.EndSequence)) {
+    if (CurrRange == InvalidRange ||
+        Row.Address.SectionIndex != CurrRange.start().SectionIndex ||
+        Row.Address.Address < CurrRange.start().Address ||
+        Row.Address.Address > CurrRange.stop().Address ||
+        (Row.Address.Address == CurrRange.stop().Address && !Row.EndSequence)) {
       // We just stepped out of a known range. Insert a end_sequence
       // corresponding to the end of the range.
       uint64_t StopAddress = CurrRange != InvalidRange
-                                 ? CurrRange.stop() + CurrRange.value()
-                                 : -1ULL;
-      CurrRange = FunctionRanges.find(Row.Address.Address);
+                                 ? CurrRange.stop().Address + CurrRange.value()
+                                 : std::numeric_limits<uint64_t>::max();
+      CurrRange = FunctionRanges.find(Row.Address);
       bool CurrRangeValid =
-          CurrRange != InvalidRange && CurrRange.start() <= Row.Address.Address;
+          CurrRange != InvalidRange &&
+          CurrRange.start().SectionIndex == Row.Address.SectionIndex &&
+          CurrRange.start().Address <= Row.Address.Address;
       if (!CurrRangeValid) {
         CurrRange = InvalidRange;
-        if (StopAddress != -1ULL) {
+        if (StopAddress != std::numeric_limits<uint64_t>::max()) {
           // Try harder by looking in the Address ranges map.
           // There are corner cases where this finds a
           // valid entry. It's unclear if this is right or wrong, but
           // for now do as dsymutil.
           // FIXME: Understand exactly what cases this addresses and
           // potentially remove it along with the Ranges map.
-          auto Range = Ranges.lower_bound(Row.Address.Address);
+          auto Range = Ranges.lower_bound(Row.Address);
           if (Range != Ranges.begin() && Range != Ranges.end())
             --Range;
 
-          if (Range != Ranges.end() && Range->first <= Row.Address.Address &&
+          if (Range != Ranges.end() &&
+              Range->first.SectionIndex == Row.Address.SectionIndex &&
+              Range->first.Address <= Row.Address.Address &&
               Range->second.HighPC >= Row.Address.Address) {
             StopAddress = Row.Address.Address + Range->second.Offset;
           }
         }
       }
-      if (StopAddress != -1ULL && !Seq.empty()) {
+      if (StopAddress != std::numeric_limits<uint64_t>::max() && !Seq.empty()) {
         // Insert end sequence row with the computed end address, but
         // the same line as the previous one.
         auto NextLine = Seq.back();
         NextLine.Address.Address = StopAddress;
         NextLine.EndSequence = 1;
         NextLine.PrologueEnd = 0;
         NextLine.BasicBlock = 0;
         NextLine.EpilogueBegin = 0;

 void DWARFLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
   switch (Options.TheAccelTableKind) {
   case AccelTableKind::Apple:
     emitAppleAcceleratorEntriesForUnit(Unit);
     break;
   case AccelTableKind::Dwarf:
     emitDwarfAcceleratorEntriesForUnit(Unit);
     break;
+  case AccelTableKind::None:
+    // nothing to do
+    break;
   case AccelTableKind::Default:
     llvm_unreachable("The default must be updated to a concrete value.");
     break;
   }
 }
 
 void DWARFLinker::emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit) {
   // Add namespaces.
while (Data.isValidOffset(InputOffset)) {
     }
 
     uint32_t Loc = Data.getUnsigned(&InputOffset, AddrSize);
 
     // Some compilers seem to emit frame info that doesn't start at
     // the function entry point, thus we can't just lookup the address
     // in the debug map. Use the AddressInfo's range map to see if the FDE
     // describes something that we can relocate.
-    auto Range = Ranges.upper_bound(Loc);
+    auto Range =
+        Ranges.upper_bound({Loc, object::SectionedAddress::UndefSection});
     if (Range != Ranges.begin())
       --Range;
-    if (Range == Ranges.end() || Range->first > Loc ||
+    if (Range == Ranges.end() || Range->first.Address > Loc ||
         Range->second.HighPC <= Loc) {
       // The +4 is to account for the size of the InitialLength field itself.
       InputOffset = EntryOffset + InitialLength + 4;
       continue;
     }
 
     // This is an FDE, and we have a mapping.
     // Have we already emitted a corresponding CIE?
if (!Options.NoOutput) {
         TheDwarfEmitter->emitAppleNames(AppleNames);
         TheDwarfEmitter->emitAppleNamespaces(AppleNamespaces);
         TheDwarfEmitter->emitAppleTypes(AppleTypes);
         TheDwarfEmitter->emitAppleObjc(AppleObjc);
         break;
       case AccelTableKind::Dwarf:
         TheDwarfEmitter->emitDebugNames(DebugNames);
         break;
+      case AccelTableKind::None:
+        // nothing to do
+        break;
       case AccelTableKind::Default:
         llvm_unreachable("Default should have already been resolved.");
         break;
       }
     }
   };
 
   auto AnalyzeAll = [&]() {

llvm/lib/DWARFLinker/DWARFLinkerCompileUnit.cpp

 //===- DWARFLinkerCompileUnit.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
 #include "llvm/DWARFLinker/DWARFLinkerDeclContext.h"
 
 namespace llvm {
 
+object::SectionedAddress DenseMapInfo<object::SectionedAddress>::getEmptyKey() {
+  return {object::SectionedAddress::UndefSection,
+          object::SectionedAddress::UndefSection - 1};
+}
+
+object::SectionedAddress
+DenseMapInfo<object::SectionedAddress>::getTombstoneKey() {
+  return {object::SectionedAddress::UndefSection,
+          object::SectionedAddress::UndefSection - 2};
+}
+
+unsigned DenseMapInfo<object::SectionedAddress>::getHashValue(
+    const object::SectionedAddress &val) {
+  return llvm::hash_value(std::make_pair(val.Address, val.SectionIndex));
+}
+
+bool DenseMapInfo<object::SectionedAddress>::isEqual(
+    const object::SectionedAddress &lhs, const object::SectionedAddress &rhs) {
+  return lhs == rhs;
+}
+
 /// Check if the DIE at \p Idx is in the scope of a function.
 static bool inFunctionScope(CompileUnit &U, unsigned Idx) {
   while (Idx) {
     if (U.getOrigUnit().getDIEAtIndex(Idx).getTag() == dwarf::DW_TAG_subprogram)
       return true;
     Idx = U.getInfo(Idx).ParentIdx;
   }
   return false;
for (const auto &Ref : ForwardDIEReferences) {
     std::tie(RefDie, RefUnit, Ctxt, Attr) = Ref;
     if (Ctxt && Ctxt->getCanonicalDIEOffset())
       Attr.set(Ctxt->getCanonicalDIEOffset());
     else
       Attr.set(RefDie->getOffset() + RefUnit->getStartOffset());
   }
 }
 
-void CompileUnit::addLabelLowPc(uint64_t LabelLowPc, int64_t PcOffset) {
+void CompileUnit::addLabelLowPc(object::SectionedAddress LabelLowPc,
+                                int64_t PcOffset) {
   Labels.insert({LabelLowPc, PcOffset});
 }
 
-void CompileUnit::addFunctionRange(uint64_t FuncLowPc, uint64_t FuncHighPc,
+void CompileUnit::addFunctionRange(object::SectionedAddress FuncLowPc,
+                                   object::SectionedAddress FuncHighPc,
                                    int64_t PcOffset) {
+  assert(FuncLowPc.SectionIndex == FuncHighPc.SectionIndex);
+
   //  Don't add empty ranges to the interval map.  They are a problem because
   //  the interval map expects half open intervals. This is safe because they
   //  are empty anyway.
   if (FuncHighPc != FuncLowPc)
     Ranges.insert(FuncLowPc, FuncHighPc, PcOffset);
-  this->LowPc = std::min(LowPc, FuncLowPc + PcOffset);
-  this->HighPc = std::max(HighPc, FuncHighPc + PcOffset);
+  LowPc = std::min(LowPc, FuncLowPc.Address + PcOffset);
+  HighPc = std::max(HighPc, FuncHighPc.Address + PcOffset);
 }
 
 void CompileUnit::noteRangeAttribute(const DIE &Die, PatchLocation Attr) {
   if (Die.getTag() != dwarf::DW_TAG_compile_unit)
     RangeAttributes.push_back(Attr);
   else
     UnitRangeAttribute = Attr;
 }

llvm/lib/DWARFLinker/DWARFStreamer.cpp

bool DwarfStreamer::init(Triple TheTriple) {
   if (!MRI)
     return error(Twine("no register info for target ") + TripleName, Context),
            false;
 
   MCTargetOptions MCOptions = mc::InitMCTargetOptionsFromFlags();
   MAI.reset(TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
   if (!MAI)
     return error("no asm info for target " + TripleName, Context), false;
+  MAI->setDwarfUseRelocationsAcrossSections(false);
 
   MOFI.reset(new MCObjectFileInfo);
   MC.reset(new MCContext(MAI.get(), MRI.get(), MOFI.get()));
   MOFI->InitMCObjectFileInfo(TheTriple, /*PIC*/ false, *MC);
 
   MSTI.reset(TheTarget->createMCSubtargetInfo(TripleName, "", ""));
   if (!MSTI)
     return error("no subtarget info for target " + TripleName, Context), false;
bool DwarfStreamer::init(Triple TheTriple) {
   TM.reset(TheTarget->createTargetMachine(TripleName, "", "", TargetOptions(),
                                           None));
   if (!TM)
     return error("no target machine for target " + TripleName, Context), false;
 
   Asm.reset(TheTarget->createAsmPrinter(*TM, std::unique_ptr<MCStreamer>(MS)));
   if (!Asm)
     return error("no asm printer for target " + TripleName, Context), false;
+  const_cast<MCAsmInfo *>(Asm->MAI)->setDwarfUseRelocationsAcrossSections(
+      false);
 
   RangesSectionSize = 0;
   LocSectionSize = 0;
   LineSectionSize = 0;
   FrameSectionSize = 0;
   DebugInfoSectionSize = 0;
 
   return true;
if (Range.isBaseAddressSelectionEntry(AddressSize)) {
            "emitting debug_ranges");
       break;
     }
     // Do not emit empty ranges.
     if (Range.StartAddress == Range.EndAddress)
       continue;
 
     // All range entries should lie in the function range.
-    if (!(Range.StartAddress + OrigLowPc >= FuncRange.start() &&
-          Range.EndAddress + OrigLowPc <= FuncRange.stop()))
+    if (!(Range.SectionIndex == FuncRange.start().SectionIndex &&
+          Range.StartAddress + OrigLowPc >= FuncRange.start().Address &&
+          Range.EndAddress + OrigLowPc <= FuncRange.stop().Address))
       warn("inconsistent range data.", "emitting debug_ranges");
     MS->emitIntValue(Range.StartAddress + PcOffset, AddressSize);
     MS->emitIntValue(Range.EndAddress + PcOffset, AddressSize);
     RangesSectionSize += 2 * AddressSize;
   }
 
   // Add the terminator entry.
   MS->emitIntValue(0, AddressSize);
void DwarfStreamer::emitUnitRangesEntries(CompileUnit &Unit,
   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
   // Gather the ranges in a vector, so that we can simplify them. The
   // IntervalMap will have coalesced the non-linked ranges, but here
   // we want to coalesce the linked addresses.
   std::vector<std::pair<uint64_t, uint64_t>> Ranges;
   const auto &FunctionRanges = Unit.getFunctionRanges();
   for (auto Range = FunctionRanges.begin(), End = FunctionRanges.end();
        Range != End; ++Range)
-    Ranges.push_back(std::make_pair(Range.start() + Range.value(),
-                                    Range.stop() + Range.value()));
+    Ranges.push_back(std::make_pair(Range.start().Address + Range.value(),
+                                    Range.stop().Address + Range.value()));
 
   // The object addresses where sorted, but again, the linked
   // addresses might end up in a different order.
   llvm::sort(Ranges);
 
   if (!Ranges.empty()) {
     MS->SwitchSection(MC->getObjectFileInfo()->getDwarfARangesSection());
 
if (!Ranges.empty()) {
     Asm->OutStreamer->emitLabel(EndLabel);
   }
 
   if (!DoDebugRanges)
     return;
 
   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfRangesSection());
   // Offset each range by the right amount.
-  int64_t PcOffset = -Unit.getLowPc();
+  int64_t PcOffset = 0;
+  PcOffset = -Unit.getLowPc();
   // Emit coalesced ranges.
   for (auto Range = Ranges.begin(), End = Ranges.end(); Range != End; ++Range) {
     MS->emitIntValue(Range->first + PcOffset, AddressSize);
     while (Range + 1 != End && Range->second == (Range + 1)->first)
       ++Range;
     MS->emitIntValue(Range->second + PcOffset, AddressSize);
     RangesSectionSize += 2 * AddressSize;
   }

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

DWARFContext::getLineTableForUnit(DWARFUnit *U) {
   return *ExpectedLineTable;
 }
 
 Expected<const DWARFDebugLine::LineTable *> DWARFContext::getLineTableForUnit(
     DWARFUnit *U, function_ref<void(Error)> RecoverableErrorHandler) {
   if (!Line)
     Line.reset(new DWARFDebugLine);
 
-  auto UnitDIE = U->getUnitDIE();
-  if (!UnitDIE)
-    return nullptr;
-
-  auto Offset = toSectionOffset(UnitDIE.find(DW_AT_stmt_list));
+  auto Offset = U->getStmtListOffset();
   if (!Offset)
     return nullptr; // No line table for this compile unit.
 
   uint64_t stmtOffset = *Offset + U->getLineTableOffset();
   // See if the line table is cached.
   if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
     return lt;
 

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

while (!Worklist.empty()) {
     Worklist.pop_back();
 
     if (!Die.isValid())
       continue;
 
     if (auto Value = Die.find(Attrs))
       return Value;
 
-    if (auto D = Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
+    if (auto D = Die.getAttributeValueAsReferencedDie(DW_AT_abstract_origin)) {
       if (Seen.insert(D).second)
         Worklist.push_back(D);
-
+    }
     if (auto D = Die.getAttributeValueAsReferencedDie(DW_AT_specification))
       if (Seen.insert(D).second)
         Worklist.push_back(D);
   }
 
   return None;
 }
 

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

void DWARFUnit::clear() {
   BaseAddr.reset();
   RangeSectionBase = 0;
   LocSectionBase = 0;
   AddrOffsetSectionBase = None;
   clearDIEs(false);
   DWO.reset();
 }
 
+Optional<uint64_t> DWARFUnit::getStmtListOffset() {
+  if (!StmtListOffset)
+    StmtListOffset = toSectionOffset(getUnitDIE().find(DW_AT_stmt_list));
+
+  return StmtListOffset;
+}
+
 const char *DWARFUnit::getCompilationDir() {
-  return dwarf::toString(getUnitDIE().find(DW_AT_comp_dir), nullptr);
+  if (!CompilationDir)
+    CompilationDir =
+        dwarf::toString(getUnitDIE().find(DW_AT_comp_dir), nullptr);
+
+  return CompilationDir;
 }
 
 void DWARFUnit::extractDIEsToVector(
     bool AppendCUDie, bool AppendNonCUDies,
     std::vector<DWARFDebugInfoEntry> &Dies) const {
   if (!AppendCUDie && !AppendNonCUDies)
     return;
 

llvm/lib/Support/StringMap.cpp

 /// case, the FullHashValue field of the bucket will be set to the hash value
 /// of the string.
 unsigned StringMapImpl::LookupBucketFor(StringRef Name) {
   unsigned HTSize = NumBuckets;
   if (HTSize == 0) { // Hash table unallocated so far?
     init(16);
     HTSize = NumBuckets;
   }
+
   unsigned FullHashValue = djbHash(Name, 0);
   unsigned BucketNo = FullHashValue & (HTSize - 1);
   unsigned *HashTable = (unsigned *)(TheTable + NumBuckets + 1);
 
   unsigned ProbeAmt = 1;
   int FirstTombstone = -1;
   while (true) {
     StringMapEntryBase *BucketItem = TheTable[BucketNo];

llvm/tools/dsymutil/DwarfLinkerForBinary.h

AddressManager(DwarfLinkerForBinary &Linker, const object::ObjectFile &Obj,
       // bugs that need to be investigated, but for now we need to reproduce
       // dsymutil's behavior.
       // FIXME: Once we understood exactly if that information is needed,
       // maybe totally remove this (or try to use it to do a real
       // -gline-tables-only on Darwin.
       for (const auto &Entry : DMO.symbols()) {
         const auto &Mapping = Entry.getValue();
         if (Mapping.Size && Mapping.ObjectAddress)
-          AddressRanges[*Mapping.ObjectAddress] = ObjFileAddressRange(
+          AddressRanges[{*Mapping.ObjectAddress,
+                         object::SectionedAddress::UndefSection}] = {
               *Mapping.ObjectAddress + Mapping.Size,
-              int64_t(Mapping.BinaryAddress) - *Mapping.ObjectAddress);
+              int64_t(Mapping.BinaryAddress - *Mapping.ObjectAddress)};
       }
     }
     virtual ~AddressManager() override { clear(); }
 
-    virtual bool areRelocationsResolved() const override { return true; }
-
     bool hasValidRelocs(bool ResetRelocsPtr = true) override {
       if (ResetRelocsPtr)
         NextValidReloc = 0;
       return !ValidRelocs.empty();
     }
 
     /// \defgroup FindValidRelocations Translate debug map into a list
     /// of relevant relocations

llvm/tools/dsymutil/DwarfLinkerForBinary.cpp

if (auto E =
       return error(toString(std::move(E)));
   }
 
   if (Map.getTriple().isOSDarwin() && !Map.getBinaryPath().empty() &&
       Options.FileType == OutputFileType::Object)
     return MachOUtils::generateDsymCompanion(
         Options.VFS, Map, Options.Translator,
         *Streamer->getAsmPrinter().OutStreamer, OutFile);
 
   Streamer->finish();
   return true;
 }
 
 static bool isMachOPairedReloc(uint64_t RelocType, uint64_t Arch) {
   switch (Arch) {
   case Triple::x86:
     return RelocType == MachO::GENERIC_RELOC_SECTDIFF ||
            RelocType == MachO::GENERIC_RELOC_LOCAL_SECTDIFF;

 /// in the debug_info section.
 ///
 /// Like for findValidRelocs(), this function must be called with
 /// monotonic \p BaseOffset values.
 ///
 /// \returns whether any reloc has been applied.
 bool DwarfLinkerForBinary::AddressManager::applyValidRelocs(
     MutableArrayRef<char> Data, uint64_t BaseOffset, bool IsLittleEndian) {
-  assert(areRelocationsResolved());
   assert((NextValidReloc == 0 ||
           BaseOffset > ValidRelocs[NextValidReloc - 1].Offset) &&
          "BaseOffset should only be increasing.");
   if (NextValidReloc >= ValidRelocs.size())
     return false;
 
   // Skip relocs that haven't been applied.
   while (NextValidReloc < ValidRelocs.size() &&

llvm/unittests/DebugInfo/DWARF/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   AsmPrinter
   BinaryFormat
   DebugInfoDWARF
+  DWARFLinker
   MC
   Object
   ObjectYAML
   Support
   )
 
 add_llvm_unittest(DebugInfoDWARFTests
   DwarfGenerator.cpp
   DwarfUtils.cpp
   DWARFAcceleratorTableTest.cpp
   DWARFDataExtractorTest.cpp
   DWARFDebugArangeSetTest.cpp
   DWARFDebugFrameTest.cpp
   DWARFDebugInfoTest.cpp
   DWARFDebugLineTest.cpp
   DWARFDieTest.cpp
   DWARFExpressionCompactPrinterTest.cpp
   DWARFFormValueTest.cpp
   DWARFListTableTest.cpp
   DWARFLocationExpressionTest.cpp
+  DWARFLinkerCompileUnit.cpp
   )
 
 target_link_libraries(DebugInfoDWARFTests PRIVATE LLVMTestingSupport)

llvm/unittests/DebugInfo/DWARF/DWARFLinkerCompileUnit.cpp

+//===- llvm/unittest/DebugInfo/DWARFLinkerCompileUnit.cpp -----------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DWARFLinker/DWARFLinkerCompileUnit.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/ObjectYAML/DWARFEmitter.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace llvm::dwarf;
+using object::SectionedAddress;
+
+namespace {
+
+TEST(DWARFLinkerCompileUnit, sectionedAddressRanges) {
+  const char *yamldata = "debug_abbrev:\n"
+                         "  - Table:\n"
+                         "      - Code:            0x00000001\n"
+                         "        Tag:             DW_TAG_compile_unit\n"
+                         "        Children:        DW_CHILDREN_yes\n"
+                         "debug_info:\n"
+                         "  - Version:         4\n"
+                         "    AddrSize:        8\n"
+                         "    Entries:\n"
+                         "      - AbbrCode:        0x00000001\n"
+                         "      - AbbrCode:        0x00000000\n";
+
+  auto ErrOrSections = DWARFYAML::emitDebugSections(StringRef(yamldata), true);
+  ASSERT_TRUE((bool)ErrOrSections);
+  std::unique_ptr<DWARFContext> DwarfContext =
+      DWARFContext::create(*ErrOrSections, 8);
+
+  // Verify the number of compile units is correct.
+  uint32_t NumCUs = DwarfContext->getNumCompileUnits();
+  EXPECT_EQ(NumCUs, 1u);
+  DWARFCompileUnit *U = cast<DWARFCompileUnit>(DwarfContext->getUnitAtIndex(0));
+
+  // Check the compile unit DIE is valid.
+  auto DieDG = U->getUnitDIE(false);
+  EXPECT_TRUE(DieDG.isValid());
+
+  // Create DWARFLinker compile unit.
+  CompileUnit CU(*U, 1, false, "");
+
+  // Check for adding zero address range from undefined section.
+  CU.addFunctionRange({0x10, object::SectionedAddress::UndefSection},
+                      {0x10, object::SectionedAddress::UndefSection}, 0x4000);
+  EXPECT_TRUE(CU.getFunctionRanges().empty());
+
+  EXPECT_TRUE(CU.getLowPc() == 0x4010);
+  EXPECT_TRUE(CU.getHighPc() == 0x4010);
+
+  // Check for adding zero address range from first section.
+  CU.addFunctionRange({0x10, 1}, {0x10, 1}, 0x4500);
+  EXPECT_TRUE(CU.getFunctionRanges().empty());
+
+  EXPECT_TRUE(CU.getLowPc() == 0x4010);
+  EXPECT_TRUE(CU.getHighPc() == 0x4510);
+
+  // Check for adding valid address range from undefined section.
+  CU.addFunctionRange({0x10, object::SectionedAddress::UndefSection},
+                      {0x20, object::SectionedAddress::UndefSection}, 0x4000);
+  EXPECT_TRUE(!CU.getFunctionRanges().empty());
+  EXPECT_TRUE(CU.getFunctionRanges().find(
+                  {0x10, object::SectionedAddress::UndefSection}) !=
+              CU.getFunctionRanges().end());
+  EXPECT_TRUE(CU.getFunctionRanges().lookup(
+                  {0x10, object::SectionedAddress::UndefSection}) == 0x4000);
+
+  // Check for adding second valid address range from undefined section.
+  CU.addFunctionRange({0x20, object::SectionedAddress::UndefSection},
+                      {0x40, object::SectionedAddress::UndefSection}, 0x5000);
+  EXPECT_TRUE(!CU.getFunctionRanges().empty());
+  EXPECT_TRUE(CU.getFunctionRanges().find(
+                  {0x20, object::SectionedAddress::UndefSection}) !=
+              CU.getFunctionRanges().end());
+  EXPECT_TRUE(CU.getFunctionRanges().lookup(
+                  {0x20, object::SectionedAddress::UndefSection}) == 0x5000);
+  EXPECT_TRUE(CU.getFunctionRanges().lookup(
+                  {0x19, object::SectionedAddress::UndefSection}) == 0x4000);
+
+  // Check for adding third valid address range from undefined section.
+  CU.addFunctionRange({0x100, object::SectionedAddress::UndefSection},
+                      {0x200, object::SectionedAddress::UndefSection}, 0x6000);
+  EXPECT_TRUE(!CU.getFunctionRanges().empty());
+  EXPECT_TRUE(CU.getFunctionRanges().find(
+                  {0x100, object::SectionedAddress::UndefSection}) !=
+              CU.getFunctionRanges().end());
+
+  // Check that function ranges does not contain values which were not put there
+  // previously.
+  EXPECT_TRUE(CU.getFunctionRanges().lookup(
+                  {0x5, object::SectionedAddress::UndefSection}, -1LL) == -1LL);
+  EXPECT_TRUE(CU.getFunctionRanges().lookup(
+                  {0x100, object::SectionedAddress::UndefSection}) == 0x6000);
+
+  // Check compile unit low/high pc values.
+  EXPECT_TRUE(CU.getLowPc() == 0x4010);
+  EXPECT_TRUE(CU.getHighPc() == 0x6200);
+
+  // Check for adding valid address range from first section.
+  CU.addFunctionRange({0x10, 1}, {0x20, 1}, 0x1000);
+  EXPECT_TRUE(!CU.getFunctionRanges().empty());
+  EXPECT_TRUE(CU.getFunctionRanges().find({0x10, 1}) !=
+              CU.getFunctionRanges().end());
+  EXPECT_TRUE(CU.getFunctionRanges().lookup({0x10, 1}) == 0x1000);
+
+  // Check for adding second valid address range from first section.
+  CU.addFunctionRange({0x20, 1}, {0x40, 1}, 0x2000);
+  EXPECT_TRUE(!CU.getFunctionRanges().empty());
+  EXPECT_TRUE(CU.getFunctionRanges().find({0x20, 1}) !=
+              CU.getFunctionRanges().end());
+  EXPECT_TRUE(CU.getFunctionRanges().lookup({0x20, 1}) == 0x2000);
+  EXPECT_TRUE(CU.getFunctionRanges().lookup({0x19, 1}) == 0x1000);
+
+  // Check for adding valid address range from second section.
+  CU.addFunctionRange({0x10, 2}, {0x20, 2}, 0x3000);
+  EXPECT_TRUE(!CU.getFunctionRanges().empty());
+  EXPECT_TRUE(CU.getFunctionRanges().find({0x10, 2}) !=
+              CU.getFunctionRanges().end());
+  EXPECT_TRUE(CU.getFunctionRanges().lookup({0x10, 2}) == 0x3000);
+
+  // Check that function ranges does not contain values which were not put there
+  // previously.
+  EXPECT_TRUE(CU.getFunctionRanges().lookup({0x10, 3}, -1LL) == -1LL);
+  EXPECT_TRUE(CU.getFunctionRanges().lookup({UINT64_MAX, 2}, -1LL) == -1LL);
+
+  EXPECT_TRUE(CU.getLowPc() == 0x1010);
+  EXPECT_TRUE(CU.getHighPc() == 0x6200);
+
+  // Check for adding valid address range from four section.
+  CU.addFunctionRange({0x0, 4}, {0x200, 4}, 0x8000);
+  EXPECT_TRUE(!CU.getFunctionRanges().empty());
+  EXPECT_TRUE(CU.getFunctionRanges().find({0x10, 4}) !=
+              CU.getFunctionRanges().end());
+  EXPECT_TRUE(CU.getFunctionRanges().lookup({0x10, 4}) == 0x8000);
+
+  EXPECT_TRUE(CU.getLowPc() == 0x1010);
+  EXPECT_TRUE(CU.getHighPc() == 0x8200);
+
+  // Check adding labels.
+  CU.addLabelLowPc({0x10, object::SectionedAddress::UndefSection}, 0x4000);
+  EXPECT_TRUE(CU.hasLabelAt({0x10, object::SectionedAddress::UndefSection}));
+  EXPECT_TRUE(!CU.hasLabelAt({0x0, object::SectionedAddress::UndefSection}));
+
+  CU.addLabelLowPc({0x10, 1}, 0x4000);
+  EXPECT_TRUE(CU.hasLabelAt({0x10, 1}));
+  EXPECT_TRUE(!CU.hasLabelAt({0x0, 1}));
+
+  EXPECT_TRUE(!CU.hasLabelAt({0x10, 2}));
+}
+
+} // end anonymous namespace