[llvm-objcopy] Add support for removing sections

[jakehehrlich]

Summary

This change adds support for removing sections using the -R field (as GNU objcopy does as well). This change should let us add many helpful tests and is a proper stepping stone for adding more general kinds of stripping.

[jhenderson]

There are no tests here for what happens to segments. Two cases I can think of: sections between segments, sections in segments.

test/tools/llvm-objcopy/reloc-error-remove-symtab.test

8 ↗

(On Diff #116611)

Minor quibble, but this should probably be ET_REL, since it's a relocatable object file.

test/tools/llvm-objcopy/remove-section.test

3 ↗

(On Diff #116611)

Could you please check the ELF header here, as well, and show that e_shnum is correct.

tools/llvm-objcopy/Object.cpp

157 ↗

(On Diff #116611)

"referenced by the symbol table" -> "referenced by a symbol table", or "referenced by the symbol table" + Name

299 ↗

(On Diff #116611)

Why has this changed?

635 ↗

(On Diff #116611)

This function strikes me as overly complex for what is doing. I think the SecsToRemove set and the second stable_partition can be removed by changing the first one's predicate to test both the section itself for removal, and if it is a relocation section, the section it refers to:

if (ToRemove(*Sec))
  return false;
if (auto RelSec = dyn_cast<DefinedOnRelocSection>(Sec.get()))
  return !ToRemove(*RelSec->SecToApplyRel);
return true;

652 ↗

(On Diff #116611)

"... throw errors here." -> "... emit an error here instead."

tools/llvm-objcopy/Object.h

199 ↗

(On Diff #116611)

What is the purpose of this new class? Can't we just use RelocationSectionBase?

tools/llvm-objcopy/llvm-objcopy.cpp

59 ↗

(On Diff #116611)

objcopy also allows --remove-section as an alias. It also allows specifying the option multiple times to strip multiple sections.

72 ↗

(On Diff #116611)

Why a lambda here? Also, the explicit return type is unnecessary.

[jakehehrlich]

tools/llvm-objcopy/Object.cpp

299 ↗

(On Diff #116611)

Oh whoops. I forgot to mention this. It was wrong before. I was using StringTableSection for what under the hood was actually a Section. This was fine because I wasn't using anything that wasn't in SectionBase here. Additionally dynamic string tables have SHT_STRTAB so the cast went though just fine. I think to avoid this mistake in the future I should probably add a check that StringTableSection is not allocated.

tools/llvm-objcopy/llvm-objcopy.cpp

59 ↗

(On Diff #116611)

I'll add --remove-section as an alias. Would you take making ToRemove a cl::list as a todo?

72 ↗

(On Diff #116611)

What alternative are you proposing? Or are you just asking why this method takes a lambda? That's because many other conditions for removal will be added. This interface should cover all of them however.

[jakehehrlich]

1. Added --remove-section alias (actually, I made --remove-section the main parameter and -R the alias)
2. Simplified removal algorithm as recommended by James
3. Added check for e_shnum to a test.

[jakehehrlich]

tools/llvm-objcopy/Object.h

199 ↗

(On Diff #116611)

It lets me cast both to DefinedOnRelocSection so that I can handle both cases uniformly.

[jakehehrlich]

I uploaded the wrong diff. This is the right one.

[jhenderson]

test/tools/llvm-objcopy/remove-section.test

22 ↗

(On Diff #116750)

As things stand, this test only shows that .test2 is not between .test1 and .test3. I think there are two ways to change this: 1) CHECK-NOT: .test2 between every block of CHECKs or 2) CHECK for each section (not just .test1 and .test3) by name specifically.

tools/llvm-objcopy/Object.cpp

299 ↗

(On Diff #116611)

Ok, that sort of makes sense. In that case, however, could you make this change in a separate review/commit, please, as it's not really related to removing sections.

tools/llvm-objcopy/Object.h

216 ↗

(On Diff #116750)

I think this member should now be deleted?

199 ↗

(On Diff #116611)

Ah, okay, I forgot that we had templated RelocationSectionBase. In that case, could we rename them, because I do not understand what "DefinedOnRelocSection" is supposed to represent - what is defined here?

I would seriously consider renaming DefinedOnRelocSection "RelocationSectionBase", since that is the base class for relocation sections, and then maybe RelocationSectionBase to "RelocSectionWithSymtabBase" or similar.

tools/llvm-objcopy/llvm-objcopy.cpp

59 ↗

(On Diff #116611)

Yes, that's fine with me.

72 ↗

(On Diff #116611)

The alternative would be to pass in the section name(s) to the function and test them there, but if the plan is to add other ways to remove sections, then this is fine with me. The explicit return type is still unnecessary, I believe.

[jakehehrlich]

1. Removed "-> bool"
2. Renamed relocation class hierarchy as recommended
3. Reverted fixing the StringTableSection vs SectionBase issue. I will upload another patch to fix that
4. Removed duplicate member

[jhenderson]

Not sure if this got missed from my earlier comments, but I think you need tests for removing sections when there are segments present, to show that the addresses are unchanged, even if the offset changes, and to show the restriction on moving sections within segments etc. I've suggested changing the remaining yaml2obj-based tests to use ET_REL, to crudely indicate these are missing segments (feel free to ignore those comments), and then any new tests involving segments would use ET_EXEC.

test/tools/llvm-objcopy/remove-section-with-symbol.test

9 ↗

(On Diff #116859)

ET_EXEC -> ET_REL

test/tools/llvm-objcopy/remove-section.test

9 ↗

(On Diff #116859)

ET_EXEC -> ET_REL

tools/llvm-objcopy/Object.h

213 ↗

(On Diff #116859)

Could we add a comment to explain why we need separate RelocationSectionBase and RelocationSectionWtihSymtabBase classes, please.

Also, I think we need to prevent users directly instantiating RelocationSectionBase somehow, maybe by giving it a protected constructor?

[jhenderson]

tools/llvm-objcopy/llvm-objcopy.cpp

62 ↗

(On Diff #116859)

Alias for -quiet -> copy and paste error?

(Spotted this when looking at D38335!)

[jakehehrlich]

1. Changed test ELF types to ET_REL were appropriate
2. Added segment test that I forgot to add
3. Added a comment describing the need for the strange hierarchy around relocations.

[jhenderson]

I think we could use one more test, if it is possible to construct: a section between two segments that is then removed, allowing the second segment to move in the file (but not in memory):

| Section 1 | Section 2 | Section 3 |
| Segment 1 |-----------| Segment 2 |

Don't worry about it, if it's not possible to sensibly, as I think this an edge case that is unlikely to be seen in most situations.

test/tools/llvm-objcopy/segment-test-remove-section.test

4 ↗

(On Diff #117027)

it's -> its

test/tools/llvm-objcopy/symtab-error-on-remove-strtab.test

11 ↗

(On Diff #117027)

by the symbol table .symtab

tools/llvm-objcopy/Object.h

200 ↗

(On Diff #117027)

However some... -> However, some

206 ↗

(On Diff #117027)

the other handles... -> another which handles

221 ↗

(On Diff #117027)

Too many full stops this time!

222 ↗

(On Diff #117027)

two relocation types -> two symbol table types

Two relocation types implies to me "Rel" and "Rela" relocations, which isn't what is relevant here. What's relevant is the symbol table being referred to.

[jakehehrlich]

In D38260#884157, @jhenderson wrote:

I think we could use one more test, if it is possible to construct: a section between two segments that is then removed, allowing the second segment to move in the file (but not in memory):

| Section 1 | Section 2 | Section 3 |
| Segment 1 |-----------| Segment 2 |

Don't worry about it, if it's not possible to sensibly, as I think this an edge case that is unlikely to be seen in most situations.

A test like this is possible but I'm not sure it will test the desired behavior.

If an input file starts out like this

| Section 1 | Section 2 | Section 3 |
| Segment 1 |-----------| Segment 2 |

Then it will end up like this after copy (note that Section 2 is not removed) because of the new layout algortihm

| Section 1 | Section 3 | Section 2 | 
| Segment 1 | Segment 2 | ---------- |

I can add the test but it's worth pointing out that the reason the segments get placed together has nothing to do with Section 2 being removed or not removed.

[jakehehrlich]

1. I was playing with the recommended test that I said would not prove anything and it actually exposed a bunch of issues. I submitted https://reviews.llvm.org/D38436 for review and that should be landed before this is landed.
2. I made the recommended grammatical changes
3. The new test in https://reviews.llvm.org/D38436 named "segment-shift.test" is exactly the test case James recommended minus the section removal.

[jhenderson]

In D38260#884729, @jakehehrlich wrote:

I can add the test but it's worth pointing out that the reason the segments get placed together has nothing to do with Section 2 being removed or not removed.

I see your point. However, I think it is still worth adding a remove-section version of the test you added in D38436, as it will demonstrate that the section is removed properly, and that no space is allocated for it at the end. It means that even if the layout algorithm changes, the correct behaviour is still tested for this case. Ideally, I'd then like to see that the trailing sections (.symtab, .strtab etc) appear directly after the final segment, without any gap caused by the removed section.

test/tools/llvm-objcopy/segment-test-remove-section.test

2 ↗

(On Diff #117249)

There's another it's -> its here.

[jakehehrlich]

1. Added test
2. Fixed "it's vs its" typo

[jakehehrlich]

Don't LGTM this just yet. I want to add things from D38335 beforehand. I need to add a bunch of tests still but I'll upload the code for review tonight.

tests I want to add

1. Trigger the error for .shstrtab being removed. Right now this should always be an error
2. Make sure segment data is kept regardless of section removal.

[jakehehrlich]

1. PT_LOAD Segment data is now copied though regardless of section removal
2. Added checks for .shstrtab and .symtab to handle removal of those sections

I also think an error should be added if an allocated section is removed. It isn't clear to me what should happen in that case and the best thing I can come up with in that case is *very* different from what I think GNU objcopy would do. So until we know what should happen when an allocated section is removed I think would should throw an error saying that removing an allocated section isn't supported.

[jakehehrlich]

1. Added test to make sure that segment data is kept regardless of section removal
2. Added test to make sure that .symtab can be removed without causing error
3. Added test to make sure that .shstrtab can't be removed. Once we have an option to not emit the section header table we can also add an option to allow .shstrtab to be removed in that case.

[jhenderson]

I did an experiment using objcopy, to see what happened if it removes a SHF_ALLOC section in a linked ELF with segments. As it turns out, objcopy removes the section without warning or error, and leaves 0s in its place. This could be dangerous on x86 at least, I think. If you do this to an executable section, and there's still the ability to jump there, then this could lead to execution of invalid instructions. At the very least, we should write trap instructions in place of the removed section, if it is in the executable segment. Alternatively, I'm quite happy you emit an error in this case.

A possible suggestion might be to have both behaviours, but have the "blank section" behaviour under another switch (e.g. --blank-section). This could be useful if the user wants to send somebody an ELF to inspect some specific characteristics, but without allowing them to actually run the program or see certain bits of data for whatever reason. I'd still replace the section contents with trap instructions in this case.

test/tools/llvm-objcopy/segment-data-kept.test

3 ↗

(On Diff #117708)

Why not fold this and segment-test-remove-section.test together?

[jhenderson]

By the way, not sure if you noticed my comment in D38335:

I'm not sure it [stripping the section header string table] should be an error anyway - it looks like GNU binutils at the very least can handle an ELF with no section header string table, but with section headers, without too much problem, although I'd expect the e_shstrndx field to be set to 0 in this case.

Can I just confirm here that you are deliberately not allowing this behaviour? FWIW, objcopy refuses to strip the section, although it is silent about doing so.

[jakehehrlich]

In D38260#889160, @jhenderson wrote:

By the way, not sure if you noticed my comment in D38335:

I'm not sure it [stripping the section header string table] should be an error anyway - it looks like GNU binutils at the very least can handle an ELF with no section header string table, but with section headers, without too much problem, although I'd expect the e_shstrndx field to be set to 0 in this case.

Can I just confirm here that you are deliberately not allowing this behaviour? FWIW, objcopy refuses to strip the section, although it is silent about doing so.

Sorry, yes. I heard this and want to add that ability in another change. Specifically the --strip-sections change.

[jakehehrlich]

In D38260#889154, @jhenderson wrote:

I did an experiment using objcopy, to see what happened if it removes a SHF_ALLOC section in a linked ELF with segments. As it turns out, objcopy removes the section without warning or error, and leaves 0s in its place. This could be dangerous on x86 at least, I think. If you do this to an executable section, and there's still the ability to jump there, then this could lead to execution of invalid instructions. At the very least, we should write trap instructions in place of the removed section, if it is in the executable segment. Alternatively, I'm quite happy you emit an error in this case.

A possible suggestion might be to have both behaviours, but have the "blank section" behaviour under another switch (e.g. --blank-section). This could be useful if the user wants to send somebody an ELF to inspect some specific characteristics, but without allowing them to actually run the program or see certain bits of data for whatever reason. I'd still replace the section contents with trap instructions in this case.

So someone on IRC requested that llvm-objcopy support the -j option. The particular way this is used is in conjunction with -O binary. This winds up showing a difference between what I did and what GNU objcopy actually does under the hood. GNU objcopy is section oriented not segment oriented. So if you use -O binary and -j in conjunction it will output just the data from that specific section. In the process of thinking about how to support this it became clear to me that removing allocated sections is something that's important to support, we can't just throw an error. It also became clear that I need to make -O binary work differently but more on that later. I talked with Roland McGrath about what seemed like expected behavior since I was quite ambivalent about what should happen when you remove a section that's in the middle of a segment. I pitched writing with gap fill (zero by default but using <gap fill> from --gap-fill=<gap fill> otherwise) vs just keeping the segment data. Roland seemed to think that keeping the segment data made no sense at all. This being the case it makes most sense to copy what GNU objcopy does. This also gives you both behaviors by default. Namely if you don't want a section overwritten with zeros just don't remove it. So to support the only change we would make is to just leave Object::writeSectionData alone rather than having it write segment data out first. In the --strip-sections diff we then remove only the non-allocated sections and don't emit the section header table. Everything should be consistent with what GNU objcopy does in the relevant cases.

In summary I propose the following:

1. Leave writeSectionData alone so that it writes zeros. When we implement --gap-fill that can change slightly
2. In --strip-sections we should only remove non-allocated sections

[jakehehrlich]

1. Removed data-kept test because a) it was a bit redundant as James pointed out and b) I no longer think that is correct functionality as I explained. Basically I wasn't sure what correct functionality was and after talking with Roland McGrath and reading what James wrote I think I'm convinced that overwriting with zeros by default is better than keeping segment data.
2. I made Object::writeSegmentData just behave like it used to which will mimic what GNU objcopy does when an allocated section is removed.

[jhenderson]

In D38260#889492, @jakehehrlich wrote:

In D38260#889160, @jhenderson wrote:

By the way, not sure if you noticed my comment in D38335:

I'm not sure it [stripping the section header string table] should be an error anyway - it looks like GNU binutils at the very least can handle an ELF with no section header string table, but with section headers, without too much problem, although I'd expect the e_shstrndx field to be set to 0 in this case.

Can I just confirm here that you are deliberately not allowing this behaviour? FWIW, objcopy refuses to strip the section, although it is silent about doing so.

Sorry, yes. I heard this and want to add that ability in another change. Specifically the --strip-sections change.

Okay, that's fine with me.

In D38260#890066, @jakehehrlich wrote:

In summary I propose the following:

1. Leave writeSectionData alone so that it writes zeros. When we implement --gap-fill that can change slightly
2. In --strip-sections we should only remove non-allocated sections

I agree with this as an approach.

I think we need a test to demonstrate that we have zeros instead though, to demonstrate that this is the desired behaviour. I guess it would look very similar to the kept data test, but with zeroes instead of the old data.

[jakehehrlich]

Added test to make sure that zeros are being output

[jhenderson]

Sorry, this should have occurred to me earlier, but the tests that actually remove sections need to have checks for the e_shnum field, to show that it has been updated.

Once that's done, I'm happy with this change.

[jakehehrlich]

Added checks for section header table size to each test.

[jhenderson]

LGTM, aside from one comment addition.

test/tools/llvm-objcopy/remove-section-with-symbol.test

31 ↗

(On Diff #118284)

Could you add a comment saying what the other 4 section headers should be, please, to avoid confusion (I assume it is null, .symtab, .strtab, and .shstrtab).

llvm/trunk/test/tools/llvm-objcopy/dynsym-error-remove-strtab.test

+# RUN: not llvm-objcopy -R .dynstr %p/Inputs/dynsym.so %t 2>&1 >/dev/null | FileCheck %s
+
+# CHECK: String table .dynstr cannot be removed because it is referenced by the section .dynsym

llvm/trunk/test/tools/llvm-objcopy/reloc-error-remove-symtab.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-objcopy -R .symtab %t %t2 2>&1 >/dev/null | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x0000000000000010
+    Content:         "0000000000000000"
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    Info:            .text
+    Relocations:
+      - Offset: 0x1000
+        Symbol: foo
+        Type:   R_X86_64_PC32
+
+Symbols:
+  Global:
+    - Name:     foo
+      Type:     STT_FUNC
+      Size:     4
+
+# CHECK: Symbol table .symtab cannot be removed because it is referenced by the relocation section .rel.text.

llvm/trunk/test/tools/llvm-objcopy/remove-section-with-symbol.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-objcopy -R .test %t %t2
+# RUN: llvm-readobj -file-headers -symbols %t2 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .test
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+  - Name:            .test2
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+Symbols:
+  Global:
+    - Name:     test
+      Type:     STT_FUNC
+      Section:  .test
+      Value:    0x1000
+      Size:     4
+    - Name:     test2
+      Type:     STT_FUNC
+      Section:  .test2
+      Value:    0x1000
+      Size:     4
+
+# The sections counted here should be .test, .symtab, .strtab, and .shstrtab.
+# The 5th section is the null section.
+#CHECK: SectionHeaderCount: 5
+
+#CHECK: Symbols [
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name:
+#CHECK-NEXT:    Value: 0x0
+#CHECK-NEXT:    Size: 0
+#CHECK-NEXT:    Binding: Local
+#CHECK-NEXT:    Type: None
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: Undefined
+#CHECK-NEXT:  }
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: test2
+#CHECK-NEXT:    Value: 0x1000
+#CHECK-NEXT:    Size: 4
+#CHECK-NEXT:    Binding: Global
+#CHECK-NEXT:    Type: Function
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: .test2
+#CHECK-NEXT:  }
+#CHECK-NEXT:]

llvm/trunk/test/tools/llvm-objcopy/remove-section.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-objcopy -R=.test2 %t %t2
+# RUN: llvm-readobj -file-headers -sections %t2 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .test1
+    Type:            SHT_PROGBITS
+    Flags:           [ ]
+  - Name:            .test2
+    Type:            SHT_PROGBITS
+    Flags:           [ ]
+  - Name:            .test3
+    Type:            SHT_PROGBITS
+    Flags:           [ ]
+
+# CHECK: SectionHeaderCount: 6
+
+# CHECK: Sections [
+# CHECK:   Section {
+# CHECK:     Index: 0
+# CHECK:     Name:  (0)
+# CHECK:     Type: SHT_NULL (0x0)
+# CHECK:     Flags [ (0x0)
+# CHECK:     ]
+# CHECK:     Address: 0x0
+# CHECK:     Offset:
+# CHECK:     Size:
+# CHECK:     Link: 0
+# CHECK:     Info: 0
+# CHECK:     AddressAlignment: 0
+# CHECK:     EntrySize: 0
+# CHECK:   }
+# CHECK:   Section {
+# CHECK:     Index: 1
+# CHECK:     Name: .test1
+# CHECK:     Type: SHT_PROGBITS (0x1)
+# CHECK:     Flags [ (0x0)
+# CHECK:     ]
+# CHECK:     Address: 0x0
+# CHECK:     Offset:
+# CHECK:     Size:
+# CHECK:     Link: 0
+# CHECK:     Info: 0
+# CHECK:     AddressAlignment: 0
+# CHECK:     EntrySize: 0
+# CHECK:   }
+# CHECK:   Section {
+# CHECK:     Index: 2
+# CHECK:     Name: .test3
+# CHECK:     Type: SHT_PROGBITS (0x1)
+# CHECK:     Flags [ (0x0)
+# CHECK:     ]
+# CHECK:     Address: 0x0
+# CHECK:     Offset:
+# CHECK:     Size:
+# CHECK:     Link: 0
+# CHECK:     Info: 0
+# CHECK:     AddressAlignment: 0
+# CHECK:     EntrySize: 0
+# CHECK:   }
+# CHECK:   Section {
+# CHECK:     Index: 3
+# CHECK:     Name: .symtab
+# CHECK:     Type: SHT_SYMTAB (0x2)
+# CHECK:     Flags [ (0x0)
+# CHECK:     ]
+# CHECK:     Address: 0x0
+# CHECK:     Offset:
+# CHECK:     Size:
+# CHECK:     Link: 4
+# CHECK:     Info: 1
+# CHECK:     AddressAlignment: 8
+# CHECK:     EntrySize: 24
+# CHECK:   }
+# CHECK:   Section {
+# CHECK:     Index: 4
+# CHECK:     Name: .strtab
+# CHECK:     Type: SHT_STRTAB (0x3)
+# CHECK:     Flags [ (0x0)
+# CHECK:     ]
+# CHECK:     Address: 0x0
+# CHECK:     Offset:
+# CHECK:     Size:
+# CHECK:     Link: 0
+# CHECK:     Info: 0
+# CHECK:     AddressAlignment: 1
+# CHECK:     EntrySize: 0
+# CHECK:   }
+# CHECK:   Section {
+# CHECK:     Index: 5
+# CHECK:     Name: .shstrtab
+# CHECK:     Type: SHT_STRTAB (0x3)
+# CHECK:     Flags [ (0x0)
+# CHECK:     ]
+# CHECK:     Address: 0x0
+# CHECK:     Offset:
+# CHECK:     Size:
+# CHECK:     Link: 0
+# CHECK:     Info: 0
+# CHECK:     AddressAlignment: 1
+# CHECK:     EntrySize: 0
+# CHECK:   }
+# CHECK: ]

llvm/trunk/test/tools/llvm-objcopy/remove-shstrtab-error.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-objcopy -R .shstrtab %t %t2 2>&1 >/dev/null | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+
+# CHECK: Cannot remove .shstrtab because it is the section header string table.

llvm/trunk/test/tools/llvm-objcopy/remove-symtab.test

+# RUN: yaml2obj %s > %t
+# RUN: llvm-objcopy -R .symtab %t %t2
+# RUN: llvm-readobj -file-headers -sections %t2 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+
+#CHECK: SectionHeaderCount: 3
+
+#CHECK:        Sections [
+#CHECK-NEXT:     Section {
+#CHECK-NEXT:       Index: 0
+#CHECK-NEXT:       Name:  (0)
+#CHECK-NEXT:       Type: SHT_NULL (0x0)
+#CHECK-NEXT:       Flags [ (0x0)
+#CHECK-NEXT:       ]
+#CHECK-NEXT:       Address: 0x0
+#CHECK-NEXT:       Offset: 0x0
+#CHECK-NEXT:       Size: 0
+#CHECK-NEXT:       Link: 0
+#CHECK-NEXT:       Info: 0
+#CHECK-NEXT:       AddressAlignment: 0
+#CHECK-NEXT:       EntrySize: 0
+#CHECK-NEXT:     }
+#CHECK-NEXT:     Section {
+#CHECK-NEXT:       Index: 1
+#CHECK-NEXT:       Name: .strtab
+#CHECK-NEXT:       Type: SHT_STRTAB (0x3)
+#CHECK-NEXT:       Flags [ (0x0)
+#CHECK-NEXT:       ]
+#CHECK-NEXT:       Address: 0x0
+#CHECK-NEXT:       Offset:
+#CHECK-NEXT:       Size: 1
+#CHECK-NEXT:       Link: 0
+#CHECK-NEXT:       Info: 0
+#CHECK-NEXT:       AddressAlignment: 1
+#CHECK-NEXT:       EntrySize: 0
+#CHECK-NEXT:     }
+#CHECK-NEXT:     Section {
+#CHECK-NEXT:       Index: 2
+#CHECK-NEXT:       Name: .shstrtab (1)
+#CHECK-NEXT:       Type: SHT_STRTAB (0x3)
+#CHECK-NEXT:       Flags [ (0x0)
+#CHECK-NEXT:       ]
+#CHECK-NEXT:       Address: 0x0
+#CHECK-NEXT:       Offset:
+#CHECK-NEXT:       Size:
+#CHECK-NEXT:       Link: 0
+#CHECK-NEXT:       Info: 0
+#CHECK-NEXT:       AddressAlignment: 1
+#CHECK-NEXT:       EntrySize: 0
+#CHECK-NEXT:     }
+#CHECK-NEXT:   ]

llvm/trunk/test/tools/llvm-objcopy/segment-shift-section-remove.test

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objcopy -R .text2 %t %t2
+# RUN: llvm-readobj -file-headers -sections -program-headers %t2 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x1000
+    Size:            0x1000
+  - Name:            .text2
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x2000
+    AddressAlign:    0x1000
+    Size:            0x1000
+  - Name:            .text3
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x3000
+    AddressAlign:    0x1000
+    Size:            0x1000
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x1000
+    PAddr: 0x1000
+    Sections:
+      - Section: .text
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x3000
+    PAddr: 0x3000
+    Sections:
+      - Section: .text3
+
+#CHECK: SectionHeaderCount: 6
+
+# CHECK:           Sections [
+# CHECK-NEXT:        Section {
+# CHECK-NEXT:          Index: 0
+# CHECK-NEXT:          Name:  (0)
+# CHECK-NEXT:          Type: SHT_NULL (0x0)
+# CHECK-NEXT:          Flags [ (0x0)
+# CHECK-NEXT:          ]
+# CHECK-NEXT:          Address: 0x0
+# CHECK-NEXT:          Offset: 0x0
+# CHECK-NEXT:          Size: 0
+# CHECK-NEXT:          Link: 0
+# CHECK-NEXT:          Info: 0
+# CHECK-NEXT:          AddressAlignment: 0
+# CHECK-NEXT:          EntrySize: 0
+# CHECK-NEXT:        }
+# CHECK-NEXT:        Section {
+# CHECK-NEXT:          Index: 1
+# CHECK-NEXT:          Name: .text
+# CHECK-NEXT:          Type: SHT_PROGBITS (0x1)
+# CHECK-NEXT:          Flags [ (0x6)
+# CHECK-NEXT:            SHF_ALLOC (0x2)
+# CHECK-NEXT:            SHF_EXECINSTR (0x4)
+# CHECK-NEXT:          ]
+# CHECK-NEXT:          Address: 0x1000
+# CHECK-NEXT:          Offset: 0x1000
+# CHECK-NEXT:          Size: 4096
+# CHECK-NEXT:          Link: 0
+# CHECK-NEXT:          Info: 0
+# CHECK-NEXT:          AddressAlignment: 4096
+# CHECK-NEXT:          EntrySize: 0
+# CHECK-NEXT:        }
+# CHECK-NEXT:        Section {
+# CHECK-NEXT:          Index: 2
+# CHECK-NEXT:          Name: .text3
+# CHECK-NEXT:          Type: SHT_PROGBITS (0x1)
+# CHECK-NEXT:          Flags [ (0x6)
+# CHECK-NEXT:            SHF_ALLOC (0x2)
+# CHECK-NEXT:            SHF_EXECINSTR (0x4)
+# CHECK-NEXT:          ]
+# CHECK-NEXT:          Address: 0x3000
+# CHECK-NEXT:          Offset: 0x2000
+# CHECK-NEXT:          Size: 4096
+# CHECK-NEXT:          Link: 0
+# CHECK-NEXT:          Info: 0
+# CHECK-NEXT:          AddressAlignment: 4096
+# CHECK-NEXT:          EntrySize: 0
+# CHECK-NEXT:        }
+# CHECK-NEXT:        Section {
+# CHECK-NEXT:          Index: 3
+# CHECK-NEXT:          Name: .symtab
+# CHECK-NEXT:          Type: SHT_SYMTAB (0x2)
+# CHECK-NEXT:          Flags [ (0x0)
+# CHECK-NEXT:          ]
+# CHECK-NEXT:          Address: 0x0
+# CHECK-NEXT:          Offset: 0x3000
+# CHECK-NEXT:          Size: 24
+# CHECK-NEXT:          Link: 4
+# CHECK-NEXT:          Info: 1
+# CHECK-NEXT:          AddressAlignment: 8
+# CHECK-NEXT:          EntrySize: 24
+# CHECK-NEXT:        }
+# CHECK-NEXT:        Section {
+# CHECK-NEXT:          Index: 4
+# CHECK-NEXT:          Name: .strtab
+# CHECK-NEXT:          Type: SHT_STRTAB (0x3)
+# CHECK-NEXT:          Flags [ (0x0)
+# CHECK-NEXT:          ]
+# CHECK-NEXT:          Address: 0x0
+# CHECK-NEXT:          Offset: 0x3018
+# CHECK-NEXT:          Size:
+# CHECK-NEXT:          Link: 0
+# CHECK-NEXT:          Info: 0
+# CHECK-NEXT:          AddressAlignment: 1
+# CHECK-NEXT:          EntrySize: 0
+# CHECK-NEXT:        }
+# CHECK-NEXT:        Section {
+# CHECK-NEXT:          Index: 5
+# CHECK-NEXT:          Name: .shstrtab
+# CHECK-NEXT:          Type: SHT_STRTAB (0x3)
+# CHECK-NEXT:          Flags [ (0x0)
+# CHECK-NEXT:          ]
+# CHECK-NEXT:          Address: 0x0
+# CHECK-NEXT:          Offset:
+# CHECK-NEXT:          Size:
+# CHECK-NEXT:          Link: 0
+# CHECK-NEXT:          Info: 0
+# CHECK-NEXT:          AddressAlignment: 1
+# CHECK-NEXT:          EntrySize: 0
+# CHECK-NEXT:        }
+# CHECK-NEXT:      ]
+
+
+# CHECK:     ProgramHeaders [
+# CHECK-NEXT:  ProgramHeader {
+# CHECK-NEXT:    Type: PT_LOAD (0x1)
+# CHECK-NEXT:    Offset: 0x1000
+# CHECK-NEXT:    VirtualAddress: 0x1000
+# CHECK-NEXT:    PhysicalAddress: 0x1000
+# CHECK-NEXT:    FileSize: 4096
+# CHECK-NEXT:    MemSize: 4096
+# CHECK-NEXT:    Flags [ (0x4)
+# CHECK-NEXT:      PF_R (0x4)
+# CHECK-NEXT:    ]
+# CHECK-NEXT:    Alignment: 4096
+# CHECK-NEXT:  }
+# CHECK-NEXT:  ProgramHeader {
+# CHECK-NEXT:    Type: PT_LOAD (0x1)
+# CHECK-NEXT:    Offset: 0x2000
+# CHECK-NEXT:    VirtualAddress: 0x3000
+# CHECK-NEXT:    PhysicalAddress: 0x3000
+# CHECK-NEXT:    FileSize: 4096
+# CHECK-NEXT:    MemSize: 4096
+# CHECK-NEXT:    Flags [ (0x5)
+# CHECK-NEXT:      PF_R (0x4)
+# CHECK-NEXT:      PF_X (0x1)
+# CHECK-NEXT:    ]
+# CHECK-NEXT:    Alignment: 4096
+# CHECK-NEXT:  }
+# CHECK-NEXT:]

llvm/trunk/test/tools/llvm-objcopy/segment-test-remove-section.test

+# This test is checking to ensure that if a section is removed in the presence
+# of a segment that the segment maintains its shape and properties and that any
+# section inside that segment maintains the relative positioning it had in the
+# segment. Note worthy is that .text3 keeps its offset despite it being
+# possible to place it after .text when .text2 is removed.
+
+# RUN: yaml2obj %s -o %t
+# RUN: llvm-objcopy -R .text2 %t %t2
+# RUN: llvm-readobj -file-headers -program-headers -sections %t2 | FileCheck %s
+# RUN: od -t x1 -j 8192 %t2 | FileCheck %s --check-prefix=DATA
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x1000
+    Size:            4096
+  - Name:            .text2
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x2000
+    AddressAlign:    0x1000
+    Size:            4096
+    Content:         "DEADBEEF"
+  - Name:            .text3
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x3000
+    AddressAlign:    0x1000
+    Size:            4096
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_R ]
+    Sections:
+      - Section: .text
+      - Section: .text2
+      - Section: .text3
+
+# Make sure that when we remove a section we overwrite it with zeros
+# DATA: 0020000 00 00 00 00
+
+#CHECK: SectionHeaderCount: 6
+
+# CHECK: Sections [
+# CHECK:   Section {
+# CHECK-NEXT:     Index: 0
+# CHECK-NEXT:     Name:  (0)
+# CHECK-NEXT:     Type: SHT_NULL (0x0)
+# CHECK-NEXT:     Flags [ (0x0)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x0
+# CHECK-NEXT:     Offset:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Link: 0
+# CHECK-NEXT:     Info: 0
+# CHECK-NEXT:     AddressAlignment: 0
+# CHECK-NEXT:     EntrySize: 0
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 1
+# CHECK-NEXT:     Name: .text
+# CHECK-NEXT:     Type: SHT_PROGBITS
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       SHF_ALLOC
+# CHECK-NEXT:       SHF_EXECINSTR
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x1000
+# CHECK-NEXT:     Offset: 0x1000
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Link: 0
+# CHECK-NEXT:     Info: 0
+# CHECK-NEXT:     AddressAlignment: 4096
+# CHECK-NEXT:     EntrySize: 0
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 2
+# CHECK-NEXT:     Name: .text3
+# CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
+# CHECK-NEXT:     Flags [
+# CHECK-NEXT:       SHF_ALLOC
+# CHECK-NEXT:       SHF_EXECINSTR
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x3000
+# CHECK-NEXT:     Offset: 0x3000
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Link: 0
+# CHECK-NEXT:     Info: 0
+# CHECK-NEXT:     AddressAlignment: 4096
+# CHECK-NEXT:     EntrySize: 0
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 3
+# CHECK-NEXT:     Name: .symtab
+# CHECK-NEXT:     Type: SHT_SYMTAB (0x2)
+# CHECK-NEXT:     Flags [ (0x0)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x0
+# CHECK-NEXT:     Offset:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Link: 4
+# CHECK-NEXT:     Info: 1
+# CHECK-NEXT:     AddressAlignment: 8
+# CHECK-NEXT:     EntrySize: 24
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 4
+# CHECK-NEXT:     Name: .strtab
+# CHECK-NEXT:     Type: SHT_STRTAB (0x3)
+# CHECK-NEXT:     Flags [ (0x0)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x0
+# CHECK-NEXT:     Offset:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Link: 0
+# CHECK-NEXT:     Info: 0
+# CHECK-NEXT:     AddressAlignment: 1
+# CHECK-NEXT:     EntrySize: 0
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 5
+# CHECK-NEXT:     Name: .shstrtab
+# CHECK-NEXT:     Type: SHT_STRTAB (0x3)
+# CHECK-NEXT:     Flags [ (0x0)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Address: 0x0
+# CHECK-NEXT:     Offset:
+# CHECK-NEXT:     Size:
+# CHECK-NEXT:     Link: 0
+# CHECK-NEXT:     Info: 0
+# CHECK-NEXT:     AddressAlignment: 1
+# CHECK-NEXT:     EntrySize: 0
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+#CHECK:     ProgramHeaders [
+#CHECK-NEXT:  ProgramHeader {
+#CHECK-NEXT:    Type: PT_LOAD (0x1)
+#CHECK-NEXT:    Offset: 0x1000
+#CHECK-NEXT:    VirtualAddress: 0x0
+#CHECK-NEXT:    PhysicalAddress: 0x0
+#CHECK-NEXT:    FileSize: 12288
+#CHECK-NEXT:    MemSize: 12288
+#CHECK-NEXT:    Flags [ (0x5)
+#CHECK-NEXT:      PF_R (0x4)
+#CHECK-NEXT:      PF_X (0x1)
+#CHECK-NEXT:    ]
+#CHECK-NEXT:    Alignment: 4096
+#CHECK-NEXT:  }
+#CHECK-NEXT:]

llvm/trunk/test/tools/llvm-objcopy/symtab-error-on-remove-strtab.test

+# RUN: yaml2obj %s > %t
+# RUN: not llvm-objcopy -R .strtab %t %t2 2>&1 >/dev/null | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+
+# CHECK: String table .strtab cannot be removed because it is referenced by the symbol table .symtab

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

public:
   uint64_t NameIndex = 0;
   uint64_t Offset = 0;
   uint64_t Size = 0;
   uint64_t Type = llvm::ELF::SHT_NULL;
 
   virtual ~SectionBase() {}
   virtual void initialize(SectionTableRef SecTable);
   virtual void finalize();
+  virtual void removeSectionReferences(const SectionBase *Sec);
   template <class ELFT> void writeHeader(llvm::FileOutputBuffer &Out) const;
   virtual void writeSection(llvm::FileOutputBuffer &Out) const = 0;
 };
 
 class Segment {
 private:
   struct SectionCompare {
     bool operator()(const SectionBase *Lhs, const SectionBase *Rhs) const {
public:
   Segment *ParentSegment = nullptr;
 
   Segment(llvm::ArrayRef<uint8_t> Data) : Contents(Data) {}
   const SectionBase *firstSection() const {
     if (!Sections.empty())
       return *Sections.begin();
     return nullptr;
   }
-  void addSection(const SectionBase *sec) { Sections.insert(sec); }
+  void removeSection(const SectionBase *Sec) { Sections.erase(Sec); }
+  void addSection(const SectionBase *Sec) { Sections.insert(Sec); }
   template <class ELFT> void writeHeader(llvm::FileOutputBuffer &Out) const;
   void writeSegment(llvm::FileOutputBuffer &Out) const;
 };
 
 class Section : public SectionBase {
 private:
   llvm::ArrayRef<uint8_t> Contents;
 
struct Symbol {
   uint16_t getShndx() const;
 };
 
 class SymbolTableSection : public SectionBase {
 protected:
   std::vector<std::unique_ptr<Symbol>> Symbols;
   StringTableSection *SymbolNames = nullptr;
 
+  typedef std::unique_ptr<Symbol> SymPtr;
+
 public:
   void setStrTab(StringTableSection *StrTab) { SymbolNames = StrTab; }
   void addSymbol(llvm::StringRef Name, uint8_t Bind, uint8_t Type,
                  SectionBase *DefinedIn, uint64_t Value, uint16_t Shndx,
                  uint64_t Sz);
   void addSymbolNames();
   const Symbol *getSymbolByIndex(uint32_t Index) const;
+  void removeSectionReferences(const SectionBase *Sec) override;
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
   static bool classof(const SectionBase *S) {
     return S->Type == llvm::ELF::SHT_SYMTAB;
   }
 };
 
 // Only writeSection depends on the ELF type so we implement it in a subclass.
 template <class ELFT> class SymbolTableSectionImpl : public SymbolTableSection {
   void writeSection(llvm::FileOutputBuffer &Out) const override;
 };
 
 struct Relocation {
   const Symbol *RelocSymbol = nullptr;
   uint64_t Offset;
   uint64_t Addend;
   uint32_t Type;
 };
 
-template <class SymTabType> class RelocationSectionBase : public SectionBase {
+// All relocation sections denote relocations to apply to another section.
+// However, some relocation sections use a dynamic symbol table and others use
+// a regular symbol table. Because the types of the two symbol tables differ in
+// our system (because they should behave differently) we can't uniformly
+// represent all relocations with the same base class if we expose an interface
+// that mentions the symbol table type. So we split the two base types into two
+// different classes, one which handles the section the relocation is applied to
+// and another which handles the symbol table type. The symbol table type is
+// taken as a type parameter to the class (see RelocSectionWithSymtabBase).
+class RelocationSectionBase : public SectionBase {
+protected:
+  SectionBase *SecToApplyRel = nullptr;
+
+public:
+  const SectionBase *getSection() const { return SecToApplyRel; }
+  void setSection(SectionBase *Sec) { SecToApplyRel = Sec; }
+
+  static bool classof(const SectionBase *S) {
+    return S->Type == llvm::ELF::SHT_REL || S->Type == llvm::ELF::SHT_RELA;
+  }
+};
+
+// Takes the symbol table type to use as a parameter so that we can deduplicate
+// that code between the two symbol table types.
+template <class SymTabType>
+class RelocSectionWithSymtabBase : public RelocationSectionBase {
 private:
   SymTabType *Symbols = nullptr;
-  SectionBase *SecToApplyRel = nullptr;
+
+protected:
+  RelocSectionWithSymtabBase() {}
 
 public:
   void setSymTab(SymTabType *StrTab) { Symbols = StrTab; }
-  void setSection(SectionBase *Sec) { SecToApplyRel = Sec; }
+
+  void removeSectionReferences(const SectionBase *Sec) override;
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
 };
 
 template <class ELFT>
-class RelocationSection : public RelocationSectionBase<SymbolTableSection> {
+class RelocationSection
+    : public RelocSectionWithSymtabBase<SymbolTableSection> {
 private:
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
 
   std::vector<Relocation> Relocations;
 
   template <class T> void writeRel(T *Buf) const;
 

 
 class SectionWithStrTab : public Section {
 private:
   StringTableSection *StrTab = nullptr;
 
 public:
   SectionWithStrTab(llvm::ArrayRef<uint8_t> Data) : Section(Data) {}
   void setStrTab(StringTableSection *StringTable) { StrTab = StringTable; }
+  void removeSectionReferences(const SectionBase *Sec) override;
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
   static bool classof(const SectionBase *S);
 };
 
 class DynamicSymbolTableSection : public SectionWithStrTab {
 public:
   DynamicSymbolTableSection(llvm::ArrayRef<uint8_t> Data)
       : SectionWithStrTab(Data) {}
   static bool classof(const SectionBase *S) {
     return S->Type == llvm::ELF::SHT_DYNSYM;
   }
 };
 
 class DynamicSection : public SectionWithStrTab {
 public:
   DynamicSection(llvm::ArrayRef<uint8_t> Data) : SectionWithStrTab(Data) {}
   static bool classof(const SectionBase *S) {
     return S->Type == llvm::ELF::SHT_DYNAMIC;
   }
 };
 
 class DynamicRelocationSection
-    : public RelocationSectionBase<DynamicSymbolTableSection> {
+    : public RelocSectionWithSymtabBase<DynamicSymbolTableSection> {
 private:
   llvm::ArrayRef<uint8_t> Contents;
 
 public:
   DynamicRelocationSection(llvm::ArrayRef<uint8_t> Data) : Contents(Data) {}
   void writeSection(llvm::FileOutputBuffer &Out) const override;
   static bool classof(const SectionBase *S) {
     if (!(S->Flags & llvm::ELF::SHF_ALLOC))
public:
   uint64_t Entry;
   uint64_t SHOffset;
   uint32_t Type;
   uint32_t Machine;
   uint32_t Version;
   uint32_t Flags;
 
   Object(const llvm::object::ELFObjectFile<ELFT> &Obj);
+  void removeSections(std::function<bool(const SectionBase &)> ToRemove);
   virtual size_t totalSize() const = 0;
   virtual void finalize() = 0;
   virtual void write(llvm::FileOutputBuffer &Out) const = 0;
   virtual ~Object() = default;
 };
 
 template <class ELFT> class ELFObject : public Object<ELFT> {
 private:

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

 
 void Segment::writeSegment(FileOutputBuffer &Out) const {
   uint8_t *Buf = Out.getBufferStart() + Offset;
   // We want to maintain segments' interstitial data and contents exactly.
   // This lets us just copy segments directly.
   std::copy(std::begin(Contents), std::end(Contents), Buf);
 }
 
+void SectionBase::removeSectionReferences(const SectionBase *Sec) {}
 void SectionBase::initialize(SectionTableRef SecTable) {}
 void SectionBase::finalize() {}
 
 template <class ELFT>
 void SectionBase::writeHeader(FileOutputBuffer &Out) const {
   uint8_t *Buf = Out.getBufferStart();
   Buf += HeaderOffset;
   typename ELFT::Shdr &Shdr = *reinterpret_cast<typename ELFT::Shdr *>(Buf);
void SymbolTableSection::addSymbol(StringRef Name, uint8_t Bind, uint8_t Type,
   }
   Sym.Value = Value;
   Sym.Size = Sz;
   Sym.Index = Symbols.size();
   Symbols.emplace_back(llvm::make_unique<Symbol>(Sym));
   Size += this->EntrySize;
 }
 
+void SymbolTableSection::removeSectionReferences(const SectionBase *Sec) {
+  if (SymbolNames == Sec) {
+    error("String table " + SymbolNames->Name +
+          " cannot be removed because it is referenced by the symbol table " +
+          this->Name);
+  }
+  auto Iter =
+      std::remove_if(std::begin(Symbols), std::end(Symbols),
+                     [=](const SymPtr &Sym) { return Sym->DefinedIn == Sec; });
+  Size -= (std::end(Symbols) - Iter) * this->EntrySize;
+  Symbols.erase(Iter, std::end(Symbols));
+}
+
 void SymbolTableSection::initialize(SectionTableRef SecTable) {
   Size = 0;
   setStrTab(SecTable.getSectionOfType<StringTableSection>(
       Link,
       "Symbol table has link index of " + Twine(Link) +
           " which is not a valid index",
       "Symbol table has link index of " + Twine(Link) +
           " which is not a string table"));
for (auto &Symbol : Symbols) {
     Sym->setBinding(Symbol->Binding);
     Sym->setType(Symbol->Type);
     Sym->st_shndx = Symbol->getShndx();
     ++Sym;
   }
 }
 
 template <class SymTabType>
-void RelocationSectionBase<SymTabType>::initialize(SectionTableRef SecTable) {
+void RelocSectionWithSymtabBase<SymTabType>::removeSectionReferences(
+    const SectionBase *Sec) {
+  if (Symbols == Sec) {
+    error("Symbol table " + Symbols->Name + " cannot be removed because it is "
+                                            "referenced by the relocation "
+                                            "section " +
+          this->Name);
+  }
+}
+
+template <class SymTabType>
+void RelocSectionWithSymtabBase<SymTabType>::initialize(
+    SectionTableRef SecTable) {
   setSymTab(SecTable.getSectionOfType<SymTabType>(
       Link,
       "Link field value " + Twine(Link) + " in section " + Name + " is invalid",
       "Link field value " + Twine(Link) + " in section " + Name +
           " is not a symbol table"));
 
   if (Info != SHN_UNDEF)
     setSection(SecTable.getSection(Info,
                                    "Info field value " + Twine(Info) +
                                        " in section " + Name + " is invalid"));
   else
     setSection(nullptr);
 }
 
-template <class SymTabType> void RelocationSectionBase<SymTabType>::finalize() {
+template <class SymTabType>
+void RelocSectionWithSymtabBase<SymTabType>::finalize() {
   this->Link = Symbols->Index;
   if (SecToApplyRel != nullptr)
     this->Info = SecToApplyRel->Index;
 }
 
 template <class ELFT>
 void setAddend(Elf_Rel_Impl<ELFT, false> &Rel, uint64_t Addend) {}
 
else
     writeRel(reinterpret_cast<Elf_Rela *>(Buf));
 }
 
 void DynamicRelocationSection::writeSection(llvm::FileOutputBuffer &Out) const {
   std::copy(std::begin(Contents), std::end(Contents),
             Out.getBufferStart() + Offset);
 }
 
+void SectionWithStrTab::removeSectionReferences(const SectionBase *Sec) {
+  if (StrTab == Sec) {
+    error("String table " + StrTab->Name + " cannot be removed because it is "
+                                           "referenced by the section " +
+          this->Name);
+  }
+}
+
 bool SectionWithStrTab::classof(const SectionBase *S) {
   return isa<DynamicSymbolTableSection>(S) || isa<DynamicSection>(S);
 }
 
 void SectionWithStrTab::initialize(SectionTableRef SecTable) {
   setStrTab(SecTable.getSectionOfType<StringTableSection>(
       Link,
       "Link field value " + Twine(Link) + " in section " + Name + " is invalid",

 }
 
 template <class ELFT>
 void Object<ELFT>::writeSectionData(FileOutputBuffer &Out) const {
   for (auto &Section : Sections)
     Section->writeSection(Out);
 }
 
+template <class ELFT>
+void Object<ELFT>::removeSections(
+    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 (auto RelSec = dyn_cast<RelocationSectionBase>(Sec.get()))
+          return !ToRemove(*RelSec->getSection());
+        return true;
+      });
+  if (SymbolTable != nullptr && ToRemove(*SymbolTable))
+    SymbolTable = nullptr;
+  if (ToRemove(*SectionNames)) {
+    // Right now llvm-objcopy always outputs section headers. This will not
+    // always be the case. Eventully the section header table will become
+    // optional and if no section header is output then there dosn't need to be
+    // a section header string table.
+    error("Cannot remove " + SectionNames->Name +
+          " because it is the section header string table.");
+  }
+  // Now make sure there are no remaining references to the sections that will
+  // be removed. Sometimes it is impossible to remove a reference so we emit
+  // an error here instead.
+  for (auto &RemoveSec : make_range(Iter, std::end(Sections))) {
+    for (auto &Segment : Segments)
+      Segment->removeSection(RemoveSec.get());
+    for (auto &KeepSec : make_range(std::begin(Sections), Iter))
+      KeepSec->removeSectionReferences(RemoveSec.get());
+  }
+  // Now finally get rid of them all togethor.
+  Sections.erase(Iter, std::end(Sections));
+}
+
 template <class ELFT> void ELFObject<ELFT>::sortSections() {
   // Put all sections in offset order. Maintain the ordering as closely as
   // possible while meeting that demand however.
   auto CompareSections = [](const SecPtr &A, const SecPtr &B) {
     return A->OriginalOffset < B->OriginalOffset;
   };
   std::stable_sort(std::begin(this->Sections), std::end(this->Sections),
                    CompareSections);

 }
 
 template <class ELFT> void ELFObject<ELFT>::finalize() {
   // Make sure we add the names of all the sections.
   for (const auto &Section : this->Sections) {
     this->SectionNames->addString(Section->Name);
   }
   // Make sure we add the names of all the symbols.
+  if (this->SymbolTable != nullptr)
     this->SymbolTable->addSymbolNames();
 
   sortSections();
   assignOffsets();
 
   // Finalize SectionNames first so that we can assign name indexes.
   this->SectionNames->finalize();
   // Finally now that all offsets and indexes have been set we can finalize any
   // remaining issues.

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

 }
 
 cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input>"));
 cl::opt<std::string> OutputFilename(cl::Positional, cl::desc("<output>"),
                                     cl::init("-"));
 cl::opt<std::string>
     OutputFormat("O", cl::desc("set output format to one of the following:"
                                "\n\tbinary"));
+// TODO: make this a cl::list to support removing multiple sections
+cl::opt<std::string> ToRemove("remove-section",
+                              cl::desc("Remove a specific section"));
+cl::alias ToRemoveA("R", cl::desc("Alias for remove-section"), cl::aliasopt(ToRemove));
 
 void CopyBinary(const ELFObjectFile<ELF64LE> &ObjFile) {
   std::unique_ptr<FileOutputBuffer> Buffer;
   std::unique_ptr<Object<ELF64LE>> Obj;
   if (!OutputFormat.empty() && OutputFormat != "binary")
     error("invalid output format '" + OutputFormat + "'");
-
   if (!OutputFormat.empty() && OutputFormat == "binary")
     Obj = llvm::make_unique<BinaryObject<ELF64LE>>(ObjFile);
   else
     Obj = llvm::make_unique<ELFObject<ELF64LE>>(ObjFile);
+  if (!ToRemove.empty()) {
+    Obj->removeSections(
+        [&](const SectionBase &Sec) { return ToRemove == Sec.Name; });
+  }
   Obj->finalize();
   ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
       FileOutputBuffer::create(OutputFilename, Obj->totalSize(),
                                FileOutputBuffer::F_executable);
   if (BufferOrErr.getError())
     error("failed to open " + OutputFilename);
   else
     Buffer = std::move(*BufferOrErr);