[llvm-objcopy][MachO] Rebuild the symbol/string table in the writer

[seiya]

Summary

Build the string table using StringTableBuilder, reassign symbol indices, and update symbol indices in relocations to allow adding/modifying/removing symbols from the object.

[jhenderson]

I've got several stylistic comments, but don't have time to read up on Mach-O right now to review that aspect of it.

llvm/tools/llvm-objcopy/MachO/MachOWriter.cpp

124

This shouldn't be auto.

275

Standard LLVM style says that you should put the end() evaluation in the initializer part of a for loop, unless it can change:

for (auto Iter = O.SymTable.Symbols.begin(), End = O.SymTable.Symbols.end(); Iter != End; Iter++)

277

Can you just make this a raw pointer and do Iter->get()?

561

Maybe too much auto here.

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

88

Is int the right type here? It seems dubious to me without knowing anything about the file format.

113

Don't need struct here I believe.

[seiya]

Addressed review comments.

[seiya]

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

88

I was wrong. This should be uint32_t. Thanks.

[alexander-shaposhnikov]

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

173

StringRef(StrTable.data() + nlist.n_strx).str()

186

i think you don't need the explicit specification of the template parameter here, it'll be deduced from the type of the second argument

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

11

khm, why is this const_cast needed here ?

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

100

SymbolEntry *getSymbolByIndex(uint32_t Index) const;

[seiya]

• Addressed review comments.

[alexander-shaposhnikov]

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

227

I'm wondering if MachOWriter would be a better place for StrTableBuilder ?
MachOWriter::constructStringTable, MachOWriter::writeStringTable, MachOWriter::totalSize, MachOWriter::writeSymbolTable are the only users of this object, aren't they ?

[seiya]

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

11

First I thought we need to modify something in the SymbolEntry pointed from the RelocationInfo.Symbol, but I realized it is not necessary in this patch.

FYI, I used the ELF implementation as reference:

class SymbolTableSection : public SectionBase {
...
public:
  const Symbol *getSymbolByIndex(uint32_t Index) const;
  Symbol *getSymbolByIndex(uint32_t Index);
};

[seiya]

• Move StrTableBuilder into MachOWriter.

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

227

You're correct! I'll fix this.

[alexander-shaposhnikov]

Just to double check - do the existing tests pass with this patch ? If so - LGTM

[seiya]

In D63309#1551411, @alexshap wrote:

Just to double check - do the existing tests pass with this patch ? If so - LGTM

Yes they pass with this patch. Thanks!

[anushabasana]

I am getting the compile warnings below when compiling on gcc version 7.3.1.

[1/4] Building CXX object tools/llvm-objcopy/CMakeFiles/llvm-objcopy.dir/MachO/MachOReader.cpp.o
/home/anushabasana/local/llvm-project/llvm/tools/llvm-objcopy/MachO/MachOReader.cpp: In instantiation of ‘std::vector<llvm::objcopy::macho::Section> llvm::objcopy::macho::extractSections(const llvm::object::MachOObjectFile::LoadCommandInfo&, const llvm::object::MachOObjectFile&, size_t&) [with SectionType = llvm::MachO::section; SegmentType = llvm::MachO::segment_command; size_t = long unsigned int]’:
/home/anushabasana/local/llvm-project/llvm/tools/llvm-objcopy/MachO/MachOReader.cpp:124:46:   required from here
/home/anushabasana/local/llvm-project/llvm/tools/llvm-objcopy/MachO/MachOReader.cpp:106:17: warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
           reinterpret_cast<MachO::scattered_relocation_info *>(&R.Info)
           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
               ->r_scattered;
               ~~^~~~~~~~~~~
