[lld-macho] handle option -headerpad_max_install_names

[int3]

lld/MachO/Writer.cpp

380

nit: make 1024 a named constant

nit 2: I assume we are checking for MH_DYLIB here because the LC_DYLIB_ID command also contains an install name. Would be good to have a comment.

Also -- don't we need to allocate space for the LC_REEXPORT_DYLIB commands as well?

381–382

would be nice to have a test where the -headerpad argument is higher than the max install names size

lld/test/MachO/headerpad.s

64

ultra nit: delete one space for alignment

[gkm]

lld/MachO/Writer.cpp

380

Yes to all.

[gkm]

• Count instances of LCDylib inside constructor rather than at construction sites
• Elide uninteresting columns from llvm-objdump --all-headers output to reduce length and noise of the lines
• Add tests for all types of LCDylib: self, load, reexport
• Add tests for null-effect of -headerpad_max_install_names when no LCDylibs are present
• Add test for -headerpad N exceeding size of -headerpad_max_install_names

[gkm]

• revert unnecessary parens in MachHeaderSection::getSize()

[int3]

it would be nice to have some comments in the test indicating what behaviors are being tested... PADOVR and PADx aren't the most descriptive :)

[gkm]

• Add overview comments to tests

lld/MachO/Config.h

 
 struct Configuration {
   Symbol *entry;
   bool hasReexports = false;
   bool allLoad = false;
   bool forceLoadObjC = false;
   bool staticLink = false;
   bool searchDylibsFirst = false;
+  bool headerPadMaxInstallNames = false;
   uint32_t headerPad;
   llvm::StringRef installName;
   llvm::StringRef outputFile;
   llvm::MachO::Architecture arch;
   PlatformInfo platform;
   llvm::MachO::HeaderFileType outputType;
   std::vector<llvm::StringRef> systemLibraryRoots;
   std::vector<llvm::StringRef> librarySearchPaths;

lld/MachO/Driver.cpp

bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
   symtab = make<SymbolTable>();
   target = createTargetInfo(args);
 
   config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"));
   config->outputFile = args.getLastArgValue(OPT_o, "a.out");
   config->installName =
       args.getLastArgValue(OPT_install_name, config->outputFile);
   config->headerPad = args::getHex(args, OPT_headerpad, /*Default=*/32);
+  config->headerPadMaxInstallNames =
+      args.hasArg(OPT_headerpad_max_install_names);
   config->outputType = args.hasArg(OPT_dylib) ? MH_DYLIB : MH_EXECUTE;
   config->runtimePaths = args::getStrings(args, OPT_rpath);
   config->allLoad = args.hasArg(OPT_all_load);
 
   if (const opt::Arg *arg = args.getLastArg(OPT_static, OPT_dynamic))
     config->staticLink = (arg->getOption().getID() == OPT_static);
 
   std::vector<StringRef> &roots = config->systemLibraryRoots;
for (const auto &arg : args) {
     case OPT_all_load:
     case OPT_o:
     case OPT_dylib:
     case OPT_e:
     case OPT_F:
     case OPT_L:
     case OPT_ObjC:
     case OPT_headerpad:
+    case OPT_headerpad_max_install_names:
     case OPT_install_name:
     case OPT_rpath:
     case OPT_sub_library:
     case OPT_Z:
     case OPT_arch:
     case OPT_syslibroot:
     case OPT_sectcreate:
     case OPT_dynamic:

lld/MachO/Options.td

def client_name : Separate<["-"], "client_name">,
      Group<grp_rare>;
 def umbrella : Separate<["-"], "umbrella">,
      MetaVarName<"<<name>>">,
      HelpText<"Re-export this dylib through the umbrella framework <name>a">,
      Flags<[HelpHidden]>,
      Group<grp_rare>;
 def headerpad : Separate<["-"], "headerpad">,
      MetaVarName<"<size>">,
-     HelpText<"Allocate hex <size> extra space for future expansion of the load commands via install_name_tool">,
+     HelpText<"Allocate hex <size> extra space for future expansion of the load commands via install_name_tool (default is 0x20)">,
      Group<grp_rare>;
 def headerpad_max_install_names : Flag<["-"], "headerpad_max_install_names">,
      HelpText<"Allocate extra space so all load-command paths can expand to MAXPATHLEN via install_name_tool">,
-     Flags<[HelpHidden]>,
      Group<grp_rare>;
 def bind_at_load : Flag<["-"], "bind_at_load">,
      HelpText<"Tell dyld to bind all symbols at load time, rather than lazily">,
      Flags<[HelpHidden]>,
      Group<grp_rare>;
 def force_flat_namespace : Flag<["-"], "force_flat_namespace">,
      HelpText<"Tell dyld to use a flat namespace on this executable and all its dependent dylibs & bundles">,
      Flags<[HelpHidden]>,

lld/MachO/Writer.cpp

 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 
+#include <algorithm>
+
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace lld;
 using namespace lld::macho;
 
 namespace {
 class LCLinkEdit;
 class LCDyldInfo;

 };
 
 // There are several dylib load commands that share the same structure:
 //   * LC_LOAD_DYLIB
 //   * LC_ID_DYLIB
 //   * LC_REEXPORT_DYLIB
 class LCDylib : public LoadCommand {
 public:
-  LCDylib(LoadCommandType type, StringRef path) : type(type), path(path) {}
+  LCDylib(LoadCommandType type, StringRef path) : type(type), path(path) {
+    instanceCount++;
+  }
 
   uint32_t getSize() const override {
     return alignTo(sizeof(dylib_command) + path.size() + 1, 8);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<dylib_command *>(buf);
     buf += sizeof(dylib_command);
 
     c->cmd = type;
     c->cmdsize = getSize();
     c->dylib.name = sizeof(dylib_command);
 
     memcpy(buf, path.data(), path.size());
     buf[path.size()] = '\0';
   }
 
+  static uint32_t getInstanceCount() { return instanceCount; }
+
 private:
   LoadCommandType type;
   StringRef path;
+  static uint32_t instanceCount;
 };
 
+uint32_t LCDylib::instanceCount = 0;
+
 class LCLoadDylinker : public LoadCommand {
 public:
   uint32_t getSize() const override {
     return alignTo(sizeof(dylinker_command) + path.size() + 1, 8);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<dylinker_command *>(buf);
if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
           make<LCDylib>(LC_LOAD_DYLIB, dylibFile->dylibName));
       dylibFile->ordinal = dylibOrdinal++;
 
       if (dylibFile->reexport)
         in.header->addLoadCommand(
             make<LCDylib>(LC_REEXPORT_DYLIB, dylibFile->dylibName));
     }
   }
+
+  const uint32_t MACOS_MAXPATHLEN = 1024;
+  config->headerPad = std::max(
+      config->headerPad, (config->headerPadMaxInstallNames
+                              ? LCDylib::getInstanceCount() * MACOS_MAXPATHLEN
+                              : 0));
 }
 
 static size_t getSymbolPriority(const SymbolPriorityEntry &entry,
                                 const InputFile &file) {
   return std::max(entry.objectFiles.lookup(sys::path::filename(file.getName())),
                   entry.anyObjectFile);
 }
 

