[lld-macho] Implement -headerpad

[int3]

Summary

Tools like install_name_tool and codesign may modify the Mach-O
header and increase its size. The linker has to provide padding to make this
possible. This diff does that, plus sets its default value to 32 bytes (which
is what ld64 does).

Unlike ld64, however, we lay out our sections *exactly* -headerpad bytes from
the header, whereas ld64 just treats the padding requirement as a lower bound.
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. I
am not sure whether it's important to emulate that behavior, so I'm sticking
with our simpler lay-out-from-front implementation for now.

[compnerd]

I think that the page offset trick that ld64 does is important. That sounds very much like page handling for the loader to be more efficient, and I think that we should emulate that behaviour (with a comment in the code).

lld/MachO/Driver.cpp

399

Would be nice to comment the default value (32).

[int3]

Happy to emulate that behavior, but I'd like to check my understanding of the performance implications. Is it just a matter of saving one page? I guess it'd be significant if the first or last page in __TEXT was hot code and benefits from being in the L1 TLB, but I'm not sure how often that is the case.

[int3]

Also, would you be fine with the emulation of ld64's alignment behavior being punted to a future diff? I think it's pretty orthogonal in terms of the code changes required.

[compnerd]

Yes, that is roughly the tradeoff. It matters more for smaller binaries, but it also helps ensure that the code page is aligned and ensures that any offset differences don't matter and you can do same page merging. I don't have any objections against it being a follow up patch.

[int3]

lld/MachO/Driver.cpp

399

oops, forgot about this, addressed in c89e46e767e2

lld/Common/Args.cpp

 // function metadata.
 CodeGenOpt::Level lld::args::getCGOptLevel(int optLevelLTO) {
   if (optLevelLTO == 3)
     return CodeGenOpt::Aggressive;
   assert(optLevelLTO < 3);
   return CodeGenOpt::Default;
 }
 
