Emit a .debug_addr section with dsymutil

[rastogishubham]

Summary

DWARF5 has support for DW_FORM_addrx, which can be useful for space savings, but it needs a .debug_addr section to be used. dsymutil does not have the ability to emit a debug_addr section currently. This patch adds support for that

[avl]

Could you compare size of .debug_info, .debug_addr sections for clang binary with and without this patch, please?

[rastogishubham]

In D154638#4478628, @avl wrote:

Could you compare size of .debug_info, .debug_addr sections for clang binary with and without this patch, please?

Of course!

The size of a clang.dSYM debug_info section built with -gdwarf-5 without this patch is 930,375,162 Bytes or 930 MB

The size of a clang.dSYM debug_info + debug_addr section built with -gdwarf-5 with this patch is 914,086,636 Bytes or 914 MB

I would also like to note, that at the moment I am not optimizing for the addrx values, i.e. no work is done to sort the addrx values by frequency to optimize the size of the addrx values in the debug info section based on frequency, and we still get a modest 1.8% decrease in size

[avl]

In D154638#4478742, @rastogishubham wrote:

In D154638#4478628, @avl wrote:

Could you compare size of .debug_info, .debug_addr sections for clang binary with and without this patch, please?

Of course!

The size of a clang.dSYM debug_info section built with -gdwarf-5 without this patch is 930,375,162 Bytes or 930 MB

The size of a clang.dSYM debug_info + debug_addr section built with -gdwarf-5 with this patch is 914,086,636 Bytes or 914 MB

I would also like to note, that at the moment I am not optimizing for the addrx values, i.e. no work is done to sort the addrx values by frequency to optimize the size of the addrx values in the debug info section based on frequency, and we still get a modest 1.8% decrease in size

Thank you! yep, 1.8% is a good result.

How about changing DW_RLE_start_length/DW_LLE_start_length into DW_RLE_startx_length/DW_LLE_startx_length for rnglists/loclists? Or this is for another patch?

llvm/include/llvm/DWARFLinker/DWARFLinker.h

100

add a Doxygen comment, please.

642

llvm coding standard suggests to use SmallVector instead std::vector. https://llvm.org/docs/CodingStandards.html#c-standard-library

llvm/lib/DWARFLinker/DWARFLinker.cpp

1393

probably it would make sense to hide this code under method of DebugAddrPool?

