[ELF] Add --strip-debug-non-line option

[luciang]

Summary

Add support for gold's --strip-debug-non-line added in May 2008 (see: https://sourceware.org/ml/binutils/2008-05/msg00232.html)

Stripping strategy:

• .debug_info
  • .debug_info is usually the largest debug section, but for file:lineno info we don't need most of the DIEs in it.
  • The top-level DIE corresponds to the CU and contains the name of the path to the file DW_AT_comp_dir/DW_AT_name.
  • Keep top-level compilation unit DIEs and skip children (recursively).
• .debug_abbrev - only keep DW_TAG_compile_unit abbreviations for these top-level compilation unit DIEs
• .debug_aranges - update offsets into .debug_info as they changed after stripping children of entries.

Test Plan: check-lld: added single-CU and multi-CU tests

Also tested manually that gdb is able to print file:lineno info.

$ cat foo.cpp
#include <stdexcept>
void foo() { throw std::exception(); }

$ cat bar.cpp
void foo();
int main() { foo(); }

$ clang++ -g -gdwarf-aranges   -c -o bar.o bar.cpp
$ clang++ -g -gdwarf-aranges   -c -o foo.o foo.cpp
$ clang++ foo.o bar.o -fuse-ld=lld -Xlinker --no-threads -Xlinker --strip-debug-non-line -o bar-lld-strip-debug-non-line

$ llvm-dwarfdump bar-lld-strip-debug-non-line
bar-lld-strip-debug-non-line:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000026 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x0000002a)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("bar.cpp")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	("/home/lucian/local/github/llvm-project/test")
              DW_AT_low_pc	(0x0000000000201100)
              DW_AT_high_pc	(0x000000000020110d)
0x0000002a: Compile Unit: length = 0x00000026 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000054)

0x00000035: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("foo.cpp")
              DW_AT_stmt_list	(0x00000042)
              DW_AT_comp_dir	("/home/lucian/local/github/llvm-project/test")
              DW_AT_low_pc	(0x0000000000000000)
              DW_AT_ranges	(0x00000000
                 [0x0000000000201110, 0x0000000000201154)
                 [0x0000000000201160, 0x0000000000201181))

$ llvm-dwarfdump --verify bar-lld-strip-debug-non-line  | less
Verifying bar-lld-strip-debug-non-line:	file format ELF64-x86-64
Verifying .debug_abbrev...
Verifying .debug_info Unit Header Chain...
Verifying .debug_info references...
Verifying .debug_types Unit Header Chain...
No errors.

gdb ./bar-lld-strip-debug-non-line-compress-debug-sections -batch  --ex run --ex bt --ex quit
3.6.3rc1+ (default, Feb  5 2019, 15:51:57)
[GCC 5.x 20180625 (Facebook) 5.5.0+]
Script information not found in binary, assuming oldest version
Type "fbload" to load fb-specific gdb extensions.
terminate called after throwing an instance of 'std::exception'
  what():  std::exception

Program received signal SIGABRT, Aborted.
0x00007ffff7225277 in raise () from /lib64/libc.so.6
#0  0x00007ffff7225277 in raise () from /lib64/libc.so.6
#1  0x00007ffff7226968 in abort () from /lib64/libc.so.6
#2  0x00007ffff7b347d5 in __gnu_cxx::__verbose_terminate_handler() () from /lib64/libstdc++.so.6
#3  0x00007ffff7b32746 in ?? () from /lib64/libstdc++.so.6
#4  0x00007ffff7b32773 in std::terminate() () from /lib64/libstdc++.so.6
#5  0x00007ffff7b32993 in __cxa_throw () from /lib64/libstdc++.so.6
#6  0x0000000000201154 in foo() () at foo.cpp:2
#7  0x0000000000201109 in main () at bar.cpp:2
A debugging session is active.

	Inferior 1 [process 3496864] will be killed.

Quit anyway? (y or n) [answered Y; input not from terminal]

[ruiu]

ELF/Driver.cpp

505–508 ↗

