[LLD] Fix a padding bug in the old Mach-O backend in LLD.

[sheredom]

Summary

This commit fixes a bug with the old Mach-O backend, where it is
possible for a header to be written that does not contain enough
space for the UUID and codesign sections to be present.

To fix it, we simply add a padding to the header to ensure there is
always enough space.

Note: this bug is not present in the new Mach-O backend, but
we couldn't use that for other reasons.

[tschuett]

lld/lib/ReaderWriter/MachO/MachONormalizedFile.h

264

could that be something like headerPad = sizeof(xxx) + sizeof(yyy)?

[sheredom]

lld/lib/ReaderWriter/MachO/MachONormalizedFile.h

264

I can't find anything in LLD that states the size of these sections (although from binary inspecting we could tell we needed 16 + 24 bytes).

[thakis]

Can you share the other reasons? From what I understand, the plan is to delete the old backend eventually, so it'd be good to fix problems in the new one :)

[sheredom]

In D105431#2858777, @thakis wrote:

Can you share the other reasons? From what I understand, the plan is to delete the old backend eventually, so it'd be good to fix problems in the new one :)

Sure! It was all Apple Silicon related -> I just assumed that whatever was broken was being worked on as the new backend was spun up, and it'd automagically be fixed by the time we needed to use it!

[thakis]

Is it still broken on master? Apple Silicon should work fairly well by now.

[lhames]

@thakis is right that we should make sure this works in the new MachO LLD.

That said I have no problem with this being added to the old one in the interim. LGTM.

[int3]

@smeenai and I were discussing the possibility of deleting the old Mach-O backend soon, now that the new one is more or less ready. Will that be an issue for you @sheredom? (I don't know what Apple Silicon issues you were running into, so I'm not sure if they're fixed in the new one...)

[thevinster]

@sheredom Following up on here. Any plans to migrate off the old MachO port over to the new port? I would also love to learn more about what some of the problems are for migrating over to the new MachO port. Part of doing this is also out of selfish reasons as it's been messing up with my IDE and harder for newer devs to ramp up on the new LLD for Mach-O.

[int3]

we've deleted the old mach-o backend, so this can probably be abandoned

lld/lib/ReaderWriter/MachO/MachONormalizedFile.h

struct NormalizedFile {
   std::vector<RebaseLocation> rebasingInfo;
   std::vector<BindLocation>   bindingInfo;
   std::vector<BindLocation>   weakBindingInfo;
   std::vector<BindLocation>   lazyBindingInfo;
   std::vector<Export>         exportInfo;
   std::vector<uint8_t>        functionStarts;
   std::vector<DataInCode>     dataInCode;
 
+  uint32_t                    headerPad = 16 + 24; // Space for UUID + CODESIGN
+
   // TODO:
   // code-signature
   // split-seg-info
   // function-starts
 
   // For any allocations in this struct which need to be owned by this struct.
   BumpPtrAllocator            ownedAllocations;
 };

lld/lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp

private:
   uint8_t              *_buffer;
   const bool            _is64;
   const bool            _swap;
   const bool            _bigEndianArch;
   uint64_t              _seg1addr;
   uint32_t              _startOfLoadCommands;
   uint32_t              _countOfLoadCommands;
   uint32_t              _endOfLoadCommands;
+  uint32_t              _endOfHeader;
   uint32_t              _startOfRelocations;
   uint32_t              _startOfFunctionStarts;
   uint32_t              _startOfDataInCode;
   uint32_t              _startOfSymbols;
   uint32_t              _startOfIndirectSymbols;
   uint32_t              _startOfSymbolStrings;
   uint32_t              _endOfSymbolStrings;
   uint32_t              _symbolTableLocalsStartIndex;

 }
 
 uint32_t MachOFileLayout::pointerAlign(uint32_t value) {
   return llvm::alignTo(value, _is64 ? 8 : 4);
 }
 
 
 size_t MachOFileLayout::headerAndLoadCommandsSize() const {
-  return _endOfLoadCommands;
+  return _endOfHeader;
 }
 
 MachOFileLayout::MachOFileLayout(const NormalizedFile &file,
                                  bool alwaysIncludeFunctionStarts)
     : _file(file),
       _is64(MachOLinkingContext::is64Bit(file.arch)),
       _swap(!MachOLinkingContext::isHostEndian(file.arch)),
       _bigEndianArch(MachOLinkingContext::isBigEndian(file.arch)),