uint64_t DebugAddrPool::getAddrIndex ( uint64_t Addr ) {
   DenseMap<uint64_t, uint64_t>::iterator It = AddrPool.AddrIndexMap.find(Addr);

    if (It == AddrPool.AddrIndexMap.end()) {
      AddrPool.Addrs.push_back(*Addr);
      It = AddrPool.AddrIndexMap.insert(std::make_pair(Addr, AddrPool.Addrs.size()).first;
    }

    return It.second;
}

1400

assuming DebugAddrPool::getAddrIndex exist:

DIEInteger(AddrAttribute->getForm() == dwarf::DW_FORM_addr
               ? *Addr 
               :  DebugAddrPool::getAddrIndex(*Addr));

2579

probably, the dwarf::DW_AT_addr_base should be updated here with the proper offset to .debug_addr section.

2725

It looks like AddrIndexMap&Addrs may be local for compile unit. i.e., not necessary to make them global.

llvm/lib/DWARFLinker/DWARFStreamer.cpp

278

it seems AddrSectionSize should be updated here.

[rastogishubham]

@avl

How about changing DW_RLE_start_length/DW_LLE_start_length into DW_RLE_startx_length/DW_LLE_startx_length for rnglists/loclists? Or this is for another patch?

This patch just adds the functionality to emit the debug_addr section, I will work on future patches to use the indirections in the other sections

[tschuett]

llvm::ArrayRef<uint64_t> is more common than const std::vector<uint64_t> & in the codebase.

[rastogishubham]

Addressed review comments:

1. Added a Doxygen comment for void emitAddrs

2. Replaced std::vector usage with SmallVector

3. Created function DebugAddrPool:: getAddrIndex to keep track of Addresses in a Compile Unit

4. Removed global AddrIndexMap and Addrs

llvm/include/llvm/DWARFLinker/DWARFLinker.h

642

I was just being consistent because DIECloner::DIECloner() takes a std::vector<std::unique_ptr<CompileUnit>> &CompileUnits, maybe that should be changed to?

llvm/lib/DWARFLinker/DWARFLinker.cpp

2579

Correct me if I am wrong, but there doesn't seem to be a way to modify the value of an attribute in the die after it has already been set right?

[avl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

138

nit: move this definition close to emitDwarfDebugAddrFooter so that methods emitting DebugAddr were defined together, please.

642

yes, I think it(replacing std::vector with SmallVector for CompileUnits) would be good. But with separate cleanup patch.

832

add Doxigen comment please.

llvm/lib/DWARFLinker/DWARFLinker.cpp

1396

probably, to not check for AttrSpec.Form == dwarf::DW_FORM_addr twice we can use early return pattern?

if (AttrSpec.Form == dwarf::DW_FORM_addr) {
  Die.addValue(DIEAlloc, AttrSpec.Attr, AttrSpec.Form, DIEInteger(*Addr));
  return Unit.getOrigUnit().getAddressByteSize();
}

Die.addValue(DIEAlloc, AttrSpec.Attr, AttrSpec.Form, DIEInteger(AddrPool.getAddrIndex(*Addr)));
return AttrSize;

Another thing, as we generate a new .debug_addr section, its size may be changed and original strictly sized forms (f.e. DW_FORM_addrx1) may become insufficient. On the other side, as we usually only remove addresses everything should be fine. It is probably worth adding an assertion here checking that AddrPool.getAddrIndex(*Addr) fits into the original form. f.e.

assert ((AttrSpec.Form == dwarf::DW_FORM_addrx1 && AddrPool.getAddrIndex(*Addr) <= UINT8_MAX)
            || other cases

1659

as it matches with default we can just remove this case.

2571

No need to do clear() as AddrPool is local for DIECloner.

2579

The cloned value of DW_AT_addr_base may be incorrect as we generate new .debug_addr, so it should be updated. It may be changed inside DWARFLinker::emitDebugAddrSection() the same way as DW_AT_stmt_list is updated inside DIECloner::generateLineTableForUnit():

static void patchStmtList(DIE &Die, DIEInteger Offset) {
  for (auto &V : Die.values())
    if (V.getAttribute() == dwarf::DW_AT_stmt_list) {
      V = DIEValue(V.getAttribute(), V.getForm(), Offset);
      return;
    }

  llvm_unreachable("Didn't find DW_AT_stmt_list in cloned DIE!");
}

[avl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

101

nit: move this definition close to emitDwarfDebugAddrFooter so that methods emitting DebugAddr were defined together, please.

probably name them using the same pattern:

emitDwarfDebugAddrsHeader
emitDwarfDebugAddrs
emitDwarfDebugAddrsFooter

[avl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1996

one more nit: probably it would be better to make DWARFLinker::emitDebugAddrSection to be method of DIECloner as everything seems to be DIECloner local.

also, moving check for DWARF version inside emitDebugAddrSection will make DIECloner::cloneAllCompileUnits look simpler:

if (DwarfVersion < 5)
  return;

[rastogishubham]

Patched the addr_base value, moved functions for emitting Addr section header, footer, and the section to be together, and used the same naming scheme as the other sections, and resolved nitpicks

[rastogishubham]

Added assert to make sure the index value fits within the give addrx form

[avl]

yep, thank you for the update.

Would you mind adding test for DW_AT_addr_base, please ? i.e. test having f.e. 3 compile units and testing that each DW_AT_addr_base attribute points to the proper part of .debug_addr section. Also, it looks like all(or probably most of) existing dwarf5 tests need adding checks for DW_AT_addr_base.

llvm/include/llvm/DWARFLinker/DWARFLinker.h

149

643

This field is not used. we can safely remove it.

647

We do not need to use this method it can be removed.

707

No need to pass AddrSecSize as a parameter. We already have it inside.

llvm/include/llvm/DWARFLinker/DWARFStreamer.h

113

llvm/lib/DWARFLinker/DWARFLinker.cpp

1402

it looks like this constant is not correct:

UINT16_MAX + UINT8_MAX

The proper one would be:

(UINT32_MAX >> 8)

2027

Original version of patch had a check for "-u" option. I think we still need it here. Also no need to remember and store AddrSecSize:

if (LLVM_UNLIKELY(Options.Update))
  return;

if (DwarfVersion < 5)
  return;

MCSymbol *EndLabel = Emitter->emitDwarfDebugAddrsHeader(Unit);

patchAddrBase(*Unit.getOutputUnitDIE(), DIEInteger(Emitter->getDebugAddrSectionSize()));

Emitter->emitDwarfDebugAddrs(Addrs, Unit.getOrigUnit().getAddressByteSize());
Emitter->emitDwarfDebugAddrsFooter(Unit, EndLabel);

2548

AddrSectionSize could be removed.

2596

No need to clear AddrPool as it is local to DIECloner.

llvm/lib/DWARFLinker/DWARFStreamer.cpp

612

No need to check the version again. It is already checked in DIECloner::emitDebugAddrSection().

641

655

No need to check the version again. It is already checked in DIECloner::emitDebugAddrSection().

[rastogishubham]

1. Changed assert from UINT16_MAX + UINT8_MAX to UINT32_MAX >> 8

2. Fixed some doxygen comments

3. Removed Index and clear from DebugAddrPool

4. Removed AddrSecSize parameter

5. Added check for -u option in emitDebugAddrSection

5. Removed AddrPool.clear() from cloneAllCompileUnits

6. Removed dwarf version checks where unnecessary

7. Added a test for DW_AT_addr_base and updated dwarf5 tests to check for that attribute as well wherever appropriate

[avl]

Thanks for changes,

there are failures during pre-integration testing. They need to be fixed before integration of this patch. I think the problem could probably be fixed by adding check for empty addresses into the DIECloner::emitDebugAddrSection():

if (Addrs.empty())
  return;

llvm/include/llvm/DWARFLinker/DWARFLinker.h

707

No need to pass Addrs as AddrPool is a member of DIECloner.

llvm/test/tools/dsymutil/ARM/dwarf5-addr_base.test

2

50

add a check for "-u" case, please.

[JDevlieghere]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1393–1405

Let's extract AddrPool.getAddrIndex(*Addr) and assign it to a variable that you can reuse in the assert. Also, is the assert actually checking internal consistency or catching invalid DWARF? If it's the latter we should emit an error/warning instead.

2011

Similar question as for the assert: is this checking internal consistency (i.e. that we have created a DW_AT_addr_base in the cloned DIE) or can this trip for invalid input?

[avl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1393–1405

The purpose for the assert is to check internal consistency - newly generated addresses set should fit within the used form. We use original form for the newly generated addresses set as we assume that we do not add addresses and then original form should be enough. The assert proves this assumption.

2011

This is also should be check for internal consistency: We should not miss DW_AT_addr_base when we generate .debug_addr. The patchAddrBase is called from DIECloner::emitDebugAddrSection, thus we check for DW_AT_addr_base exactly when we are going to generate .debug_addr. The only problem with current implementation is this check will fail when original DWARF does not have .debug_addr but we call emitDebugAddrSection for generation of empty .debug_addr. The check for empty addresses set needs to be added into emitDebugAddrSection.

For the case of invalid DWARF(DW_AT_addr_base missed in input file) - we should not generate any addresses as we could not correctly read original addresses. DWARFLinker should report warning here and do not generate any address:

DIECloner::cloneAddressAttribute

std::optional<uint64_t> Addr = AddrAttribute->getAsAddress();
if (!Addr) {
  Linker.reportWarning("Cann't read address attribute value.", ObjFile);
  Addr = 0;
}

Though, this place looks a bit incorrect. Instead of using zero Addr, the attribute should probably be skipped.

[rastogishubham]

Addressed review comments

llvm/lib/DWARFLinker/DWARFLinker.cpp

1393–1405

It is checking internal consistency.

2011

This one can trip for invalid input, if the input dwarf doesn't have an addr base, then the cloned die would not either.

[rastogishubham]

llvm/test/tools/dsymutil/ARM/dwarf5-addr_base.test

50

I am not sure what should happen in a -u case

Should the DW_AT_addr_base be patched in a -u case? It doesn't get patched now

[rastogishubham]

llvm/lib/DWARFLinker/DWARFLinker.cpp

2011

DW_AT_addr_base is of form DW_FORM_sec_offset, so it will call DWARFLinker::DIECloner::cloneScalarAttribute(, are you suggesting that I add a warning there if there is no addr_base found?

[avl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

704–705

llvm/lib/DWARFLinker/DWARFLinker.cpp

2011

No, I do not suggest to add warning into DWARFLinker::DIECloner::cloneScalarAttribute which would report if DW_AT_addr_base is invalid.

My suggestion is to - not create address attributes if input DW_AT_addr_base is invalid. If DW_AT_addr_base is invalid then it is not possible to read input addresses correctly. Instead of using zero or dummy value for the address attribute, it would be better to skip it .For that purpose we have AddrAttribute->getAsAddress() to be optional. If the DW_AT_addr_base is invalid it should return std::nullopt. So we can skip address attribute and report a warning inside DIECloner::cloneAddressAttribute().

Another thing is that it would be better to not report_fatal_error here. This is the place where an output DWARF is emitted. It looks too late to validate and report errors for input DWARF. At this point we need to have llvm_unreachable() indicating that generated DWARF is inconsistent.

In short:

1. I think we need to change(with separate patch) the code in DIECloner::cloneAddressAttribute into this:

std::optional<uint64_t> Addr = AddrAttribute->getAsAddress();
if (!Addr) {
  Linker.reportWarning("Cann't read address attribute value.", ObjFile);
  return 0;
}

• 2. use llvm_unreachable() here to indicate that required DW_AT_addr_base is not generated.

llvm/test/tools/dsymutil/ARM/dwarf5-addr_base.test

50

For -u case we need to check that generated DWARF is exactly the same as input DWARF. That DW_AT_addr_base is presented with correct value, that indexed addresses are used, that .debug_addr contains proper values.

[avl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

2011

My suggestion is to - not create address attributes if input DW_AT_addr_base is invalid.

one thing to clarify - if all address attributes are skipped because DW_AT_addr_base is missed then we do not need to generate .debug_addr and then it is not a problem that DW_AT_addr_base is missed.

[aprantl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1398

This is the first time I'm reading through the patch, so I might be missing something: Since the address pool is growing as we are processing multiple object files, shouldn't we dynamically decide on the FORM based on the value of AddrIndex? Or is this happening elsewhere already?

llvm/lib/DWARFLinker/DWARFStreamer.cpp

619

Nit: Emit

624

Emit version.

[rastogishubham]

Fixed some comments

instead of emitting the addrx form present in the compile unit, rewrite the addrx form to use addrx1, addrx2, addrx3, addrx4, or addrx based on number of addresses

[avl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

653

Doing things that way we create many unnecessary abbreviations. f.e. for index 255 there would be used this abbreviation:

DW_TAG_subprogram 
  DW_AT_low_pc [DW_FORM_addrx1]

For index 256 there would be created new abbreviation:

DW_TAG_subprogram 
  DW_AT_low_pc [DW_FORM_addrx2]

I cann't tell whether that solution takes less space. It is necessary to measure impact of many abbreviations to the DWARF size. From one side DIE records having DW_FORM_addrx1 would take less bytes. From another side many abbreviation codes will be increased and then DIEs would take more space.

The solution from the previous version of this patch looks simpler and is OK. It is safe to just copy source form. DWARFLinker does not add new addresses for compile unit, so original form should be enough to keep address index. Just copy original form and check by assertion that everything is correct.

[avl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1398

the generated .debug_addr is local for compile unit. The number of addresses usually should not be increased for single compile unit. So we can use original form which was enough to keep source addresses.

[avl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

653

Or, as another alternative, we can always replace sized forms with DW_FORM_addrx. DW_FORM_addrx would always be enough. In many cases it would be shorter then DW_FORM_addrx3 or DW_FORM_addrx4. This is simple solution which does not increase number of abbreviations.

[aprantl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1398

Ah I see. So, sorting the addresses by frequency and merging them into a global address pool would be a future optimization.

[avl]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1398

yep. I assume that the idea of that optimization is to save space. So that most used addresses has smaller index and it would be possible to use smaller fixed sized form.

It would be interesting to measure how that optimization affects abbreviations. It should increase numbers of abbreviations and size of some DIEs(since every DIE has abbreviation number in the beggining)

[rastogishubham]

Looks like @avl is correct:
Using just addrx, the size of the debug_info + the debug_addr + debug_abbrev sections is 903,287,425 Bytes or ~903 MB
Using addrx1, addrx2, addrx3, addrx4 the size of the debug_info + debug_addr + debug_abbrev sections is 905,953,864 MB or ~906 MB

I will make it so that dsymutil only uses addrx

[rastogishubham]

Always emit the form DW_FORM_addrx in the debug_info section when using dsymutil

[rastogishubham]

Added new line at the end of dwarf5-addr_base.test

[avl]

Thank you for the update! I think it is mostly done. Please, check two small things in inline comments.

llvm/lib/DWARFLinker/DWARFLinker.cpp

1398

It would be incorrect to return size of original attribute here.
Instead we need to calculate size of DW_FORM_addrx:

unsigned NewAttrSize = Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
               dwarf::Form::DW_FORM_addrx, DIEInteger(AddrIndex))->sizeOf(OrigUnit.getFormParams());

return NewAttrSize;

llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-addresses.test

44

should not it be DW_FORM_addrx here and in following cases?

[rastogishubham]

@avl

We have to clear the AddrPool after one compile unit is processed. If we consider the following test case with the attached files:

test.o1 KBDownload

test.map162 BDownload

when using the following command:
dwarfdump -a -v test.o| less

The output looks like:

.debug_info contents:
0x00000000: Compile Unit: length = 0x0000004d, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000051)

0x0000000c: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_string]   ("by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_string]       ("GoodCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000001130)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)

0x0000002b: DW_TAG_subprogram [2] * (0x0000000c)

DW_AT_name [DW_FORM_string]     ("foo")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000001130)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref4]       (cu + 0x003e => {0x0000003e} "int")

0x0000003d: NULL

0x0000003e: DW_TAG_base_type [3] (0x0000000c)

DW_AT_name [DW_FORM_string]     ("int")

0x00000043: DW_TAG_variable [4] (0x0000000c)

DW_AT_name [DW_FORM_string]     ("var1")
DW_AT_type [DW_FORM_ref4]       (cu + 0x003e => {0x0000003e} "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addrx 0x0)

0x00000050: NULL
0x00000051: Compile Unit: length = 0x0000004d, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0031, addr_size = 0x08 (next unit at 0x000000a2)

0x0000005d: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_string]   ("by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_string]       ("BadCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000000010)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000018)

0x0000007b: DW_TAG_subprogram [2] * (0x0000005d)

DW_AT_name [DW_FORM_string]     ("foo1")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000000010)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref4]       (cu + 0x003e => {0x0000008f} "int")

0x0000008e: NULL

0x0000008f: DW_TAG_base_type [3] (0x0000005d)

DW_AT_name [DW_FORM_string]     ("int")

0x00000094: DW_TAG_variable [4] (0x0000005d)

DW_AT_name [DW_FORM_string]     ("var1")
DW_AT_type [DW_FORM_ref4]       (cu + 0x003e => {0x0000008f} "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addrx 0x0)

0x000000a1: NULL

.debug_addr contents:
0x00000000: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000001130
]
0x00000010: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000000010

Notice how the debug_addr section only has one address for each compile unit

If we use the following testcase:
llvm-project/build_ninja/bin/dsymutil -y test.map -o test.o.dSYM
dwarfdump -a -v test.o.dSYM | less
and dsymutil does not clear the AddrPool

.debug_info contents:
0x00000000: Compile Unit: length = 0x0000004b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000004f)

0x0000000c: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000009] = "GoodCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000012260)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)

0x00000024: DW_TAG_subprogram [2] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000010] = "foo")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000012260)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000036 "int")

0x00000036: DW_TAG_base_type [3] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000014] = "int")

0x0000003b: DW_TAG_variable [4] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000018] = "var1")
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000036 "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr 0x12260)

0x0000004e: NULL
0x0000004f: Compile Unit: length = 0x0000004b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000009e)

0x0000005b: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000001d] = "BadCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000001) address = 0x0000000000010010)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000018)

