Add mach-o LC_RPATH support to llvm-objdump

[Jean-Daniel]

Summary

Add rpath load command support in Mach-O object and update llvm-objdump to use it.

[• jddupas]

Closed by commit rL223343 (authored by @jddupas).

include/llvm/Object/MachO.h

public:
   MachO::dylib_command
   getDylibIDLoadCommand(const LoadCommandInfo &L) const;
   MachO::dyld_info_command
   getDyldInfoLoadCommand(const LoadCommandInfo &L) const;
   MachO::dylinker_command
   getDylinkerCommand(const LoadCommandInfo &L) const;
   MachO::uuid_command
   getUuidCommand(const LoadCommandInfo &L) const;
+  MachO::rpath_command
+  getRpathCommand(const LoadCommandInfo &L) const;
   MachO::source_version_command
   getSourceVersionCommand(const LoadCommandInfo &L) const;
   MachO::entry_point_command
   getEntryPointCommand(const LoadCommandInfo &L) const;
 
   MachO::any_relocation_info getRelocation(DataRefImpl Rel) const;
   MachO::data_in_code_entry getDice(DataRefImpl Rel) const;
   MachO::mach_header getHeader() const;

include/llvm/Support/MachO.h

inline void swapStruct(dylinker_command &d) {
       sys::swapByteOrder(d.name);
     }
 
     inline void swapStruct(uuid_command &u) {
       sys::swapByteOrder(u.cmd);
       sys::swapByteOrder(u.cmdsize);
     }
 
