[llvm-objcopy][llvm-strip] Support --only-keep-debug

[MaskRay]

Summary

--only-keep-debug is used to create separate debug files. In GNU
objcopy, it makes non-SHT_NOTE SHF_ALLOC|SHT_GROUP sections SHT_NOBITS.
The intended use case is:

llvm-objcopy --only-keep-debug a a.dbg  # or llvm-strip --only-keep-debug a -o a.dbg
llvm-objcopy --strip-debug a b
llvm-objcopy --add-gnu-debuglink=a.dbg b

The current sh_offset assignment algorithm is incapable of deleting
space used by sections that are made SHT_NOBITS. Add a new one
customized for --only-keep-debug.

After the rewrite of sh_offset fields, p_offset/p_filesz in program
headers are no longer correct. Just delete program headers. gdb and lldb
can still debug b.

We cannot delete the sections that are made SHT_NOBITS, because gdb will
warn:

// gdb/symfile.c:addr_info_make_relative
warning: section .got not found in /tmp/a.dbg
warning: section .bss.rel.ro not found in /tmp/c/ccls.dbg
...

lldb does not have the warnings.

GNU objcopy does some more things like making SHT_GROUP sections
SHT_NOBITS. --only-keep-debug is not intended for object files and
SHT_GROUP are not kept in ET_EXEC/ET_DYN. We don't copy the behavior.

[MaskRay]

Delete a MemSize change

Delete a comment (layoutBinarySections and layoutSections cannot be merged)

[jhenderson]

preserve-segment-contents.test I'm not sure how to test this. They new layout algorithm no longer leaves holes in the file (the behavior matches GNU objcopy).

I don't see any update to this test. What are you planning on doing with it? We have deliberately decided to deviate from GNU objcopy's behaviour here, because there are many cases where we want to preserve the contents of data within a segment that aren't covered by sections. A good example is 0xcc padding introduced to conform to alignment rules, or linker script modifications. Another example is when --strip-sections has been run on an object, there are no more sections to cover the data, so the bytes need to be preserved.

A fairly major deliberate decision we've agreed on previously in llvm-objcopy is that the layout of sections within a segment is immutable, as is the majority of a program header's fields (p_offset being the only exception I can think of currently). The only thing that can be done is explicitly removing a section, which will cause the resultant hole to be filled with null bytes instead of the old data content. This is because it is impossible to fix up address references etc without effectively relinking the entire program, should sections be compacted within a segment.

I haven't yet looked at the detail of this change, but I wanted to make sure you are aware of these points. I think we can make exceptions to specific aspects of the rules outlined above to ensure certain switches function well, but I'd be reluctant to completely redo the layout algorithm to support such situations, unless the above rules are preserved.

[MaskRay]

[ 1] foo               PROGBITS        0000000000002000 002000 000004 00      0   0  0
[ 2] bar               PROGBITS        0000000000002004 002004 000004 00      0   0  0

GNU objcopy (and this patch) can rewrite sh_offset to smaller addresses starting from 0x900 (assuming sizeof(ehdr)+sizeof(phdr) = 0x900)

[ 1] foo               PROGBITS        0000000000002000 000900 000004 00      0   0  0
[ 2] bar               PROGBITS        0000000000002004 000904 000004 00      0   0  0

If we think this behavior is too subtle, and want segments as immutable as possible (e.g. PR41005),
we can enable the new layout algorithm only when --only-keep-debug is specified. You can find more info in the description of D64906.
My feeling is that such optimization probably only makes sense in the linker. So, it is my mistake to implement it in llvm-objcopy.
(In BFD, the file offset assignment code is shared by GNU ld and objcopy. So their behaviors are very similar.)

To make things easier, we can diverge from GNU objcopy further:
let --only-keep-debug delete all sections except SHT_NOTE and .debug*, and also delete all segments.
Then we can use a very simple layout algorithm:

off = 0
for each note section sec
  off = alignTo(off, sec->align)
  off += sec->size
for each debug section sec
  off = alignTo(off, sec->align)
  off += sec->size

If this scheme looks good, I'll check if debuggers are still happy without phdr and try fixing segment-shift.test with a simpler approach.

[jakehehrlich]

The desired behavior is to keep the program headers intact as much as possible. elf utils for instance just flatout ignores them in this case. Program headers are needed by many tools to matchup the virtual addresses with the sections. I think outside of virtual address and memory size there isn't much that's actully needed in practice however. Ideally we wouldn't even change the file size of segments but I think I've structured llvm-objcopy in a way that makes that difficult unfortunately. I'm 100% ok using a distinct layout algorithm for --only-keep-debug as its a special snowflake where the meaning of segments drastically changes and segments are critical to layout. I'm also ok changing the file size of segments as I don't think its likely to cause a problem with tools like debuggers (there also exist other tools that aren't debuggers that need to perform the same kinds of actions).

