[llvm-objcopy] --add-symbol: fix crash if SHT_SYMTAB does not exist

[MaskRay]

Summary

Exposed by D69041. If SHT_SYMTAB does not exist, ELFObjcopy.cpp:handleArgs will crash due
to a null pointer dereference.

for (const NewSymbolInfo &SI : Config.ELF->SymbolsToAdd) {
  ...
  Obj.SymbolTable->addSymbol(

Fix this by creating .symtab and .strtab on demand in ELFBuilder<ELFT>::readSections,
if --add-symbol is specified.

[grimar]

test/tools/llvm-objcopy/ELF/add-symbol-no-symtab.test

5 ↗

(On Diff #225379)

Will we want to remove this call when yaml2obj patch that supports omiting ".strtab" be landed?
If so - worth adding a TODOs, probably, I am not sure it is critical though.

30 ↗

(On Diff #225379)

I'd say - "Check we create ... "

36 ↗

(On Diff #225379)

".shstrtab" != ".strtab"

tools/llvm-objcopy/ELF/Object.cpp

1554 ↗

(On Diff #225379)

Perhaps if (!StrTab)? Note that code above doesn't do if (Obj.SymbolTable != null for example.

1557 ↗

(On Diff #225379)

Avoid auto?

[grimar]

test/tools/llvm-objcopy/ELF/add-symbol-no-symtab.test

5 ↗

(On Diff #225379)

I meant ".symtab".

[MaskRay]

test/tools/llvm-objcopy/ELF/add-symbol-no-symtab.test

5 ↗

(On Diff #225379)

I have added an explicit Symbols: to ensure .symtab exists, even after D69041.

This should make the TODO unnecessary?

For similar reasons, I use an explicit llvm-objcopy --remove-section=.symtab --remove-section=.strtab instead of llvm-strip to make it clear both sections are stripped below.

36 ↗

(On Diff #225379)

Yes, we overload .shstrtab (section names only) for more purposes (section names+symbol names). I think this is fine, but it definitely deserves a comment.

(Similarly, clang reuse .strtab for both section names and symbol names.)

GNU objcopy does not allow such object files (I haven't looked into details what sections (.strtab or .symtab) it expects).

% objcopy --add-symbol=abs1=1 t t2
objcopy: error: the input file 'a' has no sections

[grimar]

test/tools/llvm-objcopy/ELF/add-symbol-no-symtab.test

5 ↗

(On Diff #225379)

I have added an explicit Symbols: to ensure .symtab exists, even after D69041.

Yeah, that was my question. Do you plan to remove "Symbols:" and this call later or not.
I think it is not a problem to keep it, it makes things self-documented. So its OK as is.

[MaskRay]

Address review comments

[MaskRay]

tools/llvm-objcopy/ELF/Object.cpp

1557 ↗

(On Diff #225379)

In all existing call sites auto are used.. Anyway, SymbolTableSection is clearer (it is not obvious addSection<T> returns T&) so I will avoid auto.

[MaskRay]

test/tools/llvm-objcopy/ELF/add-symbol-no-symtab.test

36 ↗

(On Diff #225379)

To expand a bit more on this topic.

For better test coverage, we should have a test that places .shstrtab before .strtab so that we can check the created .symtab picks .strtab as its sh_link field. But I don't know any way to reorder sections.

Since rL238073, clang no longer produces .shstrtab and uses a unified .strtab for both section names and symbol names. I cannot write something like

if (Sec.Type == ELF::SHT_STRTAB && Obj.SectionNames != &Sec)

because such use cases will fail. Again, I cannot test it with existing yaml2obj functionality (I am not sure it is useful enough to make it possible to test such scenarios... probably not worth it)

[MaskRay]

if (Sec.Type == ELF::SHT_STRTAB) {

>

if (Sec.Type == ELF::SHT_STRTAB && !(Sec.Flags & SHF_ALLOC)) {

And add a test.

[grimar]

LGTM with a 2 suggestions.

test/tools/llvm-objcopy/ELF/add-symbol-no-symtab.test

30 ↗

(On Diff #225383)

So this should probably say "create both symbol table and string table".
I.e. use "string table" instead of ".strtab", because it is a bit confusing that
there is no any ".strtab" in the output.

36 ↗

(On Diff #225379)

I see, thanks for the explanation.

tools/llvm-objcopy/ELF/Object.cpp

1546 ↗

(On Diff #225383)

nit: I think you need to add curly bracers to wrap the 'for' body.

Perhaps something like the following?

for (auto &Sec : Obj.sections()) {
  if (Sec.Type == ELF::SHT_STRTAB)
    continue:
  StrTab = static_cast<StringTableSection *>(&Sec);
  // Prefer .strtab to .shstrtab.
  if (Obj.SectionNames != &Sec)
    break;
}

[MaskRay]

Address comments

[rupprecht]

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

1547

Why do we need to check SHF_ALLOC?

1550–1552

Should .dynstr also be avoided? Is it better to just check that the name is literally .strtab?

[MaskRay]

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

1547

.dynstr (SHT_STRTAB) has the SHF_ALLOC flag. We can't reuse .dynstr for .symtab (non-SHF_ALLOC).

The case is tested by # SEC3: in add-symbol-no-symtab.test

1550–1552

.dynstr is avoided by !(Sec.Flags & SHF_ALLOC). .strtab works as well but Obj.SectionNames != &Sec is more general. There are multiple ways to accomplish the samething. I just wanted to make the code less magical.

tools/llvm-objcopy/ELF/Object.cpp

1546 ↗

(On Diff #225383)

Added the brace, but I will not the early-return pattern here. The body is short and I think it might be clearer as is.

[rupprecht]

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

1550–1552

From: http://www.sco.com/developers/gabi/latest/ch4.sheader.html#special_sections

.strtab
This section holds strings, most commonly the strings that represent the names associated with symbol table entries. If the file has a loadable segment that includes the symbol string table, the section's attributes will include the SHF_ALLOC bit; otherwise, that bit will be off.

So, .strtab can also be SHF_ALLOC.

[abrachet]

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

1550–1552

For reference, we used to have a file in test/tools/llvm-objcopy/ELF/Inputs/ called alloc-symtab which had an SHF_ALLOC .strtab. It was removed in D65278.

[MaskRay]

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

1550–1552

To confirm, I think ... && !(Sec.Flags & SHF_ALLOC) is correct here.

[grimar]

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

1550–1552

For reference, we used to have a file in test/tools/llvm-objcopy/ELF/Inputs/ called alloc-symtab which had an SHF_ALLOC .strtab. It was removed in D65278.

Thanks for the reference. I completely forgot that saw an allocatable .symtab that time.

To clarify: in D65278 I've replaced a precompiled binary with a YAML description (with a SHF_ALLOC .symtab).
The logic of tests shouldn't have been affected, because tests wanted to see the SHF_ALLOC symbol table (but not SHF_ALLOC string table)
I believe.

If we need a test with a SHF_ALLOC .strtab, it should be possible to craft one with a yaml2obj too I think.
(I haven't check, but I think all that needed is to define a string table section and a Flag property which should override the default).

1550–1552

So, .strtab can also be SHF_ALLOC.

To confirm, I think ... && !(Sec.Flags & SHF_ALLOC) is correct here.

To summarize and clarify this a bit:
This part of code is called when there is no symbol table (.symtab).
Jordan mentioned that .strtab can be allocatable in according to specification.

So if I understand correctly, the question is: is it possible that
we have no symbol table, but have an allocatable .strtab in the object?

If it is, this code might either use the .shstrtab instead of existent .strtab,
or perform an attemp to create a new string table (if there is no .shstrtab to reuse) it seems.
Then it will create a .symtab using the string table either found or created instead of the existent allocatable '.strtab'.
Does not sound correct perhaps?

[MaskRay]

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

1550–1552

Both SHF_ALLOC .strtab and non-SHF_ALLOC .strtab are possible, though I don't think ld or objcopy could create SHF_ALLOC .strtab.

Generally objcopy should not alter SHF_ALLOC sections. The code skips both .dynstr (SHF_ALLOC) and SHF_ALLOC .strtab. SHF_ALLOC .strtab is not tested, though.

[rupprecht]

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

1550–1552

Yes, exactly. Repro:

$ cat strtab.yaml
--- !ELF
FileHeader:
  Class:   ELFCLASS64
  Data:    ELFDATA2LSB
  Type:    ET_REL
  Machine: EM_X86_64
Sections:
  - Name: .strtab
    Type: SHT_STRTAB
    Flags: [ SHF_ALLOC ]
$ yaml2obj strtab.yaml > strtab.o
$ llvm-objcopy --add-symbol=abs1=1 strtab.o strtab2.o
$ llvm-readobj --sections strtab2.o
...
  Section {
    Index: 1
    Name: .strtab (11)
    Type: SHT_STRTAB (0x3)
    Flags [ (0x2)
      SHF_ALLOC (0x2)
    ]
  }
  Section {
    Index: 2
    Name: .shstrtab (1)
    Type: SHT_STRTAB (0x3)
    Flags [ (0x0)
    ]
  }
  Section {
    Index: 3
    Name: .symtab (19)
    Type: SHT_SYMTAB (0x2)
    Flags [ (0x0)
    ]
    Link: 2  # <-- .shstrtab, not .strtab
  }
...

Running the same example through a recent GNU objcopy, it looks like it creates a second .strtab without the SHF_ALLOC bit and links to that:

$ llvm-objcopy --add-symbol=abs1=1 strtab.o strtab2.o
$ llvm-readobj --sections strtab2.o
  Section {
    Index: 1
    Name: .strtab (9)
    Type: SHT_STRTAB (0x3)
    Flags [ (0x2)
      SHF_ALLOC (0x2)
    ]
  }
  Section {
    Index: 2
    Name: .symtab (1)
    Type: SHT_SYMTAB (0x2)
    Flags [ (0x0)
    ]
    Link: 3 # <-- non-SHF_ALLOC .strtab below, not the SHF_ALLOC .strtab above
  }
  Section {
    Index: 3
    Name: .strtab (9)
    Type: SHT_STRTAB (0x3)
    Flags [ (0x0)
    ]
  }
  Section {
    Index: 4
    Name: .shstrtab (17)
    Type: SHT_STRTAB (0x3)
    Flags [ (0x0)
    ]
  }

This behavior seems reasonable to me vs re-using the .shstrtab for strings that aren't section headers.

To confirm, I think ... && !(Sec.Flags & SHF_ALLOC) is correct here.

BTW, I don't find it particularly constructive to simply state a position without any rationale.

[rupprecht]

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

1550–1552

Running the same example through a recent GNU objcopy, it looks like it creates a second .strtab without the SHF_ALLOC bit and links to that:

$ llvm-objcopy --add-symbol=abs1=1 strtab.o strtab2.o
$ llvm-readobj --sections strtab2.o

This second example is actually what happens w/ GNU objcopy, not llvm-objcopy.

[rupprecht]

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

1593–1599

Obj.SectionNames seems to be first initialized here, so the check above doesn't work.

[MaskRay]

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

1550–1552

Reusing .shstrtab is what SEC3 tests. It may look a bit strange. e_shstrndx may refer to .strtab (clang reuses the section for both section names and symbol names). If we want to behave like GNU objcopy, we will have to special case the string .strtab. In any case, I don't think the (1) .symtab does not exist (2) --add-symbol= causes .symtab to be created edge case needs more treatment for GNU compatibility.

[grimar]

test/tools/llvm-objcopy/ELF/add-symbol-no-symtab.test

36 ↗

(On Diff #225379)

For better test coverage, we should have a test that places .shstrtab before .strtab so that we can check the created .symtab picks .strtab as its sh_link field. But I don't know any way to reorder sections.

btw, I've realized that actually you can make a test for this with yaml2obj:

--- !ELF
FileHeader:
  Class:   ELFCLASS64
  Data:    ELFDATA2LSB
  Type:    ET_REL
  Machine: EM_X86_64
Sections:
  - Name: .shstrtab
    Type: SHT_STRTAB
  - Name: .strtab
    Type: SHT_STRTAB
Symbols:
  - Name: a1
    Binding: STB_GLOBAL

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .shstrtab         STRTAB           0000000000000000  00000040
       000000000000001b  0000000000000000           0     0     0
  [ 2] .strtab           STRTAB           0000000000000000  0000005b
       0000000000000004  0000000000000000           0     0     0
  [ 3] .symtab           SYMTAB           0000000000000000  00000060
       0000000000000030  0000000000000018           2     1     8

[jhenderson]

llvm/test/tools/llvm-objcopy/ELF/add-symbol-no-symtab.test

28

You don't necessarily need to update your test here, but in future, could you avoid reusing %t, %t1 etc for different cases if they get modified (e.g. %t is fine to use in this line, but the output should be %t3 or whatever to avoid clashing with the previous case). It makes debugging somewhat easier if there are problems with the test.

32

This comment seems stale? We are reusing .shstrtab, and nothing shows we create .strtab here. Should the test also show that .strtab has NOT been created?

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

1544

the existing -> an existing (since there can be multiple)
if exists -> if it exists

1550–1552

In an ideal world, the names of ELF sections should be largely irrelevant. I think rather than explicitly prefer ".strtab" over ".shstrtab", it's more correct to say we prefer a string table that is not the section header string table, if such a table exists.

I'm quite alright with a new string table to be created if needed for symbol names, if the existing one is SHF_ALLOC. I don't have a preference for the name (.strtab seems fine, even if it already exists). Is there anything stopping the section header string table having the SHF_ALLOC bit set however? If not, we need a separate test for this case, I believe.

llvm/test/tools/llvm-objcopy/ELF/add-symbol-no-symtab.test

+## Test --add-symbol creates .symtab if it does not exist.
+
+# RUN: yaml2obj --docnum=1 %s -o %t
+
+## If a non-SHF_ALLOC SHT_STRTAB exists but SHT_SYMTAB does not, create .symtab
+## and set its sh_link to the SHT_STRTAB.
+# RUN: llvm-objcopy --remove-section=.symtab %t %t1
+# RUN: llvm-objcopy --add-symbol='abs1=1' %t1 %t2
+# RUN: llvm-readobj -S %t2 | FileCheck --check-prefix=SEC %s
+# RUN: llvm-readelf -s %t2 | FileCheck %s
+
+# SEC:      Index: 1
+# SEC-NEXT: Name: .strtab
+# SEC-NEXT: Type: SHT_STRTAB
+# SEC:      Index: 2
+# SEC-NEXT: Name: .shstrtab
+# SEC-NEXT: Type: SHT_STRTAB
+# SEC:      Index: 3
+# SEC-NEXT: Name: .symtab
+# SEC-NEXT: Type: SHT_SYMTAB
+# SEC-NOT:  }
+# SEC:      Link: 1
+
+# CHECK:      0: 0000000000000000 0 NOTYPE LOCAL  DEFAULT UND
+# CHECK-NEXT: 1: 0000000000000001 0 NOTYPE GLOBAL DEFAULT ABS abs1
+
+## Don't create .symtab if --add-symbol is not specified.
+# RUN: llvm-objcopy --remove-section=.symtab --remove-section=.strtab %t %t1
+# RUN: llvm-objcopy %t1 %t2
+# RUN: llvm-readobj -S %t2 | FileCheck --implicit-check-not=.symtab /dev/null
+
+## Check that we create both .strtab and .symtab.
+## We reuse the existing .shstrtab (section names) for symbol names.
+## This may look strange but it works.
+# RUN: llvm-objcopy --add-symbol='abs1=1' %t1 %t2
+# RUN: llvm-readobj -S %t2 | FileCheck --check-prefix=SEC2 %s
+# RUN: llvm-readelf -s %t2 | FileCheck %s
+
+# SEC2:      Index: 1
+# SEC2-NEXT: Name: .shstrtab
+# SEC2-NEXT: Type: SHT_STRTAB
+# SEC2:      Index: 2
+# SEC2-NEXT: Name: .symtab
+# SEC2-NEXT: Type: SHT_SYMTAB
+# SEC2-NOT:  }
+# SEC2:      Link: 1
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Symbols:
+...
+
+## Check the created .symtab does not link to .dynstr (SHF_ALLOC).
+# RUN: yaml2obj --docnum=2 %s -o %t
+# RUN: llvm-objcopy --remove-section=.symtab --remove-section=.strtab %t %t1
+# RUN: llvm-objcopy --add-symbol='abs1=1' %t1 %t2
+# RUN: llvm-readobj -S %t2 | FileCheck --check-prefix=SEC3 %s
+
+# SEC3:      Index: 1
+# SEC3-NEXT: Name: .shstrtab
+# SEC3-NEXT: Type: SHT_STRTAB
+# SEC3:      Name: .symtab
+# SEC3-NEXT: Type: SHT_SYMTAB
+# SEC3-NOT:  }
+# SEC3:      Link: 1
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+DynamicSymbols:
+  - Name:    dummy
+    Binding: STB_GLOBAL
+Symbols:
+...

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

if (auto EC = sys::fs::remove(TmpPath)) {
     TmpPath.push_back('\0');
     return makeStringError(EC, "could not remove '%s'", TmpPath.data());
   }
   return Error::success();
 }
 
 static Error splitDWOToFile(const CopyConfig &Config, const Reader &Reader,
                             StringRef File, ElfType OutputElfType) {
-  auto DWOFile = Reader.create();
+  auto DWOFile = Reader.create(false);
   auto OnlyKeepDWOPred = [&DWOFile](const SectionBase &Sec) {
     return onlyKeepDWOPred(*DWOFile, Sec);
   };
   if (Error E = DWOFile->removeSections(Config.AllowBrokenLinks, 
                                         OnlyKeepDWOPred))
     return E;
   if (Config.OutputArch) {
     DWOFile->Machine = Config.OutputArch.getValue().EMachine;
static Error writeOutput(const CopyConfig &Config, Object &Obj, Buffer &Out,
   if (Error E = Writer->finalize())
     return E;
   return Writer->write();
 }
 
 Error executeObjcopyOnIHex(const CopyConfig &Config, MemoryBuffer &In,
                            Buffer &Out) {
   IHexReader Reader(&In);
-  std::unique_ptr<Object> Obj = Reader.create();
+  std::unique_ptr<Object> Obj = Reader.create(true);
   const ElfType OutputElfType =
     getOutputElfType(Config.OutputArch.getValueOr(MachineInfo()));
   if (Error E = handleArgs(Config, *Obj, Reader, OutputElfType))
     return E;
   return writeOutput(Config, *Obj, Out, OutputElfType);
 }
 
 Error executeObjcopyOnRawBinary(const CopyConfig &Config, MemoryBuffer &In,
                                 Buffer &Out) {
   uint8_t NewSymbolVisibility =
       Config.ELF->NewSymbolVisibility.getValueOr((uint8_t)ELF::STV_DEFAULT);
   BinaryReader Reader(&In, NewSymbolVisibility);
-  std::unique_ptr<Object> Obj = Reader.create();
+  std::unique_ptr<Object> Obj = Reader.create(true);
 
   // Prefer OutputArch (-O<format>) if set, otherwise fallback to BinaryArch
   // (-B<arch>).
   const ElfType OutputElfType =
       getOutputElfType(Config.OutputArch.getValueOr(MachineInfo()));
   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, Config.ExtractPartition);
-  std::unique_ptr<Object> Obj = Reader.create();
+  std::unique_ptr<Object> Obj = Reader.create(!Config.SymbolsToAdd.empty());
   // 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()) {
     auto BuildIdBytesOrErr = findBuildID(Config, In);

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

public:
   explicit GnuDebugLinkSection(StringRef File, uint32_t PrecomputedCRC);
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
 };
 
 class Reader {
 public:
   virtual ~Reader();
-  virtual std::unique_ptr<Object> create() const = 0;
+  virtual std::unique_ptr<Object> create(bool EnsureSymtab) const = 0;
 };
 
 using object::Binary;
 using object::ELFFile;
 using object::ELFObjectFile;
 using object::OwningBinary;
 
 class BasicELFBuilder {
private:
   size_t EhdrOffset = 0;
   Optional<StringRef> ExtractPartition;
 
   void setParentSegment(Segment &Child);
   void readProgramHeaders(const ELFFile<ELFT> &HeadersFile);
   void initGroupSection(GroupSection *GroupSec);
   void initSymbolTable(SymbolTableSection *SymTab);
   void readSectionHeaders();
-  void readSections();
+  void readSections(bool EnsureSymtab);
   void findEhdrOffset();
   SectionBase &makeSection(const Elf_Shdr &Shdr);
 
 public:
   ELFBuilder(const ELFObjectFile<ELFT> &ElfObj, Object &Obj,
              Optional<StringRef> ExtractPartition)
       : ElfFile(*ElfObj.getELFFile()), Obj(Obj),
         ExtractPartition(ExtractPartition) {}
 
-  void build();
+  void build(bool EnsureSymtab);
 };
 
 class BinaryReader : public Reader {
   MemoryBuffer *MemBuf;
   uint8_t NewSymbolVisibility;
 
 public:
   BinaryReader(MemoryBuffer *MB, const uint8_t NewSymbolVisibility)
       : MemBuf(MB), NewSymbolVisibility(NewSymbolVisibility) {}
-  std::unique_ptr<Object> create() const override;
+  std::unique_ptr<Object> create(bool EnsureSymtab) const override;
 };
 
 class IHexReader : public Reader {
   MemoryBuffer *MemBuf;
 
   Expected<std::vector<IHexRecord>> parse() const;
   Error parseError(size_t LineNo, Error E) const {
     return LineNo == -1U
                ? createFileError(MemBuf->getBufferIdentifier(), std::move(E))
                : createFileError(MemBuf->getBufferIdentifier(), LineNo,
                                  std::move(E));
   }
   template <typename... Ts>
   Error parseError(size_t LineNo, char const *Fmt, const Ts &... Vals) const {
     Error E = createStringError(errc::invalid_argument, Fmt, Vals...);
     return parseError(LineNo, std::move(E));
   }
 
 public:
   IHexReader(MemoryBuffer *MB) : MemBuf(MB) {}
 
-  std::unique_ptr<Object> create() const override;
+  std::unique_ptr<Object> create(bool EnsureSymtab) const override;
 };
 
 class ELFReader : public Reader {
   Binary *Bin;
   Optional<StringRef> ExtractPartition;
 
 public:
-  std::unique_ptr<Object> create() const override;
+  std::unique_ptr<Object> create(bool EnsureSymtab) const override;
   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>;

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

for (const auto &Shdr : unwrapOrError(ElfFile.sections())) {
     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() {
+template <class ELFT> void ELFBuilder<ELFT>::readSections(bool EnsureSymtab) {
   // 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
   // any relocations.
   if (Obj.SymbolTable) {
     Obj.SymbolTable->initialize(Obj.sections());
     initSymbolTable(Obj.SymbolTable);
+  } else if (EnsureSymtab) {
+    // Reuse the existing SHT_STRTAB section if exists.
+    StringTableSection *StrTab = nullptr;
+    for (auto &Sec : Obj.sections()) {
+      if (Sec.Type == ELF::SHT_STRTAB && !(Sec.Flags & SHF_ALLOC)) {
+        StrTab = static_cast<StringTableSection *>(&Sec);
+
+        // Prefer .strtab to .shstrtab.
+        if (Obj.SectionNames != &Sec)
+          break;
+      }
+    }
+    if (!StrTab)
+      StrTab = &Obj.addSection<StringTableSection>();
+
+    SymbolTableSection &SymTab = Obj.addSection<SymbolTableSection>();
+    SymTab.Name = ".symtab";
+    SymTab.Link = StrTab->Index;
+    SymTab.initialize(Obj.sections());
+    SymTab.addSymbol("", 0, 0, nullptr, 0, 0, 0, 0);
+    Obj.SymbolTable = &SymTab;
   }
 
   // Now that all sections and symbols have been added we can add
   // relocations that reference symbols and set the link and info fields for
   // relocation sections.
   for (auto &Sec : Obj.sections()) {
     if (&Sec == Obj.SymbolTable)
       continue;
template <class ELFT> void ELFBuilder<ELFT>::readSections(bool EnsureSymtab) {
 
   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() {
+template <class ELFT> void ELFBuilder<ELFT>::build(bool EnsureSymtab) {
   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;
 
-  readSections();
+  readSections(EnsureSymtab);
   readProgramHeaders(HeadersFile);
 }
 
 Writer::~Writer() {}
 
 Reader::~Reader() {}
 
-std::unique_ptr<Object> BinaryReader::create() const {
+std::unique_ptr<Object> BinaryReader::create(bool /*EnsureSymtab*/) const {
   return BinaryELFBuilder(MemBuf, NewSymbolVisibility).build();
 }
 
 Expected<std::vector<IHexRecord>> IHexReader::parse() const {
   SmallVector<StringRef, 16> Lines;
   std::vector<IHexRecord> Records;
   bool HasSections = false;
 
for (size_t LineNo = 1; LineNo <= Lines.size(); ++LineNo) {
     Records.push_back(*R);
   }
   if (!HasSections)
     return parseError(-1U, "no sections");
 
   return std::move(Records);
 }
 
-std::unique_ptr<Object> IHexReader::create() const {
+std::unique_ptr<Object> IHexReader::create(bool /*EnsureSymtab*/) const {
   std::vector<IHexRecord> Records = unwrapOrError(parse());
   return IHexELFBuilder(Records).build();
 }
 
-std::unique_ptr<Object> ELFReader::create() const {
+std::unique_ptr<Object> ELFReader::create(bool EnsureSymtab) const {
   auto Obj = std::make_unique<Object>();
   if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
     ELFBuilder<ELF32LE> Builder(*O, *Obj, ExtractPartition);
-    Builder.build();
+    Builder.build(EnsureSymtab);
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
     ELFBuilder<ELF64LE> Builder(*O, *Obj, ExtractPartition);
-    Builder.build();
+    Builder.build(EnsureSymtab);
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
     ELFBuilder<ELF32BE> Builder(*O, *Obj, ExtractPartition);
-    Builder.build();
+    Builder.build(EnsureSymtab);
     return Obj;
   } else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
     ELFBuilder<ELF64BE> Builder(*O, *Obj, ExtractPartition);
-    Builder.build();
+    Builder.build(EnsureSymtab);
     return Obj;
   }
   error("invalid file type");
 }
 
 template <class ELFT> void ELFWriter<ELFT>::writeEhdr() {
   Elf_Ehdr &Ehdr = *reinterpret_cast<Elf_Ehdr *>(Buf.getBufferStart());
   std::fill(Ehdr.e_ident, Ehdr.e_ident + 16, 0);