[DWARFLinker][dsymutil][NFC] add section index into address range.

[avl]

Summary

dsymutil reads address ranges from DebugMap, which contains addresses
inside object file. These addresses could be used as unique identifiers
of address ranges since --function-sections is not used on darwin. i.e. all
code is inside one section. For the case when DWARFLinker optimizes
debug info for --function-sections (Remove obsolete debug info: D74169)
it is necessary to have additional identifier for addresses(since addresses for different
sections could clash). This patch adds SectionIndex to address ranges
to have a unique identifier for the address range.

Testing: it passes "check-all" lit testing. MD5 checksum for clang .dSYM
bundle matches for the dsymutil with/without that patch.

[dblaikie]

My only rough thought here (as I'm not especially versed in the DWARFLinker code) is that this feature (doing debug info redundancy elimination during ld -r) seems more like a stretch/later goal & I'd have thought it'd be likely/better to implement this for non"-r" linking first, since that's close(r) to the llvm-dsymutil functionality already in DWARFLinker, then in subsequent patches generalize this (in the way you're proposing) to handle the "-r" sort of case, which is probably (likely/actually) more complicated (or at least more new code, since it's not something that DWARFLuinker has had to support until this point), keeping track of addresses, etc.

Could changes like this be tested (possibly unit tested) in some way? I guess DWARFLinker funcitonality's been tested in llvm-dsymutil up until this point - but this is the first major/new functionality DWARFLinker will support that llvm-dsymutil does not support, so some in-tree testing story will need to be created.

[avl]

My only rough thought here (as I'm not especially versed in the DWARFLinker code) is that this feature (doing debug info redundancy elimination during ld -r) seems more like a stretch/later goal & I'd have thought it'd be likely/better to implement this for non"-r" linking first, since that's close(r) to the llvm-dsymutil functionality already in DWARFLinker, then in subsequent patches generalize this (in the way you're proposing) to handle the "-r" sort of case, which is probably (likely/actually) more complicated (or at least more new code, since it's not something that DWARFLuinker has had to support until this point), keeping track of addresses, etc.

At this point, I do not plan to support ld -r, since "-r and --gc-sections may not be used together". So this change is for non "-r" linking.

I think it is better not to implement "debug info redundancy elimination in lld" using the standard dsymutil scenario. Instead, it is better to use an optimized scenario:

1. standard dsymutil scenario:

• lld creates liveness map for sections.
• lld resolves relocations and generates contents of output sections.
• lld creates a debug map for DWARFLinker.
• DWARFLinker links debug info(creates a tree of cloned DIEs).
• DWARFLinker generates new content for output sections.
  
  Memory objects:

• source debug info sections.
• NON-optimized debug info sections.
• DIEs tree.
• optimized output debug info sections.

2. optimized dsymutil scenario:

• lld creates liveness map for sections.
• DWARFLinker links debug info(creates a tree of cloned DIEs).
• DWARFLinker generates new content for output sections.
• lld resolves relocations and generates contents of output sections.
  
  Memory objects:

• source debug info sections.
• DIEs tree.
• optimized debug info sections.
• optimized output debug info sections.

The second scenario does not need to create a debug map. It also requires less memory.
Thus I am planning to use this second scenario.

If we would do the first scenario and later would implement second, then all lld integration part should be thrown away and replaced with the new implementation. So implementing the first scenario would be just a waste of time.

I think it makes sense to implement the second scenario from scratch.

Could changes like this be tested (possibly unit tested) in some way? I guess DWARFLinker funcitonality's been tested in llvm-dsymutil up until this point - but this is the first major/new functionality DWARFLinker will support that llvm-dsymutil does not support, so some in-tree testing story will need to be created.

Yes. I am going to add tests together with new functionality. My overall development plan looks like this :

1. create a first version that would work for .debug_info/.debug_ranges tables. This version could be taken for evaluation, as requested in D74169.
   1. D76085 patch.
   2. internal patch implementing AddressesMap in lld.
   3. internal patch implementing DebugInputSection in lld.
   4. internal patch dumping DIEs into bytes array.
   5. internal patch implementing DwarfEmitter(dump DIEs into bytes array).

2. divide the above patch into smaller patches and integrate them with a set of tests.

3. implement the rest of the debug info tables.

So I assumed that D76085 would be done as NFC for the current codebase. And changes in interfaces would be used while integrating patches on step 2.

[dblaikie]

In D76085#1921389, @avl wrote:

My only rough thought here (as I'm not especially versed in the DWARFLinker code) is that this feature (doing debug info redundancy elimination during ld -r) seems more like a stretch/later goal & I'd have thought it'd be likely/better to implement this for non"-r" linking first, since that's close(r) to the llvm-dsymutil functionality already in DWARFLinker, then in subsequent patches generalize this (in the way you're proposing) to handle the "-r" sort of case, which is probably (likely/actually) more complicated (or at least more new code, since it's not something that DWARFLuinker has had to support until this point), keeping track of addresses, etc.

At this point, I do not plan to support ld -r, since "-r and --gc-sections may not be used together". So this change is for non "-r" linking.

I think it is better not to implement "debug info redundancy elimination in lld" using the standard dsymutil scenario. Instead, it is better to use an optimized scenario:

1. standard dsymutil scenario:

• lld creates liveness map for sections.
• lld resolves relocations and generates contents of output sections.
• lld creates a debug map for DWARFLinker.
• DWARFLinker links debug info(creates a tree of cloned DIEs).
• DWARFLinker generates new content for output sections.
  
  Memory objects:

• source debug info sections.
• NON-optimized debug info sections.

I'm not sure where this ^ happens in the scenario list you describe above. And is this fundamentally necessary for the llvm-dsymutil functionality, but not needed for lld? Or is this an improvement that could be made (& tested) in llvm-dsymutil independently/prior to the lld work?

• DIEs tree.
• optimized output debug info sections.

2. optimized dsymutil scenario:

• lld creates liveness map for sections.
• DWARFLinker links debug info(creates a tree of cloned DIEs).
• DWARFLinker generates new content for output sections.
• lld resolves relocations and generates contents of output sections.
  
  Memory objects:

• source debug info sections.
• DIEs tree.
• optimized debug info sections.
• optimized output debug info sections.

The second scenario does not need to create a debug map. It also requires less memory.
Thus I am planning to use this second scenario.

If we would do the first scenario and later would implement second, then all lld integration part should be thrown away and replaced with the new implementation. So implementing the first scenario would be just a waste of time.

I think it makes sense to implement the second scenario from scratch.

Could changes like this be tested (possibly unit tested) in some way? I guess DWARFLinker funcitonality's been tested in llvm-dsymutil up until this point - but this is the first major/new functionality DWARFLinker will support that llvm-dsymutil does not support, so some in-tree testing story will need to be created.

Yes. I am going to add tests together with new functionality.

Changes to code in the llvm/ repository should generally be tested that repository - not only by tests in another project like lld.

My overall development plan looks like this :

1. create a first version that would work for .debug_info/.debug_ranges tables. This version could be taken for evaluation, as requested in D74169.
   1. D76085 patch.
   2. internal patch implementing AddressesMap in lld.
   3. internal patch implementing DebugInputSection in lld.
   4. internal patch dumping DIEs into bytes array.
   5. internal patch implementing DwarfEmitter(dump DIEs into bytes array).

2. divide the above patch into smaller patches and integrate them with a set of tests.

3. implement the rest of the debug info tables.

So I assumed that D76085 would be done as NFC for the current codebase. And changes in interfaces would be used while integrating patches on step 2.

[avl]

Memory objects:
source debug info sections.
NON-optimized debug info sections.

I'm not sure where this ^ happens in the scenario list you describe above.

it happens at point 3. "lld resolves relocations and generates contents of output sections."
the result of this step would be non-optimized debug info section with resolved relocations(*).
this result should be later passed to dsymutil if we speak about standard dsymutil scenario.

And is this fundamentally necessary for the llvm-dsymutil functionality,
but not needed for lld? Or is this an improvement that could be made
(& tested) in llvm-dsymutil independently/prior to the lld work?

Yes. This is fundamentally necessary for dsymutil functionality.
dsymutil gets on the input - debug map(which maps symbol addresses in the object file and their linked addresses in binary)
and linked binary. So to preserve dsymutil behavior, we need to create the same input: debug map and linked binary.

But for "debug info linking" in general, it is not necessary to have linked binary and debug map.
All information available in lld before output sections are linked and generated.
As soon as the linker built liveness information for the sections, the debug info could be optimized/linked.
As a result, when lld would resolve relocations and generate output - the size of generated sections would be smaller than in (*).
That possibility is the advantage of "linking debug info in lld" before "linking debug info in dsymutil".

This optimized behavior could not be tested with dsymutil, since dsymutil is not ready to work with a non-linked binary.

But, we could test this functionality from lld.

Changes to code in the llvm/ repository should generally be tested that repository - not only by tests in another project like lld.

I agree. Having unit-tests for old dsymutil functionality and for this new functionality would be good. I am OK to do them.
Though, if that is possible, I would prefer to make them later and integrate together with related functionality.
This concrete change does not add new functionality. It only changes interface and this change is tested by existing dsymutil tests.
If that is not OK for current moment - I would start to work on creating set of unit-tests.

[dblaikie]

In D76085#1922182, @avl wrote:

Memory objects:
source debug info sections.
NON-optimized debug info sections.

I'm not sure where this ^ happens in the scenario list you describe above.

it happens at point 3. "lld resolves relocations and generates contents of output sections."
the result of this step would be non-optimized debug info section with resolved relocations(*).
this result should be later passed to dsymutil if we speak about standard dsymutil scenario.

But in the dsymutil scenario, debug info is not linked into the executable - so there would be no "non-optimized linked debug info sections". So I'm still confused here.

And is this fundamentally necessary for the llvm-dsymutil functionality,
but not needed for lld? Or is this an improvement that could be made
(& tested) in llvm-dsymutil independently/prior to the lld work?

Yes. This is fundamentally necessary for dsymutil functionality.
dsymutil gets on the input - debug map(which maps symbol addresses in the object file and their linked addresses in binary)
and linked binary. So to preserve dsymutil behavior, we need to create the same input: debug map and linked binary.

Why does dsymutil need the linked binary? Isn't the debug map sufficient? & couldn't a similar mapping be produced part-way through linking inside lld?

But for "debug info linking" in general, it is not necessary to have linked binary and debug map.
All information available in lld before output sections are linked and generated.
As soon as the linker built liveness information for the sections, the debug info could be optimized/linked.
As a result, when lld would resolve relocations and generate output - the size of generated sections would be smaller than in (*).
That possibility is the advantage of "linking debug info in lld" before "linking debug info in dsymutil".

This optimized behavior could not be tested with dsymutil, since dsymutil is not ready to work with a non-linked binary.

But, we could test this functionality from lld.

Changes to code in the llvm/ repository should generally be tested that repository - not only by tests in another project like lld.

I agree. Having unit-tests for old dsymutil functionality and for this new functionality would be good.

Since dsymutil is in the llvm subproject it's not necessary to re-test its functionality at the unit level, though it can be handy to write unit tests for more targeted testing that might be hard to reach via end-to-end testing using llvm-dsymutil itself.
For the new functionality, it should be tested in the llvm subproject /somewhere/ when it's added - testing it only in lld is insufficient (because it would be easy for llvm developers to regress/break the functionality as they aren't required to test all other subprojects for their changes).

I am OK to do them.
Though, if that is possible, I would prefer to make them later and integrate together with related functionality.
This concrete change does not add new functionality.

What would add new functionality? If by new functionality you mean new user-visible functionality in some llvm installed executable (like lld or llvm-dsymutil) then, yes, one can write lots of untested code that adds no new functionality, until it does - when that new code is finally called from some production binary. The problem with only testing once that functionality surfaces into a binary is that we'll lose track of what all the new code is taht now needs testing - it's best to add testing as the behavior is implemented in the code.

It only changes interface and this change is tested by existing dsymutil tests.
If that is not OK for current moment - I would start to work on creating set of unit-tests.

[avl]

But in the dsymutil scenario, debug info is not linked into the executable - so there would be no "non-optimized linked debug info sections". So I'm still confused here.

Right. I had in mind the current behavior of LLD - it has a final stage where output generated and relocations resolved for all sections. Since we need linked addresses, we need to execute that stage. As a result, the output would be generated for all sections(.text and .debug_info).

But that behavior could be changed. Debug info sections could be handled separately in two steps. lld could link non-debug sections first, then generate debug map, optimize debug info sections and finally link debug info sections.

Doing that way would avoid "NON-optimized debug info sections." generation.

Thus the only additional thing would be the generation of debug map.

Why does dsymutil need the linked binary? Isn't the debug map sufficient? & couldn't a similar mapping be produced part-way through linking inside lld?

debug map could be produced by lld.
Though it would be an additional step. That step could be avoided if DWARFLinker becomes to work with sectioned addresses.

The problem with only testing once that functionality surfaces into a binary is that we'll lose track of what all the new code is taht now needs testing - it's best to add testing as the behavior is implemented in the code.

I planned to add tests with code which would use sectioned addresses.
I will add it now, If making DWARFLinker to work with sectioned addresses is OK in general.

[dblaikie]

In D76085#1922838, @avl wrote:

But in the dsymutil scenario, debug info is not linked into the executable - so there would be no "non-optimized linked debug info sections". So I'm still confused here.

Right. I had in mind the current behavior of LLD - it has a final stage where output generated and relocations resolved for all sections. Since we need linked addresses, we need to execute that stage.

I assume LLD has to figure out the final locations of things before it actually generates the output and resolves relocations (I mean, during generating the output it could then compute the final locations - but I think the final locations would be known and /then/ those sections would all be written to the output file).

As a result, the output would be generated for all sections(.text and .debug_info).

But that behavior could be changed. Debug info sections could be handled separately in two steps. lld could link non-debug sections first, then generate debug map, optimize debug info sections and finally link debug info sections.

Doing that way would avoid "NON-optimized debug info sections." generation.

Thus the only additional thing would be the generation of debug map.

If by "debug map" you mean a literal file, or file in memory - I think that could reasonably be avoided & changes to DWARFLinker to support an API-level description of the semantic contents of the debug map ("this address/section ended up at this final addresS" sort of info) would be quite reasonable.

Why does dsymutil need the linked binary? Isn't the debug map sufficient? & couldn't a similar mapping be produced part-way through linking inside lld?

debug map could be produced by lld.
Though it would be an additional step. That step could be avoided if DWARFLinker becomes to work with sectioned addresses.

The problem with only testing once that functionality surfaces into a binary is that we'll lose track of what all the new code is taht now needs testing - it's best to add testing as the behavior is implemented in the code.

I planned to add tests with code which would use sectioned addresses.
I will add it now, If making DWARFLinker to work with sectioned addresses is OK in general.

[avl]

If by "debug map" you mean a literal file, or file in memory - I think that could reasonably be avoided & changes to DWARFLinker to support an API-level description of the semantic contents of the debug map ("this address/section ended up at this final addresS" sort of info) would be quite reasonable.

But even if that map would be done as API-level description - this map would require time to be build and memory to be kept. Wouldn`t it be good if we are able to not do it?

[dblaikie]

In D76085#1926829, @avl wrote:

If by "debug map" you mean a literal file, or file in memory - I think that could reasonably be avoided & changes to DWARFLinker to support an API-level description of the semantic contents of the debug map ("this address/section ended up at this final addresS" sort of info) would be quite reasonable.

But even if that map would be done as API-level description - this map would require time to be build and memory to be kept. Wouldn`t it be good if we are able to not do it?

I'm not sure I understand the alternative - are you picturing doing the DWARF reduction and updating relocations and then feeding the reduced but unrelocated DWARF into lld's linking step?

The debug map seems like it should be the same data structure that would be used for applying relocations anyway - is it not? I'd be surprised if it was significantly different/new cost to have that data available for the DWARF linking as it would be for the relocation application.

[avl]

I'm not sure I understand the alternative - are you picturing doing the DWARF reduction and updating relocations and then feeding the reduced but unrelocated DWARF into lld's linking step?

yes. I planned to do in that way.

1. Do DWARF reduction. (Do not patch DWARF address values(LowPC, HighPC...) as dsymutil usually does, fix relocations in-sections offsets)
2. Go through usual linking process which would resolve relocations and put proper address values.

The debug map seems like it should be the same data structure that would be used for applying relocations anyway - is it not? I'd be surprised if it was significantly different/new cost to have that data available for the DWARF linking as it would be for the relocation application.

I would check it more. If all necessary info could be produced from the single relocation(without preliminary gathering data and creating additional maps) then - yes, it is cheap.

[dblaikie]

In D76085#1927241, @avl wrote:

I'm not sure I understand the alternative - are you picturing doing the DWARF reduction and updating relocations and then feeding the reduced but unrelocated DWARF into lld's linking step?

yes. I planned to do in that way.

1. Do DWARF reduction. (Do not patch DWARF address values(LowPC, HighPC...) as dsymutil usually does, fix relocations in-sections offsets)
2. Go through usual linking process which would resolve relocations and put proper address values.

While these are understandably different situations, keeping them similar seems like there's some value - so I'd be inclined to encourage you to see if there's a way to make the lld situation more like the llvm-dsymutil situation (where the DWARF reduction also applies relocations, essentially) or potentially make the llvm-dsymutil situation more like lld (could be useful to reuse pieces of lld that make for efficient section rewriting, etc, to improve llvm-dsymutil/share more code there).

Certainly llvm-dwp would probably benefit from being rephrased in terms of lld functionality (as binutils dwp uses some of gold's infrastructure - though admittedly not a lot, in part because dwp doesn't need to apply relocations, for instance).

The debug map seems like it should be the same data structure that would be used for applying relocations anyway - is it not? I'd be surprised if it was significantly different/new cost to have that data available for the DWARF linking as it would be for the relocation application.

I would check it more. If all necessary info could be produced from the single relocation(without preliminary gathering data and creating additional maps) then - yes, it is cheap.

I think that'd be worthwhile to investigate/understand.

[avl]

While these are understandably different situations, keeping them similar seems like there's some value - so I'd be inclined to encourage you to see if there's a way to make the lld situation more like the llvm-dsymutil situation (where the DWARF reduction also applies relocations, essentially) or potentially make the llvm-dsymutil situation more like lld (could be useful to reuse pieces of lld that make for efficient section rewriting, etc, to improve llvm-dsymutil/share more code there).

Certainly llvm-dwp would probably benefit from being rephrased in terms of lld functionality (as binutils dwp uses some of gold's infrastructure - though admittedly not a lot, in part because dwp doesn't need to apply relocations, for instance).

Agreed. It would be good if DWARFLinker would use the same handling for both dsymutil and lld.

I think that'd be worthwhile to investigate/understand.

I prototyped this scheme - DWARF reduction is done in lld after addresses assigned, but before output sections are generated; DWARF reduction also applies relocations; DebugMap information created from relocations: It is equally cheap. It does not need additional time and memory for creating DebugMap.

So from the point of required resources and performance : both schemes are equal.

But this patch is still necessary. The problem is that in darwin case -ffunction-sections does nothing. And address ranges do not clash. Thus following code is working:

auto LowPc = dwarf::toAddress(DIE.find(dwarf::DW_AT_low_pc));

Ranges[*LowPc] = ObjFileAddressRange(*HighPc, MyInfo.AddrAdjust);

But in linux case all address ranges start from 0(in -ffunction-sections case). So above code would not work.
It is necessary to add SectionIndex to have possibility to differentiate address ranges.

So, I am going to add unit tests to this patch...

[dblaikie]

In D76085#1931600, @avl wrote:

While these are understandably different situations, keeping them similar seems like there's some value - so I'd be inclined to encourage you to see if there's a way to make the lld situation more like the llvm-dsymutil situation (where the DWARF reduction also applies relocations, essentially) or potentially make the llvm-dsymutil situation more like lld (could be useful to reuse pieces of lld that make for efficient section rewriting, etc, to improve llvm-dsymutil/share more code there).

Certainly llvm-dwp would probably benefit from being rephrased in terms of lld functionality (as binutils dwp uses some of gold's infrastructure - though admittedly not a lot, in part because dwp doesn't need to apply relocations, for instance).

Agreed. It would be good if DWARFLinker would use the same handling for both dsymutil and lld.

I think that'd be worthwhile to investigate/understand.

I prototyped this scheme - DWARF reduction is done in lld after addresses assigned, but before output sections are generated; DWARF reduction also applies relocations; DebugMap information created from relocations: It is equally cheap. It does not need additional time and memory for creating DebugMap.

So from the point of required resources and performance : both schemes are equal.

But this patch is still necessary. The problem is that in darwin case -ffunction-sections does nothing. And address ranges do not clash. Thus following code is working:

auto LowPc = dwarf::toAddress(DIE.find(dwarf::DW_AT_low_pc));

Ranges[*LowPc] = ObjFileAddressRange(*HighPc, MyInfo.AddrAdjust);

But in linux case all address ranges start from 0(in -ffunction-sections case). So above code would not work.
It is necessary to add SectionIndex to have possibility to differentiate address ranges.

So, I am going to add unit tests to this patch...

Sounds good (& FWIW, even without function-sections, inline functions, and function template implicit specializations also end up in their own sections, etc (or you might've put functions in sections explicitly with attribute((section("..."))) attribute)) - thankss for all the due diligence and explanation!

[avl]

addressed comments: added unit test for compile unit addresses ranges.
(I put the unit test into the unittests/DebugInfo/DWARF/ instead of
separate unittests/DWARFLinker, since unittests/DebugInfo/DWARF
already has an implementation of DwarfGenerator for unit tests).

[avl]

@dblaikie David, Does added unit test do what you`ve asked for?

[dblaikie]

@aprantl Would probably prefer one of you folks more familiar with dsymutil/DWARFLinker to do final review on this

llvm/lib/DWARFLinker/DWARFLinker.cpp

1035–1048

What happened here? (is this change related/necessary for the rest of this patch)

1097–1102

Skip unnecessary refactors (if this is unnecessary)

1636

(similarly - best to leave out changes that aren't related to this patch, if that's the case here)

1657

Is this change motivated by/necessary/related to the rest of this patch? If not, best to leave it out.

llvm/lib/DWARFLinker/DWARFLinkerCompileUnit.cpp

138–146

Probably commit the "this->" removal as a separate patch (no need to send that for review) to keep this change on-topic.

llvm/tools/dsymutil/DwarfLinkerForBinary.h

118

Why the change in () here?

llvm/tools/dsymutil/DwarfStreamer.cpp

390–391 ↗

(On Diff #253714)

What's the purpose of this change?

[avl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1035–1048

I would remove this and others unrelated changes.

llvm/tools/dsymutil/DwarfLinkerForBinary.h

118

It looks like it needs explicit type conversion for braced initialization.

[avl]

addressed comments(removed unrelated refactorings).

[avl]

ping.

[avl]

ping.

[avl]

@JDevlieghere @clayborg @aprantl Could you take a look at this review, please ?

[clayborg]

Sorry about the delay, I had comments on this but I never submitted them!...

Structure is good. Just a few nits about cleaning up using std::numeric_limits<uint64_t>::max() and -1ULL for max address and cleaning the code up by not having multiple locations that are implementing SectionAddress::contains() and SectionAddress::operator <= manually.

llvm/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h

107

Remove whitespace only change.

llvm/lib/DWARFLinker/DWARFLinker.cpp

451

do we need to use dwarf::toSectionedAddress() and verify sections are the same?

1033–1034

Can we make a constexpr MAX_ADDR or INVALID_ADDR for the max address and use it here instead of std::numeric_limits<uint64_t>::max() being inlined everywhere?

1036–1038

constexpr MAX_ADDR or INVALID_ADDR

1097–1100

constexpr MAX_ADDR or INVALID_ADDR

1473–1474

constexpr MAX_ADDR or INVALID_ADDR and do we need to use dwarf::toSectionedAddress() now?

1473–1475

use dwarf::toSectionedAddress here? We don't want to assume anything about the low PC section here do we?

1477–1478

constexpr MAX_ADDR or INVALID_ADDR

1498–1502

This code would be much cleaner if we add a SectionedAddress::contains() method.

1627–1630

If we had a object::SectionAddressRange this code would look a lot cleaner:

if (!CurrRange.contains(Row.Address) || (Row.Address.Address == CurrRange.stop().Address && !Row.EndSequence))

1634

constexpr MAX_ADDR or INVALID_ADDR

1637–1638

This code would be much cleaner if we add a SectionedAddress::operator <=() method.

1640

constexpr MAX_ADDR or INVALID_ADDR

1652–1653

This code would be much cleaner if we add a SectionedAddress::operator <=() method.

1657

constexpr MAX_ADDR or INVALID_ADDR

llvm/lib/DWARFLinker/DWARFStreamer.cpp

303–305

This code would be much cleaner if we add a SectionedAddress::contains() method.

[avl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1473–1474

We do not need to have SectionedAddress here. LowPc/Unit.getLowPc() is a property of Compile unit. We could not have values pointing to different sections here. And Unit.getLowPc() is recalculated in terms of resulting binary address :

LowPc = std::min(*LowPc, FuncLowPc.Address + PcOffset);

[avl]

addressed comments(added Optional values, added contains function for interval).

[clayborg]

lgtm now. Probably best to have someone that worked on llvm-dsymutil do the final accept on this.

[avl]

ping.

llvm/include/llvm/DWARFLinker/DWARFLinker.h

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.
 };
 
 /// 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();
struct AttributesInfo {
       /// Names.
       DwarfStringPoolEntryRef Name, MangledName, NameWithoutTemplate;
 
       /// Offsets in the string pool.
       uint32_t NameOffset = 0;
       uint32_t MangledNameOffset = 0;
 
       /// Value of AT_low_pc in the input DIE
-      uint64_t OrigLowPc = std::numeric_limits<uint64_t>::max();
+      Optional<uint64_t> OrigLowPc;
 
       /// Value of AT_high_pc in the input DIE
-      uint64_t OrigHighPc = 0;
+      Optional<uint64_t> OrigHighPc;
 
       /// Value of DW_AT_call_return_pc in the input DIE
-      uint64_t OrigCallReturnPc = 0;
+      Optional<uint64_t> OrigCallReturnPc;
 
       /// Value of DW_AT_call_pc in the input DIE
-      uint64_t OrigCallPc = 0;
+      Optional<uint64_t> OrigCallPc;
 
       /// Offset to apply to PC addresses inside a function.
       int64_t PCOffset = 0;
 
       /// Does the DIE have a low_pc attribute?
       bool HasLowPc = false;
 
       /// Does the DIE have a ranges attribute?

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>;
+
+inline bool
+IntervalContainsAddress(const FunctionIntervals::const_iterator &Interval,
+                        const object::SectionedAddress &Address) {
+  assert(Interval.start().SectionIndex == Interval.stop().SectionIndex);
+
+  if (Interval.start().SectionIndex != Address.SectionIndex)
+    return false;
+
+  return Interval.start().Address <= Address.Address &&
+         Interval.stop().Address > Address.Address;
+}
 
 // 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)))
       HasODR = CanUseODR && (*Lang == dwarf::DW_LANG_C_plus_plus ||
public:
 
   DIEInfo &getInfo(unsigned Idx) { return Info[Idx]; }
   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); }
+  Optional<uint64_t> getLowPc() const { return LowPc; }
+  Optional<uint64_t> getHighPc() const { return HighPc; }
+  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:
   unsigned ID;
   std::vector<DIEInfo> Info; ///< DIE info indexed by DIE index.
   Optional<BasicDIEUnit> NewUnit;
   MCSymbol *LabelBegin = nullptr;
 
   uint64_t StartOffset;
   uint64_t NextUnitOffset;
 
-  uint64_t LowPc = std::numeric_limits<uint64_t>::max();
-  uint64_t HighPc = 0;
+  Optional<uint64_t> LowPc;
+  Optional<uint64_t> HighPc;
 
   /// A list of attributes to fixup with the absolute offset of
   /// a DIE in the debug_info section.
   ///
   /// The offsets for the attributes in this array couldn't be set while
   /// cloning because for cross-cu forward references the target DIE's offset
   /// isn't known you emit the reference attribute.
   std::vector<
       std::tuple<DIE *, const CompileUnit *, DeclContext *, PatchLocation>>
       ForwardDIEReferences;
 
   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/DWARFDie.h

public:
   /// In DWARF version 4 and later the high PC can be encoded as an offset from
   /// the DW_AT_low_pc. This function takes care of extracting the value as an
   /// address or offset and adds it to the low PC if needed and returns the
   /// value as an optional in case the DIE doesn't have a DW_AT_high_pc
   /// attribute.
   ///
   /// \param LowPC the low PC that might be needed to calculate the high PC.
   /// \returns an optional address value for the attribute.
-  Optional<uint64_t> getHighPC(uint64_t LowPC) const;
+  Optional<uint64_t> getHighPC(object::SectionedAddress LowPC) const;
 
   /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
   /// Returns true if both attributes are present.
   bool getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC,
                        uint64_t &SectionIndex) const;
 
   /// Get the address ranges for this DIE.
   ///

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);
   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,
unsigned DWARFLinker::DIECloner::cloneAddressAttribute(
   }
 
   if (AttrSpec.Attr == dwarf::DW_AT_low_pc) {
     if (Die.getTag() == dwarf::DW_TAG_inlined_subroutine ||
         Die.getTag() == dwarf::DW_TAG_lexical_block)
       // The low_pc of a block or inline subroutine might get
       // 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;
+      Addr = (Info.OrigLowPc ? *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())
+      if (Optional<uint64_t> LowPc = Unit.getLowPc())
+        Addr = *LowPc;
+      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;
+      if (Optional<uint64_t> HighPc = Unit.getHighPc())
+        Addr = *HighPc;
       else
         return 0;
     } 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;
+      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)
-      Addr = (Info.OrigCallReturnPc ? Info.OrigCallReturnPc : Addr) +
+      Addr = (Info.OrigCallReturnPc ? *Info.OrigCallReturnPc : Addr) +
              Info.PCOffset;
   } else if (AttrSpec.Attr == dwarf::DW_AT_call_pc) {
     // Relocate the address of a branch instruction within a call site entry.
     if (Die.getTag() == dwarf::DW_TAG_call_site)
-      Addr = (Info.OrigCallPc ? Info.OrigCallPc : Addr) + Info.PCOffset;
+      Addr = (Info.OrigCallPc ? *Info.OrigCallPc : Addr) + Info.PCOffset;
   }
 
   Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
                static_cast<dwarf::Form>(AttrSpec.Form), DIEInteger(Addr));
   return Unit.getOrigUnit().getAddressByteSize();
 }
 
 unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
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() && Unit.getHighPc())
       // Dwarf >= 4 high_pc is an size, not an address.
-    Value = Unit.getHighPc() - Unit.getLowPc();
+      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(
         "Unsupported scalar attribute form. Dropping attribute.", File,
if (ObjFile.Addresses->areRelocationsResolved() &&
                                           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().
-    AttrInfo.OrigHighPc =
-        dwarf::toAddress(InputDIE.find(dwarf::DW_AT_high_pc), 0);
+    AttrInfo.OrigHighPc = dwarf::toAddress(InputDIE.find(dwarf::DW_AT_high_pc));
     // Also store the low_pc. It might get relocated in an
     // inline_subprogram that happens at the beginning of its
     // inlining function.
-    AttrInfo.OrigLowPc = dwarf::toAddress(InputDIE.find(dwarf::DW_AT_low_pc),
-                                          std::numeric_limits<uint64_t>::max());
+    AttrInfo.OrigLowPc = dwarf::toAddress(InputDIE.find(dwarf::DW_AT_low_pc));
     AttrInfo.OrigCallReturnPc =
-        dwarf::toAddress(InputDIE.find(dwarf::DW_AT_call_return_pc), 0);
+        dwarf::toAddress(InputDIE.find(dwarf::DW_AT_call_return_pc));
   }
 
   // Reset the Offset to 0 as we will be working on the local copy of
   // the data.
   Offset = 0;
 
   const auto *Abbrev = InputDIE.getAbbreviationDeclarationPtr();
   Offset += getULEB128Size(Abbrev->getCode());
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);
+  Optional<uint64_t> OrigLowPc =
+      dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc));
   // 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)
-    UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
+  if (OrigLowPc && Unit.getLowPc())
+    UnitPcOffset = int64_t(*OrigLowPc) - *Unit.getLowPc();
+  else
+    OrigLowPc = 0;
 
   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();
 
+      object::SectionedAddress RangeListEntryStartAddress = {
+          First.StartAddress + *OrigLowPc, First.SectionIndex};
       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) {
+          !IntervalContainsAddress(CurrRange, RangeListEntryStartAddress)) {
+        CurrRange = FunctionRanges.find(RangeListEntryStartAddress);
+        if (CurrRange == InvalidRange || CurrRange == FunctionRanges.end() ||
+            !IntervalContainsAddress(CurrRange, RangeListEntryStartAddress)) {
           reportWarning("no mapping for range.", File);
           continue;
         }
       }
     }
 
-    TheDwarfEmitter->emitRangesEntries(UnitPcOffset, OrigLowPc, CurrRange,
+    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.
 /// FIXME: this could actually be done right in patchRangesForUnit,
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 ||
+        !IntervalContainsAddress(CurrRange, Row.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()
+                                 ? CurrRange.stop().Address + CurrRange.value()
                                  : -1ULL;
-      CurrRange = FunctionRanges.find(Row.Address.Address);
+      CurrRange = FunctionRanges.find(Row.Address);
       bool CurrRangeValid =
-          CurrRange != InvalidRange && CurrRange.start() <= Row.Address.Address;
+          CurrRange != InvalidRange && CurrRange.start() <= Row.Address;
       if (!CurrRangeValid) {
         CurrRange = InvalidRange;
         if (StopAddress != -1ULL) {
           // 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 <= Row.Address &&
               Range->second.HighPC >= Row.Address.Address) {
             StopAddress = Row.Address.Address + Range->second.Offset;
           }
         }
       }
       if (StopAddress != -1ULL && !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;
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?

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);
+  if (LowPc)
+    this->LowPc = std::min(*LowPc, FuncLowPc.Address + PcOffset);
+  else
+    this->LowPc = FuncLowPc.Address + PcOffset;
+  if (HighPc)
+    this->HighPc = std::max(*HighPc, FuncHighPc.Address + PcOffset);
+  else
+    this->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

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 (!(IntervalContainsAddress(
+            FuncRange, {Range.StartAddress + OrigLowPc, Range.SectionIndex})))
       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);
   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 = Unit.getLowPc() ? -*Unit.getLowPc() : 0;
   // 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;
   }
void DwarfStreamer::emitLocationsForUnit(
   uint64_t BaseAddressMarker = (AddressSize == 8)
                                    ? std::numeric_limits<uint64_t>::max()
                                    : std::numeric_limits<uint32_t>::max();
   const DWARFSection &InputSec = Dwarf.getDWARFObj().getLocSection();
   DataExtractor Data(InputSec.Data, Dwarf.isLittleEndian(), AddressSize);
   DWARFUnit &OrigUnit = Unit.getOrigUnit();
   auto OrigUnitDie = OrigUnit.getUnitDIE(false);
   int64_t UnitPcOffset = 0;
-  if (auto OrigLowPc = dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc)))
-    UnitPcOffset = int64_t(*OrigLowPc) - Unit.getLowPc();
-
+  if (auto OrigLowPc =
+          dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc))) {
+    if (Unit.getLowPc())
+      UnitPcOffset = int64_t(*OrigLowPc) - *Unit.getLowPc();
+    else
+      UnitPcOffset = int64_t(*OrigLowPc);
+  }
   SmallVector<uint8_t, 32> Buffer;
   for (const auto &Attr : Attributes) {
     uint64_t Offset = Attr.first.get();
     Attr.first.set(LocSectionSize);
     // This is the quantity to add to the old location address to get
     // the correct address for the new one.
     int64_t LocPcOffset = Attr.second + UnitPcOffset;
     while (Data.isValidOffset(Offset)) {

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

 Optional<uint64_t> DWARFDie::getRangesBaseAttribute() const {
   return toSectionOffset(find({DW_AT_rnglists_base, DW_AT_GNU_ranges_base}));
 }
 
 Optional<uint64_t> DWARFDie::getLocBaseAttribute() const {
   return toSectionOffset(find(DW_AT_loclists_base));
 }
 
-Optional<uint64_t> DWARFDie::getHighPC(uint64_t LowPC) const {
+Optional<uint64_t> DWARFDie::getHighPC(object::SectionedAddress LowPC) const {
   if (auto FormValue = find(DW_AT_high_pc)) {
-    if (auto Address = FormValue->getAsAddress()) {
+    if (auto Address = FormValue->getAsSectionedAddress()) {
       // High PC is an address.
-      return Address;
+      if (Address->SectionIndex == LowPC.SectionIndex)
+        return Address->Address;
     }
     if (auto Offset = FormValue->getAsUnsignedConstant()) {
       // High PC is an offset from LowPC.
-      return LowPC + *Offset;
+      return LowPC.Address + *Offset;
     }
   }
   return None;
 }
 
 bool DWARFDie::getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC,
                                uint64_t &SectionIndex) const {
   auto F = find(DW_AT_low_pc);
   auto LowPcAddr = toSectionedAddress(F);
   if (!LowPcAddr)
     return false;
-  if (auto HighPcAddr = getHighPC(LowPcAddr->Address)) {
+  if (auto HighPcAddr = getHighPC(*LowPcAddr)) {
     LowPC = LowPcAddr->Address;
     HighPC = *HighPcAddr;
     SectionIndex = LowPcAddr->SectionIndex;
     return true;
   }
   return false;
 }
 

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)

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
   DWARFFormValueTest.cpp
   DWARFLocationExpressionTest.cpp
+  DWARFLinkerCompileUnit.cpp
   )
 
 target_link_libraries(DebugInfoDWARFTests PRIVATE LLVMTestingSupport)

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

template <uint16_t Version, class AddrType> void TestAddresses() {
   EXPECT_FALSE((bool)OptU64);
   OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
   OptU64 = toAddress(SubprogramDieNoPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = toUnsigned(SubprogramDieNoPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
-  OptU64 = SubprogramDieNoPC.getHighPC(ActualLowPC);
+  OptU64 = SubprogramDieNoPC.getHighPC(
+      {ActualLowPC, object::SectionedAddress::UndefSection});
   EXPECT_FALSE((bool)OptU64);
   EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
 
   // Verify the that our subprogram with only a low PC value succeeds when
   // we ask for the Low PC, but fails appropriately when asked for the high PC
   // or both low and high PC values.
   auto SubprogramDieLowPC = SubprogramDieNoPC.getSibling();
   EXPECT_TRUE(SubprogramDieLowPC.isValid());
   EXPECT_EQ(SubprogramDieLowPC.getTag(), DW_TAG_subprogram);
   OptU64 = toAddress(SubprogramDieLowPC.find(DW_AT_low_pc));
   EXPECT_TRUE((bool)OptU64);
   EXPECT_EQ(OptU64.getValue(), ActualLowPC);
   OptU64 = toAddress(SubprogramDieLowPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
   OptU64 = toUnsigned(SubprogramDieLowPC.find(DW_AT_high_pc));
   EXPECT_FALSE((bool)OptU64);
-  OptU64 = SubprogramDieLowPC.getHighPC(ActualLowPC);
+  OptU64 = SubprogramDieLowPC.getHighPC(
+      {ActualLowPC, object::SectionedAddress::UndefSection});
   EXPECT_FALSE((bool)OptU64);
   EXPECT_FALSE(SubprogramDieLowPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
 
   // Verify the that our subprogram with only a low PC value succeeds when
   // we ask for the Low PC, but fails appropriately when asked for the high PC
   // or both low and high PC values.
   auto SubprogramDieLowHighPC = SubprogramDieLowPC.getSibling();
   EXPECT_TRUE(SubprogramDieLowHighPC.isValid());
template <uint16_t Version, class AddrType> void TestAddresses() {
   OptU64 = toUnsigned(SubprogramDieLowHighPC.find(DW_AT_high_pc));
   if (SupportsHighPCAsOffset) {
     EXPECT_TRUE((bool)OptU64);
     EXPECT_EQ(OptU64.getValue(), ActualHighPCOffset);
   } else {
     EXPECT_FALSE((bool)OptU64);
   }
 
-  OptU64 = SubprogramDieLowHighPC.getHighPC(ActualLowPC);
+  OptU64 = SubprogramDieLowHighPC.getHighPC(
+      {ActualLowPC, object::SectionedAddress::UndefSection});
   EXPECT_TRUE((bool)OptU64);
   EXPECT_EQ(OptU64.getValue(), ActualHighPC);
 
   EXPECT_TRUE(SubprogramDieLowHighPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
   EXPECT_EQ(LowPC, ActualLowPC);
   EXPECT_EQ(HighPC, ActualHighPC);
 }
 

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"
+                         "  - Code:            0x00000001\n"
+                         "    Tag:             DW_TAG_compile_unit\n"
+                         "    Children:        DW_CHILDREN_yes\n"
+                         "    Attributes:\n"
+                         "debug_info:\n"
+                         "  - Length:\n"
+                         "      TotalLength:          0\n"
+                         "    Version:         4\n"
+                         "    AbbrOffset:      0\n"
+                         "    AddrSize:        8\n"
+                         "    Entries:\n"
+                         "      - AbbrCode:        0x00000001\n"
+                         "        Values:\n"
+                         "      - AbbrCode:        0x00000000\n"
+                         "        Values:\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