Proposed behavoir:

• Program headers are maintained exactly as they went in except their file sizes are set to zero. I think in the past I've pushed back on this but this flag is becoming such a pain point it might be the way forward.
• All sections are maintained except that allocated sections are swapped to be SHT_NOBITS sections
• To maintain the invariant that program headers are not touched elsewhere I'd ask that we only touch program headers in the --only-keep-debug case

If we're willing to set FileSize to zero and we have a good way to replace allocated sections do we need a new layout algorithm? If we still do I'm 100% ok with using it in the --only-keep-debug case.

tools/llvm-objcopy/ELF/Object.cpp

1765

@jhenderson I seem to recall you had a tricky non-allocated data in a segment case. Is this still kosher? Perhaps in that case the sections can write themselves and we don't have to worry about the interstitial data?

1930

I just realized this comment wasn't correctly updated when we fixed the naming convention. OrderSegments should be orderSegments. Would be nice if you could fix this for us but it isn't a requirement for this change.

[MaskRay]

In D67090#1656588, @jakehehrlich wrote:

The desired behavior is to keep the program headers intact as much as possible. elf utils for instance just flatout ignores them in this case. Program headers are needed by many tools to matchup the virtual addresses with the sections. I think outside of virtual address and memory size there isn't much that's actully needed in practice however. Ideally we wouldn't even change the file size of segments but I think I've structured llvm-objcopy in a way that makes that difficult unfortunately. I'm 100% ok using a distinct layout algorithm for --only-keep-debug as its a special snowflake where the meaning of segments drastically changes and segments are critical to layout. I'm also ok changing the file size of segments as I don't think its likely to cause a problem with tools like debuggers (there also exist other tools that aren't debuggers that need to perform the same kinds of actions).

For a separate debug file created by --only-keep-debug, the program header is not used. I tried removing all insignificant sections but gdb would give warnings: .got .dynsym ... etc cannot be found. So I'll stick with the "making insignificant sections SHT_NOBITS" approach. Because sh_offset fields are now rewritten, they no longer match p_offset/p_filesz in program headers. To avoid confusion, I'll just delete program headers.

  if (Config.OnlyKeepDebug)
   RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
     if (RemovePred(Sec))
       return true;
     if (Obj.SectionNames == &Sec)
       return false;
     if (Obj.SymbolTable == &Sec ||
         (Obj.SymbolTable && Obj.SymbolTable->getStrTab() == &Sec))
       return false;
     return !(Sec.Type == SHT_NOTE || isDebugSection(Sec));
   };

// gdb warns:
    warning: section .got not found in /tmp/a.dbg
    warning: section .bss.rel.ro not found in /tmp/c/ccls.dbg

Proposed behavoir:

• Program headers are maintained exactly as they went in except their file sizes are set to zero. I think in the past I've pushed back on this but this flag is becoming such a pain point it might be the way forward.
• All sections are maintained except that allocated sections are swapped to be SHT_NOBITS sections
• To maintain the invariant that program headers are not touched elsewhere I'd ask that we only touch program headers in the --only-keep-debug case

If we're willing to set FileSize to zero and we have a good way to replace allocated sections do we need a new layout algorithm? If we still do I'm 100% ok with using it in the --only-keep-debug case.

[MaskRay]

Use the custom layout algorithm only for --only-keep-debug

This simplies the patch a lot.

The old approach is kept at D67137 for exposition purposes.

[MaskRay]

tools/llvm-objcopy/ELF/Object.cpp

1765

preserve-segment-contents.test is the tricky test. For the new approach for --only-keep-debug, program headers are deleted and sections' sh_offset are rewritten, writeSegmentData should not be called.

1930

There are a few others. Fixed in rL370838.

[grimar]

test/tools/llvm-objcopy/ELF/only-keep-debug.test

29

Perhaps not '.debug_*', but all non-alloc sections (looking at the logic implemented)?

What about adding non-alloc section that is not '.debug_*' to the test?

80

Do you need symbol?

tools/llvm-objcopy/ELF/ELFObjcopy.cpp

491

Avoid auto?

tools/llvm-objcopy/ELF/Object.cpp

1931

Don't use auto?

[MaskRay]

Address review comments: auto -> actual type

test/tools/llvm-objcopy/ELF/only-keep-debug.test

29

Thanks. I added a .comment to test it is not stripped.