if (file.fileType == llvm::MachO::MH_OBJECT) {
     if (!_file.functionStarts.empty() || alwaysIncludeFunctionStarts) {
       _endOfLoadCommands += sizeof(linkedit_data_command);
       _countOfLoadCommands++;
     }
     if (_file.generateDataInCodeLoadCommand) {
       _endOfLoadCommands += sizeof(linkedit_data_command);
       _countOfLoadCommands++;
     }
+    _endOfHeader = _endOfLoadCommands;
     // Assign file offsets to each section.
-    _startOfSectionsContent = _endOfLoadCommands;
+    _startOfSectionsContent = _endOfHeader;
     unsigned relocCount = 0;
     uint64_t offset = _startOfSectionsContent;
     for (const Section &sect : file.sections) {
       if (isZeroFillSection(sect.type))
         _sectInfo[&sect].fileOffset = 0;
       else {
         offset = llvm::alignTo(offset, sect.alignment);
         _sectInfo[&sect].fileOffset = offset;
if (file.fileType == llvm::MachO::MH_OBJECT) {
     // Add Indirect symbol table.
     _startOfIndirectSymbols = _startOfSymbols + _symbolTableSize;
     // Align start of symbol table and symbol strings.
     _startOfSymbolStrings = _startOfIndirectSymbols
                   + pointerAlign(_indirectSymbolTableCount * sizeof(uint32_t));
     _endOfSymbolStrings = _startOfSymbolStrings
                           + pointerAlign(_symbolStringPoolSize);
     _endOfLinkEdit = _endOfSymbolStrings;
     DEBUG_WITH_TYPE("MachOFileLayout",
                   llvm::dbgs() << "MachOFileLayout()\n"
       << "  startOfLoadCommands=" << _startOfLoadCommands << "\n"
       << "  countOfLoadCommands=" << _countOfLoadCommands << "\n"
       << "  endOfLoadCommands=" << _endOfLoadCommands << "\n"
+      << "  endOfHeader=" << _endOfHeader << "\n"
       << "  startOfRelocations=" << _startOfRelocations << "\n"
       << "  startOfSymbols=" << _startOfSymbols << "\n"
       << "  startOfSymbolStrings=" << _startOfSymbolStrings << "\n"
       << "  endOfSymbolStrings=" << _endOfSymbolStrings << "\n"
       << "  startOfSectionsContent=" << _startOfSectionsContent << "\n"
       << "  endOfSectionsContent=" << _endOfSectionsContent << "\n");
   } else {
     // Final linked images have one load command per segment.
     _endOfLoadCommands = _startOfLoadCommands
                           + loadCommandsSize(_countOfLoadCommands,
                                              alwaysIncludeFunctionStarts);
 
+    _endOfHeader = _endOfLoadCommands + _file.headerPad;
+
     // Assign section file offsets.
     buildFileOffsets();
     buildLinkEditInfo();
 
     // LINKEDIT of final linked images has in order:
     // rebase info, binding info, lazy binding info, weak binding info,
     // data-in-code, symbol table, indirect symbol table, symbol table strings.
     _startOfRebaseInfo = _startOfLinkEdit;
     _endOfRebaseInfo = _startOfRebaseInfo + _rebaseInfo.size();
     _startOfBindingInfo = _endOfRebaseInfo;
     _endOfBindingInfo = _startOfBindingInfo + _bindingInfo.size();
     _startOfLazyBindingInfo = _endOfBindingInfo;
     _endOfLazyBindingInfo = _startOfLazyBindingInfo + _lazyBindingInfo.size();
     _startOfExportTrie = _endOfLazyBindingInfo;
     _endOfExportTrie = _startOfExportTrie + _exportTrie.size();
     _startOfFunctionStarts = _endOfExportTrie;
     _startOfDataInCode = _startOfFunctionStarts + _functionStartsSize;
     _startOfSymbols = _startOfDataInCode + _dataInCodeSize;
     _startOfIndirectSymbols = _startOfSymbols + _symbolTableSize;
     _startOfSymbolStrings = _startOfIndirectSymbols
                   + pointerAlign(_indirectSymbolTableCount * sizeof(uint32_t));
     _endOfSymbolStrings = _startOfSymbolStrings
                           + pointerAlign(_symbolStringPoolSize);
     _endOfLinkEdit = _endOfSymbolStrings;
     DEBUG_WITH_TYPE("MachOFileLayout",
                   llvm::dbgs() << "MachOFileLayout()\n"
       << "  startOfLoadCommands=" << _startOfLoadCommands << "\n"
       << "  countOfLoadCommands=" << _countOfLoadCommands << "\n"
       << "  endOfLoadCommands=" << _endOfLoadCommands << "\n"
+      << "  endOfHeader=" << _endOfHeader << "\n"
       << "  startOfLinkEdit=" << _startOfLinkEdit << "\n"
       << "  startOfRebaseInfo=" << _startOfRebaseInfo << "\n"
       << "  endOfRebaseInfo=" << _endOfRebaseInfo << "\n"
       << "  startOfBindingInfo=" << _startOfBindingInfo << "\n"
       << "  endOfBindingInfo=" << _endOfBindingInfo << "\n"
       << "  startOfLazyBindingInfo=" << _startOfLazyBindingInfo << "\n"
       << "  endOfLazyBindingInfo=" << _endOfLazyBindingInfo << "\n"
       << "  startOfExportTrie=" << _startOfExportTrie << "\n"
llvm::Error MachOFileLayout::writeSingleSegmentLoadCommand(uint8_t *&lc) {
   typename T::command* seg = reinterpret_cast<typename T::command*>(lc);
   seg->cmd = T::LC;
   seg->cmdsize = sizeof(typename T::command)
                           + _file.sections.size() * sizeof(typename T::section);
   uint8_t *next = lc + seg->cmdsize;
   memset(seg->segname, 0, 16);
   seg->flags = 0;
   seg->vmaddr = 0;
-  seg->fileoff = _endOfLoadCommands;
+  seg->fileoff = _endOfHeader;
   seg->maxprot = VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE;
   seg->initprot = VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE;
   seg->nsects = _file.sections.size();
   if (seg->nsects) {
     seg->vmsize = _file.sections.back().address
                 + _file.sections.back().content.size();
     seg->filesize = _sectInfo[&_file.sections.back()].fileOffset +
                     _file.sections.back().content.size() -
if (_file.generateDataInCodeLoadCommand) {
       dl->cmdsize  = sizeof(linkedit_data_command);
       dl->dataoff  = _startOfDataInCode;
       dl->datasize = _dataInCodeSize;
       if (_swap)
         swapStruct(*dl);
       lc += sizeof(linkedit_data_command);
     }
   }
+
   assert(lc == &_buffer[_endOfLoadCommands]);
   return llvm::Error::success();
 }
 
 void MachOFileLayout::writeSectionContent() {
   for (const Section &s : _file.sections) {
     // Copy all section content to output buffer.
     if (isZeroFillSection(s.type))
       continue;
     if (s.content.empty())
       continue;
     uint32_t offset = _sectInfo[&s].fileOffset;
-    assert(offset >= _endOfLoadCommands);
+    assert(offset >= _endOfHeader);
     uint8_t *p = &_buffer[offset];
     memcpy(p, &s.content[0], s.content.size());
     p += s.content.size();
   }
 }
 
 void MachOFileLayout::writeRelocations() {
   uint32_t relOffset = _startOfRelocations;