/home/anushabasana/local/llvm-project/llvm/tools/llvm-objcopy/MachO/MachOReader.cpp: In instantiation of ‘std::vector<llvm::objcopy::macho::Section> llvm::objcopy::macho::extractSections(const llvm::object::MachOObjectFile::LoadCommandInfo&, const llvm::object::MachOObjectFile&, size_t&) [with SectionType = llvm::MachO::section_64; SegmentType = llvm::MachO::segment_command_64; size_t = long unsigned int]’:
/home/anushabasana/local/llvm-project/llvm/tools/llvm-objcopy/MachO/MachOReader.cpp:129:50:   required from here
/home/anushabasana/local/llvm-project/llvm/tools/llvm-objcopy/MachO/MachOReader.cpp:106:17: warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]

[alexander-shaposhnikov]

@anushabasana , this is addressed in https://reviews.llvm.org/D63699 (jfyi)

[MaskRay]

From https://developer.apple.com/documentation/kernel/relocation_info?changes=latest_major&language=ob_7:

r_symbolnum

Indicates either an index into the symbol table (when the r_extern field is set to 1) or a section number (when the r_extern field is set to 0). As previously mentioned, sections are ordered from 1 to 255 in the order in which they appear in the LC_SEGMENT load commands. This field is set to R_ABS for relocation entries for absolute symbols, which need no relocation.

The current Mach-O reader and writer do not handle r_extern=0 relocations.

// MachO/MachOReader
void MachOReader::setSymbolInRelocationInfo(Object &O) const {
  for (auto &LC : O.LoadCommands)
    for (auto &Sec : LC.Sections)
      for (auto &Reloc : Sec.Relocations)
        if (!Reloc.Scattered) {
          auto *Info = reinterpret_cast<MachO::relocation_info *>(&Reloc.Info);
          Reloc.Symbol = O.SymTable.getSymbolByIndex(Info->r_symbolnum);  //// this can reference a section when r_extern=0
        }
}

[seiya]

In D63309#1780984, @MaskRay wrote:

From https://developer.apple.com/documentation/kernel/relocation_info?changes=latest_major&language=ob_7:

r_symbolnum

Indicates either an index into the symbol table (when the r_extern field is set to 1) or a section number (when the r_extern field is set to 0). As previously mentioned, sections are ordered from 1 to 255 in the order in which they appear in the LC_SEGMENT load commands. This field is set to R_ABS for relocation entries for absolute symbols, which need no relocation.

The current Mach-O reader and writer do not handle r_extern=0 relocations.

// MachO/MachOReader
void MachOReader::setSymbolInRelocationInfo(Object &O) const {
  for (auto &LC : O.LoadCommands)
    for (auto &Sec : LC.Sections)
      for (auto &Reloc : Sec.Relocations)
        if (!Reloc.Scattered) {
          auto *Info = reinterpret_cast<MachO::relocation_info *>(&Reloc.Info);
          Reloc.Symbol = O.SymTable.getSymbolByIndex(Info->r_symbolnum);  //// this can reference a section when r_extern=0
        }
}

Thank you for pointing that out. I'll take a look at that.

llvm/tools/llvm-objcopy/CMakeLists.txt

add_llvm_tool(llvm-objcopy
   COFF/Object.cpp
   COFF/Reader.cpp
   COFF/Writer.cpp
   ELF/ELFObjcopy.cpp
   ELF/Object.cpp
   MachO/MachOObjcopy.cpp
   MachO/MachOReader.cpp
   MachO/MachOWriter.cpp
+  MachO/Object.cpp
   DEPENDS
   ObjcopyOptsTableGen
   StripOptsTableGen
   )
 
 add_llvm_tool_symlink(llvm-strip llvm-objcopy)
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(objcopy llvm-objcopy)
   add_llvm_tool_symlink(strip llvm-objcopy)
 endif()