80

This is to test --only-keep-debug does not strip .symtab

I guess it may be used by debuggers to help symbolize addresses, i.e. lib/DebugInfo/Symbolize* has logic to override DWARF results with .symtab. gdb and lldb may have similar behaviors but I'm not sure.

Added a comment.

tools/llvm-objcopy/ELF/Object.cpp

1931

Thanks. If I did D67143 first, I should have not written code like this..

[manojgupta]

Thanks for working on it. Have you tested if Linux perf can symbolize the perf traces using the split debug files especially with large binaries?

Meanwhile, I'll try the patch on Chrome OS to verify that gdb and perf still work.

[MaskRay]

@labath to confirm whether it works on lldb if the separate debug file (created by --only-keep-debug) has no program header.

I played with some executable and it appears to work.

[labath]

In D67090#1657449, @MaskRay wrote:

@labath to confirm whether it works on lldb if the separate debug file (created by --only-keep-debug) has no program header.

I played with some executable and it appears to work.

Given how separate debug file handling is implemented in lldb (we just fetch some well known sections from the file (.debug_***, .symtab) and completely ignore everything else), I have a strong belief that this will not cause any problems in lldb. Even if it did cause some problem somehow, it does not sound like it would be too much to ask for lldb to handle this situation (the main file should always have the program headers, and it should be the authoritative source about the in-memory layout of the file).

[jakehehrlich]

We should certainly check perf. I'd also like to wait on this until Roland gets back in order for him to chime in since he had specific examples of use cases where program headers are required as I recall. Specifically the section virtual addresses are not sufficient in the arcane case of prelinking but prelinking isn't really something I know very much about.

tools/llvm-objcopy/ELF/Object.cpp

1786

ELFWriter is never allowed to depend on Config but you're more than welcome to add a flag of some kind to it to know if OnlyKeepDebug is being used.

[jhenderson]

You'll need to update the llvm-objcopy and llvm-strip documentation too, since the --only-keep-debug switch is currently listed as "COFF specific".

test/tools/llvm-objcopy/ELF/only-keep-debug.test

54

Not sure if it works in this situation, but a trick I've used on a number of occasions is to set AddressAlign to some nice round number. yaml2obj then aligns the section offset in the file accordingly, and it's much less likely that the address looks like just a random number.

For example:

- Name: .note
    Address: 0x400
    AddressAlign: 0x400

tools/llvm-objcopy/ELF/Object.cpp

1765

My feeling is that with --only-keep-debug we don't need to do the segment content preservation. The examples I had were a) the section headers were stripped, leaving data in the segments, and b) arbitrary data written to gaps between sections in a segment (e.g. padding bytes). I think in both cases, they are not going to be to do with debugging, so --only-keep-debug can ignore it.

In the case of a section within a segment that is non-alloc, we'd need to write the data still, if we want to strictly conform to what GNU objcopy does (I do slightly question some of the decisions it makes though - why keep NOTEs and arbitrary non-debug PROGBITS sections for example?). An obvious example of this is non-alloc SHT_NOTE sections, but I have seen other examples of non-NOTE sections inside program headers before (particularly platform-specific program headers). However, in every case I know of (aside from the NOTE sections), there's no reason to keep that data.

Anyway, my understanding of the latest version of the code is that sections in segments will still have their data written, so much of this is moot.

[MaskRay]

Update docs/CommandGuide/llvm-objcopy.rst
Use a bool instead of const Config & in ELFWriter

[MaskRay]

In D67090#1657187, @manojgupta wrote:

Thanks for working on it. Have you tested if Linux perf can symbolize the perf traces using the split debug files especially with large binaries?

Meanwhile, I'll try the patch on Chrome OS to verify that gdb and perf still work.

I've learned that @manojgupta actually has a different use case: symbolization without requiring access to the stripped binary. To support that use case, stripping program headers + simple section layout:

+static uint64_t layoutSectionsForOnlyKeepDebug(Object &Obj, uint64_t Off) {
+  uint32_t Index = 1;
+  for (SectionBase &Sec : Obj.sections()) {
+    Sec.Index = Index++;
+    Sec.Offset = alignTo(Off, Sec.Align ? Sec.Align : 1);
+    if (Sec.Type != SHT_NOBITS)
+      Off = Sec.Offset + Sec.Size;
+  }
+  return Off;
+}

cannot be used. We'll need a full-fledged layout algorithm that rewrites p_offset/p_filesz as well as sh_offset - much like the one used in lld/ELF/Writer.cpp (https://reviews.llvm.org/D67137). The problem will be conflicting sources of information.