lld/test/MachO/headerpad.s

 # REQUIRES: x86
 
 ## NOTE: Here we check that the first non-header section -- __text -- appears
 ## *exactly* `-headerpad` bytes from the end of the header. ld64 actually
 ## starts laying out the non-header sections in the __TEXT segment from the end
 ## of the (page-aligned) segment rather than the front, so its binaries
 ## typically have more than `-headerpad` bytes of actual padding. `-headerpad`
 ## just enforces a lower bound. We should consider implementing the same
 ## alignment behavior.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+# RUN: lld -flavor darwinnew -o %t %t.o
+# RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PADx
+#
+# PADx:      magic        {{.+}}  ncmds sizeofcmds        flags
+# PADx-NEXT: MH_MAGIC_64  {{.+}}  9     [[#%u, CMDSIZE:]] {{.*}}
+# PADx:      sectname __text
+# PADx-NEXT: segname __TEXT
+# PADx-NEXT: addr
+# PADx-NEXT: size
+# PADx-NEXT: offset [[#%u, CMDSIZE + 0x20 + 0x20]]
+
 # RUN: lld -flavor darwinnew -o %t %t.o -headerpad 0
 # RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PAD0
-# PAD0:      magic        cputype  cpusubtype  caps    filetype ncmds sizeofcmds               flags
-# PAD0-NEXT: MH_MAGIC_64  X86_64   ALL         LIB64   EXECUTE  9     [[#%u, CMDSIZE:]] {{.*}}
+# RUN: lld -flavor darwinnew -o %t %t.o -headerpad 0 -headerpad_max_install_names
+# RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PAD0
+#
+# PAD0:      magic        {{.+}}  ncmds sizeofcmds        flags
+# PAD0-NEXT: MH_MAGIC_64  {{.+}}  9     [[#%u, CMDSIZE:]] {{.*}}
 # PAD0:      sectname __text
 # PAD0-NEXT: segname __TEXT
 # PAD0-NEXT: addr
 # PAD0-NEXT: size