0x00000073: DW_TAG_subprogram [2] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000023] = "foo1")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000010010)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000085 "int")

0x00000085: DW_TAG_base_type [3] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000014] = "int")

0x0000008a: DW_TAG_variable [4] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000018] = "var1")
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000085 "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr 0x10010)

0x0000009d: NULL

.debug_addr contents:
0x00000000: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000012260
]
0x00000010: Address table header: length = 0x00000014, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000012260
0x0000000000010010
]

Notice how the debug_addr section for the second compile unit, contains the address in the first compile unit as well.

But if we clear the AddrPool

llvm-project/build_ninja/bin/dsymutil -y test.map -o test.o.dSYM
dwarfdump -a -v test.o.dSYM | less

.debug_info contents:
0x00000000: Compile Unit: length = 0x0000004b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000004f)

0x0000000c: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000009] = "GoodCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000012260)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)

0x00000024: DW_TAG_subprogram [2] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000010] = "foo")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000012260)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000036 "int")

0x00000036: DW_TAG_base_type [3] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000014] = "int")

0x0000003b: DW_TAG_variable [4] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000018] = "var1")
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000036 "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr 0x12260)

0x0000004e: NULL
0x0000004f: Compile Unit: length = 0x0000004b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000009e)

0x0000005b: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000001d] = "BadCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000010010)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000018)

0x00000073: DW_TAG_subprogram [2] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000023] = "foo1")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000010010)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000085 "int")

0x00000085: DW_TAG_base_type [3] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000014] = "int")

0x0000008a: DW_TAG_variable [4] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000018] = "var1")
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000085 "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr 0x10010)

0x0000009d: NULL

.debug_addr contents:
0x00000000: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000012260
]
0x00000010: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000010010
]

Notice how the debug_addr section matches the one in the object file, and doesn't contain a copy of the address from the first compile unit

[rastogishubham]

Clear AddrPool after processing a compile unit

[avl]

In D154638#4520579, @rastogishubham wrote:

@avl

We have to clear the AddrPool after one compile unit is processed. If we consider the following test case with the attached files:

test.o1 KBDownload

test.map162 BDownload

when using the following command:
dwarfdump -a -v test.o| less

The output looks like:

.debug_info contents:
0x00000000: Compile Unit: length = 0x0000004d, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000051)

0x0000000c: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_string]   ("by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_string]       ("GoodCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000001130)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)

0x0000002b: DW_TAG_subprogram [2] * (0x0000000c)

DW_AT_name [DW_FORM_string]     ("foo")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000001130)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref4]       (cu + 0x003e => {0x0000003e} "int")

0x0000003d: NULL

0x0000003e: DW_TAG_base_type [3] (0x0000000c)

DW_AT_name [DW_FORM_string]     ("int")

0x00000043: DW_TAG_variable [4] (0x0000000c)

DW_AT_name [DW_FORM_string]     ("var1")
DW_AT_type [DW_FORM_ref4]       (cu + 0x003e => {0x0000003e} "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addrx 0x0)

0x00000050: NULL
0x00000051: Compile Unit: length = 0x0000004d, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0031, addr_size = 0x08 (next unit at 0x000000a2)

0x0000005d: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_string]   ("by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_string]       ("BadCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000000010)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000018)

0x0000007b: DW_TAG_subprogram [2] * (0x0000005d)

DW_AT_name [DW_FORM_string]     ("foo1")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000000010)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref4]       (cu + 0x003e => {0x0000008f} "int")

0x0000008e: NULL

0x0000008f: DW_TAG_base_type [3] (0x0000005d)

DW_AT_name [DW_FORM_string]     ("int")

0x00000094: DW_TAG_variable [4] (0x0000005d)

DW_AT_name [DW_FORM_string]     ("var1")
DW_AT_type [DW_FORM_ref4]       (cu + 0x003e => {0x0000008f} "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addrx 0x0)

0x000000a1: NULL

.debug_addr contents:
0x00000000: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000001130
]
0x00000010: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000000010

Notice how the debug_addr section only has one address for each compile unit

If we use the following testcase:
llvm-project/build_ninja/bin/dsymutil -y test.map -o test.o.dSYM
dwarfdump -a -v test.o.dSYM | less
and dsymutil does not clear the AddrPool

.debug_info contents:
0x00000000: Compile Unit: length = 0x0000004b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000004f)

0x0000000c: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000009] = "GoodCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000012260)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)

0x00000024: DW_TAG_subprogram [2] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000010] = "foo")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000012260)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000036 "int")

0x00000036: DW_TAG_base_type [3] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000014] = "int")

0x0000003b: DW_TAG_variable [4] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000018] = "var1")
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000036 "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr 0x12260)

0x0000004e: NULL
0x0000004f: Compile Unit: length = 0x0000004b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000009e)

0x0000005b: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000001d] = "BadCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000001) address = 0x0000000000010010)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000018)

0x00000073: DW_TAG_subprogram [2] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000023] = "foo1")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000010010)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000085 "int")

0x00000085: DW_TAG_base_type [3] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000014] = "int")

0x0000008a: DW_TAG_variable [4] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000018] = "var1")
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000085 "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr 0x10010)

0x0000009d: NULL

.debug_addr contents:
0x00000000: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000012260
]
0x00000010: Address table header: length = 0x00000014, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000012260
0x0000000000010010
]

Notice how the debug_addr section for the second compile unit, contains the address in the first compile unit as well.

But if we clear the AddrPool

llvm-project/build_ninja/bin/dsymutil -y test.map -o test.o.dSYM
dwarfdump -a -v test.o.dSYM | less

.debug_info contents:
0x00000000: Compile Unit: length = 0x0000004b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000004f)

0x0000000c: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_strp] ( .debug_str[0x00000009] = "GoodCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000012260)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)

0x00000024: DW_TAG_subprogram [2] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000010] = "foo")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000012260)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000036 "int")

0x00000036: DW_TAG_base_type [3] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000014] = "int")

0x0000003b: DW_TAG_variable [4] (0x0000000c)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000018] = "var1")
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000036 "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr 0x12260)

0x0000004e: NULL
0x0000004f: Compile Unit: length = 0x0000004b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000009e)

0x0000005b: DW_TAG_compile_unit [1] *

DW_AT_producer [DW_FORM_strp]     ( .debug_str[0x00000001] = "by_hand")
DW_AT_language [DW_FORM_data2]    (DW_LANG_C_plus_plus)
DW_AT_name [DW_FORM_strp] ( .debug_str[0x0000001d] = "BadCU")
DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000010010)
DW_AT_high_pc [DW_FORM_data8]     (0x0000000000000010)
DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000018)

0x00000073: DW_TAG_subprogram [2] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000023] = "foo1")
DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000010010)
DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000085 "int")

0x00000085: DW_TAG_base_type [3] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000014] = "int")

0x0000008a: DW_TAG_variable [4] (0x0000005b)

DW_AT_name [DW_FORM_strp]       ( .debug_str[0x00000018] = "var1")
DW_AT_type [DW_FORM_ref_addr]   (0x0000000000000085 "int")
DW_AT_location [DW_FORM_exprloc]        (DW_OP_addr 0x10010)

0x0000009d: NULL

.debug_addr contents:
0x00000000: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000012260
]
0x00000010: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
Addrs: [
0x0000000000010010
]

Notice how the debug_addr section matches the one in the object file, and doesn't contain a copy of the address from the first compile unit

Right. We need to clean(), sorry. I missed the fact that DIECloner enumerates several compile units.

[rastogishubham]

Right. We need to clean(), sorry. I missed the fact that DIECloner enumerates several compile units.

Does the rest of the patch look okay?

[avl]

In D154638#4520782, @rastogishubham wrote:

Right. We need to clean(), sorry. I missed the fact that DIECloner enumerates several compile units.

Does the rest of the patch look okay?

It looks like the comment for DWARFLinker.cpp::1398 is not addressed:

It would be incorrect to return size of original attribute here.
Instead we need to calculate size of DW_FORM_addrx:

unsigned NewAttrSize = Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
               dwarf::Form::DW_FORM_addrx, DIEInteger(AddrIndex))->sizeOf(OrigUnit.getFormParams());

return NewAttrSize;

and the comment for llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-addresses.test::44

should not it be DW_FORM_addrx here and in following cases?

[rastogishubham]

Return proper size of DW_FORM_addrx, fix dwarf5-addresses.test

[rastogishubham]

Rebased on top of main

[rastogishubham]

@avl Hi Alexey, can you please let me know if this patch looks okay now? Thanks

[avl]

LGTM. Thank you for spending time on it! Please, also fix a problem with LLVM.tools/dsymutil/ARM::dwarf5-addr_base.test shown while pre-integration testing.

[rastogishubham]

@avl I think those pre-integration errors are happening because phabricator doesn't have the binaries

[avl]

In D154638#4524273, @rastogishubham wrote:

@avl I think those pre-integration errors are happening because phabricator doesn't have the binaries

phabricator has these files: Inputs/DWARF5-addr_base/
1.o
2.o
3.o

but they are of zero size. it looks like patch was created incorrectly or these files are broken.

llvm/include/llvm/DWARFLinker/DWARFLinker.h

emitAbbrevs(const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
               unsigned DwarfVersion) = 0;
 
   /// Emit the string table described by \p Pool into .debug_str table.
   virtual void emitStrings(const NonRelocatableStringpool &Pool) = 0;
 
   /// Emit the string table described by \p Pool into .debug_line_str table.
   virtual void emitLineStrings(const NonRelocatableStringpool &Pool) = 0;
 
   /// Emit DWARF debug names.
   virtual void
   emitDebugNames(AccelTable<DWARF5AccelTableStaticData> &Table) = 0;
 
   /// Emit Apple namespaces accelerator table.
   virtual void
   emitAppleNamespaces(AccelTable<AppleAccelTableStaticOffsetData> &Table) = 0;
 
   /// Emit Apple names accelerator table.
   virtual void
public:
   virtual void emitDwarfDebugRangeListFooter(const CompileUnit &Unit,
                                              MCSymbol *EndLabel) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) header.
   virtual MCSymbol *emitDwarfDebugLocListHeader(const CompileUnit &Unit) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) fragment.
   virtual void emitDwarfDebugLocListFragment(
       const CompileUnit &Unit,
       const DWARFLocationExpressionsVector &LinkedLocationExpression,
       PatchLocation Patch) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) footer.
   virtual void emitDwarfDebugLocListFooter(const CompileUnit &Unit,
                                            MCSymbol *EndLabel) = 0;
 