(On Diff #145863)

Maybe I would call getOption().getID() twice instead of using a local variable because the cost of the function call should be negligible.

1314 ↗

(On Diff #145863)

Do you think you can make a list of sections you want to strip, instead of making a list of sections you want to keep?

test/ELF/strip-debug-non-line.s

1 ↗

(On Diff #145863)

I wonder if there's a way to verify that the debug info generated by --strip-debug-non-line is valid. (Say, if we accidentally removed .debug_str for that option, the result wouldn't work, so I want to make sure that the result can be consumed by the debugger, for example.)

[modocache]

Thanks for the review! I adopted the changes you suggested. As for validating the debug info, what about using 'llvm-dwarfdump -verify'? In fact running that on the output of this new option resulted in errors, so I'll address those.

[grimar]

In D46628#1094011, @modocache wrote:

Thanks for the review! I adopted the changes you suggested. As for validating the debug info, what about using 'llvm-dwarfdump -verify'? In fact running that on the output of this new option resulted in errors, so I'll address those.

I like the idea. In theory output after this patch is valid, right? (it produce the valid set of DWARF sections), so I think llvm-dwarfdump just should not report any errors probably for this case.

ELF/Driver.cpp

1314 ↗

(On Diff #145863)

Rui, why? I think this should be a whitelist. DWARF can add new debug sections,
but linker should just keep the sections that allow to "map program counter values to line
numbers". It's whitelist behavior.

[grimar]

+ David and Adrian just in case they have a different opinion about how this option might work / or how 'llvm-dwarfdump -verify' should behave here.

[aprantl]

test/ELF/strip-debug-non-line.s

1 ↗

(On Diff #145863)

llvm-dwarfdump --verify ?

[aprantl]

If dwarfdump can't find a problem with the output (and there is a problem with it) then that's a bug in dwarfdump. If you want to do functional testing, you'll probably want to pipe the result through something like llvm-symbolizer or lldb as an end-to-end test.

[grimar]

In D46628#1094613, @aprantl wrote:

If dwarfdump can't find a problem with the output (and there is a problem with it) then that's a bug in dwarfdump. If you want to do functional testing, you'll probably want to pipe the result through something like llvm-symbolizer or lldb as an end-to-end test.

In fact running that on the output of this new option resulted in errors, so I'll address those.

If I correctly understood the case, then it means that dwarfdump was able to find problems, but looks it does not like the new output. In that case, fixing/updating the dwarfdump and then using it for this patch looks reasonable to me.

[grimar]

So I mean it was able to find problems in a correct (technically) but uncommon output :)

[ruiu]

ELF/Driver.cpp

1314 ↗

(On Diff #145863)

It's because just a blacklist is easier to understand than a mix of blacklist/whitelist.

507 ↗

(On Diff #146066)

nit: no else after return.

[modocache]

Thanks for all the review!

So I mean it was able to find problems in a correct (technically) but uncommon output

I'm not sure this is the case. I think llvm-dwarfdump -verify points out a valid error in the invalid output generated by this patch. So, to clarify, I'm working on fixing this patch, I don't plan on changing llvm-dwarfdump.

[grimar]

In D46628#1094694, @modocache wrote:

Thanks for all the review!

So I mean it was able to find problems in a correct (technically) but uncommon output

I'm not sure this is the case. I think llvm-dwarfdump -verify points out a valid error in the invalid output generated by this patch. So, to clarify, I'm working on fixing this patch, I don't plan on changing llvm-dwarfdump.

Ok, I misunderstood then. Will be happy to see the update.

[grimar]

ELF/Driver.cpp

1314 ↗

(On Diff #145863)

We should be able to have whitelist only I believe. Brian, can you do that?

[ruiu]

Whitelist is a list of debug sections that you want to remove, and blacklist contains all the other debug sections. So what you are suggesting is not whitelist-only.

[grimar]

In D46628#1094717, @ruiu wrote:

Whitelist is a list of debug sections that you want to remove, and blacklist contains all the other debug sections. So what you are suggesting is not whitelist-only.

What I am trying to suggest is to keep the sections we *do not want* to remove. It's a whitelist.
Remove everything else. This should be applied to debug sections only.

[ruiu]

I know what you are saying, but my question is, is it likely to add new sections in the future? If so, are you sure that a new section is for something other than line info? I don't really have a strong opinion, I'm trying to reduce complexity.

[grimar]

In D46628#1094751, @ruiu wrote:

I know what you are saying, but my question is, is it likely to add new sections in the future? If so, are you sure that a new section is for something other than line info? I don't really have a strong opinion, I'm trying to reduce complexity.

Reducing complexity (of LLD) is my aim too. I *think* the DWARF standard is open for any new sections. So we can't rely on something. But it is a guessing for sure what is planned to be added.

We have DWARF people here, fortunately. Would be great to hear their opinions.

[ruiu]

LGTM

George,

No one can really predict the future. So let's not overthink. I don't think it is wroth a long detailed discussion because this is not really important. I did not ask anyone to use a whitelist, but I just asked if it is (easily) doable. If it is not easily doable, we shouldn't do that.

Brian,

Please just bring back the first patch to line 1316 and submit. Thanks!

[grimar]

OK, Rui, thanks! I am OK with that way too.

[modocache]

Please just bring back the first patch to line 1316 and submit. Thanks!

Will do! But, functionally, I think it's not in a great state, even in the prior patch. On your suggestion, I tried attaching to an executable linked with --strip-debug-non-line, and when I attempted to break at a source location, lldb crashed. I think that points to a serious flaw in the debug info that this patch is generating, so I'd like to fix that before landing. Just give me a few days to learn more about DWARF :)

[ruiu]

Got it. If that's the case, and if you need to modify this patch heavily, maybe you need another round of review. Anyways, thank you for working on this!

[probinson]

Does gold really preserve .debug_info and .debug_abbrev? Generally .debug_info is by far the largest DWARF section and so the one you most likely want to remove.

[modocache]

Sorry for letting this languish a bit. I took some time to experiment. Long story short I think llvm-dwarfdump and lldb aren't able to verify this option at the moment.

In D46628#1094011, @modocache wrote:

As for validating the debug info, what about using 'llvm-dwarfdump -verify'? In fact running that on the output of this new option resulted in errors, so I'll address those.

It turns out that both gold --strip-debug-non-line and the implementation of ld.lld --strip-debug-non-line in this patch output debug info that (1) llvm-dwarfdump -verify reports errors with, and (2) causes SIGSEVs in lldb.

I'll demonstrate with program bar.cpp:

#include <stdexcept>

void foo() {
  throw std::exception();
}

int main() {
  foo();
}

Compiling and linking this program with Clang trunk and GNU gold version 2.25.1 results in invalid DWARF info, according to llvm-dwarfdump:

$ clang++ bar.cpp -g -fuse-ld=gold -Xlinker --strip-debug-non-line -o bar-gold-strip-debug-non-line
$ llvm-dwarfdump -verify bar-gold-strip-debug-non-line
Verifying bar-gold-strip-debug-non-line:        file format ELF64-x86-64
Verifying .debug_abbrev...
Verifying .debug_info Unit Header Chain...
error: DW_AT_ranges offset is beyond .debug_ranges bounds:

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer    ("clang version 7.0.0 (http://llvm.org/git/clang.git 1aad2818adcb106eb0b350c8c9028b75a055647e) (http://llvm.org/git/llvm.git e7343867622e65294892168ec85edf426e5c3430)")
              DW_AT_language    (DW_LANG_C_plus_plus)
              DW_AT_name        ("bar.cpp")
              DW_AT_stmt_list   (0x00000000)
              DW_AT_comp_dir    ("/data/users/bgesiak/Source/fb/llvm/build")
              DW_AT_GNU_pubnames        (true)
              DW_AT_low_pc      (0x0000000000000000)
              DW_AT_ranges      (0x00000000)

Verifying .debug_info references...
Errors detected.

The exact same error occurs with this patch:

$ clang++ bar.cpp -g -fuse-ld=lld -Xlinker --strip-debug-non-line -o bar-lld-strip-debug-non-line
$ llvm-dwarfdump -verify bar-lld-strip-debug-non-line
Verifying bar-lld-strip-debug-non-line: file format ELF64-x86-64
Verifying .debug_abbrev...
Verifying .debug_info Unit Header Chain...
error: DW_AT_ranges offset is beyond .debug_ranges bounds:

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer    ("clang version 7.0.0 (http://llvm.org/git/clang.git 1aad2818adcb106eb0b350c8c9028b75a055647e) (http://llvm.org/git/llvm.git e7343867622e65294892168ec85edf426e5c3430)")
              DW_AT_language    (DW_LANG_C_plus_plus)
              DW_AT_name        ("bar.cpp")
              DW_AT_stmt_list   (0x00000000)
              DW_AT_comp_dir    ("/data/users/bgesiak/Source/fb/llvm/build")
              DW_AT_GNU_pubnames        (true)
              DW_AT_low_pc      (0x0000000000000000)
              DW_AT_ranges      (0x00000000)

Verifying .debug_info references...
Errors detected.

I think llvm-dwarfdump points to a legitimate error in both of these cases, because when I attempt to use lldb trunk to place a breakpoint in the program, lldb crashes:

$ lldb -- bar-gold-strip-debug-non-line
(lldb) target create "bar-gold-strip-debug-non-line"
Current executable set to 'bar-gold-strip-debug-non-line' (x86_64).
(lldb) b main
Stack dump:
0.      HandleCommand(command = "b main")
1.      HandleCommand(command = "breakpoint set --name 'main'")
fish: “bin/lldb -- bar-gold-strip-debu…” terminated by signal SIGSEGV (Address boundary error)

$ lldb -- bar-lld-strip-debug-non-line
(lldb) target create "bar-lld-strip-debug-non-line"
Current executable set to 'bar-lld-strip-debug-non-line' (x86_64).
(lldb) b main
Stack dump:
0.      HandleCommand(command = "b main")
1.      HandleCommand(command = "breakpoint set --name 'main'")
fish: “bin/lldb -- bar-lld-strip-debug…” terminated by signal SIGSEGV (Address boundary error)

gdb works just fine with both of these programs, however. It doesn't print line numbers in its backtrace, even if the program is linked with gold, like I would have expected. But the line numbers are still present in the debug info, and symbolizers like this one are capable of producing stack traces with those line numbers included.

In D46628#1094613, @aprantl wrote:

If dwarfdump can't find a problem with the output (and there is a problem with it) then that's a bug in dwarfdump. If you want to do functional testing, you'll probably want to pipe the result through something like llvm-symbolizer or lldb as an end-to-end test.

On the contrary, it turns out that llvm-dwarfdump does find problems with the output, and if crashing lldb is any indication, there are actually problems with the output -- both with this patch, and with gold. Would the correct next step to be to patch lldb and llvm-dwarfdump? Is there something else I've neglected to consider? Feedback welcome!

[modocache]

In D46628#1095084, @probinson wrote:

Does gold really preserve .debug_info and .debug_abbrev? Generally .debug_info is by far the largest DWARF section and so the one you most likely want to remove.

Good point. gold doesn't remove those sections completely, but it does prune them. For example, here's the difference between gold and gold --strip-debug-non-line for a simple program: https://reviews.llvm.org/P8082

[modocache]

Thanks again for the reviews. I removed the extraneous else, and reverted the string switch back to what I had originally.

[probinson]

In D46628#1108997, @modocache wrote:

In D46628#1095084, @probinson wrote:

Does gold really preserve .debug_info and .debug_abbrev? Generally .debug_info is by far the largest DWARF section and so the one you most likely want to remove.

Good point. gold doesn't remove those sections completely, but it does prune them. For example, here's the difference between gold and gold --strip-debug-non-line for a simple program: https://reviews.llvm.org/P8082

Ah ha. And if the compile-unit DIE has DW_AT_ranges but .debug_ranges has been eliminated, that's a verifier error. LLDB probably won't like it either. Maybe the stripping function needs to become a little smarter.

[christylee]

I spoke with @modocache and I'm going to take a crack at this.

[luciang]

Update to strip data from .debug_abbrev, .debug_info, .debug_aranges

[modocache]

Excellent, thank you! One of the comments on this diff mentioned using llvm-dwarfdump --verify to test whether the debug info generated by this option is valid. Have you tried doing so? Could you add a test case to this patch?

[luciang]

add single-cu and multi-cu tests

[MaskRay]

lld/ELF/Config.h

47

Since there is a total order, this can be ordered by the strip level: None, DebugNonLine, Debug, All.

lld/ELF/Driver.cpp

1851

Do you need .debug_rnglists?

lld/ELF/OutputSections.cpp

234

Consider using the double dash form since that is what will be in the manpage.

lld/ELF/OutputSections.h

117

Is size 1 ReducedDebugData common? If not, a container other than SmallVector<char, 1> may be better.

lld/ELF/Writer.cpp

595

double-dash form

lld/test/ELF/Inputs/strip-debug-non-line-multi-cu-bar.s

7

The comment markers are misaligned. Do you mix tabs and spaces? That'll render the comments badly on Phabricator.

lld/test/ELF/strip-debug-non-line-multi-cu.s

117

misaligned

lld/test/ELF/strip-debug-non-line.s

56

misaligned

209

.ident, .note.GNU-stack are unnecessary

[luciang]

`

lld/ELF/Driver.cpp

1851

I'll add a test for dwarf 5.

The gdb I have locally didn't print line number info with dwarf 5. I'll try a newer version of gdb.

lld/ELF/OutputSections.h

117

I used the same container as for CompressedData bellow. I'll use std::vector. Anything is fine here as I only allocate memory once.

lld/test/ELF/Inputs/strip-debug-non-line-multi-cu-bar.s

7

This file was created using clang++. I'll convert the tabs to spaces. I thought it was preferred to keep this as close to the original clang output as possible.

lld/test/ELF/strip-debug-non-line.s

209

I got this from clang output.

I thought I saw similar in other tests.

I didn't want to edit strings to avoid messing offsets but these are fair game to remove. Will do.

[MaskRay]

lld/test/ELF/strip-debug-non-line.s

209

If it is not lots of trouble, it'd be nice to minimize the tests. That will emphasize the important parts and make tests easier to understand. Thanks!

[MaskRay]

lld/test/ELF/strip-debug-non-line.s

211

.addrsig is also not necessary (it cannot be consumed by GNU as).

[MaskRay]

lld/ELF/Driver.cpp

1853

if (S->Name.consume_front(".debug_") || S->Name.consume_front(".zdebug_")) {
  ...
}

lld/ELF/OutputSections.cpp

205

Neither vector::clear nor SmallVector::clear deallocates the storage. Did you intend to call shrink_to_fit()?

lld/ELF/Writer.cpp

1073

Delete this helper.

Use endian::write(OS, UINT32_C(0xffffffff), Endian); below.

(this utility is defined in llvm/Support/EndianStream.h)

1078

NonLine. The option name treats non-line separately.

1083

for (OutputSection *Sec : OutputSections) {
  if (Sec->Name == ".debug_abbrev")
    AbbrSec = Sec;
  else if ...
}

1103

Config->IsLE

1161

SmallString<0>

The allocation is likely unavoidable. Don't waste stack space.

1181

NextInfoOffset is only used once. Just InfoOffset += Length below.

1219

delete {}

lld/test/ELF/strip-debug-non-line-multi-cu.s

6

--long (instead of -long) is preferred in llvm-readobj.

73

.byte 8 # DW_FORM_string allows you to inline the DW_AT_producer string. Or delete it if it is not necessary (the clang version string is too long but probably not relevant to this feature)

lld/test/ELF/strip-debug-non-line.s

3

-o %t.o

It is more natural to use .o for object files. Then use %t for the executable.

6

llvm-dwarfdump -verify returns 1 if there is any error, so you can omit | FileCheck.

11

.zdebug_str is not possible in the output. So you can just check Name: .debug_str

16

The *-NOT directive checks a string doesn’t occur between two matches. This doesn't guarantee .debug_macinfo is absent.

You may need: --implicit-check-not=.debug_macinfo --implicit-check-not=.debug_types

72

The # string offset= comments are not necessary - the literal offsets are not referenced in this file.

[MaskRay]

It seems --strip-debug-non-line is not popular (internally we have never used this option...nor can I find its use case in any open-source project). The full output section .debug_info is produced then reduced, so I bet it will not help with the memory usage. So the benefit is a smaller output size.

However, there is another way to retain line table information, at the compiler level: -gmlt. I wonder whether -gmlt + regular lld link will be a better alternative than -g + lld --strip-debug-non-line... Another thing is that if we care about output sizes, we will likely use -gsplit-dwarf. I don't know how this option will interact with -gsplit-dwarf. .debug*.dwo sections are ignored by the linkers... This option may be useless when -gsplit-dwarf is used.

Note, this task does not have to be done by the linker (no input section is read): ld + objcopy -R .debug_foo -R .debug_bar can discard unnecessary debug sections as well, though a separate tool will be needed if we want to reduce .debug_abbrev and .debug_info.

@luciang @modocache @christylee Have you thought about these options and compared the output sizes/memory usage of them?

[luciang]

convert tabs to spaces, align comments, remove some noise from tests, add dwarf5 test

[luciang]

So the benefit is a smaller output size.

Yes. That's what we're currently using gold + strip-debug-non-line for: to reduce binary sizes in a context where a very large number of very large binaries are produced and executed.

We've also considered the items you brought up (building and deploying a separate tool to strip out the debug info after creation, create .o with minimal set of debug info), but went with this approach for:

• lld feature parity with gold
  • based on initial response to earlier version of the diff it seemed desirable
  • the flag is useful on its own

• producting large binaries, reading and re-writing with reduced size is a waste of IO / time

• the patch seemed reasonable in size and intrusiveness -- I intentionally kept the implementation in a single function and avoided adding new types or passing maps or structs between phases and leveraged as much as llvm libraries as I could.

• input .o come from a shared cache and have rich debug info and we're not using split-dwarf

[luciang]

simplify tests more

[MaskRay]

In D46628#1555375, @luciang wrote:

So the benefit is a smaller output size.

Yes. That's what we're currently using gold + strip-debug-non-line for: to reduce binary sizes in a context where a very large number of very large binaries are produced and executed.

We've also considered the items you brought up (building and deploying a separate tool to strip out the debug info after creation, create .o with minimal set of debug info), but went with this approach for:

• lld feature parity with gold
  • based on initial response to earlier version of the diff it seemed desirable
  • the flag is useful on its own

• producting large binaries, reading and re-writing with reduced size is a waste of IO / time

• the patch seemed reasonable in size and intrusiveness -- I intentionally kept the implementation in a single function and avoided adding new types or passing maps or structs between phases and leveraged as much as llvm libraries as I could.

• input .o come from a shared cache and have rich debug info and we're not using split-dwarf

Then how about -gmlt? If you compile the program (say a.c) twice, once with -g and once with -gmlt, then you link the program twice. The -g link gets full debug info, while the -gmlt link naturally gets smaller input and produces smaller output.

If you compile the program once with -g, and expect to get two programs, one with full debug info, the other with sufficient debug info to retain line tables. You can link it once and then postprocess the program with another tool.

In neither case a linker option is needed.

If you compile with -g, but never use the full debug info. This is the case that --strip-debug-non-line will become handy. However, why can't the program be compiled with -gmlt in the first place?

I tried digging up some history and it seems that --strip-debug-non-line may be a (legacy) solution that dated before -gmlt (-g1) and -gsplit-dwarf. My understanding is that with either compiler option, the linker option will become significantly less useful.

lld/ELF/Driver.cpp

1853

This is not done.

lld/ELF/Writer.cpp

1073

This is not done.

1181

This is not done.

[luciang]

Sorry, I forgot I didn't submit comments.

lld/ELF/Driver.cpp

1853

Can't use consume_front: that changes the Name of the section.

/// Returns true if this StringRef has the given prefix and removes that
/// prefix.
bool consume_front(StringRef Prefix) {
  if (!startswith(Prefix))
    return false;
 
  *this = drop_front(Prefix.size());
  return true;
}

lld/ELF/OutputSections.cpp

205

I used clear here not to free memory, but to signal that ReducedDebugData doesn't hold information anymore -- it has been moved to CompressedData.

I did call shrink_to_fit as you suggested in the std::string version, but later switched to SmallString and swapped with a temporary to free memory.

lld/ELF/OutputSections.h

117

I can't use a std::vector as I mentioned above. I couldn't find a raw_ostream implementation that prints to a std::vector.

I only found https://llvm.org/doxygen/classllvm_1_1raw__string__ostream.html

• raw_svector_ostream which prints to a SmallVector
• raw_string_ostream which prints to a std::string

I'll go with a std::string here.

lld/ELF/Writer.cpp

1073

Unfortunately I can't include that header as it defines another Writer class which clashes with the one defined in this file:

This is what happens if I include it:

$ git diff
diff --git a/lld/ELF/Writer.cpp b/lld/ELF/Writer.cpp
index 6f16cf21daf..b3c54b47251 100644
--- a/lld/ELF/Writer.cpp
+++ b/lld/ELF/Writer.cpp
@@ -28,6 +28,7 @@
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/EndianStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"

/home/lucian/local/github/llvm-project/lld/ELF/Writer.cpp: In function ‘void lld::elf::writeResult()’:
/home/lucian/local/github/llvm-project/lld/ELF/Writer.cpp:152:49: error: reference to ‘Writer’ is ambiguous
 template <class ELFT> void elf::writeResult() { Writer<ELFT>().run(); }
                                                 ^
/home/lucian/local/github/llvm-project/lld/ELF/Writer.cpp:51:29: note: candidates are: template<class ELFT> class {anonymous}::Writer
 template <class ELFT> class Writer {
                             ^
In file included from /home/lucian/local/github/llvm-project/lld/ELF/Writer.cpp:31:0:
/home/lucian/local/github/llvm-project/llvm/include/llvm/Support/EndianStream.h:51:8: note:                 struct llvm::support::endian::Writer
 struct Writer {
        ^
/home/lucian/local/github/llvm-project/lld/ELF/Writer.cpp:152:60: error: expected primary-expression before ‘>’ token
 template <class ELFT> void elf::writeResult() { Writer<ELFT>().run(); }
                                                            ^
/home/lucian/local/github/llvm-project/lld/ELF/Writer.cpp:152:62: error: expected primary-expression before ‘)’ token
 template <class ELFT> void elf::writeResult() { Writer<ELFT>().run(); }
                                                              ^

I could re-name the Writer class in this file, but wanted to keep the diff focused on the task.

1161

I had all of these as SmallString<1, char> earlier and switched to std::string after a previous comment. I misunderstood your intent there. I switched all of them to SmallString<0>.

1181

InfoOffset is updated by the getU8 & co. calls.

http://dwarfstd.org/doc/DWARF5.pdf
7.5.1.1 Full and Partial Compilation Unit Headers

unit_length (initial length)
A 4-byte or 12-byte unsigned integer representing the length of the
.debug_info contribution for that compilation unit, not including the length
field itself. In the 32-bit DWARF format, this is a 4-byte unsigned integer
(which must be less than 0xfffffff0); in the 64-bit DWARF format, this
consists of the 4-byte value 0xffffffff followed by an 8-byte unsigned
integer that gives the actual length (see Section 7.4 on page 196).

Length is the length of this CU + all its children. I don't copy the children into the reduced buffer, just the DIE for the CU.

At the end of the loop bellow InfoOffset bellow will only point to the end of the DIE corresponding to this CU. I need it to skip the children too.

As written here NextInfoOffset will point to the next CU. I'll keep this behavior.

[luciang]

Then how about -gmlt?

Sorry, I tried to reply in this bullet point but wasn't very clear:

input .o come from a shared cache and have rich debug info

We have two kinds of .o:

• always built from source - we could use -gmlt here (even though it would be preferable to fetch them from a shared cache).
• prebuilt .o with full debug info - (eg. prebuilt external third-party code managed by an *inflexible* tp management system).

[MaskRay]

This option is a bit weird to me because:

• In binutils-gdb, only two commits were specific to gold/reduced_debug_output.cc. This suggests to me either the feature works really reliably, or it stays unused since then.
• This features requires partial DWARF rewriting. I think this is against the spirit of ELF. .debug_abbrev and .debug_info get rewritten then references to them get repaired: fortunately there aren't many! Probably only .debug_info and .debug_aranges can reference .debug_info and for line tables to work, only .debug_aranges needs adjustment.

I believe the following is the list of debug sections that gold --strip-debug-non-line keeps:

static const char* lines_only_debug_sections[] =
{
  "abbrev",
  // "addr",      // Fission extension
  // "aranges",   // not used by gdb as of 7.4
  // "frame",
  // "gdb_scripts",
  "info",
  // "types",
  "line",
  // "loc",
  // "macinfo",
  // "macro",
  // "pubnames",  // not used by gdb as of 7.4
  // "pubtypes",  // not used by gdb as of 7.4
  // "gnu_pubnames",  // Fission extension
  // "gnu_pubtypes",  // Fission extension
  // "ranges",
  "str",
  "str_offsets",  // Fission extension
};

Note the aranges line that is filtered out. I don't know how users of this feature expects to get a fast symbolizer...

[MaskRay]

In D46628#1555467, @luciang wrote:

Then how about -gmlt?

Sorry, I tried to reply in this bullet point but wasn't very clear:

input .o come from a shared cache and have rich debug info

We have two kinds of .o:

• always built from source - we could use -gmlt here (even though it would be preferable to fetch them from a shared cache).
• prebuilt .o with full debug info - (eg. prebuilt external third-party code managed by an *inflexible* tp management system).

See this part of my question:

If you compile the program (say a.c) twice, once with -g and once with -gmlt, then you link the program twice. The -g link gets full debug info, while the -gmlt link naturally gets smaller input and produces smaller output.

If you compile the program once with -g, and expect to get two programs, one with full debug info, the other with sufficient debug info to retain line tables. You can link it once and then postprocess the program with another tool.

In neither case a linker option is needed.

[luciang]

Here's where we use aranges: instead of linearly scanning .debug_info you can jump to the correct CU DIE using info from .debug_aranges

• init: https://github.com/facebook/folly/blob/master/folly/experimental/symbolizer/Dwarf.cpp#L322
• use aranges to jump to CU DIE: https://github.com/facebook/folly/blob/master/folly/experimental/symbolizer/Dwarf.cpp#L583-L592
• linear scan as fallback: https://github.com/facebook/folly/blob/master/folly/experimental/symbolizer/Dwarf.cpp#L605-L610

We have internal changes to gold to keep .debug_aranges.

[luciang]

prebuilt .o with full debug info - (eg. prebuilt external third-party code managed by an *inflexible* tp management system).

Let's assume .o will continue to have no-nline debug info due to the inflexible tp management system -- properly supporting -gmlt this would much delay adoption of lld.

You can link it once and then postprocess the program with another tool.

There are a few aspects for which we chose doing this in lld

• RAM use reduction: debug section are processed and reduced before creating the output file and the ReducedDebugData are small (from 2-3GiB -> tens of MiB).
• inefficiency: wasted IO / time: writing huge binaries twice
• complexity of integrating binary shrinking into the build system

[MaskRay]

In D46628#1555491, @luciang wrote:

prebuilt .o with full debug info - (eg. prebuilt external third-party code managed by an *inflexible* tp management system).

Let's assume .o will continue to have no-nline debug info due to the inflexible tp management system -- properly supporting -gmlt this would much delay adoption of lld.

You can link it once and then postprocess the program with another tool.

There are a few aspects for which we chose doing this in lld

• RAM use reduction: debug section are processed and reduced before creating the output file and the ReducedDebugData are small (from 2-3GiB -> tens of MiB).
• inefficiency: wasted IO / time: writing huge binaries twice
• complexity of integrating binary shrinking into the build system

If you do the following before:

# compile once
clang -g -c a.c
# link twice
clang a.o -o a.full
clang a.o -Wl,--strip-debug-non-line -o a.line  # will be changed

I wonder if you can change the second link to reduce-tool a.full -o a.line.

If you do:

# compile twice
clang -g -c a.c -o a.full.o
clang -g1 -c a.c -o a.line.o
# link twice
clang a.full.o -o a.full
clang a.line.o -o a.line   # no -Wl,--strip-debug-non-line is necessary

In neither case a linker option is necessary.

If the tp management system is so inflexible that it can't even change -g to -g1, then you can add a -g1 to override the debug level of -g:

clang -g a.c -o a.line.o -g1   # the debug level is decided by the last -g*

On the GCC side, GCC started to emit minimum line tables at -g1 with this patch https://github.com/gcc-mirror/gcc/commit/7fa9fa16198d84fe9354a1adc644c84b3b4dba79
I think it is included in GCC 4.9 though it is not included in the release log.

[luciang]

Some clarifications: our third-party management system stores a single version of .o and doesn't allow you to choose between flavors like a.full.o + a.line.o.

Other companies' third-party code is always built from source -- applying whatever compiler options the author needs at that point (-g1 or -g2 as needed), but ours doesn't :(

If I change our TP to use -g1 we lose debug info for TP code.

In many contexts we need rich debug info (e.g. when debugging something or shipping to production),

In other contexts (e.g. in a continuous integration system) we build binaries with minimal debug info (stacktraces + file:line info are sufficient).

• code built from source uses -g1
• but not all code is built from source: a significant amount comes from this central TP store where .os are built with -g2 and can't be easily adapted to use -g1.

---

compile once + link twice

clang a.o -o a.full
clang a.o -Wl,--strip-debug-non-line -o a.line # will be changed
I wonder if you can change the second link to reduce-tool a.full -o a.line.

We don't do that.

• In the CI system we don't create both a.full and a.line binaries: we only create a.line
• when creating release binaries or binaries for local debugging we create a.full

---

compile twice + link twice
clang -g -c a.c -o a.full.o
clang -g1 -c a.c -o a.line.o

As I mentioned above the TP system doesn't support a.full.o + a.line.o flavors, just a.o.

[luciang]

GCC with -g1 produces extra information not necessary for stacktrace + file:line info production:

https://gcc.gnu.org/onlinedocs/gcc/Debugging-Options.html

Level 1 produces minimal information, enough for making backtraces in parts of the program that you don’t plan to debug. This includes descriptions of functions and external variables, and line number tables, but no information about local variables.

Using GCC 7: note the generation of DW_TAG_subprogram -- so --strip-debug-non-line is still useful in reducing that info

$ echo "int foo() { return 0; } int bar() { return foo(); }" | g++ -g1 -S -x c - -o - > /tmp/test/gcc.s
$ llvm-mc -filetype=obj -triple=x86_64-unknown-linux /tmp/test/gcc.s -o /tmp/test/gcc.o
$ llvm-dwarfdump --debug-info /tmp/test/gcc.o
/tmp/test/gcc.o:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x0000005a version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x0000005e)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("GNU C17 7.x 20190403 (Facebook) 8.x -mtune=generic -march=x86-64 -g1")
              DW_AT_language	(DW_LANG_C99)
              DW_AT_comp_dir	("/tmp/test")
              DW_AT_low_pc	(0x0000000000000000)
              DW_AT_high_pc	(0x000000000000001b)
              DW_AT_stmt_list	(0x00000000)

0x00000029:   DW_TAG_subprogram
                DW_AT_external	(true)
                DW_AT_name	("bar")
                DW_AT_decl_file	("/tmp/test/<stdin>")
                DW_AT_decl_line	(1)
                DW_AT_decl_column	(0x1d)
                DW_AT_low_pc	(0x000000000000000b)
                DW_AT_high_pc	(0x000000000000001b)
                DW_AT_frame_base	(DW_OP_call_frame_cfa)
                DW_AT_unknown_2116	(true)

0x00000043:   DW_TAG_subprogram
                DW_AT_external	(true)
                DW_AT_name	("foo")
                DW_AT_decl_file	("/tmp/test/<stdin>")
                DW_AT_decl_line	(1)
                DW_AT_decl_column	(0x05)
                DW_AT_low_pc	(0x0000000000000000)
                DW_AT_high_pc	(0x000000000000000b)
                DW_AT_frame_base	(DW_OP_call_frame_cfa)
                DW_AT_GNU_all_call_sites	(true)

0x0000005d:   NULL

clang does better (I tried clang-7, clang-8) and only produces DW_TAG_compile_unit:

$ echo "int foo() { return 0; } int bar() { return foo(); }" | clang++ -Os -g1 -S -x c - -Xclang -fdebug-compilation-dir -Xclang . -o - > /tmp/test/clang.s
$ llvm-mc -filetype=obj -triple=x86_64-unknown-linux /tmp/test/clang.s -o /tmp/test/clang.o
$ llvm-dwarfdump --debug-info /tmp/test/clang.o
/tmp/test/clang.o:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000026 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x0000002a)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 8.0.20181009 ")
              DW_AT_language	(DW_LANG_C99)
              DW_AT_name	("-")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	(".")
              DW_AT_low_pc	(0x0000000000000000)
              DW_AT_high_pc	(0x0000000000000006)

[luciang]

I found that clang 9 (and previous versions) also generates non CU info in .debug_info with -gmlt:

$ echo 'struct A { A() {} int a = 0; }; struct B { B(); A a; }; B::B() {}' | clang++ -x c++ -O2 -gmlt -o clang-02-gmlt.o -c - && llvm-dwarfdump --debug-info clang-02-gmlt.o
clang-02-gmlt.o:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000051 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000055)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("-")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	("/tmp/test")
              DW_AT_low_pc	(0x0000000000000000)
              DW_AT_high_pc	(0x0000000000000007)

0x0000002a:   DW_TAG_subprogram
                DW_AT_name	("A")

0x0000002f:   DW_TAG_subprogram
                DW_AT_low_pc	(0x0000000000000000)
                DW_AT_high_pc	(0x0000000000000007)
                DW_AT_name	("B")

0x00000040:     DW_TAG_inlined_subroutine
                  DW_AT_abstract_origin	(0x0000002a "A")
                  DW_AT_low_pc	(0x0000000000000000)
                  DW_AT_high_pc	(0x0000000000000006)
                  DW_AT_call_file	("/tmp/test/<stdin>")
                  DW_AT_call_line	(1)

0x00000053:     NULL

0x00000054:   NULL

Note that dropping with -O0 or -O1 .debug_info the DW_TAG_subprogram and DW_TAG_inlined_subroutine DIEs are not generated. -Os, -O2 and -O3 do.

$ echo 'struct A { A() {} int a = 0; }; struct B { B(); A a; }; B::B() {}' | clang++ -x c++ -O0 -gmlt -o clang-02-gmlt.o -c - && llvm-dwarfdump --debug-info clang-02-gmlt.o
clang-02-gmlt.o:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000026 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x0000002a)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("-")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	("/tmp/test")
              DW_AT_low_pc	(0x0000000000000000)
              DW_AT_ranges	(0x00000000
                 [0x0000000000000000, 0x000000000000001b)
                 [0x0000000000000000, 0x0000000000000014))

---

The proposed --strip-debug-non-line is an improvement on top of what current gcc/clang produce with -g1 or -gmlt:

$ echo 'struct A { A() {} int a = 0; }; struct B { B(); A a; }; B::B() {}; int main(){ return 0;}' | clang++ -x c++ -O2 -gmlt -o clang-02-gmlt-strip -fuse-ld=lld -Wl,--strip-debug-non-line - && llvm-dwarfdump --debug-info clang-02-gmlt-strip
clang-02-gmlt-strip:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000026 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x0000002a)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("-")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	("/tmp/test")
              DW_AT_low_pc	(0x0000000000201100)
              DW_AT_high_pc	(0x0000000000201113)

vs

$ echo 'struct A { A() {} int a = 0; }; struct B { B(); A a; }; B::B() {}; int main(){ return 0;}' | clang++ -x c++ -O2 -gmlt -o clang-02-gmlt -fuse-ld=lld  - && llvm-dwarfdump --debug-info clang-02-gmlt
clang-02-gmlt:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000051 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000055)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("-")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	("/tmp/test")
              DW_AT_low_pc	(0x0000000000201100)
              DW_AT_high_pc	(0x0000000000201113)

0x0000002a:   DW_TAG_subprogram
                DW_AT_name	("A")

0x0000002f:   DW_TAG_subprogram
                DW_AT_low_pc	(0x0000000000201100)
                DW_AT_high_pc	(0x0000000000201107)
                DW_AT_name	("B")

0x00000040:     DW_TAG_inlined_subroutine
                  DW_AT_abstract_origin	(0x0000002a "A")
                  DW_AT_low_pc	(0x0000000000201100)
                  DW_AT_high_pc	(0x0000000000201106)
                  DW_AT_call_file	("/tmp/test/<stdin>")
                  DW_AT_call_line	(1)

0x00000053:     NULL

0x00000054:   NULL

(I'll look into what triggers -gmlt + -O2 to generate the extra debug sections separately).

[dblaikie]

In D46628#1558438, @luciang wrote:

I found that clang 9 (and previous versions) also generates non CU info in .debug_info with -gmlt:

$ echo 'struct A { A() {} int a = 0; }; struct B { B(); A a; }; B::B() {}' | clang++ -x c++ -O2 -gmlt -o clang-02-gmlt.o -c - && llvm-dwarfdump --debug-info clang-02-gmlt.o
clang-02-gmlt.o:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000051 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000055)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("-")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	("/tmp/test")
              DW_AT_low_pc	(0x0000000000000000)
              DW_AT_high_pc	(0x0000000000000007)

0x0000002a:   DW_TAG_subprogram
                DW_AT_name	("A")

0x0000002f:   DW_TAG_subprogram
                DW_AT_low_pc	(0x0000000000000000)
                DW_AT_high_pc	(0x0000000000000007)
                DW_AT_name	("B")

0x00000040:     DW_TAG_inlined_subroutine
                  DW_AT_abstract_origin	(0x0000002a "A")
                  DW_AT_low_pc	(0x0000000000000000)
                  DW_AT_high_pc	(0x0000000000000006)
                  DW_AT_call_file	("/tmp/test/<stdin>")
                  DW_AT_call_line	(1)

0x00000053:     NULL

0x00000054:   NULL

Note that dropping with -O0 or -O1 .debug_info the DW_TAG_subprogram and DW_TAG_inlined_subroutine DIEs are not generated. -Os, -O2 and -O3 do.

$ echo 'struct A { A() {} int a = 0; }; struct B { B(); A a; }; B::B() {}' | clang++ -x c++ -O0 -gmlt -o clang-02-gmlt.o -c - && llvm-dwarfdump --debug-info clang-02-gmlt.o
clang-02-gmlt.o:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000026 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x0000002a)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("-")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	("/tmp/test")
              DW_AT_low_pc	(0x0000000000000000)
              DW_AT_ranges	(0x00000000
                 [0x0000000000000000, 0x000000000000001b)
                 [0x0000000000000000, 0x0000000000000014))

---

The proposed --strip-debug-non-line is an improvement on top of what current gcc/clang produce with -g1 or -gmlt:

$ echo 'struct A { A() {} int a = 0; }; struct B { B(); A a; }; B::B() {}; int main(){ return 0;}' | clang++ -x c++ -O2 -gmlt -o clang-02-gmlt-strip -fuse-ld=lld -Wl,--strip-debug-non-line - && llvm-dwarfdump --debug-info clang-02-gmlt-strip
clang-02-gmlt-strip:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000026 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x0000002a)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("-")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	("/tmp/test")
              DW_AT_low_pc	(0x0000000000201100)
              DW_AT_high_pc	(0x0000000000201113)

vs

$ echo 'struct A { A() {} int a = 0; }; struct B { B(); A a; }; B::B() {}; int main(){ return 0;}' | clang++ -x c++ -O2 -gmlt -o clang-02-gmlt -fuse-ld=lld  - && llvm-dwarfdump --debug-info clang-02-gmlt
clang-02-gmlt:	file format ELF64-x86-64

.debug_info contents:
0x00000000: Compile Unit: length = 0x00000051 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000055)

0x0000000b: DW_TAG_compile_unit
              DW_AT_producer	("clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)")
              DW_AT_language	(DW_LANG_C_plus_plus)
              DW_AT_name	("-")
              DW_AT_stmt_list	(0x00000000)
              DW_AT_comp_dir	("/tmp/test")
              DW_AT_low_pc	(0x0000000000201100)
              DW_AT_high_pc	(0x0000000000201113)

0x0000002a:   DW_TAG_subprogram
                DW_AT_name	("A")

0x0000002f:   DW_TAG_subprogram
                DW_AT_low_pc	(0x0000000000201100)
                DW_AT_high_pc	(0x0000000000201107)
                DW_AT_name	("B")

0x00000040:     DW_TAG_inlined_subroutine
                  DW_AT_abstract_origin	(0x0000002a "A")
                  DW_AT_low_pc	(0x0000000000201100)
                  DW_AT_high_pc	(0x0000000000201106)
                  DW_AT_call_file	("/tmp/test/<stdin>")
                  DW_AT_call_line	(1)

0x00000053:     NULL

0x00000054:   NULL

(I'll look into what triggers -gmlt + -O2 to generate the extra debug sections separately).

While all this (the behavior of gmlt) seems unrelated to this patch, really (I agree/understand your description - if you really want to be able to compile things once and link them into debug-ish and non-debug-ish forms, something like the --strip-debug-non-line sounds nice though I can also understand some push-back against it, since it's necessarily going to make broken DWARF, well, except in DWARFv5 where there's an intentional way to support line-table-only debug info (the line table has its own string table, so you can strip /everything/ (including debug_info) except debug_line and debug_line_str, I believe) - perahps that'd be a good way to implement this in a more principled way - work for DWARFv5 only (it wouldn't necessarily need/want to check DWARF version, but be designed to work correctly for DWARFv5 & be weird/bad/problematic before that))

So, while the behavior of gmlt doesn't seem too relevant - I can explain what it does, why GCC's and Clang's are designed the way they are. Their goal is to be able to produce correct back traces, that means needing to describe inline stack frames. Both GCC and Clang used to describe all functions - but I made changes to Clang to reduce the cost of this feature by only describing functions that have inlining in them (or are inlined/need to share a description for that purpose). So the simplest test case that always produces more than just the CU DIE is:

void f1();
__attribute__((always_inline)) void f2() {
  f1();
}
void f3() {
  f2();
}

[probinson]

In D46628#1559322, @dblaikie wrote:

While all this (the behavior of gmlt) seems unrelated to this patch, really (I agree/understand your description - if you really want to be able to compile things once and link them into debug-ish and non-debug-ish forms, something like the --strip-debug-non-line sounds nice though I can also understand some push-back against it, since it's necessarily going to make broken DWARF, well, except in DWARFv5 where there's an intentional way to support line-table-only debug info (the line table has its own string table, so you can strip /everything/ (including debug_info) except debug_line and debug_line_str, I believe) - perahps that'd be a good way to implement this in a more principled way - work for DWARFv5 only (it wouldn't necessarily need/want to check DWARF version, but be designed to work correctly for DWARFv5 & be weird/bad/problematic before that))

Preserving ".debug_line*" should be fully usable for DWARFv5, and the idea is that ".debug_line*" should be sufficient in future DWARF versions that might invent other new sections related to the line table. For DWARFv4, preserving just .debug_line would lose the explicit address-size (likely you can infer that from other characteristics of the object file) and the compilation directory/root file, which might or might not be referenced within the line table.

Given that part of the use-case is pre-built 3rd party objects with full debug info, you probably can't assume everything is DWARFv5, however, so a solution that works for prior versions is probably the right way to go. It should be comparatively easy to trim a .debug_info compilation unit down to just the DW_TAG_compile_unit DIE, which gets back the missing info I mentioned in the previous paragraph,

For a traceback, this gets you source attributions but not nice subprogram names, which would require the additional inlined subprogram information that David was talking about.

lld/ELF/Config.h

 enum class BuildIdKind { None, Fast, Md5, Sha1, Hexstring, Uuid };
 
 // For --discard-{all,locals,none}.
 enum class DiscardPolicy { Default, All, Locals, None };
 
 // For --icf={none,safe,all}.
 enum class ICFLevel { None, Safe, All };
 
-// For --strip-{all,debug}.
-enum class StripPolicy { None, All, Debug };
+// For --strip-{debug-non-line,debug,all}.
+enum class StripPolicy { None, DebugNonLine, Debug, All };
 
 // For --unresolved-symbols.
 enum class UnresolvedPolicy { ReportError, Warn, Ignore };
 
 // For --orphan-handling.
 enum class OrphanHandlingPolicy { Place, Warn, Error };
 
 // For --sort-section and linkerscript sorting rules.

lld/ELF/Driver.cpp

if (Arg->getOption().getID() == OPT_icf_safe)
     return ICFLevel::Safe;
   return ICFLevel::All;
 }
 
 static StripPolicy getStrip(opt::InputArgList &Args) {
   if (Args.hasArg(OPT_relocatable))
     return StripPolicy::None;
 
-  auto *Arg = Args.getLastArg(OPT_strip_all, OPT_strip_debug);
+  auto *Arg = Args.getLastArg(OPT_strip_all, OPT_strip_debug, OPT_strip_debug_non_line);
   if (!Arg)
     return StripPolicy::None;
   if (Arg->getOption().getID() == OPT_strip_all)
     return StripPolicy::All;
+  if (Arg->getOption().getID() == OPT_strip_debug)
     return StripPolicy::Debug;
+  return StripPolicy::DebugNonLine;
 }
 
 static uint64_t parseSectionAddress(StringRef S, const opt::Arg &Arg) {
   uint64_t VA = 0;
   if (S.startswith("0x"))
     S = S.drop_front(2);
   if (!to_integer(S, VA, 16))
     error("invalid argument: " + toString(Arg));
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
 
   llvm::erase_if(InputSections, [](InputSectionBase *S) {
     if (S->Type == SHT_LLVM_SYMPART) {
       readSymbolPartitionSection<ELFT>(S);
       return true;
     }
 
     // We do not want to emit debug sections if --strip-all
-    // or -strip-debug are given.
-    return Config->Strip != StripPolicy::None &&
-           (S->Name.startswith(".debug") || S->Name.startswith(".zdebug"));
+    // or -strip-debug are given.  If --strip-debug-non-line is specified,
+    // emit only the sections used for line info.
+    if (Config->Strip == StripPolicy::All ||
+        Config->Strip == StripPolicy::Debug) {
+      return S->Name.startswith(".debug") || S->Name.startswith(".zdebug");
+    } else if (Config->Strip == StripPolicy::DebugNonLine) {
+      // Only keep debug sections used to map program counter values
+      // to file : line numbers.
+      return StringSwitch<bool>(S->Name)
+          .EndsWith("debug_abbrev", false)
+          .EndsWith("debug_addr", false)
+          .EndsWith("debug_aranges", false)
+          .EndsWith("debug_info", false)
+          .EndsWith("debug_line_str", false)
+          .EndsWith("debug_line", false)
+          .EndsWith("debug_ranges", false)
+          .EndsWith("debug_rnglists", false)
+          .EndsWith("debug_str_offsets", false)
+          .EndsWith("debug_str", false)
+          .StartsWith(".debug", true)
+          .StartsWith(".zdebug", true)
+          .Default(false);
+    }
+    return false;
   });
 
   // Now that the number of partitions is fixed, save a pointer to the main
   // partition.
   Main = &Partitions[0];
 
   // Read .note.gnu.property sections from input object files which
   // contain a hint to tweak linker's and loader's behaviors.

lld/ELF/Options.td

 
 def start_lib: F<"start-lib">,
   HelpText<"Start a grouping of objects that should be treated as if they were together in an archive">;
 
 def strip_all: F<"strip-all">, HelpText<"Strip all symbols">;
 
 def strip_debug: F<"strip-debug">, HelpText<"Strip debugging information">;
 
+def strip_debug_non_line: F<"strip-debug-non-line">,
+  HelpText<"Emit only debug line number information">;
+
 defm symbol_ordering_file:
   Eq<"symbol-ordering-file", "Layout sections to place symbols in the order specified by symbol ordering file">;
 
 defm sysroot: Eq<"sysroot", "Set the system root">;
 
 def target1_rel: F<"target1-rel">, HelpText<"Interpret R_ARM_TARGET1 as R_ARM_REL32">;
 
 def target1_abs: F<"target1-abs">, HelpText<"Interpret R_ARM_TARGET1 as R_ARM_ABS32 (default)">;

lld/ELF/OutputSections.h

 #include "Config.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "Relocations.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELF.h"
 #include <array>
+#include <string>
 
 namespace lld {
 namespace elf {
 
 struct PhdrEntry;
 class InputSection;
 class InputSectionBase;
 
public:
 
   // Tracks whether the section has ever had an input section added to it, even
   // if the section was later removed (e.g. because it is a synthetic section
   // that wasn't needed). This is needed for orphan placement.
   bool HasInputSections = false;
 
   void finalize();
   template <class ELFT> void writeTo(uint8_t *Buf);
+  void setReducedDebugData(SmallString<0> Data) {
+    ReducedDebugData = std::move(Data);
+    Size = ReducedDebugData.size();
+  }
+
   template <class ELFT> void maybeCompress();
 
   void sort(llvm::function_ref<int(InputSectionBase *S)> Order);
   void sortInitFini();
   void sortCtorsDtors();
 
 private:
+  // Reduced .debug_info/.debug_abbrev/.debug_aranges for --strip-debug-non-line
+  SmallString<0> ReducedDebugData;
+
   // Used for implementation of --compress-debug-sections option.
   std::vector<uint8_t> ZDebugHeader;
   llvm::SmallVector<char, 1> CompressedData;
 
   std::array<uint8_t, 4> getFiller();
 };
 
 int getPriority(StringRef S);

lld/ELF/OutputSections.cpp

template <class ELFT> void OutputSection::maybeCompress() {
   ZDebugHeader.resize(sizeof(Elf_Chdr));
   auto *Hdr = reinterpret_cast<Elf_Chdr *>(ZDebugHeader.data());
   Hdr->ch_type = ELFCOMPRESS_ZLIB;
   Hdr->ch_size = Size;
   Hdr->ch_addralign = Alignment;
 
   // Write section contents to a temporary buffer and compress it.
   std::vector<uint8_t> Buf(Size);
+  if (ReducedDebugData.empty())
     writeTo<ELFT>(Buf.data());
-  if (Error E = zlib::compress(toStringRef(Buf), CompressedData))
+  if (Error E = zlib::compress(
+        ReducedDebugData.empty()
+        ? toStringRef(Buf)
+        : StringRef(ReducedDebugData.data(), ReducedDebugData.size()),
+        CompressedData))
     fatal("compress failed: " + llvm::toString(std::move(E)));
 
+  {
+    // Free memory.
+    using std::swap;
+    decltype(ReducedDebugData) tmp;
+    swap(ReducedDebugData, tmp);
+  }
+
   // Update section headers.
   Size = sizeof(Elf_Chdr) + CompressedData.size();
   Flags |= SHF_COMPRESSED;
 }
 
 static void writeInt(uint8_t *Buf, uint64_t Data, uint64_t Size) {
   if (Size == 1)
     *Buf = Data;
   else if (Size == 2)
     write16(Buf, Data);
   else if (Size == 4)
     write32(Buf, Data);
   else if (Size == 8)
     write64(Buf, Data);
   else
     llvm_unreachable("unsupported Size argument");
 }
 
 template <class ELFT> void OutputSection::writeTo(uint8_t *Buf) {
   if (Type == SHT_NOBITS)
     return;
 
-  // If -compress-debug-section is specified and if this is a debug seciton,
+  // If --compress-debug-section is specified and if this is a debug section,
   // we've already compressed section contents. If that's the case,
   // just write it down.
   if (!CompressedData.empty()) {
     memcpy(Buf, ZDebugHeader.data(), ZDebugHeader.size());
     memcpy(Buf + ZDebugHeader.size(), CompressedData.data(),
            CompressedData.size());
     return;
   }
 
+  // If --strip-debug-non-line is specified and if this is a debug section,
+  // we've already reduced section contents. If that's the case,
+  // just write it down.
+  if (!ReducedDebugData.empty()) {
+    memcpy(Buf, ReducedDebugData.data(), ReducedDebugData.size());
+    return;
+  }
+
   // Write leading padding.
   std::vector<InputSection *> Sections = getInputSections(this);
   std::array<uint8_t, 4> Filler = getFiller();
   bool NonZeroFiller = read32(Filler.data()) != 0;
   if (NonZeroFiller)
     fill(Buf, Sections.empty() ? Size : Sections[0]->OutSecOff, Filler);
 
   parallelForEachN(0, Sections.size(), [&](size_t I) {

lld/ELF/Writer.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Threads.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
+#include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/LEB128.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/xxhash.h"
 #include <climits>
+#include <unordered_map>
+#include <vector>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 
 using namespace lld;
private:
   void forEachRelSec(llvm::function_ref<void(InputSectionBase &)> Fn);
   void sortSections();
   void resolveShfLinkOrder();
   void finalizeAddressDependentContent();
   void sortInputSections();
   void finalizeSections();
   void checkExecuteOnly();
   void setReservedSymbolSections();
+  void reduceNonLineDwarfDebug();
 
   std::vector<PhdrEntry *> createPhdrs(Partition &Part);
   void removeEmptyPTLoad(std::vector<PhdrEntry *> &PhdrEntry);
   void addPhdrForSection(Partition &Part, unsigned ShType, unsigned PType,
                          unsigned PFlags);
   void assignFileOffsets();
   void assignFileOffsetsBinary();
   void setPhdrs(Partition &Part);
template <class ELFT> void Writer<ELFT>::run() {
   // finalizeSections does that.
   finalizeSections();
   checkExecuteOnly();
   if (errorCount())
     return;
 
   Script->assignAddresses();
 
+  // If --strip-debug-non-line is specified reduce the .debug_abbrev/.debug_info
+  // sections. Do it right now because:
+  // - it changes the size of output sections,
+  // - OutputSection::maybeCompress should compress the reduced sections.
+  if (Config->Strip == StripPolicy::DebugNonLine)
+    reduceNonLineDwarfDebug();
+
   // If -compressed-debug-sections is specified, we need to compress
   // .debug_* sections. Do it right now because it changes the size of
   // output sections.
   for (OutputSection *Sec : OutputSections)
     Sec->maybeCompress<ELFT>();
 
   Script->allocateHeaders(Main->Phdrs);
 
for (Partition &Part : Partitions) {
     for (EhInputSection *ES : Part.EhFrame->Sections)
       Fn(*ES);
     if (Part.ARMExidx && Part.ARMExidx->isLive())
       for (InputSection *Ex : Part.ARMExidx->ExidxSections)
         Fn(*Ex);
   }
 }
 
+template <typename value_type>
+void writeInt(raw_ostream &OS, value_type value, endianness endian) {
+  value = byte_swap<value_type>(value, endian);
+  OS.write(reinterpret_cast<const char *>(&value), sizeof(value_type));
+}
+
+template <class ELFT> void Writer<ELFT>::reduceNonLineDwarfDebug() {
+  OutputSection *AbbrSec = nullptr;
+  OutputSection *ArangesSec = nullptr;
+  OutputSection *InfoSec = nullptr;
+  for (OutputSection *Sec : OutputSections) {
+    if (Sec->Name == ".debug_abbrev")
+      AbbrSec = Sec;
+    else if (Sec->Name == ".debug_info")
+      InfoSec = Sec;
+    else if (Sec->Name == ".debug_aranges")
+      ArangesSec = Sec;
+  }
+
+  if (AbbrSec == nullptr || InfoSec == nullptr)
+    return;
+
+  std::vector<uint8_t> AbbrBuf(AbbrSec->Size);
+  AbbrSec->writeTo<ELFT>(AbbrBuf.data());
+  std::vector<uint8_t> InfoBuf(InfoSec->Size);
+  InfoSec->writeTo<ELFT>(InfoBuf.data());
+
+  auto Endian = ELFT::TargetEndianness;
+  auto MakeDataExtractor = [](StringRef Data) {
+    uint8_t AddressSize = Config->Is64 ? 8 : 4;
+    return llvm::DataExtractor(Data, Config->IsLE, AddressSize);
+  };
+
+  // map original -> reduced (AbbrevCode, AbbrOffset)
+  std::unordered_map<std::pair<uint64_t, uint32_t>,
+                     std::pair<uint64_t, uint32_t>,
+                     pair_hash<uint64_t, uint32_t>>
+      AbbrCodeOffMap;
+  SmallString<0> ReducedAbbr;
+  // Reduce .debug_abbrev
+  {
+    raw_svector_ostream OS(ReducedAbbr);
+    llvm::DataExtractor AbbrData = MakeDataExtractor(toStringRef(AbbrBuf));
+    uint32_t AbbrOffset = 0;
+    uint64_t ReducedAbbrCode = 0;
+    while (AbbrOffset < AbbrData.getData().size()) {
+      uint32_t AbbrStart = AbbrOffset;
+      while (uint64_t AbbrCode = AbbrData.getULEB128(&AbbrOffset)) {
+        uint64_t AbbrType = AbbrData.getULEB128(&AbbrOffset);
+        // This would ordinarily be the has_children
+        // field of the abbreviation.  But it's going to
+        // be false after reducing the information, so
+        // there's no point in storing it.
+        AbbrData.getU8(&AbbrOffset);
+
+        // Read to the end of the current abbreviation.
+        // This is indicated by two zero unsigned LEBs
+        // in a row.  We don't need to parse the data
+        // yet, so we just scan through the data looking
+        // for two consecutive 0 bytes indicating the
+        // end of the abbreviation.
+        uint32_t AbbrEnd = AbbrOffset;
+        while ((AbbrEnd + 1 < AbbrData.getData().size()) &&
+               (AbbrData.getData()[AbbrEnd] ||
+                AbbrData.getData()[AbbrEnd + 1]))
+          AbbrEnd++;
+        // Account for the two nulls and advance to the
+        // start of the next abbreviation.
+        AbbrEnd += 2;
+
+        if (AbbrType == dwarf::DW_TAG_compile_unit) {
+          ReducedAbbrCode++;
+          encodeULEB128(ReducedAbbrCode, OS);
+          encodeULEB128(AbbrType, OS);
+          OS.write(0); // has_children: false
+          AbbrCodeOffMap[std::make_pair(AbbrCode, AbbrStart)] =
+              std::make_pair(ReducedAbbrCode, OS.str().size());
+          OS << AbbrData.getData().slice(AbbrOffset, AbbrEnd);
+        }
+        AbbrOffset = AbbrEnd;
+      }
+    }
+    // Null terminate the list of abbreviations
+    OS.write(0);
+  }
+
+  // map original -> reduced offsets to start of DIE
+  std::unordered_map<uint32_t, uint32_t> InfoOffMap;
+  SmallString<0> ReducedInfo;
+  // Reduce .debug_info
+  {
+    llvm::DataExtractor InfoData = MakeDataExtractor(toStringRef(InfoBuf));
+    llvm::DataExtractor ReducedAbbrData =
+        MakeDataExtractor(StringRef(ReducedAbbr.data(), ReducedAbbr.size()));
+
+    raw_svector_ostream OS(ReducedInfo);
+    uint32_t InfoOffset = 0;
+    while (InfoOffset < InfoData.getData().size()) {
+      uint32_t InfoStart = InfoOffset;
+      uint32_t Length = InfoData.getU32(&InfoOffset);
+      dwarf::DwarfFormat Format = dwarf::DwarfFormat::DWARF32;
+      if (Length == 0xFFFFFFFF) {
+        Format = llvm::dwarf::DwarfFormat::DWARF64;
+        Length = InfoData.getU64(&InfoOffset);
+      }
+      bool IsDWARF64 = Format == llvm::dwarf::DwarfFormat::DWARF64;
+      uint32_t SizeOfLength = IsDWARF64 ? sizeof(uint64_t) : sizeof(uint32_t);
+
+      uint32_t NextInfoOffset = InfoOffset + Length;
+      uint16_t Version = InfoData.getU16(&InfoOffset);
+
+      uint8_t UnitType = 0;
+      uint32_t AbbrOffset = 0;
+      uint8_t AddrSize = 0;
+      if (Version >= 5) {
+        UnitType = InfoData.getU8(&InfoOffset);
+        AddrSize = InfoData.getU8(&InfoOffset);
+        AbbrOffset = InfoData.getUnsigned(&InfoOffset, SizeOfLength);
+      } else {
+        AbbrOffset = InfoData.getUnsigned(&InfoOffset, SizeOfLength);
+        AddrSize = InfoData.getU8(&InfoOffset);
+      }
+      uint64_t AbbrCode = InfoData.getULEB128(&InfoOffset);
+
+      auto It = AbbrCodeOffMap.find(std::make_pair(AbbrCode, AbbrOffset));
+      if (It == AbbrCodeOffMap.end()) {
+        warn("Will not reduce debug_abbrev/debug_info: failed to find "
+             "abbrev mapping for AbbrCode: " +
+             toString(AbbrCode) + " AbbrOffset: " + toString(AbbrOffset));
+        return;
+      }
+      std::tie(AbbrCode, AbbrOffset) = It->second;
+      uint32_t AttrStart = InfoOffset;
+      do {
+        uint32_t Name = ReducedAbbrData.getULEB128(&AbbrOffset);
+        auto Form =
+            static_cast<dwarf::Form>(ReducedAbbrData.getULEB128(&AbbrOffset));
+        if (Name == 0 && Form == 0)
+          break;
+        DWARFFormValue::skipValue(
+            Form, InfoData, &InfoOffset,
+            dwarf::FormParams({Version, AddrSize, Format}));
+      } while (true);
+
+      InfoOffMap[InfoStart] = OS.str().size();
+
+      Length = sizeof(Version) + ((Version >= 5) ? sizeof(UnitType) : 0) +
+               SizeOfLength + sizeof(AddrSize) + getULEB128Size(AbbrCode) +
+               (InfoOffset - AttrStart);
+      if (IsDWARF64) {
+        writeInt(OS, uint32_t(0xFFFFFFFF), Endian);
+        writeInt(OS, uint64_t(Length), Endian);
+      } else
+        writeInt(OS, Length, Endian);
+      writeInt(OS, Version, Endian);
+      if (Version >= 5) {
+        writeInt(OS, UnitType, Endian);
+        writeInt(OS, AddrSize, Endian);
+        if (IsDWARF64)
+          writeInt(OS, uint64_t(0), Endian); // Offset: 0
+        else
+          writeInt(OS, uint32_t(0), Endian); // Offset: 0
+      } else {
+        if (IsDWARF64)
+          writeInt(OS, uint64_t(0), Endian); // Offset: 0
+        else
+          writeInt(OS, uint32_t(0), Endian); // Offset: 0
+        writeInt(OS, AddrSize, Endian);
+      }
+      encodeULEB128(AbbrCode, OS);
+      OS << InfoData.getData().slice(AttrStart, InfoOffset);
+      InfoOffset = NextInfoOffset;
+    }
+  }
+
+  AbbrSec->setReducedDebugData(std::move(ReducedAbbr));
+  InfoSec->setReducedDebugData(std::move(ReducedInfo));
+  if (!ArangesSec)
+    return;
+
+  // Fixup references from .debug_aranges to reduced .debug_info
+  SmallString<0> ReducedAranges;
+  ReducedAranges.resize(ArangesSec->Size);
+  ArangesSec->writeTo<ELFT>(reinterpret_cast<uint8_t*>(&ReducedAranges[0]));
+  {
+    char *Aranges = &ReducedAranges[0];
+    uint32_t ArangesOffset = 0;
+    auto endian = ELFT::TargetEndianness;
+    while (ArangesOffset < ReducedAranges.size()) {
+      uint32_t Length = endian::read32(Aranges + ArangesOffset, endian);
+      ArangesOffset += sizeof(uint32_t);
+      bool IsDWARF64 = false;
+      if (Length == 0xFFFFFFFF) {
+        IsDWARF64 = true;
+        Length = endian::read64(Aranges + ArangesOffset, endian);
+        ArangesOffset += sizeof(uint64_t);
+      }
+      uint32_t NextArangesOffset = ArangesOffset + Length;
+
+      ArangesOffset += 2; // Skip over version (u16).
+      uint32_t InfoOffset =
+          IsDWARF64 ? endian::read64(Aranges + ArangesOffset, endian)
+                    : endian::read32(Aranges + ArangesOffset, endian);
+      auto It = InfoOffMap.find(InfoOffset);
+      if (It != InfoOffMap.end()) {
+        if (IsDWARF64)
+          endian::write64(Aranges + ArangesOffset, It->second, endian);
+        else
+          endian::write32(Aranges + ArangesOffset, It->second, endian);
+      }
+      ArangesOffset = NextArangesOffset;
+    }
+  }
+  ArangesSec->setReducedDebugData(std::move(ReducedAranges));
+}
+
 // This function generates assignments for predefined symbols (e.g. _end or
 // _etext) and inserts them into the commands sequence to be processed at the
 // appropriate time. This ensures that the value is going to be correct by the
 // time any references to these symbols are processed and is equivalent to
 // defining these symbols explicitly in the linker script.
 template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() {
   if (ElfSym::GlobalOffsetTable) {
     // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention usually

lld/test/ELF/Inputs/strip-debug-non-line-multi-cu-bar.s

+# Generated with:
+# echo "int bar() { return 0; }" | \
+# clang++ -Os -g -S -x c - -Xclang -fdebug-compilation-dir -Xclang . -gdwarf-aranges -o -
+
+
+  .text
+  .file  "-"
+  .globl  bar
+bar:
+.Lfunc_begin0:
+  .file  1 "." "<stdin>"
+  xorl  %eax, %eax
+  retq
+.Lfunc_end0:
+  .size  bar, .Lfunc_end0-bar
+
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "clang version 9.0.0 (https://github.com/llvm/llvm-project 01a99c0aa5ae5be47ea62bd6c87ca6bb63f5a454)"
+.Linfo_string1:
+  .asciz  "-"
+.Linfo_string2:
+  .asciz  "."
+.Linfo_string3:
+  .asciz  "bar"
+.Linfo_string4:
+  .asciz  "int"
+
+
+  .section  .debug_abbrev,"",@progbits
+  .byte  1                       # Abbreviation Code
+  .byte  17                      # DW_TAG_compile_unit
+  .byte  1                       # DW_CHILDREN_yes
+  .byte  37                      # DW_AT_producer
+  .byte  14                      # DW_FORM_strp
+  .byte  19                      # DW_AT_language
+  .byte  5                       # DW_FORM_data2
+  .byte  3                       # DW_AT_name
+  .byte  14                      # DW_FORM_strp
+  .byte  16                      # DW_AT_stmt_list
+  .byte  23                      # DW_FORM_sec_offset
+  .byte  27                      # DW_AT_comp_dir
+  .byte  14                      # DW_FORM_strp
+  .byte  17                      # DW_AT_low_pc
+  .byte  1                       # DW_FORM_addr
+  .byte  18                      # DW_AT_high_pc
+  .byte  6                       # DW_FORM_data4
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  2                       # Abbreviation Code
+  .byte  46                      # DW_TAG_subprogram
+  .byte  0                       # DW_CHILDREN_no
+  .byte  17                      # DW_AT_low_pc
+  .byte  1                       # DW_FORM_addr
+  .byte  18                      # DW_AT_high_pc
+  .byte  6                       # DW_FORM_data4
+  .byte  64                      # DW_AT_frame_base
+  .byte  24                      # DW_FORM_exprloc
+  .byte  3                       # DW_AT_name
+  .byte  14                      # DW_FORM_strp
+  .byte  58                      # DW_AT_decl_file
+  .byte  11                      # DW_FORM_data1
+  .byte  59                      # DW_AT_decl_line
+  .byte  11                      # DW_FORM_data1
+  .byte  73                      # DW_AT_type
+  .byte  19                      # DW_FORM_ref4
+  .byte  63                      # DW_AT_external
+  .byte  25                      # DW_FORM_flag_present
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  3                       # Abbreviation Code
+  .byte  36                      # DW_TAG_base_type
+  .byte  0                       # DW_CHILDREN_no
+  .byte  3                       # DW_AT_name
+  .byte  14                      # DW_FORM_strp
+  .byte  62                      # DW_AT_encoding
+  .byte  11                      # DW_FORM_data1
+  .byte  11                      # DW_AT_byte_size
+  .byte  11                      # DW_FORM_data1
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  0                       # EOM(3)
+
+
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long  .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+  .short  4                      # DWARF version number
+  .long  .debug_abbrev           # Offset Into Abbrev. Section
+  .byte  8                       # Address Size (in bytes)
+  .byte  1                       # Abbrev [1] 0xb:0x40 DW_TAG_compile_unit
+  .long  .Linfo_string0          # DW_AT_producer
+  .short  12                     # DW_AT_language
+  .long  .Linfo_string1          # DW_AT_name
+  .long  .Lline_table_start0     # DW_AT_stmt_list
+  .long  .Linfo_string2          # DW_AT_comp_dir
+  .quad  .Lfunc_begin0           # DW_AT_low_pc
+  .long  .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc
+  .byte  2                       # Abbrev [2] 0x2a:0x19 DW_TAG_subprogram
+  .quad  .Lfunc_begin0           # DW_AT_low_pc
+  .long  .Lfunc_end0-.Lfunc_begin0 # DW_AT_high_pc
+  .byte  1                       # DW_AT_frame_base
+  .byte  87
+  .long  .Linfo_string3          # DW_AT_name
+  .byte  1                       # DW_AT_decl_file
+  .byte  1                       # DW_AT_decl_line
+  .long  67                      # DW_AT_type
+                                 # DW_AT_external
+  .byte  3                       # Abbrev [3] 0x43:0x7 DW_TAG_base_type
+  .long  .Linfo_string4          # DW_AT_name
+  .byte  5                       # DW_AT_encoding
+  .byte  4                       # DW_AT_byte_size
+  .byte  0                       # End Of Children Mark
+.Ldebug_info_end0:
+  .text
+.Lsec_end0:
+
+
+  .section  .debug_aranges,"",@progbits
+  .long  44                      # Length of ARange Set
+  .short  2                      # DWARF Arange version number
+  .long  .Lcu_begin0             # Offset Into Debug Info Section
+  .byte  8                       # Address Size (in bytes)
+  .byte  0                       # Segment Size (in bytes)
+  .zero  4,255
+  .quad  .Lfunc_begin0
+  .quad  .Lsec_end0-.Lfunc_begin0
+  .quad  0                       # ARange terminator
+  .quad  0
+
+
+  .section  .debug_macinfo,"",@progbits
+  .byte  0                       # End Of Macro List Mark
+
+
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

lld/test/ELF/strip-debug-non-line-dwarf5.s

+# REQUIRES: x86
+# RUN: llvm-mc -g -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld %t.o -o %t --strip-debug-non-line
+# RUN: llvm-readobj --sections --symbols %t | FileCheck %s --check-prefix=CHECK-READOBJ
+# RUN: llvm-dwarfdump --verify %t
+# RUN: llvm-dwarfdump --debug-info %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP-INFO
+# RUN: llvm-dwarfdump --debug-abbrev %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP-ABBREV
+# RUN: llvm-dwarfdump --debug-aranges %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP-ARANGES
+
+# CHECK-READOBJ: Name: .{{z?}}debug_str_offsets
+# CHECK-READOBJ: Name: .{{z?}}debug_str
+# CHECK-READOBJ: Name: .{{z?}}debug_abbrev
+# CHECK-READOBJ: Name: .{{z?}}debug_info
+# CHECK-READOBJ: Name: .{{z?}}debug_aranges
+# CHECK-READOBJ: Name: .{{z?}}debug_addr
+# CHECK-READOBJ: Name: .{{z?}}debug_line
+
+# CHECK-DWARFDUMP-INFO: .debug_info contents:
+# CHECK-DWARFDUMP-INFO: 0x0000000c: DW_TAG_compile_unit
+
+# CHECK-DWARFDUMP-ABBREV: [1] DW_TAG_compile_unit  DW_CHILDREN_no
+
+# CHECK-DWARFDUMP-ARANGES: Address Range Header: {{.*}} cu_offset = 0x00000000,
+
+
+    .text
+    .file    "-"
+    .globl    foo
+foo:
+.Lfunc_begin0:
+    .file    1 "<stdin>" md5 0xfa8c32d051b37d67a98b03bc8cdbbf02
+    xorl    %eax, %eax
+    retq
+.Lfunc_end0:
+    .size    foo, .Lfunc_end0-foo
+
+    .globl    _start
+    .type    _start,@function
+_start:
+.Lfunc_begin1:
+    retq
+.Lfunc_end1:
+    .size    _start, .Lfunc_end1-_start
+
+
+    .section    .debug_str_offsets,"",@progbits
+    .long    28
+    .short    5
+    .short    0
+.Lstr_offsets_base0:
+
+
+    .section    .debug_str,"MS",@progbits,1
+.Linfo_string4:
+    .asciz    "int"
+.Linfo_string5:
+    .asciz    "_start"
+    .section    .debug_str_offsets,"",@progbits
+    .long    .Linfo_string4
+    .long    .Linfo_string5
+
+
+    .section    .debug_abbrev,"",@progbits
+    .byte    1                       # Abbreviation Code
+    .byte    17                      # DW_TAG_compile_unit
+    .byte    1                       # DW_CHILDREN_yes
+    .byte    19                      # DW_AT_language
+    .byte    5                       # DW_FORM_data2
+    .byte    0                       # EOM(1)
+    .byte    0                       # EOM(2)
+    .byte    2                       # Abbreviation Code
+    .byte    46                      # DW_TAG_subprogram
+    .byte    0                       # DW_CHILDREN_no
+    .byte    58                      # DW_AT_decl_file
+    .byte    11                      # DW_FORM_data1
+    .byte    59                      # DW_AT_decl_line
+    .byte    11                      # DW_FORM_data1
+    .byte    0                       # EOM(1)
+    .byte    0                       # EOM(2)
+    .byte    3                       # Abbreviation Code
+    .byte    46                      # DW_TAG_subprogram
+    .byte    0                       # DW_CHILDREN_no
+    .byte    58                      # DW_AT_decl_file
+    .byte    11                      # DW_FORM_data1
+    .byte    59                      # DW_AT_decl_line
+    .byte    11                      # DW_FORM_data1
+    .byte    0                       # EOM(1)
+    .byte    0                       # EOM(2)
+    .byte    4                       # Abbreviation Code
+    .byte    36                      # DW_TAG_base_type
+    .byte    0                       # DW_CHILDREN_no
+    .byte    3                       # DW_AT_name
+    .byte    37                      # DW_FORM_strx1
+    .byte    62                      # DW_AT_encoding
+    .byte    11                      # DW_FORM_data1
+    .byte    11                      # DW_AT_byte_size
+    .byte    11                      # DW_FORM_data1
+    .byte    0                       # EOM(1)
+    .byte    0                       # EOM(2)
+    .byte    0                       # EOM(3)
+
+
+    .section    .debug_info,"",@progbits
+.Lcu_begin0:
+    .long    .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+    .short    5                      # DWARF version number
+    .byte    1                       # DWARF Unit Type
+    .byte    8                       # Address Size (in bytes)
+    .long    .debug_abbrev           # Offset Into Abbrev. Section
+    .byte    1                       # Abbrev [1] 0xc:0x36 DW_TAG_compile_unit
+    .short    12                     # DW_AT_language
+    .byte    2                       # Abbrev [2] 0x23:0xf DW_TAG_subprogram
+    .byte    1                       # DW_AT_decl_file
+    .byte    1                       # DW_AT_decl_line
+    .byte    3                       # Abbrev [3] 0x32:0xb DW_TAG_subprogram
+    .byte    1                       # DW_AT_decl_file
+    .byte    1                       # DW_AT_decl_line
+    .byte    4                       # Abbrev [4] 0x3d:0x4 DW_TAG_base_type
+    .byte    4                       # DW_AT_name
+    .byte    5                       # DW_AT_encoding
+    .byte    4                       # DW_AT_byte_size
+    .byte    0                       # End Of Children Mark
+.Ldebug_info_end0:
+    .text
+.Lsec_end0:
+
+
+    .section    .debug_aranges,"",@progbits
+    .long    44                      # Length of ARange Set
+    .short    2                      # DWARF Arange version number
+    .long    .Lcu_begin0             # Offset Into Debug Info Section
+    .byte    8                       # Address Size (in bytes)
+    .byte    0                       # Segment Size (in bytes)
+    .zero    4,255
+    .quad    .Lfunc_begin0
+    .quad    .Lsec_end0-.Lfunc_begin0
+    .quad    0                       # ARange terminator
+    .quad    0
+
+
+    .section    .debug_macinfo,"",@progbits
+    .byte    0                       # End Of Macro List Mark
+
+
+    .section    .debug_addr,"",@progbits
+    .long    .Ldebug_addr_end0-.Ldebug_addr_start0 # Length of contribution
+.Ldebug_addr_start0:
+    .short    5                      # DWARF version number
+    .byte    8                       # Address size
+    .byte    0                       # Segment selector size
+.Laddr_table_base0:
+    .quad    .Lfunc_begin0
+    .quad    .Lfunc_begin1
+.Ldebug_addr_end0:
+
+
+    .section    .debug_line,"",@progbits
+.Lline_table_start0:

lld/test/ELF/strip-debug-non-line-multi-cu.s

+# REQUIRES: x86
+# RUN: llvm-mc -g -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: llvm-mc -g -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/strip-debug-non-line-multi-cu-bar.s -o %tbar.o
+# RUN: ld.lld %t.o %tbar.o -o %t --strip-debug-non-line
+# RUN: llvm-readobj --sections --symbols %t | FileCheck %s --check-prefix=CHECK-READOBJ
+# RUN: llvm-dwarfdump --verify %t
+# RUN: llvm-dwarfdump --debug-info %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP-INFO
+# RUN: llvm-dwarfdump --debug-abbrev %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP-ABBREV
+# RUN: llvm-dwarfdump --debug-aranges %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP-ARANGES
+
+# CHECK-READOBJ: Name: .debug_str
+# CHECK-READOBJ: Name: .{{z?}}debug_abbrev
+# CHECK-READOBJ: Name: .{{z?}}debug_info
+# CHECK-READOBJ: Name: .{{z?}}debug_aranges
+# CHECK-READOBJ: Name: .{{z?}}debug_line
+
+# CHECK-DWARFDUMP-INFO: .debug_info contents:
+# CHECK-DWARFDUMP-INFO: 0x0000000b: DW_TAG_compile_unit
+# CHECK-DWARFDUMP-INFO: 0x00000019: DW_TAG_compile_unit
+
+# CHECK-DWARFDUMP-ABBREV: [1] DW_TAG_compile_unit  DW_CHILDREN_no
+# CHECK-DWARFDUMP-ABBREV: [2] DW_TAG_compile_unit  DW_CHILDREN_no
+
+# CHECK-DWARFDUMP-ARANGES: Address Range Header: {{.*}} cu_offset = 0x00000000,
+# CHECK-DWARFDUMP-ARANGES: Address Range Header: {{.*}} cu_offset = 0x0000000e,
+
+
+# Generated with:
+# echo "int bar(); void _start() { bar(); }" | \
+# clang++ -Os -g -S -x c - -Xclang -fdebug-compilation-dir -Xclang . -gdwarf-aranges -o -
+
+
+  .text
+  .file  "-"
+  .globl  _start
+_start:
+.Lfunc_begin0:
+  .file  1 "." "<stdin>"
+  xorl  %eax, %eax
+  jmp  bar
+.Lfunc_end0:
+  .size  _start, .Lfunc_end0-_start
+
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string3:
+  .asciz  "_start"
+
+
+  .section  .debug_abbrev,"",@progbits
+  .byte  1                       # Abbreviation Code
+  .byte  17                      # DW_TAG_compile_unit
+  .byte  1                       # DW_CHILDREN_yes
+  .byte  19                      # DW_AT_language
+  .byte  5                       # DW_FORM_data2
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  2                       # Abbreviation Code
+  .byte  46                      # DW_TAG_subprogram
+  .byte  0                       # DW_CHILDREN_no
+  .byte  58                      # DW_AT_decl_file
+  .byte  11                      # DW_FORM_data1
+  .byte  59                      # DW_AT_decl_line
+  .byte  11                      # DW_FORM_data1
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  0                       # EOM(3)
+
+
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long  .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+  .short  4                      # DWARF version number
+  .long  .debug_abbrev           # Offset Into Abbrev. Section
+  .byte  8                       # Address Size (in bytes)
+  .byte  1                       # Abbrev [1] 0xb:0x35 DW_TAG_compile_unit
+  .short  12                     # DW_AT_language
+  .byte  2                       # Abbrev [2] 0x2a:0x15 DW_TAG_subprogram
+  .byte  1                       # DW_AT_decl_file
+  .byte  1                       # DW_AT_decl_line
+                                 # DW_AT_external
+  .byte  0                       # End Of Children Mark
+.Ldebug_info_end0:
+  .text
+.Lsec_end0:
+
+
+  .section  .debug_aranges,"",@progbits
+  .long  44                      # Length of ARange Set
+  .short  2                      # DWARF Arange version number
+  .long  .Lcu_begin0             # Offset Into Debug Info Section
+  .byte  8                       # Address Size (in bytes)
+  .byte  0                       # Segment Size (in bytes)
+  .zero  4,255
+  .quad  .Lfunc_begin0
+  .quad  .Lsec_end0-.Lfunc_begin0
+  .quad  0                       # ARange terminator
+  .quad  0
+
+
+  .section  .debug_macinfo,"",@progbits
+  .byte  0                       # End Of Macro List Mark
+
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

lld/test/ELF/strip-debug-non-line.s

+# REQUIRES: x86
+# RUN: llvm-mc -g -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: ld.lld %t.o -o %t --strip-debug-non-line
+# RUN: llvm-readobj --sections --symbols %t | FileCheck %s --check-prefix=CHECK-READOBJ
+# RUN: llvm-dwarfdump --verify %t
+# RUN: llvm-dwarfdump --debug-info %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP-INFO
+# RUN: llvm-dwarfdump --debug-abbrev %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP-ABBREV
+# RUN: llvm-dwarfdump --debug-aranges %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP-ARANGES
+
+# CHECK-READOBJ: Name: .{{z?}}debug_str
+# CHECK-READOBJ: Name: .{{z?}}debug_abbrev
+# CHECK-READOBJ: Name: .{{z?}}debug_info
+# CHECK-READOBJ: Name: .{{z?}}debug_aranges
+# CHECK-READOBJ: Name: .{{z?}}debug_line
+
+# CHECK-DWARFDUMP-INFO: .debug_info contents:
+# CHECK-DWARFDUMP-INFO: 0x0000000b: DW_TAG_compile_unit
+
+# CHECK-DWARFDUMP-ABBREV: [1] DW_TAG_compile_unit  DW_CHILDREN_no
+
+# CHECK-DWARFDUMP-ARANGES: Address Range Header: {{.*}} cu_offset = 0x00000000,
+
+
+# Generated with:
+# echo "int foo() { return 0; } void _start() { foo(); }" | \
+# clang++ -Os -g -S -x c - -Xclang -fdebug-compilation-dir -Xclang . -gdwarf-aranges -o -
+
+  .text
+  .globl  foo
+foo:
+.Lfunc_begin0:
+  .file  1 "." "<stdin>"
+  xorl  %eax, %eax
+  retq
+.Lfunc_end0:
+  .size  foo, .Lfunc_end0-foo
+
+  .globl  _start
+_start:
+  retq
+.Lfunc_end1:
+  .size  _start, .Lfunc_end1-_start
+
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string4:
+  .asciz  "int"
+
+
+  .section  .debug_abbrev,"",@progbits
+  .byte  1                       # Abbreviation Code
+  .byte  17                      # DW_TAG_compile_unit
+  .byte  1                       # DW_CHILDREN_yes
+  .byte  19                      # DW_AT_language
+  .byte  5                       # DW_FORM_data2
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  2                       # Abbreviation Code
+  .byte  46                      # DW_TAG_subprogram
+  .byte  0                       # DW_CHILDREN_no
+  .byte  58                      # DW_AT_decl_file
+  .byte  11                      # DW_FORM_data1
+  .byte  59                      # DW_AT_decl_line
+  .byte  11                      # DW_FORM_data1
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  3                       # Abbreviation Code
+  .byte  46                      # DW_TAG_subprogram
+  .byte  0                       # DW_CHILDREN_no
+  .byte  58                      # DW_AT_decl_file
+  .byte  11                      # DW_FORM_data1
+  .byte  59                      # DW_AT_decl_line
+  .byte  11                      # DW_FORM_data1
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  4                       # Abbreviation Code
+  .byte  36                      # DW_TAG_base_type
+  .byte  0                       # DW_CHILDREN_no
+  .byte  3                       # DW_AT_name
+  .byte  14                      # DW_FORM_strp
+  .byte  62                      # DW_AT_encoding
+  .byte  11                      # DW_FORM_data1
+  .byte  11                      # DW_AT_byte_size
+  .byte  11                      # DW_FORM_data1
+  .byte  0                       # EOM(1)
+  .byte  0                       # EOM(2)
+  .byte  0                       # EOM(3)
+
+
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long  .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+  .short  4                      # DWARF version number
+  .long  .debug_abbrev           # Offset Into Abbrev. Section
+  .byte  8                       # Address Size (in bytes)
+  .byte  1                       # Abbrev [1] 0xb:0x55 DW_TAG_compile_unit
+  .short  12                     # DW_AT_language
+  .byte  2                       # Abbrev [2] 0x2a:0x19 DW_TAG_subprogram
+  .byte  1                       # DW_AT_decl_file
+  .byte  1                       # DW_AT_decl_line
+  .byte  3                       # Abbrev [3] 0x43:0x15 DW_TAG_subprogram
+  .byte  1                       # DW_AT_decl_file
+  .byte  1                       # DW_AT_decl_line
+  .byte  4                       # Abbrev [4] 0x58:0x7 DW_TAG_base_type
+  .long  .Linfo_string4          # DW_AT_name
+  .byte  5                       # DW_AT_encoding
+  .byte  4                       # DW_AT_byte_size
+  .byte  0                       # End Of Children Mark
+.Ldebug_info_end0:
+  .text
+.Lsec_end0:
+
+
+  .section  .debug_aranges,"",@progbits
+  .long  44                      # Length of ARange Set
+  .short  2                      # DWARF Arange version number
+  .long  .Lcu_begin0             # Offset Into Debug Info Section
+  .byte  8                       # Address Size (in bytes)
+  .byte  0                       # Segment Size (in bytes)
+  .zero  4,255
+  .quad  .Lfunc_begin0
+  .quad  .Lsec_end0-.Lfunc_begin0
+  .quad  0                       # ARange terminator
+  .quad  0
+
+
+  .section  .debug_macinfo,"",@progbits
+  .byte  0                       # End Of Macro List Mark
+
+
+  .section  .debug_line,"",@progbits