--- /dev/null
+# RUN: yaml2obj %s > %t
+# RUN: llvm-objcopy --strip-unneeded %t %t2
+# RUN: llvm-readobj -symbols %t2 | 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
+ Size: 64
+ - Name: .group
+ Type: SHT_GROUP
+ Link: .symtab
+ AddressAlign: 0x0000000000000004
+ Info: barfoo
+ Members:
+ - SectionOrType: GRP_COMDAT
+ - SectionOrType: .text
+ - Name: .rel.text
+ Type: SHT_REL
+ Link: .symtab
+ Info: .text
+ Relocations:
+ - Offset: 0x1000
+ Symbol: foo
+ Type: R_X86_64_PC32
+Symbols:
+ Local:
+ - Name: foo
+ Type: STT_FUNC
+ Section: .text
+ Value: 0x1000
+ Size: 8
+ - Name: bar
+ Type: STT_FUNC
+ Size: 8
+ Section: .text
+ Value: 0x1008
+ - Name: barfoo
+ Type: STT_FUNC
+ Size: 8
+ Section: .text
+ Value: 0x1010
+ - Name: fileSymbol
+ Type: STT_FILE
+ - Name: sectionSymbol
+ Type: STT_SECTION
+ Weak:
+ - Name: baz
+ Type: STT_FUNC
+ Size: 8
+ Section: .text
+ Value: 0x1018
+ - Name: foobaz
+ Type: STT_FUNC
+ Global:
+ - Name: foobar
+ Type: STT_FUNC
+ - Name: barbaz
+ Type: STT_FUNC
+ Size: 8
+ Section: .text
+ Value: 0x1020
+
+#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: foo
+#CHECK-NEXT: Value: 0x1000
+#CHECK-NEXT: Size: 8
+#CHECK-NEXT: Binding: Local
+#CHECK-NEXT: Type: Function
+#CHECK-NEXT: Other: 0
+#CHECK-NEXT: Section: .text
+#CHECK-NEXT: }
+#CHECK-NEXT: Symbol {
+#CHECK-NEXT: Name: barfoo
+#CHECK-NEXT: Value: 0x1010
+#CHECK-NEXT: Size: 8
+#CHECK-NEXT: Binding: Local
+#CHECK-NEXT: Type: Function
+#CHECK-NEXT: Other: 0
+#CHECK-NEXT: Section: .text
+#CHECK-NEXT: }
+#CHECK-NEXT: Symbol {
+#CHECK-NEXT: Name: fileSymbol
+#CHECK-NEXT: Value: 0x0
+#CHECK-NEXT: Size: 0
+#CHECK-NEXT: Binding: Local
+#CHECK-NEXT: Type: File
+#CHECK-NEXT: Other: 0
+#CHECK-NEXT: Section: Undefined
+#CHECK-NEXT: }
+#CHECK-NEXT: Symbol {
+#CHECK-NEXT: Name: sectionSymbol
+#CHECK-NEXT: Value: 0x0
+#CHECK-NEXT: Size: 0
+#CHECK-NEXT: Binding: Local
+#CHECK-NEXT: Type: Section
+#CHECK-NEXT: Other: 0
+#CHECK-NEXT: Section: Undefined
+#CHECK-NEXT: }
+#CHECK-NEXT: Symbol {
+#CHECK-NEXT: Name: barbaz
+#CHECK-NEXT: Value: 0x1020
+#CHECK-NEXT: Size: 8
+#CHECK-NEXT: Binding: Global
+#CHECK-NEXT: Type: Function
+#CHECK-NEXT: Other: 0
+#CHECK-NEXT: Section: .text
+#CHECK-NEXT: }
+#CHECK-NEXT: Symbol {
+#CHECK-NEXT: Name: baz
+#CHECK-NEXT: Value: 0x1018
+#CHECK-NEXT: Size: 8
+#CHECK-NEXT: Binding: Weak
+#CHECK-NEXT: Type: Function
+#CHECK-NEXT: Other: 0
+#CHECK-NEXT: Section: .text
+#CHECK-NEXT: }
+#CHECK-NEXT:]
Alias<keep_symbol>;
def only_keep_debug : Flag<["-", "--"], "only-keep-debug">,
HelpText<"Currently ignored. Only for compaitability with GNU objcopy.">;
+def strip_unneeded : Flag<["-", "--"], "strip-unneeded">,
+ HelpText<"Remove all symbols not needed by relocations">;
void SectionBase::removeSymbols(function_ref<bool(const Symbol &)> ToRemove) {}
void SectionBase::initialize(SectionTableRef SecTable) {}
void SectionBase::finalize() {}
+void SectionBase::markSymbols() {}
template <class ELFT> void ELFWriter<ELFT>::writeShdr(const SectionBase &Sec) {
uint8_t *Buf = BufPtr->getBufferStart();
return Symbols[Index].get();
}
+Symbol *SymbolTableSection::getSymbolByIndex(uint32_t Index) {
+ return const_cast<Symbol *>(
+ static_cast<const SymbolTableSection *>(this)->getSymbolByIndex(Index));
+}
+
template <class ELFT>
void ELFSectionWriter<ELFT>::visit(const SymbolTableSection &Sec) {
uint8_t *Buf = Out.getBufferStart();
"' because it is named in a relocation");
}
+void RelocationSection::markSymbols() {
+ for (const Relocation &Reloc : Relocations)
+ Reloc.RelocSymbol->Referenced = true;
+}
+
void SectionWriter::visit(const DynamicRelocationSection &Sec) {
std::copy(std::begin(Sec.Contents), std::end(Sec.Contents),
Out.getBufferStart() + Sec.Offset);
}
}
+void GroupSection::markSymbols() {
+ if (Sym)
+ Sym->Referenced = true;
+}
+
void Section::initialize(SectionTableRef SecTable) {
if (Link != ELF::SHN_UNDEF)
LinkSection =
virtual void removeSectionReferences(const SectionBase *Sec);
virtual void removeSymbols(function_ref<bool(const Symbol &)> ToRemove);
virtual void accept(SectionVisitor &Visitor) const = 0;
+ virtual void markSymbols();
};
class Segment {
uint8_t Type;
uint64_t Value;
uint8_t Visibility;
+ bool Referenced = false;
uint16_t getShndx() const;
};
bool empty() const { return Symbols.empty(); }
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);
void removeSectionReferences(const SectionBase *Sec) override;
};
struct Relocation {
- const Symbol *RelocSymbol = nullptr;
+ Symbol *RelocSymbol = nullptr;
uint64_t Offset;
uint64_t Addend;
uint32_t Type;
void addRelocation(Relocation Rel) { Relocations.push_back(Rel); }
void accept(SectionVisitor &Visitor) const override;
void removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
+ void markSymbols() override;
static bool classof(const SectionBase *S) {
if (S->Flags & ELF::SHF_ALLOC)
class GroupSection : public SectionBase {
MAKE_SEC_WRITER_FRIEND
const SymbolTableSection *SymTab = nullptr;
- const Symbol *Sym = nullptr;
+ Symbol *Sym = nullptr;
ELF::Elf32_Word FlagWord;
SmallVector<SectionBase *, 3> GroupMembers;
explicit GroupSection(ArrayRef<uint8_t> Data) : Contents(Data) {}
void setSymTab(const SymbolTableSection *SymTabSec) { SymTab = SymTabSec; }
- void setSymbol(const Symbol *S) { Sym = S; }
+ void setSymbol(Symbol *S) { Sym = S; }
void setFlagWord(ELF::Elf32_Word W) { FlagWord = W; }
void addMember(SectionBase *Sec) { GroupMembers.push_back(Sec); }
void accept(SectionVisitor &) const override;
void finalize() override;
void removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
+ void markSymbols() override;
static bool classof(const SectionBase *S) {
return S->Type == ELF::SHT_GROUP;
bool StripSections = false;
bool StripNonAlloc = false;
bool StripDWO = false;
+ bool StripUnneeded = false;
bool ExtractDWO = false;
bool LocalizeHidden = false;
bool Weaken = false;
Sym.Name = I->getValue();
});
+ // The purpose of this loop is to mark symbols referenced by sections
+ // (like GroupSection or RelocationSection). This way, we know which
+ // symbols are still 'needed' and wich are not.
+ if (Config.StripUnneeded) {
+ for (auto &Section : Obj.sections())
+ Section.markSymbols();
+ }
+
Obj.removeSymbols([&](const Symbol &Sym) {
if (!Config.SymbolsToKeep.empty() &&
is_contained(Config.SymbolsToKeep, Sym.Name))
return true;
}
+ // TODO: We might handle the 'null symbol' in a different way
+ // by probably handling it the same way as we handle 'null section' ?
+ if (Config.StripUnneeded && !Sym.Referenced && Sym.Index != 0 &&
+ (Sym.Binding == STB_LOCAL || Sym.getShndx() == SHN_UNDEF) &&
+ Sym.Type != STT_FILE && Sym.Type != STT_SECTION)
+ return true;
+
return false;
});
}
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.LocalizeHidden = InputArgs.hasArg(OBJCOPY_localize_hidden);
Config.Weaken = InputArgs.hasArg(OBJCOPY_weaken);