[llvm-objcopy] Add switch to allow removing referenced sections

[jhenderson]

Summary

llvm-objcopy currently emits an error if a section to be removed is referenced by another section. This is a reasonable thing to do, but is different to GNU objcopy. We should allow users who know what they are doing to have a way to produce the invalid ELF. This change adds a new switch --allow-broken-links to both llvm-strip and llvm-objcopy to do precisely that. The corresponding Link field is then set to 0 instead of an error being emitted.

I cannot use llvm-readelf/readobj to test the link fields because they emit an error if any sections, like the .dynsym, cannot be properly loaded.

[jhenderson]

A couple of examples where this might be useful:

1. Removing just the dynamic symbols. This would cause an error if there are any dynamic relocation sections. However, not all dynamic relocations require symbols, so potentially NO dynamic relocations need symbols. The .dynsym is then unnecessary.
2. Removing the .dynstr. This would cause an error due to .dynamic referencing it. This section doesn't necessarily have tags that reference strings. Additionally, users might want to strip the information, but still provide some of the ELF file for example to aid debugging an issue.

[grimar]

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

41

Why not just SECTIONS: Link: 0?

tools/llvm-objcopy/ELF/Object.cpp

563

It is a bit hard to follow ifs it seems, I would suggest adding bracers,
like you did for removeSectionReferences or
or may be even doing something like next for better readability:

if (ToRemove(Symbols)) {
  if (!AllowBrokenDependencies)
    return createStringError(
        llvm::errc::invalid_argument,
        "Symbol table %s cannot be removed because it is "
        "referenced by the relocation section %s.",
        Symbols->Name.data(), this->Name.data());

  Symbols = nullptr;
}

[jhenderson]

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

41

If the Link field is not 0 and I do SECTIONS: Link: 0, then it will find a different sh_link output later on with value 0, potentially. I could workaround this by doing CHECK-NEXT a few times on the unimportant fields, but it's not really ideal.

tools/llvm-objcopy/ELF/Object.cpp

563

I like this suggestion, thanks.

[jhenderson]

Re-arrange some if/else statements and improve/add some comments and the option help text.

[grimar]

tools/llvm-objcopy/ELF/Object.cpp

440

Perhaps also be consistent here?

if (ToRemove(SymbolNames)) {
    if (!AllowBrokenDependencies)
      return createStringError(
          llvm::errc::invalid_argument,
          "String table %s cannot be removed because it is "
          "referenced by the symbol table %s",
          SymbolNames->Name.data(), this->Name.data());

    SymbolNames = nullptr;
}

tools/llvm-objcopy/ObjcopyOpts.td

13

Not strong opinion here, but allow-broken-dependencies looks like a bit too long option name.
Will allow-broken-deps/allow-broken-links sound better?

[jhenderson]

tools/llvm-objcopy/ELF/Object.cpp

440

Thanks, I missed this one.

tools/llvm-objcopy/ObjcopyOpts.td

13

I don't like abbreviations in switches, because I don't know what "deps" stands for. However, allow-broken-links is reasonable. I was thinking this switch could also be used for other relationships via sh_info, but I don't know of any yet where this is needed.

[grimar]

Ok, this looks fine I think. Maybe worth to hold this for a while time to check that there
are no objections about the new option name/description (or anything else).

tools/llvm-objcopy/ELF/Object.cpp

440

nit: still not updated :)

[jhenderson]

tools/llvm-objcopy/ELF/Object.cpp

440

I know, I haven't updated the diff yet ;)

[grimar]

tools/llvm-objcopy/ObjcopyOpts.td

13