+  /// Emit .debug_addr header.
+  virtual MCSymbol *emitDwarfDebugAddrsHeader(const CompileUnit &Unit) = 0;
+
+  /// Emit the addresses described by \p Addrs into the .debug_addr section.
+  virtual void emitDwarfDebugAddrs(const SmallVector<uint64_t> &Addrs,
+                                   uint8_t AddrSize) = 0;
+
+  /// Emit .debug_addr footer.
+  virtual void emitDwarfDebugAddrsFooter(const CompileUnit &Unit,
+                                         MCSymbol *EndLabel) = 0;
+
   /// Emit .debug_aranges entries for \p Unit
   virtual void
   emitDwarfDebugArangesTable(const CompileUnit &Unit,
                              const AddressRanges &LinkedRanges) = 0;
 
   /// Emit specified \p LineTable into .debug_line table.
   virtual void emitLineTableForUnit(const DWARFDebugLine::LineTable &LineTable,
                                     const CompileUnit &Unit,
public:
   virtual uint64_t getDebugMacInfoSectionSize() const = 0;
 
   /// Returns size of generated .debug_macro section.
   virtual uint64_t getDebugMacroSectionSize() const = 0;
 
   /// Returns size of generated .debug_loclists section.
   virtual uint64_t getLocListsSectionSize() const = 0;
 
+  /// Returns size of generated .debug_addr section.
+  virtual uint64_t getDebugAddrSectionSize() const = 0;
+
   /// Dump the file to the disk.
   virtual void finish() = 0;
 
   /// Emit the swift_ast section stored in \p Buffer.
   virtual void emitSwiftAST(StringRef Buffer) = 0;
 
   /// Emit the swift reflection section stored in \p Buffer.
   virtual void emitSwiftReflectionSection(
private:
 
   class DIECloner {
     DWARFLinker &Linker;
     DwarfEmitter *Emitter;
     DWARFFile &ObjFile;
     OffsetsStringPool &DebugStrPool;
     OffsetsStringPool &DebugLineStrPool;
 
+    struct DebugAddrPool {
+      DenseMap<uint64_t, uint64_t> AddrIndexMap;
+      SmallVector<uint64_t> Addrs;
+
+      uint64_t getAddrIndex(uint64_t Addr) {
+        DenseMap<uint64_t, uint64_t>::iterator It = AddrIndexMap.find(Addr);
+        if (It == AddrIndexMap.end()) {
+          It = AddrIndexMap.insert(std::make_pair(Addr, Addrs.size())).first;
+          Addrs.push_back(Addr);
+        }
+        return It->second;
+      }
+
+      void clear() {
+        AddrIndexMap.clear();
+        Addrs.clear();
+      }
+
+    };
+
+    DebugAddrPool AddrPool;
+
     /// Allocator used for all the DIEValue objects.
     BumpPtrAllocator &DIEAlloc;
 
     std::vector<std::unique_ptr<CompileUnit>> &CompileUnits;
 
     /// Keeps mapping from offset of the macro table to corresponding
     /// compile unit.
     Offset2UnitMap UnitMacroMap;
DIE *cloneDIE(const DWARFDie &InputDIE, const DWARFFile &File,
                   unsigned Flags, bool IsLittleEndian, DIE *Die = nullptr);
 
     /// Construct the output DIE tree by cloning the DIEs we
     /// chose to keep above. If there are no valid relocs, then there's
     /// nothing to clone/emit.
     uint64_t cloneAllCompileUnits(DWARFContext &DwarfContext,
                                   const DWARFFile &File, bool IsLittleEndian);
 
+    /// Emit the .debug_addr section for the \p Unit.
+    void emitDebugAddrSection(CompileUnit &Unit,
+                              const uint16_t DwarfVersion) const;
+
   private:
     using AttributeSpec = DWARFAbbreviationDeclaration::AttributeSpec;
 
     /// Information gathered and exchanged between the various
     /// clone*Attributes helpers about the attributes of a particular DIE.
     struct AttributesInfo {
       /// Names.
       DwarfStringPoolEntryRef Name, MangledName, NameWithoutTemplate;
using ExpressionHandlerRef =
       function_ref<void(SmallVectorImpl<uint8_t> &, SmallVectorImpl<uint8_t> &,
                         int64_t AddrRelocAdjustment)>;
 
   /// Compute and emit debug locations (.debug_loc, .debug_loclists)
   /// for \p Unit, patch the attributes referencing it.
   void generateUnitLocations(CompileUnit &Unit, const DWARFFile &File,
                              ExpressionHandlerRef ExprHandler) const;
 
   /// Emit the accelerator entries for \p Unit.
   void emitAcceleratorEntriesForUnit(CompileUnit &Unit);
 
   /// Patch the frame info for an object file and emit it.
   void patchFrameInfoForObject(LinkContext &Context);
 
   /// FoldingSet that uniques the abbreviations.
   FoldingSet<DIEAbbrev> AbbreviationsSet;
 

llvm/include/llvm/DWARFLinker/DWARFStreamer.h

public:
 
   /// Emit debug ranges(.debug_ranges, .debug_rnglists) footer.
   void emitDwarfDebugRangeListFooter(const CompileUnit &Unit,
                                      MCSymbol *EndLabel) override;
 
   /// Emit debug locations(.debug_loc, .debug_loclists) header.
   MCSymbol *emitDwarfDebugLocListHeader(const CompileUnit &Unit) override;
 
+  /// Emit .debug_addr header.
+  MCSymbol *emitDwarfDebugAddrsHeader(const CompileUnit &Unit) override;
+
+  /// Emit the addresses described by \p Addrs into .debug_addr table.
+  void emitDwarfDebugAddrs(const SmallVector<uint64_t> &Addrs,
+                           uint8_t AddrSize) override;
+
+  /// Emit .debug_addr footer.
+  void emitDwarfDebugAddrsFooter(const CompileUnit &Unit,
+                                 MCSymbol *EndLabel) override;
+
   /// Emit debug ranges(.debug_loc, .debug_loclists) fragment.
   void emitDwarfDebugLocListFragment(
       const CompileUnit &Unit,
       const DWARFLocationExpressionsVector &LinkedLocationExpression,
       PatchLocation Patch) override;
 
   /// Emit debug ranges(.debug_loc, .debug_loclists) footer.
   void emitDwarfDebugLocListFooter(const CompileUnit &Unit,
public:
   uint64_t getDebugMacroSectionSize() const override {
     return MacroSectionSize;
   }
 
   uint64_t getLocListsSectionSize() const override {
     return LocListsSectionSize;
   }
 
+  uint64_t getDebugAddrSectionSize() const override { return AddrSectionSize; }
+
   void emitMacroTables(DWARFContext *Context,
                        const Offset2UnitMap &UnitMacroMap,
                        OffsetsStringPool &StringPool) override;
 
 private:
   inline void warn(const Twine &Warning, StringRef Context = "") {
     if (WarningHandler)
       WarningHandler(Warning, Context, nullptr);
private:
   uint64_t RngListsSectionSize = 0;
   uint64_t LocSectionSize = 0;
   uint64_t LocListsSectionSize = 0;
   uint64_t LineSectionSize = 0;
   uint64_t FrameSectionSize = 0;
   uint64_t DebugInfoSectionSize = 0;
   uint64_t MacInfoSectionSize = 0;
   uint64_t MacroSectionSize = 0;
+  uint64_t AddrSectionSize = 0;
 
   /// Keep track of emitted CUs and their Unique ID.
   struct EmittedUnit {
     unsigned ID;
     MCSymbol *LabelBegin;
   };
   std::vector<EmittedUnit> EmittedUnits;
 

llvm/lib/DWARFLinker/DWARFLinker.cpp

if (InputDIE.getTag() == dwarf::DW_TAG_compile_unit &&
     if (uint64_t HighPc = Unit.getHighPc())
       Addr = HighPc;
     else
       return 0;
   } else {
     *Addr += Info.PCOffset;
   }
 
-  switch (AttrSpec.Form) {
-  case dwarf::DW_FORM_addrx:
-  case dwarf::DW_FORM_addrx1:
-  case dwarf::DW_FORM_addrx2:
-  case dwarf::DW_FORM_addrx3:
-  case dwarf::DW_FORM_addrx4: {
-    // DWARFLinker does not use addrx forms since it generates relocated
-    // addresses. Replace DW_FORM_addrx* with DW_FORM_addr here.
-    AttrSpec.Form = dwarf::DW_FORM_addr;
-    break;
-  }
-  default:
-    // Nothing to do.
-    break;
-  }
-
+  if (AttrSpec.Form == dwarf::DW_FORM_addr) {
     Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
                  AttrSpec.Form, DIEInteger(*Addr));
     return Unit.getOrigUnit().getAddressByteSize();
   }
 
+  auto AddrIndex = AddrPool.getAddrIndex(*Addr);
+
+  return Die
+      .addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
+                dwarf::Form::DW_FORM_addrx, DIEInteger(AddrIndex))
+      ->sizeOf(Unit.getOrigUnit().getFormParams());
+}
+
 unsigned DWARFLinker::DIECloner::cloneScalarAttribute(
     DIE &Die, const DWARFDie &InputDIE, const DWARFFile &File,
     CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     unsigned AttrSize, AttributesInfo &Info) {
   uint64_t Value;
 
   // Check for the offset to the macro table. If offset is incorrect then we
   // need to remove the attribute.
   if (AttrSpec.Attr == dwarf::DW_AT_macro_info) {
     if (std::optional<uint64_t> Offset = Val.getAsSectionOffset()) {
       const DWARFDebugMacro *Macro = File.Dwarf->getDebugMacinfo();
       if (Macro == nullptr || !Macro->hasEntryForOffset(*Offset))
         return 0;
     }

 shouldSkipAttribute(bool Update,
                     DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
                     bool SkipPC) {
   switch (AttrSpec.Attr) {
   default:
     return false;
   case dwarf::DW_AT_low_pc:
   case dwarf::DW_AT_high_pc:
   case dwarf::DW_AT_ranges:
     return !Update && SkipPC;
-  case dwarf::DW_AT_addr_base:
-    // In case !Update the .debug_addr table is not generated/preserved.
-    return !Update;
   case dwarf::DW_AT_rnglists_base:
     // In case !Update the .debug_addr table is not generated/preserved.
     // Thus instead of DW_FORM_rnglistx the DW_FORM_sec_offset is used.
     // Since DW_AT_rnglists_base is used for only DW_FORM_rnglistx the
     // DW_AT_rnglists_base is removed.
     return !Update;
   case dwarf::DW_AT_str_offsets_base:
     // FIXME: Use the string offset table with Dwarf 5.
for (auto &CurLocAttr : AllLocListAttributes) {
     TheDwarfEmitter->emitDwarfDebugLocListFragment(
         Unit, LinkedLocationExpressions, CurLocAttr);
   }
 
   // Emit locations list table footer.
   TheDwarfEmitter->emitDwarfDebugLocListFooter(Unit, EndLabel);
 }
 
+static void patchAddrBase(DIE &Die, DIEInteger Offset) {
+  for (auto &V : Die.values())
+    if (V.getAttribute() == dwarf::DW_AT_addr_base) {
+      V = DIEValue(V.getAttribute(), V.getForm(), Offset);
+      return;
+    }
+
+  llvm_unreachable("Didn't find a DW_AT_addr_base in cloned DIE!");
+}
+
+void DWARFLinker::DIECloner::emitDebugAddrSection(
+    CompileUnit &Unit,
+    const uint16_t DwarfVersion) const {
+
+  if (LLVM_UNLIKELY(Linker.Options.Update))
+    return;
+
+  if (DwarfVersion < 5)
+    return;
+
+  if (AddrPool.Addrs.empty())
+    return;
+
+  MCSymbol *EndLabel = Emitter->emitDwarfDebugAddrsHeader(Unit);
+  patchAddrBase(*Unit.getOutputUnitDIE(),
+                DIEInteger(Emitter->getDebugAddrSectionSize()));
+  Emitter->emitDwarfDebugAddrs(AddrPool.Addrs, Unit.getOrigUnit().getAddressByteSize());
+  Emitter->emitDwarfDebugAddrsFooter(Unit, EndLabel);
+}
+
 /// Insert the new line info sequence \p Seq into the current
 /// set of already linked line info \p Rows.
 static void insertLineSequence(std::vector<DWARFDebugLine::Row> &Seq,
                                std::vector<DWARFDebugLine::Row> &Rows) {
   if (Seq.empty())
     return;
 
   if (!Rows.empty() && Rows.back().Address < Seq.front().Address) {
     llvm::append_range(Rows, Seq);
     Seq.clear();
     return;
   }
uint64_t DWARFLinker::DIECloner::cloneAllCompileUnits(
     DWARFContext &DwarfContext, const DWARFFile &File, bool IsLittleEndian) {
   uint64_t OutputDebugInfoSize =
       (Emitter == nullptr) ? 0 : Emitter->getDebugInfoSectionSize();
   const uint64_t StartOutputDebugInfoSize = OutputDebugInfoSize;
 
   for (auto &CurrentUnit : CompileUnits) {
     const uint16_t DwarfVersion = CurrentUnit->getOrigUnit().getVersion();
     const uint32_t UnitHeaderSize = DwarfVersion >= 5 ? 12 : 11;
     auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
     CurrentUnit->setStartOffset(OutputDebugInfoSize);
     if (!InputDIE) {
       OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
       continue;
     }
     if (CurrentUnit->getInfo(0).Keep) {
       // Clone the InputDIE into your Unit DIE in our compile unit since it
       // already has a DIE inside of it.
       CurrentUnit->createOutputDIE();
       rememberUnitForMacroOffset(*CurrentUnit);
       cloneDIE(InputDIE, File, *CurrentUnit, 0 /* PC offset */, UnitHeaderSize,
                0, IsLittleEndian, CurrentUnit->getOutputUnitDIE());
     }
 
     OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset(DwarfVersion);
 
     if (Emitter != nullptr) {
 
       generateLineTableForUnit(*CurrentUnit);
 
       Linker.emitAcceleratorEntriesForUnit(*CurrentUnit);
 
       if (LLVM_UNLIKELY(Linker.Options.Update))
         continue;
 
       Linker.generateUnitRanges(*CurrentUnit, File);
 
       auto ProcessExpr = [&](SmallVectorImpl<uint8_t> &SrcBytes,
                              SmallVectorImpl<uint8_t> &OutBytes,
                              int64_t RelocAdjustment) {
         DWARFUnit &OrigUnit = CurrentUnit->getOrigUnit();
         DataExtractor Data(SrcBytes, IsLittleEndian,
                            OrigUnit.getAddressByteSize());
         cloneExpression(Data,
                         DWARFExpression(Data, OrigUnit.getAddressByteSize(),
                                         OrigUnit.getFormParams().Format),
                         File, *CurrentUnit, OutBytes, RelocAdjustment,
                         IsLittleEndian);
       };
       Linker.generateUnitLocations(*CurrentUnit, File, ProcessExpr);
+      emitDebugAddrSection(*CurrentUnit, DwarfVersion);
     }
+    AddrPool.clear();
   }
 
   if (Emitter != nullptr) {
     assert(Emitter);
     // Emit macro tables.
     Emitter->emitMacroTables(File.Dwarf.get(), UnitMacroMap, DebugStrPool);
 
     // Emit all the compile unit's debug information.
     for (auto &CurrentUnit : CompileUnits) {
       CurrentUnit->fixupForwardReferences();
 
       if (!CurrentUnit->getOutputUnitDIE())
         continue;
if (ObjectContexts.back().File.Dwarf) {
     }
   }
 }
 
 Error DWARFLinker::link() {
   assert((Options.TargetDWARFVersion != 0) &&
          "TargetDWARFVersion should be set");
 
   // First populate the data structure we need for each iteration of the
   // parallel loop.
   unsigned NumObjects = ObjectContexts.size();
 
   // This Dwarf string pool which is used for emission. It must be used
   // serially as the order of calling getStringOffset matters for
   // reproducibility.
   OffsetsStringPool DebugStrPool(StringsTranslator, true);
   OffsetsStringPool DebugLineStrPool(StringsTranslator, false);

llvm/lib/DWARFLinker/DWARFStreamer.cpp

void DwarfStreamer::emitLineStrings(const NonRelocatableStringpool &Pool) {
   }
 }
 
 void DwarfStreamer::emitDebugNames(
     AccelTable<DWARF5AccelTableStaticData> &Table) {
   if (EmittedUnits.empty())
     return;
 
   // Build up data structures needed to emit this section.
   std::vector<MCSymbol *> CompUnits;
   DenseMap<unsigned, size_t> UniqueIdToCuMap;
   unsigned Id = 0;
   for (auto &CU : EmittedUnits) {
     CompUnits.push_back(CU.LabelBegin);
     // We might be omitting CUs, so we need to remap them.
     UniqueIdToCuMap[CU.ID] = Id++;
   }
void DwarfStreamer::emitDwarfDebugLocTableFragment(
   // Add the terminator entry.
   MS->emitIntValue(0, AddressSize);
   MS->emitIntValue(0, AddressSize);
 
   LocSectionSize += AddressSize;
   LocSectionSize += AddressSize;
 }
 
+/// Emit .debug_addr header.
+MCSymbol *DwarfStreamer::emitDwarfDebugAddrsHeader(const CompileUnit &Unit) {
+
+  // Make .debug_addr the current section.
+  MS->switchSection(MC->getObjectFileInfo()->getDwarfAddrSection());
+
+  MCSymbol *BeginLabel = Asm->createTempSymbol("Bdebugaddr");
+  MCSymbol *EndLabel = Asm->createTempSymbol("Edebugaddr");
+  unsigned AddrSize = Unit.getOrigUnit().getAddressByteSize();
+
+  // Emit length.
+  Asm->emitLabelDifference(EndLabel, BeginLabel, sizeof(uint32_t));
+  Asm->OutStreamer->emitLabel(BeginLabel);
+  AddrSectionSize += sizeof(uint32_t);
+
+  // Emit version.
+  Asm->emitInt16(5);
+  AddrSectionSize += 2;
+
+  // Emit address size.
+  Asm->emitInt8(AddrSize);
+  AddrSectionSize += 1;
+
+  // Emit segment size.
+  Asm->emitInt8(0);
+  AddrSectionSize += 1;
+
+  return EndLabel;
+}
+
+/// Emit the .debug_addr addresses stored in \p Addrs.
+void DwarfStreamer::emitDwarfDebugAddrs(const SmallVector<uint64_t> &Addrs,
+                                        uint8_t AddrSize) {
+  Asm->OutStreamer->switchSection(MOFI->getDwarfAddrSection());
+  for (auto Addr : Addrs) {
+    Asm->OutStreamer->emitIntValue(Addr, AddrSize);
+    AddrSectionSize += AddrSize;
+  }
+}
+
+/// Emit .debug_addr footer.
+void DwarfStreamer::emitDwarfDebugAddrsFooter(const CompileUnit &Unit,
+                                              MCSymbol *EndLabel) {
+
+  // Make .debug_addr the current section.
+  MS->switchSection(MC->getObjectFileInfo()->getDwarfAddrSection());
+
+  if (EndLabel != nullptr)
+    Asm->OutStreamer->emitLabel(EndLabel);
+}
+
 /// Emit piece of .debug_loclists for \p LinkedLocationExpression.
 void DwarfStreamer::emitDwarfDebugLocListsTableFragment(
     const CompileUnit &Unit,
     const DWARFLocationExpressionsVector &LinkedLocationExpression,
     PatchLocation Patch) {
   Patch.set(LocListsSectionSize);
 
   // Make .debug_loclists the current section.

llvm/test/tools/dsymutil/ARM/dummy-debug-map-amr64.map

 # This is a dummy debug map used for some tests where the contents of the
 # map are just an implementation detail. The tests wanting to use that file
 # should put all there object files in an explicitely named sub-directory
 # of Inputs, and they should be named 1.o, 2.o, ...
 # As not finding an object file or symbols isn't a fatal error for dsymutil,
 # you can extend this file with as much object files and symbols as needed.
 
 ---
 triple:          'arm64-apple-darwin'
 objects:
   - filename: 1.o
     symbols:
       - { sym: _bar, objAddr: 0x0, binAddr: 0x10000, size: 0x10 }
   - filename: 2.o
     symbols:
       - { sym: __Z3foov, objAddr: 0x0, binAddr: 0x20000, size: 0x10 }
+  - filename: 3.o
+    symbols:
+      - { sym: __Z3foov, objAddr: 0x0, binAddr: 0x30000, size: 0x10 }
 ...
 

llvm/test/tools/dsymutil/ARM/dwarf5-addr_base.test

+; This test checks to ensure that if three DWARFv5 object files have correct values for the DW_AT_addr_base in their compile units.
+
+; 1.o was produced with the source file:
+
+; a.cpp
+; __attribute__((section("1,__text_foo"))) void foo() {}
+; 
+; int foo2(int a) {
+;     return a+5;
+; }
+; 
+; int foo3(int x) {
+;     return x+2;
+; }
+; 
+; int main () {
+;     return 1;
+; }
+
+; clang -g -c -O1 a.cpp -gdwarf-5 -o 1.o
+
+; 2.o was produced with the following source file:
+
+; b.cpp
+; __attribute__((section("1,__text_foo"))) void bar() {}
+; 
+; int bar2(int a) {
+;     return a+5;
+; }
+; 
+; int bar3(int x) {
+;     return x+2;
+; }
+
+; clang -g -c -O1 b.cpp -gdwarf-5 -o 2.o
+
+; 3.o was produced with the following source file:
+
+; c.cpp
+; 
+; int baz(int x) {
+;     return x+2;
+; }
+
+; clang -g -c -O1 c.cpp -gdwarf-5 -o 3.o
+
+
+RUN: rm -rf %t.dir && mkdir -p %t.dir
+RUN: dsymutil -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-addr_base -o %t.dir/dwarf5-addr_base.dSYM
+RUN: llvm-dwarfdump %t.dir/dwarf5-addr_base.dSYM -a --verbose | FileCheck %s
+
+RUN: dsymutil --update -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-addr_base -o %t.dir/dwarf5-addr_base.dSYM
+RUN: llvm-dwarfdump %t.dir/dwarf5-addr_base.dSYM -a --verbose | FileCheck %s --check-prefix=UPD
+
+CHECK: .debug_info contents:
+CHECK-NEXT: 0x00000000: Compile Unit: length = 0x00000061, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000065)
+
+CHECK: 0x0000000c: DW_TAG_compile_unit [1] *
+CHECK:               DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
+
+CHECK: 0x00000037:   DW_TAG_subprogram [2] * (0x0000000c)
+CHECK-NEXT:                DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x[[ADDR1:[0-9a-f]+]])
+
+
+CHECK: 0x00000065: Compile Unit: length = 0x00000061, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x000000ca)
+
+CHECK: 0x00000071: DW_TAG_compile_unit [1] *
+CHECK:              DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000018)
+
+CHECK: 0x0000009c:   DW_TAG_subprogram [2] * (0x00000071)
+CHECK-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x[[ADDR2:[0-9a-f]+]])
+
+CHECK: 0x000000ca: Compile Unit: length = 0x0000005a, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000128)
+
+CHECK: 0x000000d6: DW_TAG_compile_unit [5] *
+CHECK: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000028)
+
+CHECK: 0x000000fa:   DW_TAG_subprogram [2] * (0x000000d6)
+CHECK-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x[[ADDR3:[0-9a-f]+]])
+
+CHECK: .debug_addr contents:
+CHECK-NEXT: 0x00000000: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT: Addrs: [
+CHECK-NEXT: 0x[[ADDR1]]
+CHECK-NEXT: ]
+CHECK-NEXT: 0x00000010: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT: Addrs: [
+CHECK-NEXT: 0x[[ADDR2]]
+CHECK-NEXT: ]
+CHECK-NEXT: 0x00000020: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+CHECK-NEXT: Addrs: [
+CHECK-NEXT: 0x[[ADDR3]]
+CHECK-NEXT: ]
+
+UPD: .debug_info contents:
+UPD-NEXT: 0x00000000: Compile Unit: length = 0x000000aa, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x000000ae)
+
+UPD: 0x0000000c: DW_TAG_compile_unit [1] *
+UPD:               DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
+
+UPD: 0x0000003c:   DW_TAG_subprogram [2]   (0x0000000c)
+UPD-NEXT:                DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000000018)
+
+UPD: 0x0000004e:   DW_TAG_subprogram [3] * (0x0000000c)
+UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000000000)
+
+UPD: 0x00000071:   DW_TAG_subprogram [3] * (0x0000000c)
+UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000000000008)
+
+UPD: 0x00000094:   DW_TAG_subprogram [5]   (0x0000000c)
+UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000003) address = 0x0000000000000010)
+
+
+UPD: 0x000000ae: Compile Unit: length = 0x00000098, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x0000014a)
+
+UPD: 0x000000ba: DW_TAG_compile_unit [1] *
+UPD:              DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
+
+UPD: 0x000000ea:   DW_TAG_subprogram [2]   (0x000000ba)
+UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000000018)
+
+UPD: 0x000000fc:   DW_TAG_subprogram [3] * (0x000000ba)
+UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000000000)
+
+UPD: 0x0000011f:   DW_TAG_subprogram [3] * (0x000000ba)
+UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000000000008)
+
+UPD: 0x0000014a: Compile Unit: length = 0x0000005b, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x000001a9)
+
+UPD: 0x00000156: DW_TAG_compile_unit [7] *
+UPD: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
+
+UPD: 0x0000017e:   DW_TAG_subprogram [3] * (0x00000156)
+UPD-NEXT:                 DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000000018)
+
+UPD: .debug_addr contents:
+UPD-NEXT: 0x00000000: Address table header: length = 0x00000024, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+UPD-NEXT: Addrs: [
+UPD-NEXT: 0x0000000000000018
+UPD-NEXT: 0x0000000000000000
+UPD-NEXT: 0x0000000000000008
+UPD-NEXT: 0x0000000000000010
+UPD-NEXT: ]
+UPD-NEXT: 0x00000028: Address table header: length = 0x0000001c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+UPD-NEXT: Addrs: [
+UPD-NEXT: 0x0000000000000010
+UPD-NEXT: 0x0000000000000000
+UPD-NEXT: 0x0000000000000008
+UPD-NEXT: ]
+UPD-NEXT: 0x00000048: Address table header: length = 0x0000000c, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+UPD-NEXT: Addrs: [
+UPD-NEXT: 0x0000000000000000
+UPD-NEXT: ]

