Support -headerpad cmdline option

[pete]

Summary

Hi Lang

(Note this depends on http://reviews.llvm.org/D15943).

This extends the header pad generation we have to also support the -headerpad *size* option.

Similarly to ld64, if both -headerpad_max_install_names and -headerpad are passed, then we take the maximum of the two.

Comments welcome.

Thanks,
Pete

[pete]

Updated test case to include tests for -headerpad combined with -headerpad_max_install_names

[pete]

Updated given that D15943 no longer passes a context to writeBinary

include/lld/ReaderWriter/MachOLinkingContext.h

   uint64_t baseAddress() const { return _baseAddress; }
   void setBaseAddress(uint64_t baseAddress) { _baseAddress = baseAddress; }
 
+  uint64_t headerPad() const { return _headerPad; }
+  void setHeaderPad(uint64_t headerPad) { _headerPad = headerPad; }
+
   bool padHeaderPaths() const { return _padHeaderPaths; }
   void setPadHeaderPaths(bool padHeaderPaths) {
     _padHeaderPaths = padHeaderPaths;

   uint64_t _pageSize;
   uint64_t _baseAddress;
   uint64_t _stackSize;
+  // Note, _headerPad is 32 as that leaves enough space for code signing to be
+  // done after linking.
+  uint64_t _headerPad;
   uint32_t _compatibilityVersion;
   uint32_t _currentVersion;
   StringRef _installName;

lib/Driver/DarwinLdDriver.cpp

     ctx.setStackSize(stackSizeVal);
   }
 
+  // Handle headerpad
+  if (llvm::opt::Arg *headerPad = parsedArgs.getLastArg(OPT_headerpad)) {
+    uint64_t headerPadVal;
+    if (parseNumberBase16(headerPad->getValue(), headerPadVal)) {
+      diagnostics << "error: headerpad expects a hex number\n";
+      return false;
+    }
+
+    ctx.setHeaderPad(headerPadVal);
+  }
+
   // Handle -headerpad_max_install_names
   if (parsedArgs.getLastArg(OPT_headerpad_max_install_names))
     ctx.setPadHeaderPaths(true);

lib/Driver/DarwinLdOptions.td

      HelpText<"Add path to the runpath search path list for image being created">;
 def headerpad_max_install_names : Flag<["-"], "headerpad_max_install_names">,
      HelpText<"Pads paths up to MAXPATHLEN for use with install_name_tool">;
+def headerpad : Separate<["-"], "headerpad">,
+     HelpText<"Pads the header by the given (hex) number of bytes (default=32b)">;
 
 def t : Flag<["-"], "t">,
      HelpText<"Print the names of the input files as ld processes them">;

lib/ReaderWriter/MachO/MachOLinkingContext.cpp

     : _outputMachOType(MH_EXECUTE), _outputMachOTypeStatic(false),
       _doNothing(false), _pie(false), _arch(arch_unknown), _os(OS::macOSX),
       _osMinVersion(0), _pageZeroSize(0), _pageSize(4096), _baseAddress(0),
-      _stackSize(0), _compatibilityVersion(0), _currentVersion(0),
-      _flatNamespace(false), _padHeaderPaths(false),
+      _stackSize(0), _headerPad(32), _compatibilityVersion(0),
+      _currentVersion(0), _flatNamespace(false), _padHeaderPaths(false),
       _undefinedMode(UndefinedMode::error),
       _deadStrippableDylib(false), _printAtoms(false), _testingFileUsage(false),
       _keepPrivateExterns(false), _demangle(false), _archHandler(nullptr),

lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp

       _swap(!MachOLinkingContext::isHostEndian(file.arch)),
       _bigEndianArch(MachOLinkingContext::isBigEndian(file.arch)),
       _padHeaderPaths(ctx.padHeaderPaths()),
-      _seg1addr(INT64_MAX) {
+      _seg1addr(INT64_MAX),
+      _headerPad(ctx.headerPad()) {
   _startOfLoadCommands = _is64 ? sizeof(mach_header_64) : sizeof(mach_header);
   const size_t segCommandBaseSize =
           (_is64 ? sizeof(segment_command_64) : sizeof(segment_command));

 }
 
 void MachOFileLayout::padHeader() {
-  _headerPad = 0;
   if (!_padHeaderPaths)
     return;
 

   // pad the header with enough space for each path to grow to MAXPATHLEN.
   // FIXME!: We need to get the max path in a reliable way.
   const unsigned maxpathlen = 1024;
-  size_t padding = 0;
+  uint32_t padding = 0;
   for (const DependentDylib &dep : _file.dependentDylibs) {
     size_t size = pointerAlign(dep.path.size()+1);
     if (size < maxpathlen)

       padding += maxpathlen - size;
   }
 
-  _headerPad = padding;
+  _headerPad = std::max(padding, _headerPad);
 }
 
 static bool overlaps(const Segment &s1, const Segment &s2) {