@jakehehrlich may have a similar use case:

We should certainly check perf. I'd also like to wait on this until Roland gets back in order for him to chime in since he had specific examples of use cases where program headers are required as I recall. Specifically the section virtual addresses are not sufficient in the arcane case of prelinking but prelinking isn't really something I know very much about.

I think going the program header rewriting route needs more thoughts. It should be a separate change. It is also fairly difficult to validate because an end-to-end test going through their symbolization pipeline is likely required.

@kongyi and @pirama What's your use case? Do you need program headers?

test/tools/llvm-objcopy/ELF/only-keep-debug.test

54

It works for the first section but not for subsequent sections which are in different PT_LOAD segments.

I want to teach yaml2obj to write section headers at the end so that the offsets will not change when we add/delete sections.

[labath]

In D67090#1659064, @MaskRay wrote:

In D67090#1657187, @manojgupta wrote:

Thanks for working on it. Have you tested if Linux perf can symbolize the perf traces using the split debug files especially with large binaries?

Meanwhile, I'll try the patch on Chrome OS to verify that gdb and perf still work.

I've learned that @manojgupta actually has a different use case: symbolization without requiring access to the stripped binary.

I don't want to digress to much, but since you've mentioned this use case... The main problem I encountered when trying to debug something (with lldb) without the stripped binary was that the separate debug file does not contain the eh_frame section. This meant that lldb was unable to unwind past the first frame, or if it did, the backtrace was largely inaccurate. If you're doing unwinding in this scenario, I'd be curious to hear how you get around this problem.

[MaskRay]

Abandoning this one in favor of D67137. My original plan is to split the functionality into 2 parts, this patch is the first step (no program headers), which should work for most consumers of separate debug files, while the second step (D67137) adds the program headers back and rewrites p_offset/p_filesz fields. In an ideal world we do not need step 2, but ChromeOS developers said that symbolization with Linux perf without access to the original executable requires some mechanism mapping file offsets back to VAddr. I haven't dug into the detail but this issue is further complicated by dlopen_with_offset (ELF header may not be at offset 0!) that may be the case on Android (it may not use this term but I've seen this internally in Google, though it may not have such symbolization use cases)... My feeling is that we have to do something similar to GNU objcopy --only-keep-debug in one step, D67137...

docs/CommandGuide/llvm-objcopy.rst

 
  Enable deterministic mode when copying archives, i.e. use 0 for archive member
  header UIDs, GIDs and timestamp fields. On by default.
 
 .. option:: --help, -h
 
  Print a summary of command line options.
 
+.. option:: --only-keep-debug
+
+ Remove the contents of non-debug sections from the output, but keep the section
+ headers.
+
 .. option:: --only-section <section>, -j
 
  Remove all sections from the output, except for sections named ``<section>``.
  Can be specified multiple times to keep multiple sections.
 
 .. option:: --regex
 
  If specified, symbol and section names specified by other switches are treated

 
 COFF-SPECIFIC OPTIONS
 ---------------------
 
 The following options are implemented only for COFF objects. If used with other
 objects, :program:`llvm-objcopy` will either emit an error or silently ignore
 them.
 
-.. option:: --only-keep-debug
-
- Remove the contents of non-debug sections from the output, but keep the section
- headers.
-
 ELF-SPECIFIC OPTIONS
 --------------------
 
 The following options are implemented only for ELF objects. If used with other
 objects, :program:`llvm-objcopy` will either emit an error or silently ignore
 them.
 
 .. option:: --add-symbol <name>=[<section>:]<value>[,<flags>]

test/tools/llvm-objcopy/ELF/basic-only-keep-debug.test

-# NOTE: This test is only intended to be valid as long as --only-keep-debug is
-#       implemented as a NOP. This test should fail when that changes and you
-#       will need to update this test.
-
-# RUN: yaml2obj %s > %t
-# RUN: llvm-objcopy %t %t2
-# RUN: llvm-objcopy --only-keep-debug %t %t3
-# RUN: cmp %t2 %t3
-# RUN: llvm-strip --only-keep-debug --no-strip-all %t -o %t4
-# RUN: cmp %t2 %t4
-
-!ELF
-FileHeader:
-  Class:           ELFCLASS64
-  Data:            ELFDATA2LSB
-  Type:            ET_EXEC
-  Machine:         EM_X86_64
-Sections:
-  - Name:            .text
-    Type:            SHT_PROGBITS
-    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
-    Content:         "DEADBEEF"