+    inline void swapStruct(rpath_command &r) {
+      sys::swapByteOrder(r.cmd);
+      sys::swapByteOrder(r.cmdsize);
+      sys::swapByteOrder(r.path);
+    }
+
     inline void swapStruct(source_version_command &s) {
       sys::swapByteOrder(s.cmd);
       sys::swapByteOrder(s.cmdsize);
       sys::swapByteOrder(s.version);
     }
 
     inline void swapStruct(entry_point_command &e) {
       sys::swapByteOrder(e.cmd);

lib/Object/MachOObjectFile.cpp

MachOObjectFile::getDylinkerCommand(const LoadCommandInfo &L) const {
   return getStruct<MachO::dylinker_command>(this, L.Ptr);
 }
 
 MachO::uuid_command
 MachOObjectFile::getUuidCommand(const LoadCommandInfo &L) const {
   return getStruct<MachO::uuid_command>(this, L.Ptr);
 }
 
+MachO::rpath_command
+MachOObjectFile::getRpathCommand(const LoadCommandInfo &L) const {
+  return getStruct<MachO::rpath_command>(this, L.Ptr);
+}
+
 MachO::source_version_command
 MachOObjectFile::getSourceVersionCommand(const LoadCommandInfo &L) const {
   return getStruct<MachO::source_version_command>(this, L.Ptr);
 }
 
 MachO::entry_point_command
 MachOObjectFile::getEntryPointCommand(const LoadCommandInfo &L) const {
   return getStruct<MachO::entry_point_command>(this, L.Ptr);

test/Object/objdump-private-headers.test

 RUN: llvm-objdump -p %p/Inputs/program-headers.elf-i386 \
 RUN:              | FileCheck %s -check-prefix ELF-i386
 RUN: llvm-objdump -p %p/Inputs/program-headers.elf-x86-64 \
 RUN:              | FileCheck %s -check-prefix ELF-x86-64
+RUN: llvm-objdump -p %p/Inputs/macho-rpath-x86_64 \
+RUN:              | FileCheck %s -check-prefix MACHO-x86_64
 
 ELF-i386: Program Header:
 ELF-i386:     LOAD off    0x00000000 vaddr 0x08048000 paddr 0x08048000 align 2**12
 ELF-i386:          filesz 0x00000134 memsz 0x00000134 flags r-x
 ELF-i386:    STACK off    0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**2
 ELF-i386:          filesz 0x00000000 memsz 0x00000000 flags rw-
 
 ELF-x86-64: Program Header:
 ELF-x86-64:     LOAD off    0x0000000000000000 vaddr 0x0000000000400000 paddr 0x0000000000400000 align 2**21
 ELF-x86-64:          filesz 0x0000000000000138 memsz 0x0000000000000138 flags r-x
 ELF-x86-64: EH_FRAME off    0x00000000000000f4 vaddr 0x00000000004000f4 paddr 0x00000000004000f4 align 2**2
 ELF-x86-64:          filesz 0x0000000000000014 memsz 0x0000000000000014 flags r--
 ELF-x86-64:    STACK off    0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**3
 ELF-x86-64:          filesz 0x0000000000000000 memsz 0x0000000000000000 flags rw-
+
+MACHO-x86_64: Load command 12
+MACHO-x86_64:          cmd LC_RPATH
+MACHO-x86_64:      cmdsize 32
+MACHO-x86_64:         path @executable_path/. (offset 12)

tools/llvm-objdump/MachODump.cpp

static void PrintUuidLoadCommand(MachO::uuid_command uuid) {
   outs() << format("%02" PRIX32, uuid.uuid[11]);
   outs() << format("%02" PRIX32, uuid.uuid[12]);
   outs() << format("%02" PRIX32, uuid.uuid[13]);
   outs() << format("%02" PRIX32, uuid.uuid[14]);
   outs() << format("%02" PRIX32, uuid.uuid[15]);
   outs() << "\n";
 }
 
+static void PrintRpathLoadCommand(MachO::rpath_command rpath,
+                                  const char *Ptr) {
+  outs() << "          cmd LC_RPATH\n";
+  outs() << "      cmdsize " << rpath.cmdsize;
+  if (rpath.cmdsize < sizeof(struct MachO::rpath_command))
+    outs() << " Incorrect size\n";
+  else
+    outs() << "\n";
+  if (rpath.path >= rpath.cmdsize)
+    outs() << "         path ?(bad offset " << rpath.path << ")\n";
+  else {
+    const char *P = (const char *)(Ptr) + rpath.path;
+    outs() << "         path " << P << " (offset " << rpath.path << ")\n";
+  }
+}
+
 static void PrintVersionMinLoadCommand(MachO::version_min_command vd) {
   if (vd.cmd == MachO::LC_VERSION_MIN_MACOSX)
     outs() << "      cmd LC_VERSION_MIN_MACOSX\n";
   else if (vd.cmd == MachO::LC_VERSION_MIN_IPHONEOS)
     outs() << "      cmd LC_VERSION_MIN_IPHONEOS\n";
   else
     outs() << "      cmd " << vd.cmd << " (?)\n";
   outs() << "  cmdsize " << vd.cmdsize;
for (unsigned i = 0;; ++i) {
     } else if (Command.C.cmd == MachO::LC_LOAD_DYLINKER ||
                Command.C.cmd == MachO::LC_ID_DYLINKER ||
                Command.C.cmd == MachO::LC_DYLD_ENVIRONMENT) {
       MachO::dylinker_command Dyld = Obj->getDylinkerCommand(Command);
       PrintDyldLoadCommand(Dyld, Command.Ptr);
     } else if (Command.C.cmd == MachO::LC_UUID) {
       MachO::uuid_command Uuid = Obj->getUuidCommand(Command);
       PrintUuidLoadCommand(Uuid);
+    } else if (Command.C.cmd == MachO::LC_RPATH) {
+      MachO::rpath_command Rpath = Obj->getRpathCommand(Command);
+      PrintRpathLoadCommand(Rpath, Command.Ptr);
     } else if (Command.C.cmd == MachO::LC_VERSION_MIN_MACOSX) {
       MachO::version_min_command Vd = Obj->getVersionMinLoadCommand(Command);
       PrintVersionMinLoadCommand(Vd);
     } else if (Command.C.cmd == MachO::LC_SOURCE_VERSION) {
       MachO::source_version_command Sd = Obj->getSourceVersionCommand(Command);
       PrintSourceVersionCommand(Sd);
     } else if (Command.C.cmd == MachO::LC_MAIN) {
       MachO::entry_point_command Ep = Obj->getEntryPointCommand(Command);