llvm/tools/llvm-objcopy/MachO/MachOReader.h

 };
 
 class MachOReader : public Reader {
   const object::MachOObjectFile &MachOObj;
 
   void readHeader(Object &O) const;
   void readLoadCommands(Object &O) const;
   void readSymbolTable(Object &O) const;
-  void readStringTable(Object &O) const;
+  void setSymbolInRelocationInfo(Object &O) const;
   void readRebaseInfo(Object &O) const;
   void readBindInfo(Object &O) const;
   void readWeakBindInfo(Object &O) const;
   void readLazyBindInfo(Object &O) const;
   void readExportInfo(Object &O) const;
 
 public:
   explicit MachOReader(const object::MachOObjectFile &Obj) : MachOObj(Obj) {}
 
   std::unique_ptr<Object> create() const override;
 };
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

if (Expected<ArrayRef<uint8_t>> E =
       S.Content =
           StringRef(reinterpret_cast<const char *>(E->data()), E->size());
     else
       reportError(MachOObj.getFileName(), E.takeError());
 
     S.Relocations.reserve(S.NReloc);
     for (auto RI = MachOObj.section_rel_begin(SecRef->getRawDataRefImpl()),
               RE = MachOObj.section_rel_end(SecRef->getRawDataRefImpl());
-         RI != RE; ++RI)
-      S.Relocations.push_back(MachOObj.getRelocation(RI->getRawDataRefImpl()));
+         RI != RE; ++RI) {
+      RelocationInfo R;
+      R.Symbol = nullptr; // We'll fill this field later.
+      R.Info = MachOObj.getRelocation(RI->getRawDataRefImpl());
+      R.Scattered =
+          reinterpret_cast<MachO::scattered_relocation_info *>(&R.Info)
+              ->r_scattered;
+      S.Relocations.push_back(R);
+    }
+
     assert(S.NReloc == S.Relocations.size() &&
            "Incorrect number of relocations");
   }
   return Sections;
 }
 
 void MachOReader::readLoadCommands(Object &O) const {
   // For MachO sections indices start from 1.
default:
           LoadCmd.C.cmdsize - sizeof(MachO::load_command));
       break;
 #include "llvm/BinaryFormat/MachO.def"
     }
     O.LoadCommands.push_back(std::move(LC));
   }
 }
 
