llvm-objcopy: Implement --extract-partition and --extract-main-partition.

[pcc]

Summary

This implements the functionality described in Partitions.rst in D60242
(eventually https://lld.llvm.org/Partitions.html). It works as follows:

• Reads the section headers using the ELF header at file offset 0;
• If extracting a loadable partition:
  • Finds the section containing the required partition ELF header by looking it up in the section table;
  • Reads the ELF and program headers from the section.
• If extracting the main partition:
  • Reads the ELF and program headers from file offset 0.
• Filters the section table according to which sections are in the program headers that it read:
  • If ParentSegment != nullptr or section is not SHF_ALLOC, then it goes in.
  • Sections containing partition ELF headers or program headers are excluded as there are no headers for these in ordinary ELF files.

[MaskRay]

llvm/tools/llvm-objcopy/ELF/Object.cpp

961 ↗

(On Diff #201118)

const SectionBase &. Recently there were changes to spell auto types explicitly.

llvm/tools/llvm-objcopy/ObjcopyOpts.td

152 ↗

(On Diff #201118)

Flag<["--"]. In llvm-objcopy land, we no longer use -long-option...

[pcc]

• Address review comments

[MaskRay]

llvm/test/tools/llvm-objcopy/ELF/Inputs/partitions.elf.test

5 ↗

(On Diff #201120)

ld.lld can be used in a llvm-objcopy test. This may have to be moved to lld/test/ELF/

[pcc]

llvm/test/tools/llvm-objcopy/ELF/Inputs/partitions.elf.test

5 ↗

(On Diff #201120)

(assuming you meant *can't* be used)

Yes, that's correct. That's why I'm checking in a binary (partitions.elf) to be used during this test. The purpose of this file is to document how I generated partitions.elf.

[jakehehrlich]

A few questions

1. This direction means that we can only ever convert from a multi partition binary to a single partition binary. It seems like we should be able to remove each partition individually. The naming scheme I would imagine would be "--remove-partition=<name>" or "--remove-main-partition" and for the equivalent of this feature "--only-keep-partition=<name" and "--only-keep-main-partition". Are you sure we want to limit things to work like this?
2. Can you explain the details a bit more? Like it appears that we have a section to point to partition headers but I'd expect this to be available at dynamic link time as well which should mean that there should be a program header based solution to this as well. I'm also trying to understand exactly what the resulting file format looks like and what effect other operations would have on the net result. Lots of things are not clear to me from the documentation posted.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

734 ↗

(On Diff #201120)

Adding the CopyConfig here is antithetical to the goal of making this code into a library at some point in the future. We should find a way to avoid this. This goes for propagation of Config elsewhere in the code as well. Propogation of CopyConfig is a hard no from me personally.

[pcc]

In D62364#1521845, @jakehehrlich wrote:

A few questions

1. This direction means that we can only ever convert from a multi partition binary to a single partition binary. It seems like we should be able to remove each partition individually. The naming scheme I would imagine would be "--remove-partition=<name>" or "--remove-main-partition" and for the equivalent of this feature "--only-keep-partition=<name" and "--only-keep-main-partition". Are you sure we want to limit things to work like this?
2. Can you explain the details a bit more? Like it appears that we have a section to point to partition headers but I'd expect this to be available at dynamic link time as well which should mean that there should be a program header based solution to this as well. I'm also trying to understand exactly what the resulting file format looks like and what effect other operations would have on the net result. Lots of things are not clear to me from the documentation posted.

The combined output file (i.e. the file produced by the linker) is not intended to be loaded directly. It is a description of the program with all partitions loaded. As written in the doc, it is essentially an ELF file with all of the partitions concatenated together. Further postprocessing (by llvm-objcopy) is required to produce a loadable file.

In a combined output file, each partition has its own set of data contained within segments (i.e. ELF header, program headers and SHF_ALLOC sections), while data not contained within segments (e.g. debug info, section headers) is shared between partitions. To extract a loadable partition, the partition's ELF headers are found by searching the section table for an SHT_PART_EHDR section named after the partition. From there, the program headers are found, which serve as a description of which SHF_ALLOC sections pertain to the partition. Thus the entire description of each partition can be found starting from the section headers.

This is not unlike other types of ELF files that describe (parts of) a program without being directly loadable. Two other examples are core dumps and --only-keep-debug files.

Because the combined output file is not intended to be loaded directly, there is no need for a description of the loadable partitions in any other partition's program headers. When llvm-objcopy extracts a partition, the information required to load that partition, i.e. its ELF and program headers, end up moved into place at the front of the file so that they can be read by the dynamic loader. You can think of what llvm-objcopy is doing when it extracts a partition as taking a slice of the combined output file from the start of the partition's ELF headers until the start of the next partition (or the end of the file), except that the data not contained within segments is preserved where it makes sense (i.e. debug info, section headers pertaining to preserved sections).

I'm having trouble seeing a use case for --remove-partition or --remove-main-partition, and it doesn't really fit the pattern of "make this file loadable" of the other flags, so I'd be hesitant to implement it.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

734 ↗

(On Diff #201120)

In an earlier version of the code [1] I was just passing down the name of the partition to extract. Would that work better (maybe with the name passed as a ctor argument rather than as a field)? Alternatively, we could create something like a ReaderConfig to be passed down here that for the moment would just contain the partition name.

[1] https://github.com/pcc/llvm-project/blob/c9939239d7e829e2c779138aaedea061f4a095d0/llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp#L597

[jakehehrlich]

Ok I spoke offline about some of my questions with Peter. Here are some useful facts:

All partitions share the same section header table. This means that if you don't use --extract-* parameters llvm-objcopy should still copy everything as needed. Not that this is intended to work but --strip-all (but not --strip-sections) would actually work as I would expect it to if we told it about these new section types (e.g. treat them like GNU warnings). Debug information is shared between them. I thought this was odd as they all had different address spaces. Peter did some tests and debuggers seem to handle when debug information references in DWARF to outside of the DSO just fine (Peter also pointed out that --gc-sections causes this sort of issue as well). I think --strip-sections would effectively extract the main partition.

There is no dynamic linker support planned for this so before you can run these sorts of DSOs or link them into things you have to extract them.

I'm happy with the general direction here. I don't think there are significant barriers to tweaking this sort of thing in the future or even to doing multi-partition extraction.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

734 ↗

(On Diff #201120)

Either ReaderConfig or just passing the partition name makes sense to me.

[jakehehrlich]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

734 ↗

(On Diff #201120)

I think using Option<StringRef> or having two constructors, one with and one without would be best actully. That way you can distinguish between the case for not extracting main and extracting main.

[pcc]

• Create ReaderConfig

[pcc]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

734 ↗

(On Diff #201120)

I decided to go with Optional<StringRef> in a field of ReaderConfig.

[jakehehrlich]

I'm happy with this as is but I'd like @jhenderson, @rupprecht, and @alexshap to take a look since this represents a fairly major feature addition even if the code is pretty small. I don't believe this imposes any extra assumptions or requirements on the rest of the code however.

[jhenderson]

I've got a few minor comments, but structurally this looks reasonable to me. I could potentially see other benefits to this approach in the future too.

llvm/test/tools/llvm-objcopy/ELF/partitions.test

1–3 ↗

(On Diff #202808)

It might be helpful briefly explaining what "part1" and "part2" are for those not massively familiar with the intended switch behaviour. This is probably best done by explaining what partitions.elf contains.

9–12 ↗

(On Diff #202808)

I'd prefer this part of the test to be after the MAIN: bits further down. I'd also recommend putting the first error message after the first check and the second after the second check. Keeping the first three RUNs at the top together makes sense though, so I'd do:

RUN: extract main
RUN: extract 1
RUN: extract 2

CHECKs for the first three

RUN: error 1
ERROR1:
RUN: error 2
ERROR2:

14 ↗

(On Diff #202808)

We usually add extra spacing to make all the content line up like it does in the real output, i.e:

MAIN:      ELF Header:
MAIN-NEXT:   Magic:

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

516 ↗

(On Diff #202808)

It's quite tricky looking at the test to see if this part of the code is actually tested. Could you confirm that it is, i.e. that for both switches there is a non-alloc section not in a segment that is stripped and that there is a non-alloc section in a segment that is not stripped, please?

llvm/tools/llvm-objcopy/ELF/Object.h

885 ↗

(On Diff #202808)

Do you anticipate there being multiple members in this struct in the future? If not, it seems a bit superfluous.

900 ↗

(On Diff #202808)

I think this needs a comment explaining what HdrElfFile is. Either that or the name needs changing, because it's not immediately clear to me what it's supposed to be.

[pcc]

• Address review comments

[pcc]

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

516 ↗

(On Diff #202808)

Non-alloc sections not in segments are not stripped. In the test, .comment is such a section and the test shows that it is kept in all output files.

The linker will not normally place non-alloc sections in segments (I think this is only possible with the SECTIONS directive, and lld forbids SECTIONS together with multiple partitions), so it would be tricky to construct such a test case, and I think we can consider a file with such a section to be invalid (as a multi-partition file, not in general) anyway. This condition returns false (i.e. keep) once it's determined that the section is non-alloc, so we wouldn't be increasing code coverage by having a non-alloc section in a segment.

The important case that is being tested is that alloc sections not in segments (i.e. not in segments for the current partition) are being stripped. The test shows that e.g. the main partition's .text0 is being stripped from the loadable partitions, likewise .bss1 in part1 is being stripped from the main partition and part2, etc.

I wonder whether it would be better (in a separate change) to flip the predicate here and have it return true if we want to keep the section. That seems like it would make at least this clause a little less confusing, but I'm not sure about the others.

llvm/tools/llvm-objcopy/ELF/Object.h

885 ↗

(On Diff #202808)

Okay, I changed this to a ctor arg.

900 ↗

(On Diff #202808)

Is the comment on lines 1434-1436 not enough? I think that if I were trying to understand why we're passing HdrElfFile here, I'd look at what the caller of readProgramHeaders was doing, which would lead me to that comment. Maybe there's a better place for it though?

[jhenderson]

llvm/test/tools/llvm-objcopy/ELF/partitions.test

186 ↗

(On Diff #203271)

part3 -> part2 (?) to avoid confusion with the other error message?

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

516 ↗

(On Diff #202808)

Thanks.

I don't think we should flip the predicate - the function is effectively "shouldRemove()" and so true is the correct return for sections that should be removed (and false otherwise).

I think I misread (Sec.Flags & SHF_ALLOC) != 0 as being "true if section is not-alloc", when it is the inverse. I'm not sure flipping the predicate would make this any less likely to happen.

llvm/tools/llvm-objcopy/ELF/Object.h

900 ↗

(On Diff #202808)

I tend to go with a different approach (I guess everybody is different): if I'm in readProgramHeaders, and I want to know what my input argument is, I go to the declaration, because there's usually documentation comments there, if not at the definition, so maybe the comment needs moving here.

Alternatively, maybe it would be slightly less confusing renaming it slightly to HeadersFile?

[pcc]

• Address review comments

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

516 ↗

(On Diff #202808)

Ack

llvm/tools/llvm-objcopy/ELF/Object.h

900 ↗

(On Diff #202808)

Renaming to HeadersFile works for me; done.

[jhenderson]

Thanks, LGTM, though please wait for confirmation from some of the others.

[MaskRay]

llvm/test/tools/llvm-objcopy/ELF/Inputs/partitions.elf.test

5 ↗

(On Diff #201120)

Sorry I didn't notice this file is in the Inputs/ directory so these lines do not run.

[ruiu]

I think jhenderson's LGTM is enough but in case you need one more, LGTM.

llvm/trunk/include/llvm/BinaryFormat/ELF.h

enum : unsigned {
   SHT_ANDROID_RELA = 0x60000002,
   SHT_LLVM_ODRTAB = 0x6fff4c00,         // LLVM ODR table.
   SHT_LLVM_LINKER_OPTIONS = 0x6fff4c01, // LLVM Linker Options.
   SHT_LLVM_CALL_GRAPH_PROFILE = 0x6fff4c02, // LLVM Call Graph Profile.
   SHT_LLVM_ADDRSIG = 0x6fff4c03,        // List of address-significant symbols
                                         // for safe ICF.
   SHT_LLVM_DEPENDENT_LIBRARIES = 0x6fff4c04, // LLVM Dependent Library Specifiers.
   SHT_LLVM_SYMPART = 0x6fff4c05,        // Symbol partition specification.
+  SHT_LLVM_PART_EHDR = 0x6fff4c06,      // ELF header for loadable partition.
+  SHT_LLVM_PART_PHDR = 0x6fff4c07,      // Phdrs for loadable partition.
   // Android's experimental support for SHT_RELR sections.
   // https://android.googlesource.com/platform/bionic/+/b7feec74547f84559a1467aca02708ff61346d2a/libc/include/elf.h#512
   SHT_ANDROID_RELR = 0x6fffff00,        // Relocation entries; only offsets.
   SHT_GNU_ATTRIBUTES = 0x6ffffff5,      // Object attributes.
   SHT_GNU_HASH = 0x6ffffff6,            // GNU-style hash table.
   SHT_GNU_verdef = 0x6ffffffd,          // GNU version definitions.
   SHT_GNU_verneed = 0x6ffffffe,         // GNU version references.
   SHT_GNU_versym = 0x6fffffff,          // GNU symbol versions table.

llvm/trunk/test/tools/llvm-objcopy/ELF/Inputs/partitions.elf.test

+// partitions.elf was generated by running this test in lld:
+
+// REQUIRES: x86
+// RUN: llvm-mc %s -o %t.o -filetype=obj --triple=x86_64-unknown-linux
+// RUN: ld.lld %t.o -o %t --export-dynamic --gc-sections
+
+.section .llvm_sympart.g1,"",@llvm_sympart
+.asciz "part1"
+.quad g1
+
+.section .llvm_sympart.g2,"",@llvm_sympart
+.asciz "part2"
+.quad g2
+
+.section .text0,"ax",@progbits
+.globl _start
+_start:
+ret
+
+.section .bss1,"aw",@nobits
+.globl g1
+g1:
+.zero 8
+
+.section .bss2,"aw",@nobits
+.globl g2
+g2:
+.zero 16

llvm/trunk/test/tools/llvm-objcopy/ELF/partitions.test

+partitions.elf is a file containing a main partition and two loadable
+partitions "part1" and "part2" (see https://lld.llvm.org/Partitions.html
+for a description of partitions). This file tests that extracting the main
+and loadable partitions produces a file with the correct headers and sections.
+
+RUN: llvm-objcopy --extract-main-partition %p/Inputs/partitions.elf %t1
+RUN: llvm-objcopy --extract-partition=part1 %p/Inputs/partitions.elf %t2
+RUN: llvm-objcopy --extract-partition=part2 %p/Inputs/partitions.elf %t3
+
+RUN: llvm-readelf --headers --sections --symbols %t1 | FileCheck --check-prefix=MAIN %s
+RUN: llvm-readelf --headers --sections --symbols %t2 | FileCheck --check-prefix=PART1 %s
+RUN: llvm-readelf --headers --sections --symbols %t3 | FileCheck --check-prefix=PART2 %s
+
+MAIN:      ELF Header:
+MAIN-NEXT:   Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
+MAIN-NEXT:   Class:                             ELF64
+MAIN-NEXT:   Data:                              2's complement, little endian
+MAIN-NEXT:   Version:                           1 (current)
+MAIN-NEXT:   OS/ABI:                            UNIX - System V
+MAIN-NEXT:   ABI Version:                       0x0
+MAIN-NEXT:   Type:                              EXEC (Executable file)
+MAIN-NEXT:   Machine:                           Advanced Micro Devices X86-64
+MAIN-NEXT:   Version:                           0x1
+MAIN-NEXT:   Entry point address:               0x201000
+MAIN-NEXT:   Start of program headers:          64 (bytes into file)
+MAIN-NEXT:   Start of section headers:          12488 (bytes into file)
+MAIN-NEXT:   Flags:                             0x0
+MAIN-NEXT:   Size of this header:               64 (bytes)
+MAIN-NEXT:   Size of program headers:           56 (bytes)
+MAIN-NEXT:   Number of program headers:         8
+MAIN-NEXT:   Size of section headers:           64 (bytes)
+MAIN-NEXT:   Number of section headers:         13
+MAIN-NEXT:   Section header string table index: 11
+
+MAIN: Section Headers:
+MAIN-NEXT:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+MAIN-NEXT:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+MAIN-NEXT:   [ 1] .dynsym           DYNSYM          0000000000200200 000200 000030 18   A  4   1  8
+MAIN-NEXT:   [ 2] .gnu.hash         GNU_HASH        0000000000200230 000230 000020 00   A  1   0  8
+MAIN-NEXT:   [ 3] .hash             HASH            0000000000200250 000250 000018 04   A  1   0  4
+MAIN-NEXT:   [ 4] .dynstr           STRTAB          0000000000200268 000268 000014 00   A  0   0  1
+MAIN-NEXT:   [ 5] .rodata           PROGBITS        000000000020027c 00027c 000018 00   A  0   0  4
+MAIN-NEXT:   [ 6] .text0            PROGBITS        0000000000201000 001000 000001 00  AX  0   0  1
+MAIN-NEXT:   [ 7] .dynamic          DYNAMIC         0000000000202000 002000 000080 10  WA  4   0  8
+MAIN-NEXT:   [ 8] .part.end         NOBITS          0000000000209000 003000 001000 00  WA  0   0  1
+MAIN-NEXT:   [ 9] .comment          PROGBITS        0000000000000000 003000 000008 01  MS  0   0  1
+MAIN-NEXT:   [10] .symtab           SYMTAB          0000000000000000 003008 000048 18     12   2  8
+MAIN-NEXT:   [11] .shstrtab         STRTAB          0000000000000000 003050 000060 00      0   0  1
+MAIN-NEXT:   [12] .strtab           STRTAB          0000000000000000 0030b0 000011 00      0   0  1
+
+MAIN: Symbol table '.dynsym' contains 2 entries:
+MAIN-NEXT:    Num:    Value          Size Type    Bind   Vis      Ndx Name
+MAIN-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
+MAIN-NEXT:      1: 0000000000201000     0 NOTYPE  GLOBAL DEFAULT    6 _start
+
+MAIN: Symbol table '.symtab' contains 3 entries:
+MAIN-NEXT:    Num:    Value          Size Type    Bind   Vis      Ndx Name
+MAIN-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
+MAIN-NEXT:      1: 0000000000202000     0 NOTYPE  LOCAL  HIDDEN     7 _DYNAMIC
+MAIN-NEXT:      2: 0000000000201000     0 NOTYPE  GLOBAL DEFAULT    6 _start
+
+MAIN: Program Headers:
+MAIN-NEXT:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+MAIN-NEXT:   PHDR           0x000040 0x0000000000200040 0x0000000000200040 0x0001c0 0x0001c0 R   0x8
+MAIN-NEXT:   LOAD           0x000000 0x0000000000200000 0x0000000000200000 0x000294 0x000294 R   0x1000
+MAIN-NEXT:   LOAD           0x001000 0x0000000000201000 0x0000000000201000 0x000001 0x000001 R E 0x1000
+MAIN-NEXT:   LOAD           0x002000 0x0000000000202000 0x0000000000202000 0x000080 0x000080 RW  0x1000
+MAIN-NEXT:   LOAD           0x003000 0x0000000000209000 0x0000000000209000 0x000000 0x001000 RW  0x1000
+MAIN-NEXT:   DYNAMIC        0x002000 0x0000000000202000 0x0000000000202000 0x000080 0x000080 RW  0x8
+MAIN-NEXT:   GNU_RELRO      0x002000 0x0000000000202000 0x0000000000202000 0x000080 0x001000 R   0x1
+MAIN-NEXT:   GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0x0
+
+PART1: ELF Header:
+PART1-NEXT:   Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
+PART1-NEXT:   Class:                             ELF64
+PART1-NEXT:   Data:                              2's complement, little endian
+PART1-NEXT:   Version:                           1 (current)
+PART1-NEXT:   OS/ABI:                            UNIX - System V
+PART1-NEXT:   ABI Version:                       0x0
+PART1-NEXT:   Type:                              DYN (Shared object file)
+PART1-NEXT:   Machine:                           Advanced Micro Devices X86-64
+PART1-NEXT:   Version:                           0x1
+PART1-NEXT:   Entry point address:               0x0
+PART1-NEXT:   Start of program headers:          64 (bytes into file)
+PART1-NEXT:   Start of section headers:          8336 (bytes into file)
+PART1-NEXT:   Flags:                             0x0
+PART1-NEXT:   Size of this header:               64 (bytes)
+PART1-NEXT:   Size of program headers:           56 (bytes)
+PART1-NEXT:   Number of program headers:         7
+PART1-NEXT:   Size of section headers:           64 (bytes)
+PART1-NEXT:   Number of section headers:         11
+PART1-NEXT:   Section header string table index: 9
+
+PART1: Section Headers:
+PART1-NEXT:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+PART1-NEXT:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+PART1-NEXT:   [ 1] .dynsym           DYNSYM          00000000002031c8 0001c8 000030 18   A  4   1  8
+PART1-NEXT:   [ 2] .gnu.hash         GNU_HASH        00000000002031f8 0001f8 000020 00   A  1   0  8
+PART1-NEXT:   [ 3] .hash             HASH            0000000000203218 000218 000018 04   A  1   0  4
+PART1-NEXT:   [ 4] .dynstr           STRTAB          0000000000203230 000230 00000a 00   A  0   0  1
+PART1-NEXT:   [ 5] .dynamic          DYNAMIC         0000000000204000 001000 000090 10  WA  4   0  8
+PART1-NEXT:   [ 6] .bss1             NOBITS          0000000000205000 002000 000008 00  WA  0   0  1
+PART1-NEXT:   [ 7] .comment          PROGBITS        0000000000000000 002000 000008 01  MS  0   0  1
+PART1-NEXT:   [ 8] .symtab           SYMTAB          0000000000000000 002008 000030 18     10   1  8
+PART1-NEXT:   [ 9] .shstrtab         STRTAB          0000000000000000 002038 00004d 00      0   0  1
+PART1-NEXT:   [10] .strtab           STRTAB          0000000000000000 002085 000004 00      0   0  1
+
+PART1: Symbol table '.dynsym' contains 2 entries:
+PART1-NEXT:    Num:    Value          Size Type    Bind   Vis      Ndx Name
+PART1-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+PART1-NEXT:      1: 0000000000205000     0 NOTYPE  GLOBAL DEFAULT   15 g1
+
+PART1: Symbol table '.symtab' contains 2 entries:
+PART1-NEXT:    Num:    Value          Size Type    Bind   Vis      Ndx Name
+PART1-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+PART1-NEXT:      1: 0000000000205000     0 NOTYPE  GLOBAL DEFAULT    6 g1
+
+PART1: Program Headers:
+PART1-NEXT:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+PART1-NEXT:   PHDR           0x000040 0x0000000000203040 0x0000000000203040 0x000188 0x000188 R   0x1
+PART1-NEXT:   LOAD           0x000000 0x0000000000203000 0x0000000000203000 0x00023a 0x00023a R   0x1000
+PART1-NEXT:   LOAD           0x001000 0x0000000000204000 0x0000000000204000 0x000090 0x000090 RW  0x1000
+PART1-NEXT:   LOAD           0x002000 0x0000000000205000 0x0000000000205000 0x000000 0x000008 RW  0x1000
+PART1-NEXT:   DYNAMIC        0x001000 0x0000000000204000 0x0000000000204000 0x000090 0x000090 RW  0x8
+PART1-NEXT:   GNU_RELRO      0x001000 0x0000000000204000 0x0000000000204000 0x000090 0x001000 R   0x1
+PART1-NEXT:   GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0x0
+
+PART2: ELF Header:
+PART2-NEXT:   Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
+PART2-NEXT:   Class:                             ELF64
+PART2-NEXT:   Data:                              2's complement, little endian
+PART2-NEXT:   Version:                           1 (current)
+PART2-NEXT:   OS/ABI:                            UNIX - System V
+PART2-NEXT:   ABI Version:                       0x0
+PART2-NEXT:   Type:                              DYN (Shared object file)
+PART2-NEXT:   Machine:                           Advanced Micro Devices X86-64
+PART2-NEXT:   Version:                           0x1
+PART2-NEXT:   Entry point address:               0x0
+PART2-NEXT:   Start of program headers:          64 (bytes into file)
+PART2-NEXT:   Start of section headers:          8336 (bytes into file)
+PART2-NEXT:   Flags:                             0x0
+PART2-NEXT:   Size of this header:               64 (bytes)
+PART2-NEXT:   Size of program headers:           56 (bytes)
+PART2-NEXT:   Number of program headers:         7
+PART2-NEXT:   Size of section headers:           64 (bytes)
+PART2-NEXT:   Number of section headers:         11
+PART2-NEXT:   Section header string table index: 9
+
+PART2: Section Headers:
+PART2-NEXT:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+PART2-NEXT:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+PART2-NEXT:   [ 1] .dynsym           DYNSYM          00000000002061c8 0001c8 000030 18   A  4   1  8
+PART2-NEXT:   [ 2] .gnu.hash         GNU_HASH        00000000002061f8 0001f8 000020 00   A  1   0  8
+PART2-NEXT:   [ 3] .hash             HASH            0000000000206218 000218 000018 04   A  1   0  4
+PART2-NEXT:   [ 4] .dynstr           STRTAB          0000000000206230 000230 00000a 00   A  0   0  1
+PART2-NEXT:   [ 5] .dynamic          DYNAMIC         0000000000207000 001000 000090 10  WA  4   0  8
+PART2-NEXT:   [ 6] .bss2             NOBITS          0000000000208000 002000 000010 00  WA  0   0  1
+PART2-NEXT:   [ 7] .comment          PROGBITS        0000000000000000 002000 000008 01  MS  0   0  1
+PART2-NEXT:   [ 8] .symtab           SYMTAB          0000000000000000 002008 000030 18     10   1  8
+PART2-NEXT:   [ 9] .shstrtab         STRTAB          0000000000000000 002038 00004d 00      0   0  1
+PART2-NEXT:   [10] .strtab           STRTAB          0000000000000000 002085 000004 00      0   0  1
+
+PART2: Symbol table '.dynsym' contains 2 entries:
+PART2-NEXT:    Num:    Value          Size Type    Bind   Vis      Ndx Name
+PART2-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+PART2-NEXT:      1: 0000000000208000     0 NOTYPE  GLOBAL DEFAULT   23 g2
+
+PART2: Symbol table '.symtab' contains 2 entries:
+PART2-NEXT:    Num:    Value          Size Type    Bind   Vis      Ndx Name
+PART2-NEXT:      0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
+PART2-NEXT:      1: 0000000000208000     0 NOTYPE  GLOBAL DEFAULT    6 g2
+
+PART2: Program Headers:
+PART2-NEXT:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+PART2-NEXT:   PHDR           0x000040 0x0000000000206040 0x0000000000206040 0x000188 0x000188 R   0x1
+PART2-NEXT:   LOAD           0x000000 0x0000000000206000 0x0000000000206000 0x00023a 0x00023a R   0x1000
+PART2-NEXT:   LOAD           0x001000 0x0000000000207000 0x0000000000207000 0x000090 0x000090 RW  0x1000
+PART2-NEXT:   LOAD           0x002000 0x0000000000208000 0x0000000000208000 0x000000 0x000010 RW  0x1000
+PART2-NEXT:   DYNAMIC        0x001000 0x0000000000207000 0x0000000000207000 0x000090 0x000090 RW  0x8
+PART2-NEXT:   GNU_RELRO      0x001000 0x0000000000207000 0x0000000000207000 0x000090 0x001000 R   0x1
+PART2-NEXT:   GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0x0
+
+RUN: not llvm-objcopy --extract-partition=part3 %p/Inputs/partitions.elf %t4 2>&1 | FileCheck --check-prefix=ERROR1 %s
+ERROR1: error: could not find partition named 'part3'
+
+RUN: not llvm-objcopy --extract-main-partition --extract-partition=part2 %p/Inputs/partitions.elf %t4 2>&1 | FileCheck --check-prefix=ERROR2 %s
+ERROR2: error: cannot specify --extract-partition together with --extract-main-partition

llvm/trunk/tools/llvm-objcopy/CopyConfig.h

struct CopyConfig {
 
   // Advanced options
   StringRef AddGnuDebugLink;
   // Cached gnu_debuglink's target CRC
   uint32_t GnuDebugLinkCRC32;
   StringRef BuildIdLinkDir;
   Optional<StringRef> BuildIdLinkInput;
   Optional<StringRef> BuildIdLinkOutput;
+  Optional<StringRef> ExtractPartition;
   StringRef SplitDWO;
   StringRef SymbolsPrefix;
   StringRef AllocSectionsPrefix;
   DiscardType DiscardMode = DiscardType::None;
 
   // Repeated options
   std::vector<StringRef> AddSection;
   std::vector<StringRef> DumpSection;
struct CopyConfig {
   // calculated with EntryExpr(input_address), when either --set-start or
   // --change-start is used.
   std::function<uint64_t(uint64_t)> EntryExpr;
 
   // Boolean options
   bool AllowBrokenLinks = false;
   bool DeterministicArchives = true;
   bool ExtractDWO = false;
+  bool ExtractMainPartition = false;
   bool KeepFileSymbols = false;
   bool LocalizeHidden = false;
   bool OnlyKeepDebug = false;
   bool PreserveDates = false;
   bool StripAll = false;
   bool StripAllGNU = false;
   bool StripDWO = false;
   bool StripDebug = false;

llvm/trunk/tools/llvm-objcopy/CopyConfig.cpp

Config.BuildIdLinkInput =
         InputArgs.getLastArgValue(OBJCOPY_build_id_link_input);
   if (InputArgs.hasArg(OBJCOPY_build_id_link_output))
     Config.BuildIdLinkOutput =
         InputArgs.getLastArgValue(OBJCOPY_build_id_link_output);
   Config.SplitDWO = InputArgs.getLastArgValue(OBJCOPY_split_dwo);
   Config.SymbolsPrefix = InputArgs.getLastArgValue(OBJCOPY_prefix_symbols);
   Config.AllocSectionsPrefix =
       InputArgs.getLastArgValue(OBJCOPY_prefix_alloc_sections);
+  if (auto Arg = InputArgs.getLastArg(OBJCOPY_extract_partition))
+    Config.ExtractPartition = Arg->getValue();
 
   for (auto Arg : InputArgs.filtered(OBJCOPY_redefine_symbol)) {
     if (!StringRef(Arg->getValue()).contains('='))
       return createStringError(errc::invalid_argument,
                                "Bad format for --redefine-sym");
     auto Old2New = StringRef(Arg->getValue()).split('=');
     if (!Config.SymbolsToRename.insert(Old2New).second)
       return createStringError(errc::invalid_argument,
Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
   Config.StripAll = InputArgs.hasArg(OBJCOPY_strip_all);
   Config.StripAllGNU = InputArgs.hasArg(OBJCOPY_strip_all_gnu);
   Config.StripDebug = InputArgs.hasArg(OBJCOPY_strip_debug);
   Config.StripDWO = InputArgs.hasArg(OBJCOPY_strip_dwo);
   Config.StripSections = InputArgs.hasArg(OBJCOPY_strip_sections);
   Config.StripNonAlloc = InputArgs.hasArg(OBJCOPY_strip_non_alloc);
   Config.StripUnneeded = InputArgs.hasArg(OBJCOPY_strip_unneeded);
   Config.ExtractDWO = InputArgs.hasArg(OBJCOPY_extract_dwo);
+  Config.ExtractMainPartition =
+      InputArgs.hasArg(OBJCOPY_extract_main_partition);
   Config.LocalizeHidden = InputArgs.hasArg(OBJCOPY_localize_hidden);
   Config.Weaken = InputArgs.hasArg(OBJCOPY_weaken);
   if (InputArgs.hasArg(OBJCOPY_discard_all, OBJCOPY_discard_locals))
     Config.DiscardMode =
         InputArgs.hasFlag(OBJCOPY_discard_all, OBJCOPY_discard_locals)
             ? DiscardType::All
             : DiscardType::Locals;
   Config.OnlyKeepDebug = InputArgs.hasArg(OBJCOPY_only_keep_debug);
return createStringError(
         "--decompress-debug-sections at the same time");
   }
 
   if (Config.DecompressDebugSections && !zlib::isAvailable())
     return createStringError(
         errc::invalid_argument,
         "LLVM was not compiled with LLVM_ENABLE_ZLIB: cannot decompress");
 
+  if (Config.ExtractPartition && Config.ExtractMainPartition)
+    return createStringError(errc::invalid_argument,
+                             "cannot specify --extract-partition together with "
+                             "--extract-main-partition");
+
   DC.CopyConfigs.push_back(std::move(Config));
   return std::move(DC);
 }
 
 // ParseStripOptions returns the config and sets the input arguments. If a
 // help flag is set then ParseStripOptions will print the help messege and
 // exit.
 Expected<DriverConfig> parseStripOptions(ArrayRef<const char *> ArgsArr) {

llvm/trunk/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
         return false;
       if (StringRef(Sec.Name).startswith(".gnu.warning"))
         return false;
       if (Sec.ParentSegment != nullptr)
         return false;
       return (Sec.Flags & SHF_ALLOC) == 0;
     };
 
+  if (Config.ExtractPartition || Config.ExtractMainPartition) {
+    RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
+      if (RemovePred(Sec))
+        return true;
+      if (Sec.Type == SHT_LLVM_PART_EHDR || Sec.Type == SHT_LLVM_PART_PHDR)
+        return true;
+      return (Sec.Flags & SHF_ALLOC) != 0 && !Sec.ParentSegment;
+    };
+  }
+
   // Explicit copies:
   if (!Config.OnlySection.empty()) {
     RemovePred = [&Config, RemovePred, &Obj](const SectionBase &Sec) {
       // Explicitly keep these sections regardless of previous removes.
       if (is_contained(Config.OnlySection, Sec.Name))
         return false;
 
       // Allow all implicit removes.
const ElfType OutputElfType =
       getOutputElfType(Config.OutputArch.getValueOr(Config.BinaryArch));
   if (Error E = handleArgs(Config, *Obj, Reader, OutputElfType))
     return E;
   return writeOutput(Config, *Obj, Out, OutputElfType);
 }
 
 Error executeObjcopyOnBinary(const CopyConfig &Config,
                              object::ELFObjectFileBase &In, Buffer &Out) {
-  ELFReader Reader(&In);
+  ELFReader Reader(&In, Config.ExtractPartition);
   std::unique_ptr<Object> Obj = Reader.create();
   // Prefer OutputArch (-O<format>) if set, otherwise infer it from the input.
   const ElfType OutputElfType =
       Config.OutputArch ? getOutputElfType(Config.OutputArch.getValue())
                         : getOutputElfType(In);
   ArrayRef<uint8_t> BuildIdBytes;
 
   if (!Config.BuildIdLinkDir.empty()) {

llvm/trunk/tools/llvm-objcopy/ELF/Object.h

 template <class ELFT> class ELFBuilder {
 private:
   using Elf_Addr = typename ELFT::Addr;
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Word = typename ELFT::Word;
 
   const ELFFile<ELFT> &ElfFile;
   Object &Obj;
+  uint64_t EhdrOffset = 0;
+  Optional<StringRef> ExtractPartition;
 
   void setParentSegment(Segment &Child);
-  void readProgramHeaders();
+  void readProgramHeaders(const ELFFile<ELFT> &HeadersFile);
   void initGroupSection(GroupSection *GroupSec);
   void initSymbolTable(SymbolTableSection *SymTab);
   void readSectionHeaders();
+  void readSections();
+  void findEhdrOffset();
   SectionBase &makeSection(const Elf_Shdr &Shdr);
 
 public:
-  ELFBuilder(const ELFObjectFile<ELFT> &ElfObj, Object &Obj)
-      : ElfFile(*ElfObj.getELFFile()), Obj(Obj) {}
+  ELFBuilder(const ELFObjectFile<ELFT> &ElfObj, Object &Obj,
+             Optional<StringRef> ExtractPartition)
+      : ElfFile(*ElfObj.getELFFile()), Obj(Obj),
+        ExtractPartition(ExtractPartition) {}
 
   void build();
 };
 
 class BinaryReader : public Reader {
   const MachineInfo &MInfo;
   MemoryBuffer *MemBuf;
 
 public:
   BinaryReader(const MachineInfo &MI, MemoryBuffer *MB)
       : MInfo(MI), MemBuf(MB) {}
   std::unique_ptr<Object> create() const override;
 };
 
 class ELFReader : public Reader {
   Binary *Bin;
+  Optional<StringRef> ExtractPartition;
 
 public:
   std::unique_ptr<Object> create() const override;
-  explicit ELFReader(Binary *B) : Bin(B) {}
+  explicit ELFReader(Binary *B, Optional<StringRef> ExtractPartition)
+      : Bin(B), ExtractPartition(ExtractPartition) {}
 };
 
 class Object {
 private:
   using SecPtr = std::unique_ptr<SectionBase>;
   using SegPtr = std::unique_ptr<Segment>;
 
   std::vector<SecPtr> Sections;

llvm/trunk/tools/llvm-objcopy/ELF/Object.cpp

if (&Child != &Parent && segmentOverlapsSegment(Child, Parent)) {
         if (Child.ParentSegment == nullptr ||
             compareSegmentsByOffset(&Parent, Child.ParentSegment)) {
           Child.ParentSegment = &Parent;
         }
     }
   }
 }
 
-template <class ELFT> void ELFBuilder<ELFT>::readProgramHeaders() {
+template <class ELFT> void ELFBuilder<ELFT>::findEhdrOffset() {
+  if (!ExtractPartition)
+    return;
+
+  for (const SectionBase &Section : Obj.sections()) {
+    if (Section.Type == SHT_LLVM_PART_EHDR &&
+        Section.Name == *ExtractPartition) {
+      EhdrOffset = Section.Offset;
+      return;
+    }
+  }
+  error("could not find partition named '" + *ExtractPartition + "'");
+}
+
+template <class ELFT>
+void ELFBuilder<ELFT>::readProgramHeaders(const ELFFile<ELFT> &HeadersFile) {
   uint32_t Index = 0;
-  for (const auto &Phdr : unwrapOrError(ElfFile.program_headers())) {
-    if (Phdr.p_offset + Phdr.p_filesz > ElfFile.getBufSize())
+  for (const auto &Phdr : unwrapOrError(HeadersFile.program_headers())) {
+    if (Phdr.p_offset + Phdr.p_filesz > HeadersFile.getBufSize())
       error("program header with offset 0x" + Twine::utohexstr(Phdr.p_offset) +
             " and file size 0x" + Twine::utohexstr(Phdr.p_filesz) +
             " goes past the end of the file");
 
-    ArrayRef<uint8_t> Data{ElfFile.base() + Phdr.p_offset,
+    ArrayRef<uint8_t> Data{HeadersFile.base() + Phdr.p_offset,
                            (size_t)Phdr.p_filesz};
     Segment &Seg = Obj.addSegment(Data);
     Seg.Type = Phdr.p_type;
     Seg.Flags = Phdr.p_flags;
-    Seg.OriginalOffset = Phdr.p_offset;
-    Seg.Offset = Phdr.p_offset;
+    Seg.OriginalOffset = Phdr.p_offset + EhdrOffset;
+    Seg.Offset = Phdr.p_offset + EhdrOffset;
     Seg.VAddr = Phdr.p_vaddr;
     Seg.PAddr = Phdr.p_paddr;
     Seg.FileSize = Phdr.p_filesz;
     Seg.MemSize = Phdr.p_memsz;
     Seg.Align = Phdr.p_align;
     Seg.Index = Index++;
     for (SectionBase &Section : Obj.sections()) {
       if (sectionWithinSegment(Section, Seg)) {
         Seg.addSection(&Section);
         if (!Section.ParentSegment ||
             Section.ParentSegment->Offset > Seg.Offset) {
           Section.ParentSegment = &Seg;
         }
       }
     }
   }
 
   auto &ElfHdr = Obj.ElfHdrSegment;
   ElfHdr.Index = Index++;
+  ElfHdr.OriginalOffset = ElfHdr.Offset = EhdrOffset;
 
-  const auto &Ehdr = *ElfFile.getHeader();
+  const auto &Ehdr = *HeadersFile.getHeader();
   auto &PrHdr = Obj.ProgramHdrSegment;
   PrHdr.Type = PT_PHDR;
   PrHdr.Flags = 0;
   // The spec requires us to have p_vaddr % p_align == p_offset % p_align.
   // Whereas this works automatically for ElfHdr, here OriginalOffset is
   // always non-zero and to ensure the equation we assign the same value to
   // VAddr as well.
-  PrHdr.OriginalOffset = PrHdr.Offset = PrHdr.VAddr = Ehdr.e_phoff;
+  PrHdr.OriginalOffset = PrHdr.Offset = PrHdr.VAddr = EhdrOffset + Ehdr.e_phoff;
   PrHdr.PAddr = 0;
   PrHdr.FileSize = PrHdr.MemSize = Ehdr.e_phentsize * Ehdr.e_phnum;
   // The spec requires us to naturally align all the fields.
   PrHdr.Align = sizeof(Elf_Addr);
   PrHdr.Index = Index++;
 
   // Now we do an O(n^2) loop through the segments in order to match up
   // segments.
for (const auto &Shdr : unwrapOrError(ElfFile.sections())) {
     Sec.Info = Shdr.sh_info;
     Sec.Align = Shdr.sh_addralign;
     Sec.EntrySize = Shdr.sh_entsize;
     Sec.Index = Index++;
     Sec.OriginalData =
         ArrayRef<uint8_t>(ElfFile.base() + Shdr.sh_offset,
                           (Shdr.sh_type == SHT_NOBITS) ? 0 : Shdr.sh_size);
   }
+}
 
+template <class ELFT> void ELFBuilder<ELFT>::readSections() {
   // If a section index table exists we'll need to initialize it before we
   // initialize the symbol table because the symbol table might need to
   // reference it.
   if (Obj.SectionIndexTable)
     Obj.SectionIndexTable->initialize(Obj.sections());
 
   // Now that all of the sections have been added we can fill out some extra
   // details about symbol tables. We need the symbol table filled out before
if (auto RelSec = dyn_cast<RelocationSection>(&Section)) {
                         unwrapOrError(ElfFile.rels(Shdr)));
       else
         initRelocations(RelSec, Obj.SymbolTable,
                         unwrapOrError(ElfFile.relas(Shdr)));
     } else if (auto GroupSec = dyn_cast<GroupSection>(&Section)) {
       initGroupSection(GroupSec);
     }
   }
+
+  uint32_t ShstrIndex = ElfFile.getHeader()->e_shstrndx;
+  if (ShstrIndex == SHN_XINDEX)
+    ShstrIndex = unwrapOrError(ElfFile.getSection(0))->sh_link;
+
+  if (ShstrIndex == SHN_UNDEF)
+    Obj.HadShdrs = false;
+  else
+    Obj.SectionNames =
+        Obj.sections().template getSectionOfType<StringTableSection>(
+            ShstrIndex,
+            "e_shstrndx field value " + Twine(ShstrIndex) + " in elf header " +
+                " is invalid",
+            "e_shstrndx field value " + Twine(ShstrIndex) + " in elf header " +
+                " is not a string table");
 }
 
 template <class ELFT> void ELFBuilder<ELFT>::build() {
-  const auto &Ehdr = *ElfFile.getHeader();
+  readSectionHeaders();
+  findEhdrOffset();
 
+  // The ELFFile whose ELF headers and program headers are copied into the
+  // output file. Normally the same as ElfFile, but if we're extracting a
+  // loadable partition it will point to the partition's headers.
+  ELFFile<ELFT> HeadersFile = unwrapOrError(ELFFile<ELFT>::create(toStringRef(
+      {ElfFile.base() + EhdrOffset, ElfFile.getBufSize() - EhdrOffset})));
+
+  auto &Ehdr = *HeadersFile.getHeader();
   Obj.OSABI = Ehdr.e_ident[EI_OSABI];
   Obj.ABIVersion = Ehdr.e_ident[EI_ABIVERSION];
   Obj.Type = Ehdr.e_type;
   Obj.Machine = Ehdr.e_machine;
   Obj.Version = Ehdr.e_version;
   Obj.Entry = Ehdr.e_entry;
   Obj.Flags = Ehdr.e_flags;
 
-  readSectionHeaders();
-  readProgramHeaders();
-
-  uint32_t ShstrIndex = Ehdr.e_shstrndx;
-  if (ShstrIndex == SHN_XINDEX)
-    ShstrIndex = unwrapOrError(ElfFile.getSection(0))->sh_link;
-
-  if (ShstrIndex == SHN_UNDEF)
-    Obj.HadShdrs = false;
-  else
-    Obj.SectionNames =
-        Obj.sections().template getSectionOfType<StringTableSection>(
-            ShstrIndex,
-            "e_shstrndx field value " + Twine(Ehdr.e_shstrndx) +
-                " in elf header is invalid",
-            "e_shstrndx field value " + Twine(Ehdr.e_shstrndx) +
-                " in elf header is not a string table");
+  readSections();
+  readProgramHeaders(HeadersFile);
 }
 
 Writer::~Writer() {}
 
 Reader::~Reader() {}
 
 std::unique_ptr<Object> BinaryReader::create() const {
   return BinaryELFBuilder(MInfo.EMachine, MemBuf).build();
 }
 
 std::unique_ptr<Object> ELFReader::create() const {
   auto Obj = llvm::make_unique<Object>();
   if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
-    ELFBuilder<ELF32LE> Builder(*O, *Obj);
+    ELFBuilder<ELF32LE> Builder(*O, *Obj, ExtractPartition);
     Builder.build();
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
-    ELFBuilder<ELF64LE> Builder(*O, *Obj);
+    ELFBuilder<ELF64LE> Builder(*O, *Obj, ExtractPartition);
     Builder.build();
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
-    ELFBuilder<ELF32BE> Builder(*O, *Obj);
+    ELFBuilder<ELF32BE> Builder(*O, *Obj, ExtractPartition);
     Builder.build();
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
-    ELFBuilder<ELF64BE> Builder(*O, *Obj);
+    ELFBuilder<ELF64BE> Builder(*O, *Obj, ExtractPartition);
     Builder.build();
     return Obj;
   }
   error("invalid file type");
 }
 
 template <class ELFT> void ELFWriter<ELFT>::writeEhdr() {
   Elf_Ehdr &Ehdr = *reinterpret_cast<Elf_Ehdr *>(Buf.getBufferStart());
static uint64_t layoutSections(Range Sections, uint64_t Offset) {
   }
   return Offset;
 }
 
 template <class ELFT> void ELFWriter<ELFT>::initEhdrSegment() {
   Segment &ElfHdr = Obj.ElfHdrSegment;
   ElfHdr.Type = PT_PHDR;
   ElfHdr.Flags = 0;
-  ElfHdr.OriginalOffset = ElfHdr.Offset = 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

llvm/trunk/tools/llvm-objcopy/ObjcopyOpts.td

: Eq<"strip-unneeded-symbols",
          "if they are not needed by relocations">,
       MetaVarName<"filename">;
 
 def extract_dwo
     : Flag<["--"], "extract-dwo">,
       HelpText<
           "Remove all sections that are not DWARF .dwo sections from file">;
 
+defm extract_partition
+    : Eq<"extract-partition", "Extract named partition from input file">,
+      MetaVarName<"name">;
+def extract_main_partition
+    : Flag<["--"], "extract-main-partition">,
+      HelpText<"Extract main partition from the input file">;
+
 def localize_hidden
     : Flag<["--"], "localize-hidden">,
       HelpText<
           "Mark all symbols that have hidden or internal visibility as local">;
 defm localize_symbol : Eq<"localize-symbol", "Mark <symbol> as local">,
                        MetaVarName<"symbol">;
 defm localize_symbols
     : Eq<"localize-symbols",