I also did not find any valid use case.
I.e. looking at the table of how sh_info can be used (https://docs.oracle.com/cd/E19683-01/816-1386/chapter6-94076/index.html),
it does not seem that it is fine to allow broken dependencies there perhaps.

[MaskRay]

tools/llvm-objcopy/ELF/Object.cpp

432

There is a -Wdangling-else warning.

[jhenderson]

Refactor an if block missed in previous change. Rename switch to --allow-broken-links.

[rupprecht]

lgtm, just a couple minor comments

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

9

Isn't this kind of implicit? If there's an error, then llvm-objcopy will return a non-zero status and the test will fail

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

40–41

Maybe just: # SECTIONS: Link{{.*}}: 0?

tools/llvm-objcopy/ELF/Object.cpp

437

We could make these error messages more helpful by saying something like:

String table cannot be removed ... Rerun with -R $name to also remove this section, or --allow-broken-links to suppress this error

tools/llvm-objcopy/ObjcopyOpts.td

12

The examples given seem to apply to strip as well, so can you add the option there too? And at least one test that uses strip to make sure it's hooked up.

[jhenderson]

tools/llvm-objcopy/ELF/Object.cpp

432

Is that with the latest version of this patch? There's no else anywhere around here now, so I assume it can't be.

tools/llvm-objcopy/ObjcopyOpts.td

13

Theoretically it could affect platform/OS-specific sections (which would indicate their special handling with SHF_INFO_LINK), but I don't think llvm-objcopy correctly handles them anyway.

[jhenderson]

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

9

I guess so. It's just a nice contrast to the first test case that's all, but I can remove it if you think it's unnecessary.

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

40–41

Same issue. It could match incorrectly against a later instance rather than the one we care about.

tools/llvm-objcopy/ELF/Object.cpp

437

I don't disagree, but can this be a subsequent patch, as it affects an error message that isn't currently changing?

tools/llvm-objcopy/ObjcopyOpts.td

12

Sounds reasonable.

[rupprecht]

Sorry, I should have just accepted this before -- the option missing from strip is my only objection. The rest are just suggestions.

tools/llvm-objcopy/ELF/Object.cpp

437

Yep, that's fine.

[jhenderson]

Rebase & address review comments:

• Remove unnecessary empty output checks.
• Add strip option and tests.
• Reformat one bit.
• Use distinct check prefixes for the error messages.

[grimar]

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

3

behvior -> behavior

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

4

behvior -> behavior

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

5

behvior -> behavior

6

I am not familiar with llvm-strip.
Looking at its code:

if (!Config.StripDebug && !Config.StripUnneeded &&
    Config.DiscardMode == DiscardType::None && !Config.StripAllGNU && Config.SymbolsToRemove.empty())
  Config.StripAll = true;

Seems that -N fakesymbol would prevent stripping all. Should it work in the same way for -R?

[jakehehrlich]

This seems like a good idea and looks good from an architectural standpoint. Don't wait on me to land it (e.g. I'm not giving an LGTM because I haven't reviewed it properly but I've reviewed it enough to know that this is both a) a good idea and b) nothing bad is being introduced). I'm positive Jordan and George's review have already filled what I haven't done.

[grimar]

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

6

To clarify: I do not really think using of --strip-debug to suppress the default --strip-all behavior is a stopper for landing this,
but I wonder if it worth to add a TODO about removing that in future or it is a normal thing? (it looks a bit hacky though).

i.e. for me as a person who knows nothing about llvm-strip is unclear if it should:

• Have --strip-nothing flag for such situations? At least for use in test cases?
• Do not force strip all if any -R is given. (With that you do would not need any hacks like that here)

[jhenderson]

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

6

I was surprised by this as well, but testing GNU objcopy shows that we match their behaviour in this area. I think a --no-strip-all switch would be good, personally. It's in keeping with existing switches in other tools. I'll look at adding a TODO.

[jhenderson]

Add TODOs. Fix typos.

Thanks all, I'll get this landed now.

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

 # RUN: not llvm-objcopy -R .dynstr %p/Inputs/dynsym.so %t 2>&1 >/dev/null | FileCheck %s
 
 # CHECK: Section .dynstr cannot be removed because it is referenced by the section .dynsym
+
+# RUN: llvm-objcopy --allow-broken-dependencies -R .dynstr %p/Inputs/dynsym.so %t2 2>&1 >/dev/null \
+# RUN:   | FileCheck %s --check-prefix=NO-ERR --allow-empty
+# RUN: llvm-objdump --section-headers %t2 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.dynstr
+
+# NO-ERR-NOT: {{.}}
+# SECTIONS: .dynsym
+# SECTIONS: .dynamic

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

 # RUN: yaml2obj %s > %t
-# RUN: not llvm-objcopy -R .symtab %t %t2 2>&1 >/dev/null | FileCheck %s
+# RUN: not llvm-objcopy -R .symtab %t %t2 2>&1 >/dev/null | FileCheck %s --check-prefix=ERR
 
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
   - Name:            .text
     Type:            SHT_PROGBITS
Relocations:
         Type:   R_X86_64_PC32
 
 Symbols:
   - Name:     foo
     Type:     STT_FUNC
     Size:     4
     Binding:  STB_GLOBAL
 
