[ObjectYAML/obj2yaml/yaml2obj][MachO] Support indirect symbol table

[thevinster]

Summary

Tools such as llvm-objdump or llvm-readobj support indirect symbol
tables. Here, support it for obj2yaml and yaml2obj.

[thevinster]

clang-format

[drodriguez]

llvm/lib/ObjectYAML/MachOEmitter.cpp

568

If I am not wrong, llvm::yaml::Hex32 should have the same size as an uint32_t. In any case, it might be better to use a sizeof(llvm::yaml::Hex32::BaseType) or similar instead of a naked 4 in here.

[thevinster]

llvm/lib/ObjectYAML/MachOEmitter.cpp

568

I like sizeof(llvm::yaml::Hex32::BaseType) since it's clearer.

[thevinster]

Update to use sizeof() instead of hard-coded number

[thevinster]

format...

[jhenderson]

A few nits, but mostly looks good.

llvm/include/llvm/ObjectYAML/MachOYAML.h

124

Shouldn't need the explicit llvm prefix, since you're already in the llvm namespace.

llvm/lib/ObjectYAML/MachOEmitter.cpp

567

UpperCamelCase for variable names.

Also, I'd not use auto here: the type isn't obvious from the RHS (although if you're keen on following existing style in this immediate area, I can live with it).

569

llvm/test/ObjectYAML/MachO/dsymtab.yaml

4

Is this the minimum this document can be reduced to? There's a lot of stuff that has no value to the test, although I know that Mach-O yaml2obj's side doesn't allow much to be removed to minimise noise.

[thevinster]

llvm/test/ObjectYAML/MachO/dsymtab.yaml

4

Updated. Most of the LinkEditData could be removed (except the one under test), but the FileHeader and LoadCommands are required in order to not break the continuity of the binary.

[thevinster]

Addressing nits

llvm/include/llvm/ObjectYAML/MachOYAML.h

 struct LinkEditData {
   std::vector<MachOYAML::RebaseOpcode> RebaseOpcodes;
   std::vector<MachOYAML::BindOpcode> BindOpcodes;
   std::vector<MachOYAML::BindOpcode> WeakBindOpcodes;
   std::vector<MachOYAML::BindOpcode> LazyBindOpcodes;
   MachOYAML::ExportEntry ExportTrie;
   std::vector<NListEntry> NameList;
   std::vector<StringRef> StringTable;
+  std::vector<yaml::Hex32> IndirectSymbols;
 
   bool isEmpty() const;
 };
 
 struct Object {
   bool IsLittleEndian;
   FileHeader Header;
   std::vector<LoadCommand> LoadCommands;

llvm/lib/ObjectYAML/MachOEmitter.cpp

private:
   // LinkEdit writers
   void writeRebaseOpcodes(raw_ostream &OS);
   void writeBasicBindOpcodes(raw_ostream &OS);
   void writeWeakBindOpcodes(raw_ostream &OS);
   void writeLazyBindOpcodes(raw_ostream &OS);
   void writeNameList(raw_ostream &OS);
   void writeStringTable(raw_ostream &OS);
   void writeExportTrie(raw_ostream &OS);
+  void writeDynamicSymbolTable(raw_ostream &OS);
 
   void dumpExportEntry(raw_ostream &OS, MachOYAML::ExportEntry &Entry);
   void ZeroToOffset(raw_ostream &OS, size_t offset);
 
   MachOYAML::Object &Obj;
   bool is64Bit;
   uint64_t fileStart;
   MachO::mach_header_64 Header;

 
 void MachOWriter::writeLinkEditData(raw_ostream &OS) {
   typedef void (MachOWriter::*writeHandler)(raw_ostream &);
   typedef std::pair<uint64_t, writeHandler> writeOperation;
   std::vector<writeOperation> WriteQueue;
 
   MachO::dyld_info_command *DyldInfoOnlyCmd = 0;
   MachO::symtab_command *SymtabCmd = 0;
+  MachO::dysymtab_command *DSymtabCmd = 0;
   for (auto &LC : Obj.LoadCommands) {
     switch (LC.Data.load_command_data.cmd) {
     case MachO::LC_SYMTAB:
       SymtabCmd = &LC.Data.symtab_command_data;
       WriteQueue.push_back(
           std::make_pair(SymtabCmd->symoff, &MachOWriter::writeNameList));
       WriteQueue.push_back(
           std::make_pair(SymtabCmd->stroff, &MachOWriter::writeStringTable));
       break;
     case MachO::LC_DYLD_INFO_ONLY:
       DyldInfoOnlyCmd = &LC.Data.dyld_info_command_data;
       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->rebase_off,
                                           &MachOWriter::writeRebaseOpcodes));
       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->bind_off,
                                           &MachOWriter::writeBasicBindOpcodes));
       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->weak_bind_off,
                                           &MachOWriter::writeWeakBindOpcodes));
       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->lazy_bind_off,
                                           &MachOWriter::writeLazyBindOpcodes));
       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->export_off,
                                           &MachOWriter::writeExportTrie));
       break;