llvm/test/tools/dsymutil/ARM/dwarf5-addrx-0x0-last.test

 RUN: dsymutil -oso-prepend-path %p/../Inputs %p/../Inputs/private/tmp/dwarf5/dwarf5-addrx-0x0-last.out -o %t.dSYM 2>&1 | FileCheck %s --allow-empty
 RUN: llvm-dwarfdump --verify %t.dSYM 2>&1 | FileCheck %s
 RUN: llvm-dwarfdump --verbose -debug-info %t.dSYM | FileCheck %s --check-prefix DEBUGINFO
 RUN: llvm-dwarfdump --verbose -debug-line %t.dSYM | FileCheck %s --check-prefix DEBUGLINE
 
 CHECK-NOT: error:
 
 DEBUGINFO:   DW_TAG_subprogram
-DEBUGINFO:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000100003f4c)
+DEBUGINFO:     DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000100003f4c)
 DEBUGINFO:     DW_AT_high_pc [DW_FORM_data4]   (0x00000054)
 DEBUGINFO:     DW_AT_name [DW_FORM_strp]       ( .debug_str[0x0000011c] = "main")
 
 DEBUGLINE:  0x0000000100003f4c   4   0  {{.*}}  is_stmt
 DEBUGLINE:  0x0000000100003f6c   5  17  {{.*}}  is_stmt prologue_end
 DEBUGLINE:  0x0000000100003f70   5  22  {{.*}}
 DEBUGLINE:  0x0000000100003f74   5   7  {{.*}}
 DEBUGLINE:  0x0000000100003f78   6   3  {{.*}}  is_stmt
 DEBUGLINE:  0x0000000100003f84   7   3  {{.*}}  is_stmt
 DEBUGLINE:  0x0000000100003f94   9   3  {{.*}}  is_stmt epilogue_begin
 DEBUGLINE:  0x0000000100003fa0   9   3  {{.*}}  is_stmt end_sequence