-# CHECK: Symbol table .symtab cannot be removed because it is referenced by the relocation section .rel.text.
+# ERR: Symbol table .symtab cannot be removed because it is referenced by the relocation section .rel.text.
+
+# RUN: llvm-objcopy --allow-broken-dependencies -R .symtab %t %t3 2>&1 >/dev/null \
+# RUN:   | FileCheck %s --check-prefix=NO-ERR --allow-empty
+# RUN: llvm-readobj --sections %t3 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.symtab
+
+# NO-ERR-NOT: {{.}}
+# SECTIONS:        Name: .rel.text
+# SECTIONS:        Link
+# SECTIONS-SAME: : 0

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

+# RUN: yaml2obj %s -o %t.o
+# RUN: not llvm-objcopy -R .foo %t.o %t1 2>&1 >/dev/null | FileCheck %s --check-prefix=ERR
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .foo
+    Type:            SHT_PROGBITS
+  - Name:            .bar
+    Type:            SHT_PROGBITS
+    Link:            .foo
+
+# ERR: Section .foo cannot be removed because it is referenced by the section .bar
+
+# RUN: llvm-objcopy --allow-broken-dependencies -R .foo %t.o %t2 2>&1 >/dev/null \
+# RUN:   | FileCheck %s --check-prefix=NO-ERR --allow-empty
+# RUN: llvm-readobj --sections %t2 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.foo
+
+# NO-ERR-NOT: {{.}}
+# SECTIONS:      Name: .bar
+# SECTIONS:      Link
+# SECTIONS-SAME: : 0

test/tools/llvm-objcopy/ELF/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
+
+# RUN: llvm-objcopy --allow-broken-dependencies -R .strtab %t %t3 2>&1 >/dev/null \
+# RUN:   | FileCheck %s --check-prefix=NO-ERR --allow-empty
+# RUN: llvm-objdump --section-headers %t3 | FileCheck %s --check-prefix=SECTIONS --implicit-check-not=.strtab
+
+# NO-ERR-NOT: {{.}}
+# SECTIONS: .symtab

tools/llvm-objcopy/COFF/COFFObjcopy.cpp

Obj.removeSymbols([&](const Symbol &Sym) {
     }
 
     return false;
   });
 
   if (!Config.AddGnuDebugLink.empty())
     addGnuDebugLink(Obj, Config.AddGnuDebugLink);
 
-  if (!Config.BuildIdLinkDir.empty() || Config.BuildIdLinkInput ||
-      Config.BuildIdLinkOutput || !Config.SplitDWO.empty() ||
-      !Config.SymbolsPrefix.empty() || !Config.AddSection.empty() ||
-      !Config.DumpSection.empty() || !Config.KeepSection.empty() ||
-      !Config.SymbolsToGlobalize.empty() || !Config.SymbolsToKeep.empty() ||
-      !Config.SymbolsToLocalize.empty() || !Config.SymbolsToWeaken.empty() ||
-      !Config.SymbolsToKeepGlobal.empty() || !Config.SectionsToRename.empty() ||
-      !Config.SetSectionFlags.empty() || !Config.SymbolsToRename.empty() ||
-      Config.ExtractDWO || Config.KeepFileSymbols || Config.LocalizeHidden ||
-      Config.PreserveDates || Config.StripDWO || Config.StripNonAlloc ||
-      Config.StripSections || Config.Weaken || Config.DecompressDebugSections ||
+  if (Config.AllowBrokenDependencies || !Config.BuildIdLinkDir.empty() ||
+      Config.BuildIdLinkInput || Config.BuildIdLinkOutput ||
+      !Config.SplitDWO.empty() || !Config.SymbolsPrefix.empty() ||
+      !Config.AddSection.empty() || !Config.DumpSection.empty() ||
+      !Config.KeepSection.empty() || !Config.SymbolsToGlobalize.empty() ||
+      !Config.SymbolsToKeep.empty() || !Config.SymbolsToLocalize.empty() ||
+      !Config.SymbolsToWeaken.empty() || !Config.SymbolsToKeepGlobal.empty() ||
+      !Config.SectionsToRename.empty() || !Config.SetSectionFlags.empty() ||
+      !Config.SymbolsToRename.empty() || Config.ExtractDWO ||
+      Config.KeepFileSymbols || Config.LocalizeHidden || Config.PreserveDates ||
+      Config.StripDWO || Config.StripNonAlloc || Config.StripSections ||
+      Config.Weaken || Config.DecompressDebugSections ||
       Config.DiscardMode == DiscardType::Locals ||
       !Config.SymbolsToAdd.empty() || Config.EntryExpr) {
     return createStringError(llvm::errc::invalid_argument,
                              "Option not supported by llvm-objcopy for COFF");
   }
 
   return Error::success();
 }