+    case MachO::LC_DYSYMTAB:
+      DSymtabCmd = &LC.Data.dysymtab_command_data;
+      WriteQueue.push_back(std::make_pair(
+          DSymtabCmd->indirectsymoff, &MachOWriter::writeDynamicSymbolTable));
+      break;
     }
   }
 
   llvm::sort(WriteQueue, [](const writeOperation &a, const writeOperation &b) {
     return a.first < b.first;
   });
 
   for (auto writeOp : WriteQueue) {

 
 void MachOWriter::writeStringTable(raw_ostream &OS) {
   for (auto Str : Obj.LinkEdit.StringTable) {
     OS.write(Str.data(), Str.size());
     OS.write('\0');
   }
 }
 
+void MachOWriter::writeDynamicSymbolTable(raw_ostream &OS) {
+  for (auto Data : Obj.LinkEdit.IndirectSymbols)
+    OS.write(reinterpret_cast<const char *>(&Data),
+             sizeof(yaml::Hex32::BaseType));
+}
+
 class UniversalWriter {
 public:
   UniversalWriter(yaml::YamlObjectFile &ObjectFile)
       : ObjectFile(ObjectFile), fileStart(0) {}
 
   Error writeMachO(raw_ostream &OS);
 
 private:

llvm/lib/ObjectYAML/MachOYAML.cpp

void MappingTraits<MachOYAML::LinkEditData>::mapping(
   IO.mapOptional("RebaseOpcodes", LinkEditData.RebaseOpcodes);
   IO.mapOptional("BindOpcodes", LinkEditData.BindOpcodes);
   IO.mapOptional("WeakBindOpcodes", LinkEditData.WeakBindOpcodes);
   IO.mapOptional("LazyBindOpcodes", LinkEditData.LazyBindOpcodes);
   if (!LinkEditData.ExportTrie.Children.empty() || !IO.outputting())
     IO.mapOptional("ExportTrie", LinkEditData.ExportTrie);
   IO.mapOptional("NameList", LinkEditData.NameList);
   IO.mapOptional("StringTable", LinkEditData.StringTable);
+  IO.mapOptional("IndirectSymbols", LinkEditData.IndirectSymbols);
 }
 
 void MappingTraits<MachOYAML::RebaseOpcode>::mapping(
     IO &IO, MachOYAML::RebaseOpcode &RebaseOpcode) {
   IO.mapRequired("Opcode", RebaseOpcode.Opcode);
   IO.mapRequired("Imm", RebaseOpcode.Imm);
   IO.mapOptional("ExtraData", RebaseOpcode.ExtraData);
 }

llvm/test/ObjectYAML/MachO/dsymtab.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x1000007
+  cpusubtype:      0x3
+  filetype:        0x2
+  ncmds:           16
+  sizeofcmds:      1368
+  flags:           0x200085
+  reserved:        0x0
+LoadCommands:
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         72
+    segname:         __PAGEZERO
+    vmaddr:          0
+    vmsize:          4294967296
+    fileoff:         0
+    filesize:        0
+    maxprot:         0
+    initprot:        0
+    nsects:          0
+    flags:           0
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         472
+    segname:         __TEXT
+    vmaddr:          4294967296
+    vmsize:          16384
+    fileoff:         0
+    filesize:        16384
+    maxprot:         5
+    initprot:        5
+    nsects:          5
+    flags:           0
+    Sections:
+      - sectname:        __text
+        segname:         __TEXT
+        addr:            0x100003F60
+        size:            37
+        offset:          0x3F60
+        align:           4
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         554889E54883EC10C745FC00000000488D3D30000000B000E80900000031C04883C4105DC3
+      - sectname:        __stubs
+        segname:         __TEXT
+        addr:            0x100003F86
+        size:            6
+        offset:          0x3F86
+        align:           1
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x80000408
+        reserved1:       0x0
+        reserved2:       0x6
+        reserved3:       0x0
+        content:         FF2574400000
+      - sectname:        __stub_helper
+        segname:         __TEXT
+        addr:            0x100003F8C
+        size:            26
+        offset:          0x3F8C
+        align:           2
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         4C8D1D754000004153FF2565000000906800000000E9E6FFFFFF
+      - sectname:        __cstring
+        segname:         __TEXT
+        addr:            0x100003FA6
+        size:            13
+        offset:          0x3FA6
+        align:           0
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x2
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         68656C6C6F20776F726C640A00
+      - sectname:        __unwind_info
+        segname:         __TEXT
+        addr:            0x100003FB4
+        size:            72
+        offset:          0x3FB4
+        align:           2
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x0
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         010000001C000000000000001C000000000000001C00000002000000603F00003400000034000000863F00000000000034000000030000000C000100100001000000000000000001
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         152
+    segname:         __DATA_CONST
+    vmaddr:          4294983680
+    vmsize:          16384
+    fileoff:         16384
+    filesize:        16384
+    maxprot:         3
+    initprot:        3
+    nsects:          1
+    flags:           16
+    Sections:
+      - sectname:        __got
+        segname:         __DATA_CONST
+        addr:            0x100004000
+        size:            8
+        offset:          0x4000
+        align:           3
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x6
+        reserved1:       0x1
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         '0000000000000000'
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         232
+    segname:         __DATA
+    vmaddr:          4295000064
+    vmsize:          16384
+    fileoff:         32768
+    filesize:        16384
+    maxprot:         3
+    initprot:        3
+    nsects:          2
+    flags:           0
+    Sections:
+      - sectname:        __la_symbol_ptr
+        segname:         __DATA
+        addr:            0x100008000
+        size:            8
+        offset:          0x8000
+        align:           3
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x7
+        reserved1:       0x2
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         9C3F000001000000
+      - sectname:        __data
+        segname:         __DATA
+        addr:            0x100008008
+        size:            8
+        offset:          0x8008
+        align:           3
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x0
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         '0000000000000000'
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         72
+    segname:         __LINKEDIT
+    vmaddr:          4295016448
+    vmsize:          16384
+    fileoff:         49152
+    filesize:        272
+    maxprot:         1
+    initprot:        1
+    nsects:          0
+    flags:           0
+  - cmd:             LC_DYLD_INFO_ONLY
+    cmdsize:         48
+    rebase_off:      49152
+    rebase_size:     8
+    bind_off:        49160
+    bind_size:       24
+    weak_bind_off:   0
+    weak_bind_size:  0
+    lazy_bind_off:   49184
+    lazy_bind_size:  16
+    export_off:      49200
+    export_size:     48
+  - cmd:             LC_SYMTAB
+    cmdsize:         24
+    symoff:          49256
+    nsyms:           5
+    stroff:          49352
+    strsize:         72
+  - cmd:             LC_DYSYMTAB
+    cmdsize:         80
+    ilocalsym:       0
+    nlocalsym:       1
+    iextdefsym:      1
+    nextdefsym:      2
+    iundefsym:       3
+    nundefsym:       2
+    tocoff:          0
+    ntoc:            0
+    modtaboff:       0
+    nmodtab:         0
+    extrefsymoff:    0
+    nextrefsyms:     0
+    indirectsymoff:  49336
+    nindirectsyms:   3
+    extreloff:       0
+    nextrel:         0
+    locreloff:       0
+    nlocrel:         0
+  - cmd:             LC_LOAD_DYLINKER
+    cmdsize:         32
+    name:            12
+    Content:         '/usr/lib/dyld'
+    ZeroPadBytes:    7
+  - cmd:             LC_UUID
+    cmdsize:         24
+    uuid:            FF5FAB50-C79A-3B66-AD3A-DE2F26398050
+  - cmd:             LC_BUILD_VERSION
+    cmdsize:         32
+    platform:        1
+    minos:           720896
+    sdk:             721664
+    ntools:          1
+    Tools:
+      - tool:            3
+        version:         46596096
+  - cmd:             LC_SOURCE_VERSION
+    cmdsize:         16
+    version:         0
+  - cmd:             LC_MAIN
+    cmdsize:         24
+    entryoff:        16224
+    stacksize:       0
+  - cmd:             LC_LOAD_DYLIB
+    cmdsize:         56
+    dylib:
+      name:            24
+      timestamp:       2
+      current_version: 84698117
+      compatibility_version: 65536
+    Content:         '/usr/lib/libSystem.B.dylib'
+    ZeroPadBytes:    6
+  - cmd:             LC_FUNCTION_STARTS
+    cmdsize:         16
+    dataoff:         49248
+    datasize:        8
+  - cmd:             LC_DATA_IN_CODE
+    cmdsize:         16
+    dataoff:         49256
+    datasize:        0
+LinkEditData:
+  IndirectSymbols: [ 0x3, 0x4, 0x3 ]
+...
+
+#CHECK: IndirectSymbols: [ 0x3, 0x4, 0x3 ]

llvm/tools/obj2yaml/macho2yaml.cpp

class MachODumper {
   void dumpHeader(std::unique_ptr<MachOYAML::Object> &Y);
   Error dumpLoadCommands(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpRebaseOpcodes(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpBindOpcodes(std::vector<MachOYAML::BindOpcode> &BindOpcodes,
                        ArrayRef<uint8_t> OpcodeBuffer, bool Lazy = false);
   void dumpExportTrie(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y);
+  void dumpIndirectSymbols(std::unique_ptr<MachOYAML::Object> &Y);
 
   template <typename SectionType>
   Expected<MachOYAML::Section> constructSectionCommon(SectionType Sec,
                                                       size_t SecIndex);
   template <typename SectionType>
   Expected<MachOYAML::Section> constructSection(SectionType Sec,
                                                 size_t SecIndex);
   template <typename SectionType, typename SegmentType>
void MachODumper::dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y) {
   dumpRebaseOpcodes(Y);
   dumpBindOpcodes(Y->LinkEdit.BindOpcodes, Obj.getDyldInfoBindOpcodes());
   dumpBindOpcodes(Y->LinkEdit.WeakBindOpcodes,
                   Obj.getDyldInfoWeakBindOpcodes());
   dumpBindOpcodes(Y->LinkEdit.LazyBindOpcodes, Obj.getDyldInfoLazyBindOpcodes(),
                   true);
   dumpExportTrie(Y);
   dumpSymbols(Y);
+  dumpIndirectSymbols(Y);
 }
 
 void MachODumper::dumpRebaseOpcodes(std::unique_ptr<MachOYAML::Object> &Y) {
   MachOYAML::LinkEditData &LEData = Y->LinkEdit;
 
   auto RebaseOpcodes = Obj.getDyldInfoRebaseOpcodes();
   for (auto OpCode = RebaseOpcodes.begin(); OpCode != RebaseOpcodes.end();
        ++OpCode) {
void MachODumper::dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y) {
   StringRef RemainingTable = Obj.getStringTableData();
   while (RemainingTable.size() > 0) {
     auto SymbolPair = RemainingTable.split('\0');
     RemainingTable = SymbolPair.second;
     LEData.StringTable.push_back(SymbolPair.first);
   }
 }
 
+void MachODumper::dumpIndirectSymbols(std::unique_ptr<MachOYAML::Object> &Y) {
+  MachOYAML::LinkEditData &LEData = Y->LinkEdit;
+
+  MachO::dysymtab_command DLC = Obj.getDysymtabLoadCommand();
+  for (unsigned i = 0; i < DLC.nindirectsyms; ++i)
+    LEData.IndirectSymbols.push_back(Obj.getIndirectSymbolTableEntry(DLC, i));
+}
+
 Error macho2yaml(raw_ostream &Out, const object::MachOObjectFile &Obj,
                  unsigned RawSegments) {
   std::unique_ptr<DWARFContext> DCtx = DWARFContext::create(Obj);
   MachODumper Dumper(Obj, std::move(DCtx), RawSegments);
   Expected<std::unique_ptr<MachOYAML::Object>> YAML = Dumper.dump();
   if (!YAML)
     return YAML.takeError();