llvm/test/tools/dsymutil/ARM/dwarf5-dwarf4-combination-macho.test

 RUN: dsymutil -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5-DWARF4-combination -o %t.dir/dwarf5-dwarf4-combination-macho.dSYM
 RUN: llvm-dwarfdump %t.dir/dwarf5-dwarf4-combination-macho.dSYM -a --verbose | FileCheck %s
 
 
 CHECK:.debug_abbrev contents:
 CHECK-NEXT: Abbrev table for offset: 0x00000000
 
 CHECK: .debug_info contents:
-CHECK: 0x00000000: Compile Unit: length = 0x00000064, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08
+CHECK: 0x00000000: Compile Unit: length = 0x00000061, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 
 CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x[[RANGELIST_OFFSET:[0-9a-f]+]]
 CHECK-NEXT:                  [0x[[RANGELIST_OFFSET_START:[0-9a-f]+]], 0x[[RANGELIST_OFFSET_END:[0-9a-f]+]]))
-CHECK: 0x00000033:   DW_TAG_subprogram [2] * (0x0000000c)
-CHECK-NEXT:  DW_AT_low_pc [DW_FORM_addr]     (0x[[#%.16x,LOCLIST_LOWPC:]])
-CHECK: 0x00000050:     DW_TAG_formal_parameter [3]   (0x00000033)
+CHECK-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
+CHECK: 0x00000037:   DW_TAG_subprogram [2] * (0x0000000c)
+CHECK-NEXT:  DW_AT_low_pc [DW_FORM_addrx]     (indexed (00000000) address = 0x[[#%.16x,LOCLIST_LOWPC:]])
+CHECK: 0x0000004d:     DW_TAG_formal_parameter [3]   (0x00000037)
 CHECK-NEXT:                   DW_AT_location [DW_FORM_sec_offset]   (0x[[LOCLIST_OFFSET:[0-9a-f]+]]: 
 CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START:]], 0x[[#%.16x,LOCLIST_PAIR_END:]]): [[LOCLIST_EXPR:.*]]
 CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START2:]], 0x[[#%.16x,LOCLIST_PAIR_END2:]]): [[LOCLIST_EXPR2:.*]])
 
-CHECK: 0x00000068: Compile Unit: length = 0x00000072, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08
+CHECK: 0x00000065: Compile Unit: length = 0x00000072, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 
 CHECK:              DW_AT_low_pc [DW_FORM_addr]       (0x[[#%.16x,RANGE_LOWPC:]])
 CHECK-NEXT:              DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
 CHECK-NEXT:                 [0x[[#%.16x,RANGE_START:]], 0x[[#%.16x,RANGE_END:]]))
-CHECK:0x0000009a:   DW_TAG_subprogram [2] * (0x00000073)
+CHECK: 0x00000097:   DW_TAG_subprogram [6] * (0x00000070)
 CHECK-NEXT:                DW_AT_low_pc [DW_FORM_addr]     (0x[[#%.16x,LOC_LOWPC:]])
-CHECK:0x000000b7:     DW_TAG_formal_parameter [3]   (0x0000009a)
+CHECK: 0x000000b4:     DW_TAG_formal_parameter [3]   (0x00000097)
 CHECK-NEXT:                  DW_AT_location [DW_FORM_sec_offset]   (0x[[LOC_OFFSET:[0-9a-f]+]]: 
 CHECK-NEXT:                     [0x[[#%.16x,LOC_PAIR_START:]], 0x[[#%.16x,LOC_PAIR_END:]]): [[LOC_EXPR:.*]]
 CHECK-NEXT:                     [0x[[#%.16x,LOC_PAIR_START2:]], 0x[[#%.16x,LOC_PAIR_END2:]]): [[LOC_EXPR2:.*]])
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: 0x[[LOC_OFFSET]]:
 CHECK-NEXT:            (0x[[#sub(LOC_PAIR_START,LOC_LOWPC)]], 0x[[#sub(LOC_PAIR_END,LOC_LOWPC)]]): [[LOC_EXPR:.*]]
 CHECK-NEXT:            (0x[[#sub(LOC_PAIR_START2,LOC_LOWPC)]], 0x[[#sub(LOC_PAIR_END2,LOC_LOWPC)]]): [[LOC_EXPR2:.*]]

llvm/test/tools/dsymutil/ARM/dwarf5-macho.test

 RUN: rm -rf %t.dir && mkdir -p %t.dir
 RUN: dsymutil -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5 -o %t.dir/dwarf5-macho.dSYM
 RUN: llvm-dwarfdump %t.dir/dwarf5-macho.dSYM -a --verbose | FileCheck %s
 
 CHECK:.debug_abbrev contents:
 CHECK-NEXT: Abbrev table for offset: 0x00000000
 
 CHECK: .debug_info contents:
-CHECK-NEXT: 0x00000000: Compile Unit: length = 0x00000064, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 
+CHECK-NEXT: Compile Unit: length = 0x00000061, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 
 CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x[[RANGELIST_OFFSET:[0-9a-f]+]]
 CHECK-NEXT:                  [0x[[RANGELIST_OFFSET_START:[0-9a-f]+]], 0x[[RANGELIST_OFFSET_END:[0-9a-f]+]]))
-CHECK: 0x00000033:   DW_TAG_subprogram [2] * (0x0000000c)
-CHECK-NEXT:  DW_AT_low_pc [DW_FORM_addr]     (0x[[#%.16x,LOCLIST_LOWPC:]])
-CHECK: 0x00000050:     DW_TAG_formal_parameter [3]   (0x00000033)
+CHECK-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
+CHECK: 0x00000037:   DW_TAG_subprogram [2] * (0x0000000c)
+CHECK-NEXT:  DW_AT_low_pc [DW_FORM_addrx]     (indexed (00000000) address = 0x[[#%.16x,LOCLIST_LOWPC:]])
+CHECK: 0x0000004d:     DW_TAG_formal_parameter [3]   (0x00000037)
 CHECK-NEXT:                   DW_AT_location [DW_FORM_sec_offset]   (0x[[LOC_OFFSET:[0-9a-f]+]]: 
 CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START:]], 0x[[#%.16x,LOCLIST_PAIR_END:]]): [[LOCLIST_EXPR:.*]]
 CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START2:]], 0x[[#%.16x,LOCLIST_PAIR_END2:]]): [[LOCLIST_EXPR2:.*]])
 
 CHECK: .debug_loclists contents:
 CHECK-NEXT: locations list header: length = 0x0000001f, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 CHECK-NEXT: 0x[[LOC_OFFSET]]: 
 CHECK-NEXT:            DW_LLE_base_address    (0x[[#LOCLIST_LOWPC]])

llvm/test/tools/dsymutil/X86/dwarf5-addrx.test

 RUN: llvm-dwarfdump --verify %t.dSYM 2>&1 | FileCheck %s
 
 RUN: llvm-dwarfdump --verbose %t.dSYM | FileCheck %s --check-prefix UPDATE-DWARF
 
 CHECK-NOT: error:
 
 DWARF: DW_TAG_compile_unit
 DWARF:   DW_AT_name [DW_FORM_strp]  {{.*}}     "dwarf5-addrx.c"
-DWARF:   DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000eb0)
+DWARF:   DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000100000eb0)
 DWARF:   DW_AT_high_pc [DW_FORM_data4]   (0x00000103)
+DWARF:   DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
 DWARF:   DW_TAG_subprogram
-DWARF:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000eb0)
+DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000100000eb0)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
 DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo1"
 DWARF:   DW_TAG_subprogram
-DWARF:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000ec0)
+DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000100000ec0)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
 DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo2"
 DWARF:   DW_TAG_subprogram
-DWARF:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000ed0)
+DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000100000ed0)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
 DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo3"
 DWARF:   DW_TAG_subprogram
-DWARF:     DW_AT_low_pc  [DW_FORM_addr]    (0x0000000100000ee0)
+DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000003) address = 0x0000000100000ee0)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
 DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo4"
 DWARF:   DW_TAG_subprogram
-DWARF:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000100000ef0)
+DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000004) address = 0x0000000100000ef0)
 DWARF:     DW_AT_high_pc  [DW_FORM_data4]  (0x00000010)
 DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo5"
 DWARF:   DW_TAG_subprogram
-DWARF:     DW_AT_low_pc  [DW_FORM_addr]    (0x0000000100000f00)
+DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000005) address = 0x0000000100000f00)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
 DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo6"
 DWARF:   DW_TAG_subprogram
-DWARF:     DW_AT_low_pc  [DW_FORM_addr]    (0x0000000100000f10)
+DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000006) address = 0x0000000100000f10)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
 DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo7"
 DWARF:   DW_TAG_subprogram
-DWARF:     DW_AT_low_pc  [DW_FORM_addr]    (0x0000000100000f20)
+DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000007) address = 0x0000000100000f20)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)
 DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo8"
 DWARF:   DW_TAG_subprogram
-DWARF:     DW_AT_low_pc  [DW_FORM_addr]    (0x0000000100000f30)
+DWARF:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000008) address = 0x0000000100000f30)
 DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000083)
 DWARF:     DW_AT_name  [DW_FORM_strp] {{.*}}   "main"
-DWARF-NOT:  .debug_addr contents
 
 UPDATE-DWARF: DW_TAG_compile_unit
 UPDATE-DWARF:   DW_AT_name [DW_FORM_strp]  {{.*}}     "dwarf5-addrx.c"
 UPDATE-DWARF:   DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000000) address = 0x0000000000000000)
 UPDATE-DWARF:   DW_AT_high_pc [DW_FORM_data4]   (0x00000103)
 UPDATE-DWARF:   DW_TAG_subprogram
 UPDATE-DWARF:     DW_AT_low_pc [DW_FORM_addrx] (indexed (00000000) address = 0x0000000000000000)
 UPDATE-DWARF:     DW_AT_high_pc [DW_FORM_data4]   (0x00000010)

llvm/test/tools/dsymutil/X86/dwarf5-dw-op-addrx.test

 #DWARF-CHECK:   DW_AT_name {{.*}}"arr7"
 #DWARF-CHECK:   DW_AT_location {{.*}}(DW_OP_addr 0x100007000)
 #DWARF-CHECK: DW_TAG_variable
 #DWARF-CHECK:   DW_AT_name {{.*}}"arr8"
 #DWARF-CHECK:   DW_AT_location {{.*}}(DW_OP_addr 0x100008000)
 #DWARF-CHECK: DW_TAG_variable
 #DWARF-CHECK:   DW_AT_name {{.*}}"arr9"
 #DWARF-CHECK:   DW_AT_location {{.*}}(DW_OP_addr 0x100009000)
-#DWARF-CHECK-NOT: .debug_addr
 
 #UPD-DWARF-CHECK: DW_TAG_compile_unit
 #UPD-DWARF-CHECK: DW_AT_name {{.*}}"dwarf5-dw-op-addrx.c"
 #UPD-DWARF-CHECK: DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000009) address = 0x0000000000000000)
 #UPD-DWARF-CHECK: DW_AT_high_pc [DW_FORM_data4]     (0x00000008)
 #UPD-DWARF-CHECK: DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
 #UPD-DWARF-CHECK: DW_TAG_variable
 #UPD-DWARF-CHECK:   DW_AT_name {{.*}}"arr"

llvm/test/tools/dsymutil/X86/dwarf5-rnglists.test

 #
 #RUN: dsymutil --update -oso-prepend-path %p/../Inputs -y %s -o %t.dSYM
 #RUN: llvm-dwarfdump --verify  %t.dSYM | FileCheck %s
 #RUN: llvm-dwarfdump -a --verbose  %t.dSYM | FileCheck %s --check-prefix UPD-DWARF-CHECK
 
 #CHECK: No errors.
 
 #DWARF-CHECK: DW_TAG_compile_unit
+#DWARF-CHECK:   DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
 #DWARF-CHECK: DW_TAG_lexical_block
 #DWARF-CHECK:   DW_AT_ranges [DW_FORM_sec_offset]     (0x0000000c
 #DWARF-CHECK:      [0x0000000100000f79, 0x0000000100000f96)
 #DWARF-CHECK:      [0x0000000100000fad, 0x0000000100000fb4))
-#DWARF-CHECK-NOT: debug_addr
 #DWARF-CHECK: .debug_rnglists contents:
 #DWARF-CHECK: 0x00000000: range list header: length = 0x0000001d, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 #DWARF-CHECK: ranges:
 #DWARF-CHECK: 0x0000000c: [DW_RLE_start_length]:  0x0000000100000f79, 0x000000000000001d => [0x0000000100000f79, 0x0000000100000f96)
 #DWARF-CHECK: 0x00000016: [DW_RLE_start_length]:  0x0000000100000fad, 0x0000000000000007 => [0x0000000100000fad, 0x0000000100000fb4)
 #DWARF-CHECK: 0x00000020: [DW_RLE_end_of_list ]
-#DWARF-CHECK-NOT: debug_addr
 #
 #UPD-DWARF-CHECK: DW_TAG_compile_unit
+#UPD-DWARF-CHECK:   DW_AT_addr_base [DW_FORM_sec_offset]      (0x00000008)
 #UPD-DWARF-CHECK: DW_TAG_lexical_block
 #UPD-DWARF-CHECK:   DW_AT_ranges [DW_FORM_rnglistx]       (indexed (0x0) rangelist = 0x00000010
 #UPD-DWARF-CHECK:     [0x0000000000000009, 0x0000000000000026)
 #UPD-DWARF-CHECK:     [0x000000000000003d, 0x0000000000000044))
 #UPD-DWARF-CHECK: .debug_addr contents:
 #UPD-DWARF-CHECK: 0x00000000: Address table header: length = 0x00000024, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
 #UPD-DWARF-CHECK: Addrs: [
 #UPD-DWARF-CHECK: 0x0000000000000000

llvm/test/tools/dsymutil/X86/op-convert-offset.test

 OBJ:                 DW_AT_encoding  (DW_ATE_unsigned)
 OBJ:                 DW_AT_byte_size (0x01)
 
 OBJ: 0x00000094:     DW_TAG_formal_parameter
 OBJ:                   DW_AT_location        (DW_OP_breg2 RCX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x0000007d) "DW_ATE_unsigned_1", DW_OP_convert (0x00000081) "DW_ATE_unsigned_8", DW_OP_stack_value)
 OBJ:                   DW_AT_name    ("b")
 OBJ:                   DW_AT_type    (0x000000af "_Bool")
 
-DSYM: 0x000000ae:   DW_TAG_base_type
+DSYM: 0x0000009a:   DW_TAG_base_type
 DSYM:                 DW_AT_name      ("DW_ATE_unsigned_1")
 DSYM:                 DW_AT_encoding  (DW_ATE_unsigned)
 DSYM:                 DW_AT_byte_size (0x01)
 
-DSYM: 0x000000d5:     DW_TAG_formal_parameter
-DSYM:                   DW_AT_location        (DW_OP_breg2 RCX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x000000ae) "DW_ATE_unsigned_1", DW_OP_convert (0x000000b5) "DW_ATE_unsigned_8", DW_OP_stack_value)
+DSYM: 0x000000ba:     DW_TAG_formal_parameter
+DSYM:                   DW_AT_location        (DW_OP_breg2 RCX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x0000009a) "DW_ATE_unsigned_1", DW_OP_convert (0x000000a1) "DW_ATE_unsigned_8", DW_OP_stack_value)
 DSYM:                   DW_AT_name    ("b")
-DSYM:                   DW_AT_type    (0x000000f3 "_Bool")
+DSYM:                   DW_AT_type    (0x000000d8 "_Bool")

llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-addresses.test

 # RUN: llvm-dwarfutil --no-garbage-collection --build-accelerator=DWARF %t.o %t1
 # RUN: llvm-dwarfdump -verify %t1 | FileCheck %s
 # RUN: llvm-dwarfdump -a --verbose %t1 | FileCheck %s --check-prefix UPD-DWARF-CHECK
 
 #CHECK: No errors.
 
 #DWARF-CHECK: DW_TAG_compile_unit
 #DWARF-CHECK:   DW_AT_name [DW_FORM_strp]  {{.*}}     "CU1"
-#DWARF-CHECK:   DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001130)
+#DWARF-CHECK:   DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000001130)
 #DWARF-CHECK:   DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000060)
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo1"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001130)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000001130)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo2"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001140)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000001140)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo3"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001150)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000000001150)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo4"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001160)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]   (indexed (00000003) address = 0x0000000000001160)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo5"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001170)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]   (indexed (00000004) address = 0x0000000000001170)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo6"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001180)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]   (indexed (00000005) address = 0x0000000000001180)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:   DW_TAG_variable
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "var1"
 #DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x2000)
 #DWARF-CHECK:   DW_TAG_variable
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "var2"
 #DWARF-CHECK:     DW_AT_location [DW_FORM_exprloc] (DW_OP_addr 0x2000)
 #DWARF-CHECK:   DW_TAG_variable

llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-rnglists.test

 # RUN: llvm-dwarfutil --no-garbage-collection --build-accelerator=DWARF %t.o %t1
 # RUN: llvm-dwarfdump -verify %t1 | FileCheck %s
 # RUN: llvm-dwarfdump -a --verbose %t1 | FileCheck %s --check-prefix UPD-DWARF-CHECK
 
 #CHECK: No errors.
 
 #DWARF-CHECK: DW_TAG_compile_unit
 #DWARF-CHECK:   DW_AT_name [DW_FORM_strp]  {{.*}}     "CU1"
-#DWARF-CHECK:   DW_AT_low_pc [DW_FORM_addr]  (0x0000000000001130) 
+#DWARF-CHECK:   DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000001130)
 #DWARF-CHECK:   DW_AT_ranges [DW_FORM_sec_offset] (0x[[CURANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:   [0x0000000000001130, 0x0000000000001170))
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo1"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001130)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000000) address = 0x0000000000001130)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:     DW_TAG_lexical_block
 #DWARF-CHECK:       DW_AT_ranges [DW_FORM_sec_offset]     (0x[[F1RANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:       [0x0000000000001130, 0x0000000000001140))
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo2"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001140)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000001) address = 0x0000000000001140)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:     DW_TAG_lexical_block
 #DWARF-CHECK:       DW_AT_ranges [DW_FORM_sec_offset]     (0x[[F2RANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:            [0x0000000000001140, 0x0000000000001150))
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo3"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001150)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000002) address = 0x0000000000001150)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:     DW_TAG_lexical_block
 #DWARF-CHECK:       DW_AT_ranges [DW_FORM_sec_offset]     (0x[[F3RANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:          [0x0000000000001150, 0x0000000000001160))
 #DWARF-CHECK:   DW_TAG_subprogram
 #DWARF-CHECK:     DW_AT_name  [DW_FORM_strp] {{.*}}   "foo4"
-#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addr]     (0x0000000000001160)
+#DWARF-CHECK:     DW_AT_low_pc [DW_FORM_addrx]    (indexed (00000003) address = 0x0000000000001160)
 #DWARF-CHECK:     DW_AT_high_pc [DW_FORM_data8]   (0x0000000000000010)
 #DWARF-CHECK:     DW_TAG_lexical_block
 #DWARF-CHECK:       DW_AT_ranges [DW_FORM_sec_offset]     (0x[[F4RANGE_OFF:[0-9a-f]*]]
 #DWARF-CHECK:          [0x0000000000001160, 0x0000000000001170))
-#DWARF-CHECK-NOT: .debug_addr contents:
 #DWARF-CHECK: .debug_aranges contents:
 #DWARF-CHECK: Address Range Header: length = 0x0000002c, format = DWARF32, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
 #DWARF-CHECK: [0x0000000000001130, 0x0000000000001170)
-#DWARF-CHECK-NOT: .debug_addr contents:
+#DWARF-CHECK: .debug_addr contents:
+#DWARF-CHECK: 0x00000000: Address table header: length = 0x00000024, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00
+#DWARF-CHECK: Addrs: [
+#DWARF-CHECK: 0x0000000000001130
+#DWARF-CHECK: 0x0000000000001140
+#DWARF-CHECK: 0x0000000000001150
+#DWARF-CHECK: 0x0000000000001160
+#DWARF-CHECK: ]
 #DWARF-CHECK: .debug_rnglists contents:
 #DWARF-CHECK: 0x00000000: range list header: length = 0x0000003f, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 #DWARF-CHECK: ranges:
 #DWARF-CHECK: 0x[[F1RANGE_OFF]]: [DW_RLE_start_length]:  0x0000000000001130, 0x0000000000000010 => [0x0000000000001130, 0x0000000000001140)
 #DWARF-CHECK: {{.*}} [DW_RLE_end_of_list ]
 #DWARF-CHECK: 0x[[F2RANGE_OFF]]: [DW_RLE_start_length]:  0x0000000000001140, 0x0000000000000010 => [0x0000000000001140, 0x0000000000001150)
 #DWARF-CHECK: {{.*}} [DW_RLE_end_of_list ]
 #DWARF-CHECK: 0x[[F3RANGE_OFF]]: [DW_RLE_start_length]:  0x0000000000001150, 0x0000000000000010 => [0x0000000000001150, 0x0000000000001160)
 #DWARF-CHECK: {{.*}} [DW_RLE_end_of_list ]
 #DWARF-CHECK: 0x[[F4RANGE_OFF]]: [DW_RLE_start_length]:  0x0000000000001160, 0x0000000000000010 => [0x0000000000001160, 0x0000000000001170)
 #DWARF-CHECK: {{.*}} [DW_RLE_end_of_list ]
 #DWARF-CHECK: 0x[[CURANGE_OFF]]: [DW_RLE_start_length]:  0x0000000000001130, 0x0000000000000040 => [0x0000000000001130, 0x0000000000001170)
 #DWARF-CHECK: {{.*}} [DW_RLE_end_of_list ]
-#DWARF-CHECK-NOT: .debug_addr contents:
 
 #UPD-DWARF-CHECK: DW_TAG_compile_unit
 #UPD-DWARF-CHECK:   DW_AT_name {{.*}}"CU1"
 #UPD-DWARF-CHECK:   DW_AT_low_pc [DW_FORM_addrx]      (indexed (00000000) address = 0x0000000000001130)
 #UPD-DWARF-CHECK:   DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x4) rangelist = 0x0000003e
 #UPD-DWARF-CHECK:      [0x0000000000001130, 0x0000000000001170))
 #UPD-DWARF-CHECK:   DW_TAG_subprogram
 #UPD-DWARF-CHECK:     DW_AT_name  {{.*}}"foo1"