-# PAD0-NEXT: offset [[#%u, CMDSIZE + 32]]
+# PAD0-NEXT: offset [[#%u, CMDSIZE + 0x20 + 0]]
 
 # RUN: lld -flavor darwinnew -o %t %t.o -headerpad 11
 # RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PAD11
 # RUN: lld -flavor darwinnew -o %t %t.o -headerpad 0x11
 # RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PAD11
-# RUN: lld -flavor darwinnew -o %t %t.o -headerpad 0X11
+# RUN: lld -flavor darwinnew -o %t %t.o -headerpad 0X11 -headerpad_max_install_names
 # RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PAD11
-
+#
 # PAD11:      magic        {{.+}}  ncmds sizeofcmds        flags
 # PAD11-NEXT: MH_MAGIC_64  {{.+}}  9     [[#%u, CMDSIZE:]] {{.*}}
 # PAD11:      sectname __text
 # PAD11-NEXT: segname __TEXT
 # PAD11-NEXT: addr
 # PAD11-NEXT: size
-# PAD11-NEXT: offset [[#%u, CMDSIZE + 32 + 0x11]]
+# PAD11-NEXT: offset [[#%u, CMDSIZE + 0x20 + 0x11]]
+
+# RUN: echo "" | llvm-mc -filetype=obj -triple=x86_64-apple-darwin -o %T/null.o
+# RUN: lld -flavor darwinnew -o %T/libnull.dylib %T/null.o -dylib \
+# RUN:     -headerpad_max_install_names
+# RUN: llvm-objdump --macho --all-headers %T/libnull.dylib | FileCheck %s --check-prefix=PADMAX
+# RUN: lld -flavor darwinnew -o %T/libnull.dylib %T/null.o -dylib \
+# RUN:     -headerpad_max_install_names \
+# RUN:     -syslibroot %S/Inputs/MacOSX.sdk -lSystem
+# RUN: llvm-objdump --macho --all-headers %T/libnull.dylib | FileCheck %s --check-prefix=PADMAX
+# RUN: lld -flavor darwinnew -o %T/libnull.dylib %T/null.o -dylib \
+# RUN:     -headerpad_max_install_names \
+# RUN:     -syslibroot %S/Inputs/MacOSX.sdk -lSystem -sub_library libSystem
+# RUN: llvm-objdump --macho --all-headers %T/libnull.dylib | FileCheck %s --check-prefix=PADMAX
+#
+# PADMAX:      magic        {{.+}}  ncmds        sizeofcmds         flags
+# PADMAX-NEXT: MH_MAGIC_64  {{.+}}  [[#%u, N:]]  [[#%u, CMDSIZE:]]  {{.*}}
+# PADMAX:      sectname __text
+# PADMAX-NEXT: segname __TEXT
+# PADMAX-NEXT: addr
+# PADMAX-NEXT: size
+# PADMAX-NEXT: offset [[#%u, CMDSIZE + 0x20 + mul(0x400, N - 6)]]
+
+# RUN: lld -flavor darwinnew -o %T/libnull.dylib %T/null.o -dylib \
+# RUN:     -headerpad_max_install_names -headerpad 0x1001 \
+# RUN:     -syslibroot %S/Inputs/MacOSX.sdk -lSystem -sub_library libSystem
+# RUN: llvm-objdump --macho --all-headers %T/libnull.dylib | FileCheck %s --check-prefix=PADOVR
+#
+# PADOVR:      magic        {{.+}}  ncmds        sizeofcmds         flags
+# PADOVR-NEXT: MH_MAGIC_64  {{.+}}  [[#%u, N:]]  [[#%u, CMDSIZE:]]  {{.*}}
+# PADOVR:      sectname __text
+# PADOVR-NEXT: segname __TEXT
+# PADOVR-NEXT: addr
+# PADOVR-NEXT: size
+# PADOVR-NEXT: offset [[#%u, CMDSIZE + 0x20 + 0x1001]]
 
 .globl _main
 _main:
   ret