[macho] -rpath support

[Jean-Daniel]

Summary

Work on adding -rpath support to the mach-o linker.
This patch is based on the ld64 behavior for the command line option validation.

It includes a basic test to check that the LC_RPATH load commands are properly generated when that option is used.

It also add LC_RPATH support to the binary reader, but I don't know how to test it though.

[kledzik]

LGTM.

The static linker does not need to interpret LC_RPATH in linked dylibs, so there is no need to write a test case that it can.

lld/trunk/include/lld/ReaderWriter/MachOLinkingContext.h

public:
   void setPrintAtoms(bool value=true) { _printAtoms = value; }
   void setTestingFileUsage(bool value = true) {
     _testingFileUsage = value;
   }
   void addExistingPathForDebug(StringRef path) {
     _existingPaths.insert(path);
   }
 
+  void addRpath(StringRef rpath);
+  const StringRefVector &rpaths() const { return _rpaths; }
+
   /// Add section alignment constraint on final layout.
   void addSectionAlignment(StringRef seg, StringRef sect, uint8_t align2);
 
   /// Returns true if specified section had alignment constraints.
   bool sectionAligned(StringRef seg, StringRef sect, uint8_t &align2) const;
 
   StringRef dyldPath() const { return "/usr/lib/dyld"; }
 
private:
   OS _os;
   uint32_t _osMinVersion;
   uint64_t _pageZeroSize;
   uint64_t _pageSize;
   uint64_t _baseAddress;
   uint32_t _compatibilityVersion;
   uint32_t _currentVersion;
   StringRef _installName;
+  StringRefVector _rpaths;
   bool _deadStrippableDylib;
   bool _printAtoms;
   bool _testingFileUsage;
   bool _keepPrivateExterns;
   bool _demangle;
   StringRef _bundleLoader;
   mutable std::unique_ptr<mach_o::ArchHandler> _archHandler;
   mutable std::unique_ptr<Writer> _writer;

lld/trunk/lib/Driver/DarwinLdDriver.cpp

if (std::error_code ec = parseOrderFile(orderFile->getValue(), ctx,
       diagnostics << "error: " << ec.message()
                   << ", processing '-order_file "
                   << orderFile->getValue()
                   << "'\n";
       return false;
     }
   }
 