-template <typename nlist_t> NListEntry constructNameList(const nlist_t &nlist) {
-  NListEntry NL;
-  NL.n_strx = nlist.n_strx;
-  NL.n_type = nlist.n_type;
-  NL.n_sect = nlist.n_sect;
-  NL.n_desc = nlist.n_desc;
-  NL.n_value = nlist.n_value;
-  return NL;
+template <typename nlist_t>
+SymbolEntry constructSymbolEntry(StringRef StrTable, const nlist_t &nlist) {
+  assert(nlist.n_strx < StrTable.size() &&
+         "n_strx exceeds the size of the string table");
+  SymbolEntry SE;
+  SE.Name = StringRef(StrTable.data() + nlist.n_strx).str();
+  SE.n_type = nlist.n_type;
+  SE.n_sect = nlist.n_sect;
+  SE.n_desc = nlist.n_desc;
+  SE.n_value = nlist.n_value;
+  return SE;
 }
 
 void MachOReader::readSymbolTable(Object &O) const {
+  StringRef StrTable = MachOObj.getStringTableData();
   for (auto Symbol : MachOObj.symbols()) {
-    NListEntry NLE =
-        MachOObj.is64Bit()
-            ? constructNameList<MachO::nlist_64>(
+    SymbolEntry SE =
+        (MachOObj.is64Bit()
+             ? constructSymbolEntry(
+                   StrTable,
                    MachOObj.getSymbol64TableEntry(Symbol.getRawDataRefImpl()))
-            : constructNameList<MachO::nlist>(
-                  MachOObj.getSymbolTableEntry(Symbol.getRawDataRefImpl()));
-    O.SymTable.NameList.push_back(NLE);
+             : constructSymbolEntry(
+                   StrTable,
+                   MachOObj.getSymbolTableEntry(Symbol.getRawDataRefImpl())));
+
+    O.SymTable.Symbols.push_back(llvm::make_unique<SymbolEntry>(SE));
   }
 }
 
-void MachOReader::readStringTable(Object &O) const {
-  StringRef Data = MachOObj.getStringTableData();
-  SmallVector<StringRef, 10> Strs;
-  Data.split(Strs, '\0');
-  O.StrTable.Strings.reserve(Strs.size());
-  for (auto S : Strs)
-    O.StrTable.Strings.push_back(S.str());
+void MachOReader::setSymbolInRelocationInfo(Object &O) const {
+  for (auto &LC : O.LoadCommands)
+    for (auto &Sec : LC.Sections)
+      for (auto &Reloc : Sec.Relocations)
+        if (!Reloc.Scattered) {
+          auto *Info = reinterpret_cast<MachO::relocation_info *>(&Reloc.Info);
+          Reloc.Symbol = O.SymTable.getSymbolByIndex(Info->r_symbolnum);
+        }
 }
 
 void MachOReader::readRebaseInfo(Object &O) const {
   O.Rebases.Opcodes = MachOObj.getDyldInfoRebaseOpcodes();
 }
 
 void MachOReader::readBindInfo(Object &O) const {
   O.Binds.Opcodes = MachOObj.getDyldInfoBindOpcodes();
void MachOReader::readExportInfo(Object &O) const {
   O.Exports.Trie = MachOObj.getDyldInfoExportsTrie();
 }
 
 std::unique_ptr<Object> MachOReader::create() const {
   auto Obj = llvm::make_unique<Object>();
   readHeader(*Obj);
   readLoadCommands(*Obj);
   readSymbolTable(*Obj);
-  readStringTable(*Obj);
+  setSymbolInRelocationInfo(*Obj);
   readRebaseInfo(*Obj);
   readBindInfo(*Obj);
   readWeakBindInfo(*Obj);
   readLazyBindInfo(*Obj);
   readExportInfo(*Obj);
   return Obj;
 }
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

llvm/tools/llvm-objcopy/MachO/MachOWriter.h

 namespace objcopy {
 namespace macho {
 
 class MachOWriter {
   Object &O;
   bool Is64Bit;
   bool IsLittleEndian;
   Buffer &B;
+  StringTableBuilder StrTableBuilder{StringTableBuilder::MachO};
 
   size_t headerSize() const;
   size_t loadCommandsSize() const;
   size_t symTableSize() const;
   size_t strTableSize() const;
 
   void updateDySymTab(MachO::macho_load_command &MLC);
   void updateSizeOfCmds();
+  void updateSymbolIndexes();
+  void constructStringTable();
   Error layout();
 
   void writeHeader();
   void writeLoadCommands();
   template <typename StructType>
   void writeSectionInLoadCommand(const Section &Sec, uint8_t *&Out);
   void writeSections();
   void writeSymbolTable();

llvm/tools/llvm-objcopy/MachO/MachOWriter.cpp

 
 size_t MachOWriter::headerSize() const {
   return Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
 }
 
 size_t MachOWriter::loadCommandsSize() const { return O.Header.SizeOfCmds; }
 
 size_t MachOWriter::symTableSize() const {
-  return O.SymTable.NameList.size() *
+  return O.SymTable.Symbols.size() *
          (Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist));
 }
 
-size_t MachOWriter::strTableSize() const {
-  size_t S = 0;
-  for (const auto &Str : O.StrTable.Strings)
-    S += Str.size();
-  S += (O.StrTable.Strings.empty() ? 0 : O.StrTable.Strings.size() - 1);
-  return S;
-}
-
 size_t MachOWriter::totalSize() const {
   // Going from tail to head and looking for an appropriate "anchor" to
   // calculate the total size assuming that all the offsets are either valid
   // ("true") or 0 (0 indicates that the corresponding part is missing).
 
   SmallVector<size_t, 7> Ends;
   if (O.SymTabCommandIndex) {
     const MachO::symtab_command &SymTabCommand =
         O.LoadCommands[*O.SymTabCommandIndex]
             .MachOLoadCommand.symtab_command_data;
     if (SymTabCommand.symoff) {
-      assert((SymTabCommand.nsyms == O.SymTable.NameList.size()) &&
+      assert((SymTabCommand.nsyms == O.SymTable.Symbols.size()) &&
              "Incorrect number of symbols");
       Ends.push_back(SymTabCommand.symoff + symTableSize());
     }
     if (SymTabCommand.stroff) {
-      assert((SymTabCommand.strsize == strTableSize()) &&
+      assert((SymTabCommand.strsize == StrTableBuilder.getSize()) &&
              "Incorrect string table size");
       Ends.push_back(SymTabCommand.stroff + SymTabCommand.strsize);
     }
   }
   if (O.DyLdInfoCommandIndex) {
     const MachO::dyld_info_command &DyLdInfoCommand =
         O.LoadCommands[*O.DyLdInfoCommandIndex]
             .MachOLoadCommand.dyld_info_command_data;
void MachOWriter::writeHeader() {
   if (IsLittleEndian != sys::IsLittleEndianHost)
     MachO::swapStruct(Header);
 
   auto HeaderSize =
       Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
   memcpy(B.getBufferStart(), &Header, HeaderSize);
 }
 
+void MachOWriter::updateSymbolIndexes() {
+  uint32_t Index = 0;
+  for (auto &Symbol : O.SymTable.Symbols) {
+    Symbol->Index = Index;
+    Index++;
+  }
+}
+
 void MachOWriter::writeLoadCommands() {
   uint8_t *Begin = B.getBufferStart() + headerSize();
   for (const auto &LC : O.LoadCommands) {
     // Construct a load command.
     MachO::macho_load_command MLC = LC.MachOLoadCommand;
     switch (MLC.load_command_data.cmd) {
     case MachO::LC_SEGMENT:
       if (IsLittleEndian != sys::IsLittleEndianHost)
for (const auto &Sec : LC.Sections) {
       if (Sec.isVirtualSection())
         continue;
 
       assert(Sec.Offset && "Section offset can not be zero");
       assert((Sec.Size == Sec.Content.size()) && "Incorrect section size");
       memcpy(B.getBufferStart() + Sec.Offset, Sec.Content.data(),
              Sec.Content.size());
       for (size_t Index = 0; Index < Sec.Relocations.size(); ++Index) {
-        MachO::any_relocation_info R = Sec.Relocations[Index];
+        auto RelocInfo = Sec.Relocations[Index];
+        if (!RelocInfo.Scattered) {
+          auto *Info =
+              reinterpret_cast<MachO::relocation_info *>(&RelocInfo.Info);
+          Info->r_symbolnum = RelocInfo.Symbol->Index;
+        }
+
         if (IsLittleEndian != sys::IsLittleEndianHost)
-          MachO::swapStruct(R);
+          MachO::swapStruct(
+              reinterpret_cast<MachO::any_relocation_info &>(RelocInfo.Info));
         memcpy(B.getBufferStart() + Sec.RelOff +
                    Index * sizeof(MachO::any_relocation_info),
-               &R, sizeof(R));
+               &RelocInfo.Info, sizeof(RelocInfo.Info));
       }
     }
 }
 
 template <typename NListType>
-void writeNListEntry(const NListEntry &NLE, bool IsLittleEndian, char *&Out) {
+void writeNListEntry(const SymbolEntry &SE, bool IsLittleEndian, char *&Out,
+                     uint32_t Nstrx) {
   NListType ListEntry;
-  ListEntry.n_strx = NLE.n_strx;
-  ListEntry.n_type = NLE.n_type;
-  ListEntry.n_sect = NLE.n_sect;
-  ListEntry.n_desc = NLE.n_desc;
-  ListEntry.n_value = NLE.n_value;
+  ListEntry.n_strx = Nstrx;
+  ListEntry.n_type = SE.n_type;
+  ListEntry.n_sect = SE.n_sect;
+  ListEntry.n_desc = SE.n_desc;
+  ListEntry.n_value = SE.n_value;
 
   if (IsLittleEndian != sys::IsLittleEndianHost)
     MachO::swapStruct(ListEntry);
   memcpy(Out, reinterpret_cast<const char *>(&ListEntry), sizeof(NListType));
   Out += sizeof(NListType);
 }
 
 void MachOWriter::writeSymbolTable() {
   if (!O.SymTabCommandIndex)
     return;
   const MachO::symtab_command &SymTabCommand =
       O.LoadCommands[*O.SymTabCommandIndex]
           .MachOLoadCommand.symtab_command_data;
-  assert((SymTabCommand.nsyms == O.SymTable.NameList.size()) &&
-         "Incorrect number of symbols");
-  char *Out = (char *)B.getBufferStart() + SymTabCommand.symoff;
-  for (auto NLE : O.SymTable.NameList) {
-    if (Is64Bit)
-      writeNListEntry<MachO::nlist_64>(NLE, IsLittleEndian, Out);
-    else
-      writeNListEntry<MachO::nlist>(NLE, IsLittleEndian, Out);
-  }
+
+  uint8_t *StrTable = (uint8_t *)B.getBufferStart() + SymTabCommand.stroff;
+  StrTableBuilder.write(StrTable);
 }
 
 void MachOWriter::writeStringTable() {
   if (!O.SymTabCommandIndex)
     return;
   const MachO::symtab_command &SymTabCommand =
       O.LoadCommands[*O.SymTabCommandIndex]
           .MachOLoadCommand.symtab_command_data;
-  char *Out = (char *)B.getBufferStart() + SymTabCommand.stroff;
-  assert((SymTabCommand.strsize == strTableSize()) &&
-         "Incorrect string table size");
-  for (size_t Index = 0; Index < O.StrTable.Strings.size(); ++Index) {
-    memcpy(Out, O.StrTable.Strings[Index].data(),
-           O.StrTable.Strings[Index].size());
-    Out += O.StrTable.Strings[Index].size();
-    if (Index + 1 != O.StrTable.Strings.size()) {
-      memcpy(Out, "\0", 1);
-      Out += 1;
-    }
+
+  char *SymTable = (char *)B.getBufferStart() + SymTabCommand.symoff;
+  for (auto Iter = O.SymTable.Symbols.begin(), End = O.SymTable.Symbols.end();
+       Iter != End; Iter++) {
+    SymbolEntry *Sym = Iter->get();
+    auto Nstrx = StrTableBuilder.getOffset(Sym->Name);
+
+    if (Is64Bit)
+      writeNListEntry<MachO::nlist_64>(*Sym, IsLittleEndian, SymTable, Nstrx);
+    else
+      writeNListEntry<MachO::nlist>(*Sym, IsLittleEndian, SymTable, Nstrx);
   }
 }
 
 void MachOWriter::writeRebaseInfo() {
   if (!O.DyLdInfoCommandIndex)
     return;
   const MachO::dyld_info_command &DyLdInfoCommand =
       O.LoadCommands[*O.DyLdInfoCommandIndex]
#undef HANDLE_LOAD_COMMAND
   O.Header.SizeOfCmds = Size;
 }
 
 // Updates the index and the number of local/external/undefined symbols. Here we
 // assume that MLC is a LC_DYSYMTAB and the nlist entries in the symbol table
 // are already sorted by the those types.
 void MachOWriter::updateDySymTab(MachO::macho_load_command &MLC) {
   uint32_t NumLocalSymbols = 0;
-  auto Iter = O.SymTable.NameList.begin();
-  auto End = O.SymTable.NameList.end();
+  auto Iter = O.SymTable.Symbols.begin();
+  auto End = O.SymTable.Symbols.end();
   for (; Iter != End; Iter++) {
-    if (Iter->n_type & (MachO::N_EXT | MachO::N_PEXT))
+    if ((*Iter)->n_type & (MachO::N_EXT | MachO::N_PEXT))
       break;
 
     NumLocalSymbols++;
   }
 
   uint32_t NumExtDefSymbols = 0;
   for (; Iter != End; Iter++) {
-    if ((Iter->n_type & MachO::N_TYPE) == MachO::N_UNDF)
+    if (((*Iter)->n_type & MachO::N_TYPE) == MachO::N_UNDF)
       break;
 
     NumExtDefSymbols++;
   }
 
   MLC.dysymtab_command_data.ilocalsym = 0;
   MLC.dysymtab_command_data.nlocalsym = NumLocalSymbols;
   MLC.dysymtab_command_data.iextdefsym = NumLocalSymbols;
   MLC.dysymtab_command_data.nextdefsym = NumExtDefSymbols;
   MLC.dysymtab_command_data.iundefsym = NumLocalSymbols + NumExtDefSymbols;
   MLC.dysymtab_command_data.nundefsym =
-      O.SymTable.NameList.size() - (NumLocalSymbols + NumExtDefSymbols);
+      O.SymTable.Symbols.size() - (NumLocalSymbols + NumExtDefSymbols);
 }
 
 // Recomputes and updates offset and size fields in load commands and sections
 // since they could be modified.
 Error MachOWriter::layout() {
   auto SizeOfCmds = loadCommandsSize();
   auto Offset = headerSize() + SizeOfCmds;
   O.Header.NCmds = O.LoadCommands.size();
Error MachOWriter::layout() {
 
   // Lay out tail stuff.
   auto NListSize = Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
   for (auto &LC : O.LoadCommands) {
     auto &MLC = LC.MachOLoadCommand;
     auto cmd = MLC.load_command_data.cmd;
     switch (cmd) {
     case MachO::LC_SYMTAB:
+      MLC.symtab_command_data.nsyms = O.SymTable.Symbols.size();
+      MLC.symtab_command_data.strsize = StrTableBuilder.getSize();
       MLC.symtab_command_data.symoff = Offset;
-      MLC.symtab_command_data.nsyms = O.SymTable.NameList.size();
       Offset += NListSize * MLC.symtab_command_data.nsyms;
       MLC.symtab_command_data.stroff = Offset;
       Offset += MLC.symtab_command_data.strsize;
       break;
     case MachO::LC_DYSYMTAB: {
       if (MLC.dysymtab_command_data.ntoc != 0 ||
           MLC.dysymtab_command_data.nmodtab != 0 ||
           MLC.dysymtab_command_data.nextrefsyms != 0 ||
default:
       return createStringError(llvm::errc::not_supported,
                                "unsupported load command (cmd=0x%x)", cmd);
     }
   }
 
   return Error::success();
 }
 
+void MachOWriter::constructStringTable() {
+  for (std::unique_ptr<SymbolEntry> &Sym : O.SymTable.Symbols)
+    StrTableBuilder.add(Sym->Name);
+  StrTableBuilder.finalize();
+}
+
 Error MachOWriter::finalize() {
   updateSizeOfCmds();
+  constructStringTable();
 
   if (auto E = layout())
     return E;
 
   return Error::success();
 }
 
 Error MachOWriter::write() {
   if (Error E = B.allocate(totalSize()))
     return E;
   memset(B.getBufferStart(), 0, totalSize());
   writeHeader();
+  updateSymbolIndexes();
   writeLoadCommands();
   writeSections();
   writeTail();
   return B.commit();
 }
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

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

 //===- Object.h - Mach-O object file model ----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJCOPY_MACHO_OBJECT_H
 #define LLVM_OBJCOPY_MACHO_OBJECT_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/MC/StringTableBuilder.h"
 #include "llvm/ObjectYAML/DWARFYAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <cstdint>
 #include <string>
 #include <vector>
 
 namespace llvm {
 namespace objcopy {
 namespace macho {
 
 struct MachHeader {
   uint32_t Magic;
   uint32_t CPUType;
   uint32_t CPUSubType;
   uint32_t FileType;
   uint32_t NCmds;
   uint32_t SizeOfCmds;
   uint32_t Flags;
   uint32_t Reserved = 0;
 };
 
+struct RelocationInfo;
 struct Section {
   std::string Sectname;
   std::string Segname;
   uint64_t Addr;
   uint64_t Size;
   uint32_t Offset;
   uint32_t Align;
   uint32_t RelOff;
   uint32_t NReloc;
   uint32_t Flags;
   uint32_t Reserved1;
   uint32_t Reserved2;
   uint32_t Reserved3;
 
   StringRef Content;
-  std::vector<MachO::any_relocation_info> Relocations;
+  std::vector<RelocationInfo> Relocations;
 
   MachO::SectionType getType() const {
     return static_cast<MachO::SectionType>(Flags & MachO::SECTION_TYPE);
   }
 
   bool isVirtualSection() const {
     return (getType() == MachO::S_ZEROFILL ||
             getType() == MachO::S_GB_ZEROFILL ||
struct LoadCommand {
 
   // Some load commands can contain (inside the payload) an array of sections,
   // though the contents of the sections are stored separately. The struct
   // Section describes only sections' metadata and where to find the
   // corresponding content inside the binary.
   std::vector<Section> Sections;
 };
 
-struct NListEntry {
-  uint32_t n_strx;
+// A symbol information. Fields which starts with "n_" are same as them in the
+// nlist.
+struct SymbolEntry {
+  std::string Name;
+  uint32_t Index;
   uint8_t n_type;
   uint8_t n_sect;
   uint16_t n_desc;
   uint64_t n_value;
 };
 
 /// The location of the symbol table inside the binary is described by LC_SYMTAB
 /// load command.
 struct SymbolTable {
-  std::vector<NListEntry> NameList;
+  std::vector<std::unique_ptr<SymbolEntry>> Symbols;
+
+  const SymbolEntry *getSymbolByIndex(uint32_t Index) const;
 };
 
 /// The location of the string table inside the binary is described by LC_SYMTAB
 /// load command.
 struct StringTable {
   std::vector<std::string> Strings;
 };
 
+struct RelocationInfo {
+  const SymbolEntry *Symbol;
+  // True if Info is a scattered_relocation_info.
+  bool Scattered;
+  MachO::any_relocation_info Info;
+};
+
 /// The location of the rebase info inside the binary is described by
 /// LC_DYLD_INFO load command. Dyld rebases an image whenever dyld loads it at
 /// an address different from its preferred address.  The rebase information is
 /// a stream of byte sized opcodes whose symbolic names start with
 /// REBASE_OPCODE_. Conceptually the rebase information is a table of tuples:
 ///   <seg-index, seg-offset, type>
 /// The opcodes are a compressed way to encode the table by only
 /// encoding when a column changes.  In addition simple patterns
struct Object {
   LazyBindInfo LazyBinds;
   ExportInfo Exports;
 
   /// The index of LC_SYMTAB load command if present.
   Optional<size_t> SymTabCommandIndex;
   /// The index of LC_DYLD_INFO or LC_DYLD_INFO_ONLY load command if present.
   Optional<size_t> DyLdInfoCommandIndex;
 };
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm
 
 #endif // LLVM_OBJCOPY_MACHO_OBJECT_H

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

+#include "Object.h"
+#include "../llvm-objcopy.h"
+
+namespace llvm {
+namespace objcopy {
+namespace macho {
+
+const SymbolEntry *SymbolTable::getSymbolByIndex(uint32_t Index) const {
+  assert(Index < Symbols.size() && "invalid symbol index");
+  return Symbols[Index].get();
+}
+
+} // end namespace macho
+} // end namespace objcopy
+} // end namespace llvm