tools/llvm-objcopy/CopyConfig.h

struct CopyConfig {
 
   // ELF entry point address expression. The input parameter is an entry point
   // address in the input ELF file. The entry address in the output file is
   // calculated with EntryExpr(input_address), when either --set-start or
   // --change-start is used.
   std::function<uint64_t(uint64_t)> EntryExpr;
 
   // Boolean options
+  bool AllowBrokenDependencies = false;
   bool DeterministicArchives = true;
   bool ExtractDWO = false;
   bool KeepFileSymbols = false;
   bool LocalizeHidden = false;
   bool OnlyKeepDebug = false;
   bool PreserveDates = false;
   bool StripAll = false;
   bool StripAllGNU = false;

tools/llvm-objcopy/CopyConfig.cpp

if (Error E = addSymbolsFromFile(Config.SymbolsToKeep, DC.Alloc,
       return std::move(E);
   for (auto Arg : InputArgs.filtered(OBJCOPY_add_symbol)) {
     Expected<NewSymbolInfo> NSI = parseNewSymbolInfo(Arg->getValue());
     if (!NSI)
       return NSI.takeError();
     Config.SymbolsToAdd.push_back(*NSI);
   }
 
+  Config.AllowBrokenDependencies =
+      InputArgs.hasArg(OBJCOPY_allow_broken_dependencies);
+
   Config.DeterministicArchives = InputArgs.hasFlag(
       OBJCOPY_enable_deterministic_archives,
       OBJCOPY_disable_deterministic_archives, /*default=*/true);
 
   Config.PreserveDates = InputArgs.hasArg(OBJCOPY_preserve_dates);
 
   for (auto Arg : InputArgs)
     if (Arg->getOption().matches(OBJCOPY_set_start)) {

tools/llvm-objcopy/ELF/ELFObjcopy.cpp

 }
 
 static Error splitDWOToFile(const CopyConfig &Config, const Reader &Reader,
                             StringRef File, ElfType OutputElfType) {
   auto DWOFile = Reader.create();
   auto OnlyKeepDWOPred = [&DWOFile](const SectionBase &Sec) {
     return onlyKeepDWOPred(*DWOFile, Sec);
   };
-  if (Error E = DWOFile->removeSections(OnlyKeepDWOPred))
+  if (Error E = DWOFile->removeSections(Config.AllowBrokenDependencies,
+                                        OnlyKeepDWOPred))
     return E;
   if (Config.OutputArch) {
     DWOFile->Machine = Config.OutputArch.getValue().EMachine;
     DWOFile->OSABI = Config.OutputArch.getValue().OSABI;
   }
   FileBuffer FB(File);
   auto Writer = createWriter(Config, *DWOFile, FB, OutputElfType);
   if (Error E = Writer->finalize())
else if (Config.DecompressDebugSections)
     replaceDebugSections(
         Obj, RemovePred,
         [](const SectionBase &S) { return isa<CompressedSection>(&S); },
         [&Obj](const SectionBase *S) {
           auto CS = cast<CompressedSection>(S);
           return &Obj.addSection<DecompressedSection>(*CS);
         });
 
-  return Obj.removeSections(RemovePred);
+  return Obj.removeSections(Config.AllowBrokenDependencies, RemovePred);
 }
 
 // This function handles the high level operations of GNU objcopy including
 // handling command line options. It's important to outline certain properties
 // we expect to hold of the command line operations. Any operation that "keeps"
 // should keep regardless of a remove. Additionally any removal should respect
 // any previous removals. Lastly whether or not something is removed shouldn't
 // depend a) on the order the options occur in or b) on some opaque priority

tools/llvm-objcopy/ELF/Object.h

public:
   SectionBase(const SectionBase &) = default;
 
   virtual ~SectionBase() = default;
 
   virtual void initialize(SectionTableRef SecTable);
   virtual void finalize();
   // Remove references to these sections. The list of sections must be sorted.
   virtual Error
-  removeSectionReferences(function_ref<bool(const SectionBase *)> ToRemove);
+  removeSectionReferences(bool AllowBrokenDependencies,
+                          function_ref<bool(const SectionBase *)> ToRemove);
   virtual Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove);
   virtual void accept(SectionVisitor &Visitor) const = 0;
   virtual void accept(MutableSectionVisitor &Visitor) = 0;
   virtual void markSymbols();
   virtual void
   replaceSectionReferences(const DenseMap<SectionBase *, SectionBase *> &);
 };
 
class Section : public SectionBase {
   ArrayRef<uint8_t> Contents;
   SectionBase *LinkSection = nullptr;
 