+  // Handle -rpath <path>
+  if (parsedArgs->hasArg(OPT_rpath)) {
+    switch (ctx.outputMachOType()) {
+      case llvm::MachO::MH_EXECUTE:
+      case llvm::MachO::MH_DYLIB:
+      case llvm::MachO::MH_BUNDLE:
+        if (!ctx.minOS("10.5", "2.0")) {
+          if (ctx.os() == MachOLinkingContext::OS::macOSX) {
+            diagnostics << "error: -rpath can only be used when targeting "
+                           "OS X 10.5 or later\n";
+          } else {
+            diagnostics << "error: -rpath can only be used when targeting "
+                           "iOS 2.0 or later\n";
+          }
+          return false;
+        }
+        break;
+      default:
+        diagnostics << "error: -rpath can only be used when creating "
+                       "a dynamic final linked image\n";
+        return false;
+    }
+
+    for (auto rPath : parsedArgs->filtered(OPT_rpath)) {
+      ctx.addRpath(rPath->getValue());
+    }
+  }
+
   // Handle input files
   for (auto &arg : *parsedArgs) {
     bool upward;
     ErrorOr<StringRef> resolvedPath = StringRef();
     switch (arg->getOption().getID()) {
     default:
       continue;
     case OPT_INPUT:

lld/trunk/lib/Driver/DarwinLdOptions.td

 def seg1addr : Separate<["-"], "seg1addr">, Alias<image_base>;
 def demangle : Flag<["-"], "demangle">,
      HelpText<"Demangles symbol names in errors and warnings">;
 def dependency_info : Separate<["-"], "dependency_info">,
      MetaVarName<"<file>">,
      HelpText<"Write binary list of files used during link">;
 def S : Flag<["-"], "S">,
      HelpText<"Remove debug information (STABS or DWARF) from the output file">;
+def rpath : Separate<["-"], "rpath">,
+     MetaVarName<"<path>">,
+     HelpText<"Add path to the runpath search path list for image being created">;
 
 def t : Flag<["-"], "t">,
      HelpText<"Print the names of the input files as ld processes them">;
 def v : Flag<["-"], "v">,
      HelpText<"Print linker information">;
 
 // Obsolete options
 def grp_obsolete : OptionGroup<"obsolete">, HelpText<"OBSOLETE OPTIONS">;
 def single_module : Flag<["-"], "single_module">,
      HelpText<"Default for dylibs">, Group<grp_obsolete>;
 def multi_module : Flag<["-"], "multi_module">,
      HelpText<"Unsupported way to build dylibs">, Group<grp_obsolete>;

lld/trunk/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

bool MachOLinkingContext::fileExists(StringRef path) const {
 
   return found;
 }
 
 void MachOLinkingContext::setSysLibRoots(const StringRefVector &paths) {
   _syslibRoots = paths;
 }
 
+void MachOLinkingContext::addRpath(StringRef rpath) {
+  _rpaths.push_back(rpath);
+}
+
 void MachOLinkingContext::addModifiedSearchDir(StringRef libPath,
                                                bool isSystemPath) {
   bool addedModifiedPath = false;
 
   // -syslibroot only applies to absolute paths.
   if (libPath.startswith("/")) {
     for (auto syslibRoot : _syslibRoots) {
       SmallString<256> path(syslibRoot);

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileBinaryReader.cpp

case LC_LOAD_UPWARD_DYLIB: {
       DependentDylib entry;
       entry.path = lc + read32(&dl->dylib.name, isBig);
       entry.kind = LoadCommandType(cmd);
       entry.compatVersion = read32(&dl->dylib.compatibility_version, isBig);
       entry.currentVersion = read32(&dl->dylib.current_version, isBig);
       f->dependentDylibs.push_back(entry);
      }
       break;
+    case LC_RPATH: {
+      const rpath_command *rpc = reinterpret_cast<const rpath_command *>(lc);
+      f->rpaths.push_back(lc + read32(&rpc->path, isBig));
+     }
+      break;
     case LC_DYLD_INFO:
     case LC_DYLD_INFO_ONLY:
       dyldInfo = reinterpret_cast<const dyld_info_command*>(lc);
       break;
     }
     return false;
   });
   if (ec)

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp

uint32_t MachOFileLayout::loadCommandsSize(uint32_t &count) {
   }
 
   // Add LC_LOAD_DYLIB for each dependent dylib.
   for (const DependentDylib &dep : _file.dependentDylibs) {
     size += sizeof(dylib_command) + pointerAlign(dep.path.size()+1);
     ++count;
   }
 
+  // Add LC_RPATH
+  for (const StringRef &path : _file.rpaths) {
+    size += sizeof(rpath_command) + pointerAlign(path.size()+1);
+    ++count;
+  }
+
   // Add LC_DATA_IN_CODE if needed
   if (!_file.dataInCode.empty()) {
     size += sizeof(linkedit_data_command);
     ++count;
   }
 
   return size;
 }
for (const DependentDylib &dep : _file.dependentDylibs) {
       dc->dylib.current_version       = dep.currentVersion;
       dc->dylib.compatibility_version = dep.compatVersion;
       if (_swap)
         swapStruct(*dc);
       memcpy(lc+sizeof(dylib_command), dep.path.begin(), dep.path.size());
       lc[sizeof(dylib_command)+dep.path.size()] = '\0';
       lc += size;
     }
+
+    // Add LC_RPATH
+    for (const StringRef &path : _file.rpaths) {
+      rpath_command *rpc = reinterpret_cast<rpath_command *>(lc);
+      uint32_t size = sizeof(rpath_command) + pointerAlign(path.size()+1);
+      rpc->cmd                         = LC_RPATH;
+      rpc->cmdsize                     = size;
+      rpc->path                        = sizeof(rpath_command); // offset
+      if (_swap)
+        swapStruct(*rpc);
+      memcpy(lc+sizeof(rpath_command), path.begin(), path.size());
+      lc[sizeof(rpath_command)+path.size()] = '\0';
+      lc += size;
+    }
+
     // Add LC_DATA_IN_CODE if needed.
     if (_dataInCodeSize != 0) {
       linkedit_data_command* dl = reinterpret_cast<linkedit_data_command*>(lc);
       dl->cmd      = LC_DATA_IN_CODE;
       dl->cmdsize  = sizeof(linkedit_data_command);
       dl->dataoff  = _startOfDataInCode;
       dl->datasize = _dataInCodeSize;
       if (_swap)

lld/trunk/lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

normalizedFromAtoms(const lld::File &atomFile,
   NormalizedFile &normFile = *f.get();
   normFile.arch = context.arch();
   normFile.fileType = context.outputMachOType();
   normFile.flags = util.fileFlags();
   normFile.installName = context.installName();
   normFile.currentVersion = context.currentVersion();
   normFile.compatVersion = context.compatibilityVersion();
   normFile.pageSize = context.pageSize();
+  normFile.rpaths = context.rpaths();
   util.addDependentDylibs(atomFile, normFile);
   util.copySegmentInfo(normFile);
   util.copySectionInfo(normFile);
   util.assignAddressesToSections(normFile);
   util.buildAtomToAddressMap();
   util.updateSectionInfo(normFile);
   util.copySectionContent(normFile);
   if (auto ec = util.addSymbols(atomFile, normFile)) {

lld/trunk/test/mach-o/rpath.yaml

+# Check we handle -rpath correctly:
+# RUN: lld -flavor darwin -arch x86_64 -rpath @loader_path/../Frameworks \
+# RUN:     %p/Inputs/libSystem.yaml %s -o %t
+# RUN: llvm-objdump -private-headers %t | FileCheck %s --check-prefix=CHECK-BINARY-WRITE
+
+--- !mach-o
+arch:            x86_64
+file-type:       MH_OBJECT
+flags:           [ MH_SUBSECTIONS_VIA_SYMBOLS ]
+has-UUID:        false
+OS:              unknown
+sections:
+  - segment:         __TEXT
+    section:         __text
+    type:            S_REGULAR
+    attributes:      [ S_ATTR_PURE_INSTRUCTIONS, S_ATTR_SOME_INSTRUCTIONS ]
+    alignment:       4
+    address:         0x0000000000000000
+    content:         [ 0xCC, 0xC3, 0x90, 0xC3, 0x90, 0x90, 0xC3, 0x90,
+                       0x90, 0x90, 0xC3, 0x90, 0x90, 0x90, 0x90, 0xC3,
+                       0x31, 0xC0, 0xC3 ]
+local-symbols:
+  - name:            _myStatic
+    type:            N_SECT
+    sect:            1
+    value:           0x000000000000000B
+global-symbols:
+  - name:            _main
+    type:            N_SECT
+    scope:           [ N_EXT ]
+    sect:            1
+    value:           0x0000000000000001
+...
+
+
+# CHECK-BINARY-WRITE: cmd LC_RPATH
+# CHECK-BINARY-WRITE-NEXT:  cmdsize 44
+# CHECK-BINARY-WRITE-NEXT:  path @loader_path/../Frameworks (offset 12)