-int64_t lld::args::getInteger(opt::InputArgList &args, unsigned key,
-                              int64_t Default) {
+static int64_t getInteger(opt::InputArgList &args, unsigned key,
+                          int64_t Default, unsigned base) {
   auto *a = args.getLastArg(key);
   if (!a)
     return Default;
 
   int64_t v;
-  if (to_integer(a->getValue(), v, 10))
+  if (to_integer(a->getValue(), v, base))
     return v;
 
   StringRef spelling = args.getArgString(a->getIndex());
   error(spelling + ": number expected, but got '" + a->getValue() + "'");
   return 0;
 }
 
+int64_t lld::args::getInteger(opt::InputArgList &args, unsigned key,
+                              int64_t Default) {
+  return ::getInteger(args, key, Default, 10);
+}
+
+int64_t lld::args::getHex(opt::InputArgList &args, unsigned key,
+                          int64_t Default) {
+  return ::getInteger(args, key, Default, 16);
+}
+
 std::vector<StringRef> lld::args::getStrings(opt::InputArgList &args, int id) {
   std::vector<StringRef> v;
   for (auto *arg : args.filtered(id))
     v.push_back(arg->getValue());
   return v;
 }
 
 uint64_t lld::args::getZOptionValue(opt::InputArgList &args, int id,

lld/MachO/Config.h

 namespace macho {
 
 class Symbol;
 struct SymbolPriorityEntry;
 
 struct Configuration {
   Symbol *entry;
   bool hasReexports = false;
+  uint32_t headerPad;
   llvm::StringRef installName;
   llvm::StringRef outputFile;
   llvm::MachO::Architecture arch;
   llvm::MachO::HeaderFileType outputType;
   std::vector<llvm::StringRef> librarySearchPaths;
   std::vector<llvm::StringRef> frameworkSearchPaths;
   llvm::DenseMap<llvm::StringRef, SymbolPriorityEntry> priorities;
 };

lld/MachO/Driver.cpp

bool macho::link(llvm::ArrayRef<const char *> argsArr, bool canExitEarly,
   config = make<Configuration>();
   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, 32);
   getLibrarySearchPaths(config->librarySearchPaths, args);
   getFrameworkSearchPaths(config->frameworkSearchPaths, args);
   config->outputType = args.hasArg(OPT_dylib) ? MH_DYLIB : MH_EXECUTE;
 
   if (args.hasArg(OPT_v)) {
     message(getLLDVersion());
     message(StringRef("Library search paths:") +
             (config->librarySearchPaths.size()
for (const auto &arg : args) {
     case OPT_platform_version:
       handlePlatformVersion(arg);
       break;
     case OPT_o:
     case OPT_dylib:
     case OPT_e:
     case OPT_F:
     case OPT_L:
+    case OPT_headerpad:
     case OPT_install_name:
     case OPT_Z:
     case OPT_arch:
       // handled elsewhere
       break;
     default:
       warnIfUnimplementedOption(opt);
       break;

lld/MachO/Options.td

 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">,
-     Flags<[HelpHidden]>,
      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]>,

lld/MachO/SyntheticSections.cpp

MachHeaderSection::MachHeaderSection()
     : SyntheticSection(segment_names::text, section_names::header) {}
 
 void MachHeaderSection::addLoadCommand(LoadCommand *lc) {
   loadCommands.push_back(lc);
   sizeOfCmds += lc->getSize();
 }
 
 uint64_t MachHeaderSection::getSize() const {
-  return sizeof(MachO::mach_header_64) + sizeOfCmds;
+  return sizeof(MachO::mach_header_64) + sizeOfCmds + config->headerPad;
 }
 
 void MachHeaderSection::writeTo(uint8_t *buf) const {
   auto *hdr = reinterpret_cast<MachO::mach_header_64 *>(buf);
   hdr->magic = MachO::MH_MAGIC_64;
   hdr->cputype = MachO::CPU_TYPE_X86_64;
   hdr->cpusubtype = MachO::CPU_SUBTYPE_X86_64_ALL | MachO::CPU_SUBTYPE_LIB64;
   hdr->filetype = config->outputType;

lld/include/lld/Common/Args.h

 namespace lld {
 namespace args {
 
 llvm::CodeGenOpt::Level getCGOptLevel(int optLevelLTO);
 
 int64_t getInteger(llvm::opt::InputArgList &args, unsigned key,
                    int64_t Default);
 
+int64_t getHex(llvm::opt::InputArgList &args, unsigned key, int64_t Default);
+
 std::vector<StringRef> getStrings(llvm::opt::InputArgList &args, int id);
 
 uint64_t getZOptionValue(llvm::opt::InputArgList &args, int id, StringRef key,
                          uint64_t Default);
 
 std::vector<StringRef> getLines(MemoryBufferRef mb);
 
 StringRef getFilenameWithoutExe(StringRef path);
 
 } // namespace args
 } // namespace lld
 
 #endif

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 -headerpad 0
+# RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PAD0
+# PAD0:      magic        cputype  cpusubtype  caps    filetype ncmds sizeofcmds
+# PAD0-NEXT: MH_MAGIC_64  X86_64   ALL         LIB64   EXECUTE  8     [[#%u, CMDSIZE:]] {{.*}}
+# PAD0:      sectname __text
+# PAD0-NEXT: segname __TEXT
+# PAD0-NEXT: addr
+# PAD0-NEXT: size
+# PAD0-NEXT: offset [[#%u, CMDSIZE + 32]]
+
+# RUN: lld -flavor darwinnew -o %t %t.o -headerpad 11
+# RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PAD11
+# PAD11:      magic        cputype  cpusubtype  caps    filetype ncmds sizeofcmds
+# PAD11-NEXT: MH_MAGIC_64  X86_64   ALL         LIB64   EXECUTE  8     [[#%u, CMDSIZE:]] {{.*}}
+# PAD11:      sectname __text
+# PAD11-NEXT: segname __TEXT
+# PAD11-NEXT: addr
+# PAD11-NEXT: size
+# PAD11-NEXT: offset [[#%u, CMDSIZE + 32 + 0x11]]
+
+.globl _main
+_main:
+  ret

lld/test/MachO/local-got.s

 # REQUIRES: x86
 # RUN: mkdir -p %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %p/Inputs/libhello.s \
 # RUN:   -o %t/libhello.o
 # RUN: lld -flavor darwinnew -L%S/Inputs/MacOSX.sdk/usr/lib -lSystem -dylib -install_name \
 # RUN:   @executable_path/libhello.dylib %t/libhello.o -o %t/libhello.dylib
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
 # RUN: lld -flavor darwinnew -L%S/Inputs/MacOSX.sdk/usr/lib -lSystem -o %t/test %t/test.o -L%t -lhello
 # RUN: llvm-objdump --full-contents --bind %t/test | FileCheck %s --match-full-lines
 
 ## Check that the GOT references the cstrings. --full-contents displays the
 ## address offset and the contents at that address very similarly, so am using
 ## --match-full-lines to make sure we match on the right thing.
 # CHECK:      Contents of section __cstring:
-# CHECK-NEXT: 1000003cc {{.*}}
+# CHECK-NEXT: 1000003ec {{.*}}
 
 ## 1st 8 bytes refer to the start of __cstring + 0xe, 2nd 8 bytes refer to the
 ## start of __cstring
 # CHECK:      Contents of section __got:
-# CHECK-NEXT: [[#%X,ADDR:]]  da030000 01000000 cc030000 01000000 {{.*}}
+# CHECK-NEXT: [[#%X,ADDR:]]  fa030000 01000000 ec030000 01000000 {{.*}}
 # CHECK-NEXT: [[#ADDR + 16]] 00000000 00000000 {{.*}}
 
 ## Check that a non-locally-defined symbol is still bound at the correct offset:
 # CHECK: Bind table:
 # CHECK-NEXT: segment      section  address         type     addend  dylib     symbol
 # CHECK-NEXT: __DATA_CONST __got    0x[[#ADDR+16]]  pointer  0       libhello  _hello_its_me
 
 .globl _main

lld/test/MachO/relocations.s

 # CHECK:       leaq [[#%u, STR_OFF:]](%rip), %rsi
 # CHECK-NEXT:  [[#%x, CSTRING_ADDR - STR_OFF]]
 ## Test non-extern (section) X86_64_RELOC_SIGNED
 # CHECK:       leaq [[#%u, LSTR_OFF:]](%rip), %rsi
 # CHECK-NEXT:  [[#%x, CSTRING_ADDR + 22 - LSTR_OFF]]
 
 # RUN: llvm-objdump --section=__const --full-contents -d %t | FileCheck %s --check-prefix=NONPCREL
 # NONPCREL:      Contents of section __const:
-# NONPCREL-NEXT: 100001000 b0030000 01000000 b0030000 01000000
+# NONPCREL-NEXT: 100001000 d0030000 01000000 d0030000 01000000
 
 .section __TEXT,__text
 .globl _main, _f
 _main:
   callq _f # X86_64_RELOC_BRANCH
   mov $0, %rax
   ret