 public:
   explicit Section(ArrayRef<uint8_t> Data) : Contents(Data) {}
 
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
-  Error removeSectionReferences(
+  Error removeSectionReferences(bool AllowBrokenDependencies,
       function_ref<bool(const SectionBase *)> ToRemove) override;
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
 };
 
 class OwnedDataSection : public SectionBase {
   MAKE_SEC_WRITER_FRIEND
 
void setShndxTable(SectionIndexSection *ShndxTable) {
     SectionIndexTable = ShndxTable;
   }
   const SectionIndexSection *getShndxTable() const { return SectionIndexTable; }
   const SectionBase *getStrTab() const { return SymbolNames; }
   const Symbol *getSymbolByIndex(uint32_t Index) const;
   Symbol *getSymbolByIndex(uint32_t Index);
   void updateSymbols(function_ref<void(Symbol &)> Callable);
 
-  Error removeSectionReferences(
+  Error removeSectionReferences(bool AllowBrokenDependencies,
       function_ref<bool(const SectionBase *)> ToRemove) override;
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
   Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
   void replaceSectionReferences(
       const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
class RelocationSection
   MAKE_SEC_WRITER_FRIEND
 
   std::vector<Relocation> Relocations;
 
 public:
   void addRelocation(Relocation Rel) { Relocations.push_back(Rel); }
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
-  Error removeSectionReferences(
+  Error removeSectionReferences(bool AllowBrokenDependencies,
       function_ref<bool(const SectionBase *)> ToRemove) override;
   Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
   void markSymbols() override;
   void replaceSectionReferences(
       const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
 
   static bool classof(const SectionBase *S) {
     if (S->Flags & ELF::SHF_ALLOC)
auto SecIt =
         find_if(Sections, [&](const SecPtr &Sec) { return Sec->Name == Name; });
     return SecIt == Sections.end() ? nullptr : SecIt->get();
   }
   SectionTableRef removedSections() { return SectionTableRef(RemovedSections); }
 
   Range<Segment> segments() { return make_pointee_range(Segments); }
   ConstRange<Segment> segments() const { return make_pointee_range(Segments); }
 
-  Error removeSections(std::function<bool(const SectionBase &)> ToRemove);
+  Error removeSections(bool AllowBrokenDependencies,
+                       std::function<bool(const SectionBase &)> ToRemove);
   Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove);
   template <class T, class... Ts> T &addSection(Ts &&... Args) {
     auto Sec = llvm::make_unique<T>(std::forward<Ts>(Args)...);
     auto Ptr = Sec.get();
     Sections.emplace_back(std::move(Sec));
     Ptr->Index = Sections.size();
     return *Ptr;
   }

tools/llvm-objcopy/ELF/Object.cpp

template <class ELFT> void ELFWriter<ELFT>::writePhdr(const Segment &Seg) {
   Phdr.p_vaddr = Seg.VAddr;
   Phdr.p_paddr = Seg.PAddr;
   Phdr.p_filesz = Seg.FileSize;
   Phdr.p_memsz = Seg.MemSize;
   Phdr.p_align = Seg.Align;
 }
 
 Error SectionBase::removeSectionReferences(
+    bool AllowBrokenDependencies,
     function_ref<bool(const SectionBase *)> ToRemove) {
   return Error::success();
 }
 
 Error SectionBase::removeSymbols(function_ref<bool(const Symbol &)> ToRemove) {
   return Error::success();
 }
 
void SymbolTableSection::addSymbol(Twine Name, uint8_t Bind, uint8_t Type,
   Sym.Visibility = Visibility;
   Sym.Size = Size;
   Sym.Index = Symbols.size();
   Symbols.emplace_back(llvm::make_unique<Symbol>(Sym));
   Size += this->EntrySize;
 }
 
 Error SymbolTableSection::removeSectionReferences(
+    bool AllowBrokenDependencies,
     function_ref<bool(const SectionBase *)> ToRemove) {
   if (ToRemove(SectionIndexTable))
     SectionIndexTable = nullptr;
   if (ToRemove(SymbolNames))
-    return createStringError(llvm::errc::invalid_argument,
-                             "String table %s cannot be removed because it is "
-                             "referenced by the symbol table %s",
-                             SymbolNames->Name.data(), this->Name.data());
+    if (AllowBrokenDependencies)
+      SymbolNames = nullptr;
+    else
+      return createStringError(
+          llvm::errc::invalid_argument,
   return removeSymbols(
       [ToRemove](const Symbol &Sym) { return ToRemove(Sym.DefinedIn); });
 }
 
 void SymbolTableSection::updateSymbols(function_ref<void(Symbol &)> Callable) {
   std::for_each(std::begin(Symbols) + 1, std::end(Symbols),
                 [Callable](SymPtr &Sym) { Callable(*Sym); });
   std::stable_partition(
setStrTab(SecTable.getSectionOfType<StringTableSection>(
           " which is not a valid index",
       "Symbol table has link index of " + Twine(Link) +
           " which is not a string table"));
 }
 
 void SymbolTableSection::finalize() {
   uint32_t MaxLocalIndex = 0;
   for (auto &Sym : Symbols) {
-    Sym->NameIndex = SymbolNames->findIndex(Sym->Name);
+    Sym->NameIndex =
+        SymbolNames == nullptr ? 0 : SymbolNames->findIndex(Sym->Name);
     if (Sym->Binding == STB_LOCAL)
       MaxLocalIndex = std::max(MaxLocalIndex, Sym->Index);
   }
   // Now we need to set the Link and Info fields.
-  Link = SymbolNames->Index;
+  Link = SymbolNames == nullptr ? 0 : SymbolNames->Index;
   Info = MaxLocalIndex + 1;
 }
 
 void SymbolTableSection::prepareForLayout() {
   // Add all potential section indexes before file layout so that the section
   // index section has the approprite size.
   if (SectionIndexTable != nullptr) {
     for (const auto &Sym : Symbols) {
       if (Sym->DefinedIn != nullptr && Sym->DefinedIn->Index >= SHN_LORESERVE)
         SectionIndexTable->addIndex(Sym->DefinedIn->Index);
       else
         SectionIndexTable->addIndex(SHN_UNDEF);
     }
   }
+
   // Add all of our strings to SymbolNames so that SymbolNames has the right
   // size before layout is decided.
+  // If the symbol names section has been removed, don't try to add strings to
+  // the table.
+  if (SymbolNames != nullptr)
     for (auto &Sym : Symbols)
       SymbolNames->addString(Sym->Name);
 }
 
 const Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index) const {
   if (Symbols.size() <= Index)
     error("Invalid symbol index: " + Twine(Index));
   return Symbols[Index].get();
 }
 
void SymbolTableSection::accept(SectionVisitor &Visitor) const {
   Visitor.visit(*this);
 }
 
 void SymbolTableSection::accept(MutableSectionVisitor &Visitor) {
   Visitor.visit(*this);
 }
 
 Error RelocationSection::removeSectionReferences(
+    bool AllowBrokenDependencies,
     function_ref<bool(const SectionBase *)> ToRemove) {
-  if (ToRemove(Symbols))
-    return createStringError(llvm::errc::invalid_argument,
-                             "Symbol table %s cannot be removed because it is "
-                             "referenced by the relocation section %s.",
-                             Symbols->Name.data(), this->Name.data());
+  if (ToRemove(Symbols)) {
+    if (!AllowBrokenDependencies)
+      return createStringError(
+          llvm::errc::invalid_argument,
+    Symbols = nullptr;
+  }
 
   for (const Relocation &R : Relocations) {
     if (!R.RelocSymbol->DefinedIn || !ToRemove(R.RelocSymbol->DefinedIn))
       continue;
     return createStringError(llvm::errc::invalid_argument,
                              "Section %s can't be removed: (%s+0x%" PRIx64
                              ") has relocation against symbol '%s'",
                              R.RelocSymbol->DefinedIn->Name.data(),

 void DynamicRelocationSection::accept(SectionVisitor &Visitor) const {
   Visitor.visit(*this);
 }
 
 void DynamicRelocationSection::accept(MutableSectionVisitor &Visitor) {
   Visitor.visit(*this);
 }
 
-Error Section::removeSectionReferences(
+Error Section::removeSectionReferences(bool AllowBrokenDependency,
     function_ref<bool(const SectionBase *)> ToRemove) {
-  if (ToRemove(LinkSection))
+  if (ToRemove(LinkSection)) {
+    if (!AllowBrokenDependency)
       return createStringError(llvm::errc::invalid_argument,
                                "Section %s cannot be removed because it is "
                                "referenced by the section %s",
                                LinkSection->Name.data(), this->Name.data());
+    LinkSection = nullptr;
+  }
   return Error::success();
 }
 
 void GroupSection::finalize() {
   this->Info = Sym->Index;
   this->Link = SymTab->Index;
 }
 
for (auto &Sec : Obj.removedSections()) {
     std::memset(B + Offset, 0, Sec.Size);
   }
 }
 
 template <class ELFT>
 ELFWriter<ELFT>::ELFWriter(Object &Obj, Buffer &Buf, bool WSH)
     : Writer(Obj, Buf), WriteSectionHeaders(WSH && Obj.HadShdrs) {}
 
-Error Object::removeSections(
+Error Object::removeSections(bool AllowBrokenDependencies,
     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())) {
           if (auto ToRelSec = RelSec->getSection())
Error Object::removeSections(bool AllowBrokenDependencies,
   }
 
   // For each section that remains alive, we want to remove the dead references.
   // This either might update the content of the section (e.g. remove symbols
   // from symbol table that belongs to removed section) or trigger an error if
   // a live section critically depends on a section being removed somehow
   // (e.g. the removed section is referenced by a relocation).
   for (auto &KeepSec : make_range(std::begin(Sections), Iter)) {
-    if (Error E = KeepSec->removeSectionReferences(
+    if (Error E = KeepSec->removeSectionReferences(AllowBrokenDependencies,
             [&RemoveSections](const SectionBase *Sec) {
               return RemoveSections.find(Sec) != RemoveSections.end();
             }))
       return E;
   }
 
   // Transfer removed sections into the Object RemovedSections container for use
   // later.
if (Obj.SymbolTable != nullptr && Obj.SectionIndexTable == nullptr) {
       auto &Shndx = Obj.addSection<SectionIndexSection>();
       Obj.SymbolTable->setShndxTable(&Shndx);
       Shndx.setSymTab(Obj.SymbolTable);
     }
   } else {
     // Since we don't need SectionIndexTable we should remove it and all
     // references to it.
     if (Obj.SectionIndexTable != nullptr) {
-      if (Error E = Obj.removeSections([this](const SectionBase &Sec) {
+      // We do not support sections referring to the section index table.
+      if (Error E = Obj.removeSections(false /*AllowBrokenDependencies*/,
+                                       [this](const SectionBase &Sec) {
                                          return &Sec == Obj.SectionIndexTable;
                                        }))
         return E;
     }
   }
 
   // Make sure we add the names of all the sections. Importantly this must be
   // done after we decide to add or remove SectionIndexes.
   if (Obj.SectionNames != nullptr)
     for (const auto &Section : Obj.sections()) {

tools/llvm-objcopy/ObjcopyOpts.td

 include "llvm/Option/OptParser.td"
 
 multiclass Eq<string name, string help> {
   def NAME : Separate<["--", "-"], name>;
   def NAME #_eq : Joined<["--", "-"], name #"=">,
                   Alias<!cast<Separate>(NAME)>,
                   HelpText<help>;
 }
 
 def help : Flag<["-", "--"], "help">;
 
+def allow_broken_dependencies
+    : Flag<["-", "--"], "allow-broken-dependencies">,
+      HelpText<"Allow llvm-objcopy to remove sections even if it would leave "
+               "invalid section references. The appropriate sh_link fields"
+               "will be set to zero.">;
+
 defm binary_architecture
     : Eq<"binary-architecture", "Used when transforming an architecture-less "
                                 "format (such as binary) to another format">;
 def B : JoinedOrSeparate<["-"], "B">, Alias<binary_architecture>;
 
 defm target : Eq<"target", "Format of the input and output file">,
               Values<"binary">;
 def F : JoinedOrSeparate<["-"], "F">, Alias<target>;