test/tools/llvm-objcopy/ELF/only-keep-debug.test

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objcopy --only-keep-debug %t %t.dbg
+# RUN: llvm-readelf -S -l %t.dbg | FileCheck %s
+# RUN: llvm-objdump -s %t.dbg | FileCheck --check-prefix=CONTENTS %s
+# RUN: llvm-strip --only-keep-debug %t -o %t.dbg2
+# RUN: cmp %t.dbg %t.dbg2
+
+## SHF_ALLOC sections that are not SHT_NOTE become SHT_NOBITS.
+## They do not occupy space in the output.
+
+# CHECK:      Name          Type     Address          Off    Size   ES Flg Lk Inf Al
+# CHECK:      .note         NOTE     0000000000000480 000040 000001 00   A  0   0  0
+# CHECK-NEXT: .text         NOBITS   0000000000000481 000041 000001 00  AX  0   0  0
+# CHECK-NEXT: .tdata        NOBITS   0000000000001400 000080 000007 00 WAT  0   0 128
+# CHECK-NEXT: .bss          NOBITS   0000000000001420 000060 00003f 00  WA  0   0 32
+# CHECK-NEXT: .debug_abbrev PROGBITS 0000000000000000 000041 000001 00      0   0  0
+
+## sh_offset of .debug_frame advances to the next multiple of sh_addralign.
+# CHECK-NEXT: .debug_frame  PROGBITS 0000000000000000 000048 000001 00      0   0  8
+# CHECK-NEXT: .debug_info   PROGBITS 0000000000000000 000049 000001 00      0   0  0
+# CHECK-NEXT: .comment      PROGBITS 0000000000000000 00004a 000001 00      0   0  0
+# CHECK-NEXT: .symtab       SYMTAB   0000000000000000 000050 000030 18     10   2  8
+# CHECK-NEXT: .strtab       STRTAB   0000000000000000 000080 000005 00      0   0  1
+# CHECK-NEXT: .shstrtab     STRTAB   0000000000000000 000085 000063 00      0   0  1
+
+## GNU objcopy rewrites program headers to make p_offset/p_filesz match section headers.
+## We just delete program headers. They are not used by debuggers.
+# CHECK:      There are 0 program headers, starting at offset 0
+
+## Contents of SHT_NOTE and non-SHF_ALLOC sections are kept.
+
+# CONTENTS:      Contents of section .note:
+# CONTENTS-NEXT:  0480 01
+# CONTENTS:      Contents of section .debug_abbrev:
+# CONTENTS-NEXT:  0000 02
+# CONTENTS-NEXT: Contents of section .debug_frame:
+# CONTENTS-NEXT:  0000 03
+# CONTENTS-NEXT: Contents of section .debug_info:
+# CONTENTS-NEXT:  0000 04
+# CONTENTS-NEXT: Contents of section .comment:
+# CONTENTS-NEXT:  0000 05
+
+!ELF
+FileHeader:
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_DYN
+  Machine:   EM_X86_64
+Sections:
+  - Name:         .note
+    Type:         SHT_NOTE
+    Flags:        [ SHF_ALLOC ]
+    Address:      0x480           # Ensure Address=Offset
+    Content:      01
+  - Name:         .text
+    Type:         SHT_PROGBITS
+    Flags:        [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:      0x481           # Ensure Address=Offset
+    Content:      c3
+  - Name:         .tdata
+    Type:         SHT_PROGBITS
+    Flags:        [ SHF_ALLOC, SHF_WRITE, SHF_TLS ]
+    Address:      0x1400          # Ensure Address=0x1000+Offset
+    AddressAlign: 128
+    Size:         7
+  - Name:         .bss
+    Type:         SHT_NOBITS
+    Flags:        [ SHF_ALLOC, SHF_WRITE ]
+    Address:      0x1420          # Ensure Address=0x1000+Offset
+    AddressAlign: 32
+    Size:         63
+  - Name:         .debug_abbrev
+    Type:         SHT_PROGBITS
+    Content:      02
+  - Name:         .debug_frame
+    Type:         SHT_PROGBITS
+    AddressAlign: 8
+    Content:      03
+  - Name:         .debug_info
+    Type:         SHT_PROGBITS
+    Content:      04
+  - Name:         .comment
+    Type:         SHT_PROGBITS
+    Content:      05
+Symbols:
+  - Name: foo     # A dummy symbol to test we don't strip .symtab
+ProgramHeaders:
+  - Type:     PT_LOAD
+    Flags:    [ PF_R, PF_X ]
+    Offset:   0
+    Align:    4096
+    Sections:
+      - Section: .note
+      - Section: .text
+  - Type:     PT_LOAD
+    Flags:    [ PF_R, PF_W ]
+    VAddr:    0x1400    # Ensure Offset=VAddr (mod Align) if Offset changes
+    Align:    4096
+    Sections:
+      - Section: .tdata
+      - Section: .bss
+  - Type:     PT_TLS
+    Flags:    [ PF_R, PF_W ]
+    VAddr:    0x1480    # Ensure Offset=VAddr (mod Align) if Offset changes
+    Sections:
+      - Section: .tdata
+  - Type:     PT_NOTE
+    VAddr:    0x480
+    Sections:
+      - Section: .note

tools/llvm-objcopy/CommonOpts.td

def K : JoinedOrSeparate<["-"], "K">,
         Alias<keep_symbol>,
         HelpText<"Alias for --keep-symbol">;
 
 def keep_file_symbols : Flag<["--"], "keep-file-symbols">,
                         HelpText<"Do not remove file symbols">;
 
 def only_keep_debug
     : Flag<["--"], "only-keep-debug">,
-      HelpText<"Clear sections that would not be stripped by --strip-debug. "
-               "Currently only implemented for COFF.">;
+      HelpText<"Create a separate debug file">;
 
 def discard_locals : Flag<["--"], "discard-locals">,
                      HelpText<"Remove compiler-generated local symbols, (e.g. "
                               "symbols starting with .L)">;
 def X : Flag<["-"], "X">,
         Alias<discard_locals>,
         HelpText<"Alias for --discard-locals">;
 

tools/llvm-objcopy/CopyConfig.cpp

parseStripOptions(ArrayRef<const char *> ArgsArr,
   for (auto Arg : InputArgs.filtered(STRIP_strip_symbol))
     Config.SymbolsToRemove.addMatcher({Arg->getValue(), UseRegexp});
 
   for (auto Arg : InputArgs.filtered(STRIP_keep_symbol))
     Config.SymbolsToKeep.addMatcher({Arg->getValue(), UseRegexp});
 
   if (!InputArgs.hasArg(STRIP_no_strip_all) && !Config.StripDebug &&
       !Config.StripUnneeded && Config.DiscardMode == DiscardType::None &&
-      !Config.StripAllGNU && Config.SymbolsToRemove.empty())
+      !Config.StripAllGNU && Config.SymbolsToRemove.empty() &&
+      !Config.OnlyKeepDebug)
     Config.StripAll = true;
 
   if (Config.DiscardMode == DiscardType::All)
     Config.StripDebug = true;
 
   Config.DeterministicArchives =
       InputArgs.hasFlag(STRIP_enable_deterministic_archives,
                         STRIP_disable_deterministic_archives, /*default=*/true);

tools/llvm-objcopy/ELF/ELFObjcopy.cpp

static ElfType getOutputElfType(const MachineInfo &MI) {
   else
     return MI.IsLittleEndian ? ELFT_ELF32LE : ELFT_ELF32BE;
 }
 
 static std::unique_ptr<Writer> createELFWriter(const CopyConfig &Config,
                                                Object &Obj, Buffer &Buf,
                                                ElfType OutputElfType) {
   // Depending on the initial ELFT and OutputFormat we need a different Writer.
+  bool WriteSectionHeaders = !Config.StripSections && Obj.HadShdrs;
   switch (OutputElfType) {
   case ELFT_ELF32LE:
-    return std::make_unique<ELFWriter<ELF32LE>>(Obj, Buf,
-                                                 !Config.StripSections);
+    return std::make_unique<ELFWriter<ELF32LE>>(Obj, Buf, Config.OnlyKeepDebug,
+                                                WriteSectionHeaders);
   case ELFT_ELF64LE:
-    return std::make_unique<ELFWriter<ELF64LE>>(Obj, Buf,
-                                                 !Config.StripSections);
+    return std::make_unique<ELFWriter<ELF64LE>>(Obj, Buf, Config.OnlyKeepDebug,
+                                                WriteSectionHeaders);
   case ELFT_ELF32BE:
-    return std::make_unique<ELFWriter<ELF32BE>>(Obj, Buf,
-                                                 !Config.StripSections);
+    return std::make_unique<ELFWriter<ELF32BE>>(Obj, Buf, Config.OnlyKeepDebug,
+                                                WriteSectionHeaders);
   case ELFT_ELF64BE:
-    return std::make_unique<ELFWriter<ELF64BE>>(Obj, Buf,
-                                                 !Config.StripSections);
+    return std::make_unique<ELFWriter<ELF64BE>>(Obj, Buf, Config.OnlyKeepDebug,
+                                                WriteSectionHeaders);
   }
   llvm_unreachable("Invalid output format");
 }
 
 static std::unique_ptr<Writer> createWriter(const CopyConfig &Config,
                                             Object &Obj, Buffer &Buf,
                                             ElfType OutputElfType) {
   switch (Config.OutputFormat) {
static Error replaceAndRemoveSections(const CopyConfig &Config, Object &Obj) {
   }
 
   if (Config.StripDebug || Config.StripUnneeded) {
     RemovePred = [RemovePred](const SectionBase &Sec) {
       return RemovePred(Sec) || isDebugSection(Sec);
     };
   }
 
+  if (Config.OnlyKeepDebug)
+    for (SectionBase &Sec : Obj.allocSections())
+      if (Sec.Type != SHT_NOTE)
+        Sec.Type = SHT_NOBITS;
+
   if (Config.StripNonAlloc)
     RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
       if (RemovePred(Sec))
         return true;
       if (&Sec == Obj.SectionNames)
         return false;
       return (Sec.Flags & SHF_ALLOC) == 0 && Sec.ParentSegment == nullptr;
     };

tools/llvm-objcopy/ELF/Object.h

private:
   void assignOffsets();
 
   std::unique_ptr<ELFSectionWriter<ELFT>> SecWriter;
 
   size_t totalSize() const;
 
 public:
   virtual ~ELFWriter() {}
+  bool OnlyKeepDebug;
   bool WriteSectionHeaders;
 
   Error finalize() override;
   Error write() override;
-  ELFWriter(Object &Obj, Buffer &Buf, bool WSH);
+  ELFWriter(Object &Obj, Buffer &Buf, bool OnlyKeepDebug,
+            bool WriteSectionHeaders);
 };
 
 class BinaryWriter : public Writer {
 private:
   std::unique_ptr<BinarySectionWriter> SecWriter;
 
   uint64_t TotalSize;
 
SectionBase *findSection(StringRef Name) {
     auto SecIt =
         find_if(Sections, [&](const SecPtr &Sec) { return Sec->Name == Name; });
     return SecIt == Sections.end() ? nullptr : SecIt->get();
   }
   SectionTableRef removedSections() { return SectionTableRef(RemovedSections); }
 
   Range<Segment> segments() { return make_pointee_range(Segments); }
   ConstRange<Segment> segments() const { return make_pointee_range(Segments); }
+  void clearSegments() { Segments.clear(); }
 
   Error removeSections(bool AllowBrokenLinks,
                        std::function<bool(const SectionBase &)> ToRemove);
   Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove);
   template <class T, class... Ts> T &addSection(Ts &&... Args) {
     auto Sec = std::make_unique<T>(std::forward<Ts>(Args)...);
     auto Ptr = Sec.get();
     MustBeRelocatable |= isa<RelocationSection>(*Ptr);

tools/llvm-objcopy/ELF/Object.cpp

template <class ELFT> void ELFWriter<ELFT>::writeSectionData() {
   for (SectionBase &Sec : Obj.sections())
     // Segments are responsible for writing their contents, so only write the
     // section data if the section is not in a segment. Note that this renders
     // sections in segments effectively immutable.
     if (Sec.ParentSegment == nullptr)
       Sec.accept(*SecWriter);
 }
 
 template <class ELFT> void ELFWriter<ELFT>::writeSegmentData() {
   for (Segment &Seg : Obj.segments()) {
     uint8_t *B = Buf.getBufferStart() + Seg.Offset;
     assert(Seg.FileSize == Seg.getContents().size() &&
            "Segment size must match contents size");
     std::memcpy(B, Seg.getContents().data(), Seg.FileSize);
   }
 
   // Iterate over removed sections and overwrite their old data with zeroes.
   for (auto &Sec : Obj.removedSections()) {
     Segment *Parent = Sec.ParentSegment;
     if (Parent == nullptr || Sec.Type == SHT_NOBITS || Sec.Size == 0)
       continue;
     uint64_t Offset =
         Sec.OriginalOffset - Parent->OriginalOffset + Parent->Offset;
     std::memset(Buf.getBufferStart() + Offset, 0, Sec.Size);
   }
 }
 
 template <class ELFT>
-ELFWriter<ELFT>::ELFWriter(Object &Obj, Buffer &Buf, bool WSH)
-    : Writer(Obj, Buf), WriteSectionHeaders(WSH && Obj.HadShdrs) {}
+ELFWriter<ELFT>::ELFWriter(Object &Obj, Buffer &Buf, bool OnlyKeepDebug,
+                           bool WriteSectionHeaders)
+    : Writer(Obj, Buf), OnlyKeepDebug(OnlyKeepDebug),
+      WriteSectionHeaders(WriteSectionHeaders) {}
 
 Error Object::removeSections(bool AllowBrokenLinks,
     std::function<bool(const SectionBase &)> ToRemove) {
 
   auto Iter = std::stable_partition(
       std::begin(Sections), std::end(Sections), [=](const SecPtr &Sec) {
         if (ToRemove(*Sec))
           return false;
if (Sec.ParentSegment != nullptr) {
       Sec.Offset = Offset;
       if (Sec.Type != SHT_NOBITS)
         Offset += Sec.Size;
     }
   }
   return Offset;
 }
 
+static uint64_t layoutSectionsForOnlyKeepDebug(Object &Obj, uint64_t Off) {
+  uint32_t Index = 1;
+  for (SectionBase &Sec : Obj.sections()) {
+    Sec.Index = Index++;
+    Sec.Offset = alignTo(Off, Sec.Align ? Sec.Align : 1);
+    if (Sec.Type != SHT_NOBITS)
+      Off = Sec.Offset + Sec.Size;
+  }
+  return Off;
+}
+
 template <class ELFT> void ELFWriter<ELFT>::initEhdrSegment() {
   Segment &ElfHdr = Obj.ElfHdrSegment;
   ElfHdr.Type = PT_PHDR;
   ElfHdr.Flags = 0;
   ElfHdr.VAddr = 0;
   ElfHdr.PAddr = 0;
   ElfHdr.FileSize = ElfHdr.MemSize = sizeof(Elf_Ehdr);
   ElfHdr.Align = 0;
 }
 
 template <class ELFT> void ELFWriter<ELFT>::assignOffsets() {
   // We need a temporary list of segments that has a special order to it
   // so that we know that anytime ->ParentSegment is set that segment has
   // already had its offset properly set.
   std::vector<Segment *> OrderedSegments;
   for (Segment &Segment : Obj.segments())
     OrderedSegments.push_back(&Segment);
   OrderedSegments.push_back(&Obj.ElfHdrSegment);
   OrderedSegments.push_back(&Obj.ProgramHdrSegment);
   orderSegments(OrderedSegments);
+
+  uint64_t Offset;
+  if (OnlyKeepDebug) {
+    // For --only-keep-debug, we delete program headers because
+    // p_offset/p_filesz will conflict with section headers after we rewrite
+    // sh_offset fields.
+    Obj.clearSegments();
+    Offset = layoutSectionsForOnlyKeepDebug(Obj, sizeof(Elf_Ehdr));
+  } else {
     // Offset is used as the start offset of the first segment to be laid out.
     // Since the ELF Header (ElfHdrSegment) must be at the start of the file,
     // we start at offset 0.
-  uint64_t Offset = 0;
-  Offset = layoutSegments(OrderedSegments, Offset);
+    Offset = layoutSegments(OrderedSegments, 0);
     Offset = layoutSections(Obj.sections(), Offset);
+  }
   // If we need to write the section header table out then we need to align the
   // Offset so that SHOffset is valid.
   if (WriteSectionHeaders)
     Offset = alignTo(Offset, sizeof(Elf_Addr));
   Obj.SHOffset = Offset;
 }
 
 template <class ELFT> size_t ELFWriter<ELFT>::totalSize() const {
   // We already have the section header offset so we can calculate the total
   // size by just adding up the size of each section header.
   if (!WriteSectionHeaders)
     return Obj.SHOffset;
   size_t ShdrCount = Obj.sections().size() + 1; // Includes null shdr.
   return Obj.SHOffset + ShdrCount * sizeof(Elf_Shdr);
 }
 
 template <class ELFT> Error ELFWriter<ELFT>::write() {
+  if (OnlyKeepDebug) {
+    // --only-keep-debug uses a custom layout algorithm that rewrites sh_offset
+    // fields. Only ELF header, section header and contents of non-SHT_NOBITS
+    // sections are needed.
+    writeEhdr();
+    for (SectionBase &Sec : Obj.sections())
+      if (Sec.Type != SHT_NOBITS)
+        Sec.accept(*SecWriter);
+  } else {
     // Segment data must be written first, so that the ELF header and program
     // header tables can overwrite it, if covered by a segment.
     writeSegmentData();
     writeEhdr();
     writePhdrs();
     writeSectionData();
+  }
+
   if (WriteSectionHeaders)
     writeShdrs();
   return Buf.commit();
 }
 
 static Error removeUnneededSections(Object &Obj) {
   // We can remove an empty symbol table from non-relocatable objects.
   // Relocatable objects typically have relocation sections whose