tools/llvm-objcopy/MachO/MachOLayoutBuilder.cpp - llvm-project/llvm - Git at Google

 //===- MachOLayoutBuilder.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "MachOLayoutBuilder.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"

 namespace llvm {
 namespace objcopy {
 namespace macho {

 StringTableBuilder::Kind
 MachOLayoutBuilder::getStringTableBuilderKind(const Object &O, bool Is64Bit) {
   if (O.Header.FileType == MachO::HeaderFileType::MH_OBJECT)
     return Is64Bit ? StringTableBuilder::MachO64 : StringTableBuilder::MachO;
   return Is64Bit ? StringTableBuilder::MachO64Linked
                  : StringTableBuilder::MachOLinked;
 }

 uint32_t MachOLayoutBuilder::computeSizeOfCmds() const {
   uint32_t Size = 0;
   for (const LoadCommand &LC : O.LoadCommands) {
     const MachO::macho_load_command &MLC = LC.MachOLoadCommand;
     auto cmd = MLC.load_command_data.cmd;
     switch (cmd) {
     case MachO::LC_SEGMENT:
       Size += sizeof(MachO::segment_command) +
               sizeof(MachO::section) * LC.Sections.size();
       continue;
     case MachO::LC_SEGMENT_64:
       Size += sizeof(MachO::segment_command_64) +
               sizeof(MachO::section_64) * LC.Sections.size();
       continue;
     }

     switch (cmd) {
 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
   case MachO::LCName:                                                          \
     Size += sizeof(MachO::LCStruct) + LC.Payload.size();                       \
     break;
 #include "llvm/BinaryFormat/MachO.def"
 #undef HANDLE_LOAD_COMMAND
     }
   }

   return Size;
 }

 void MachOLayoutBuilder::constructStringTable() {
   for (std::unique_ptr<SymbolEntry> &Sym : O.SymTable.Symbols)
     StrTableBuilder.add(Sym->Name);
   StrTableBuilder.finalize();
 }

 void MachOLayoutBuilder::updateSymbolIndexes() {
   uint32_t Index = 0;
   for (auto &Symbol : O.SymTable.Symbols)
     Symbol->Index = Index++;
 }

 // Updates the index and the number of local/external/undefined symbols.
 void MachOLayoutBuilder::updateDySymTab(MachO::macho_load_command &MLC) {
   assert(MLC.load_command_data.cmd == MachO::LC_DYSYMTAB);
   // Make sure that nlist entries in the symbol table are sorted by the those
   // types. The order is: local < defined external < undefined external.
   assert(llvm::is_sorted(O.SymTable.Symbols,
                          [](const std::unique_ptr<SymbolEntry> &A,
                             const std::unique_ptr<SymbolEntry> &B) {
                            bool AL = A->isLocalSymbol(),
                                 BL = B->isLocalSymbol();
                            if (AL != BL)
                              return AL;
                            return !AL && !A->isUndefinedSymbol() &&
                                   B->isUndefinedSymbol();
                          }) &&
          "Symbols are not sorted by their types.");

   uint32_t NumLocalSymbols = 0;
   auto Iter = O.SymTable.Symbols.begin();
   auto End = O.SymTable.Symbols.end();
   for (; Iter != End; ++Iter) {
     if ((*Iter)->isExternalSymbol())
       break;

     ++NumLocalSymbols;
   }

   uint32_t NumExtDefSymbols = 0;
   for (; Iter != End; ++Iter) {
     if ((*Iter)->isUndefinedSymbol())
       break;

     ++NumExtDefSymbols;
   }

   MLC.dysymtab_command_data.ilocalsym = 0;
   MLC.dysymtab_command_data.nlocalsym = NumLocalSymbols;
   MLC.dysymtab_command_data.iextdefsym = NumLocalSymbols;
   MLC.dysymtab_command_data.nextdefsym = NumExtDefSymbols;
   MLC.dysymtab_command_data.iundefsym = NumLocalSymbols + NumExtDefSymbols;
   MLC.dysymtab_command_data.nundefsym =
       O.SymTable.Symbols.size() - (NumLocalSymbols + NumExtDefSymbols);
 }

 // Recomputes and updates offset and size fields in load commands and sections
 // since they could be modified.
 uint64_t MachOLayoutBuilder::layoutSegments() {
   auto HeaderSize =
       Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
   const bool IsObjectFile =
       O.Header.FileType == MachO::HeaderFileType::MH_OBJECT;
   uint64_t Offset = IsObjectFile ? (HeaderSize + O.Header.SizeOfCmds) : 0;
   for (LoadCommand &LC : O.LoadCommands) {
     auto &MLC = LC.MachOLoadCommand;
     StringRef Segname;
     uint64_t SegmentVmAddr;
     uint64_t SegmentVmSize;
     switch (MLC.load_command_data.cmd) {
     case MachO::LC_SEGMENT:
       SegmentVmAddr = MLC.segment_command_data.vmaddr;
       SegmentVmSize = MLC.segment_command_data.vmsize;
       Segname = StringRef(MLC.segment_command_data.segname,
                           strnlen(MLC.segment_command_data.segname,
                                   sizeof(MLC.segment_command_data.segname)));
       break;
     case MachO::LC_SEGMENT_64:
       SegmentVmAddr = MLC.segment_command_64_data.vmaddr;
       SegmentVmSize = MLC.segment_command_64_data.vmsize;
       Segname = StringRef(MLC.segment_command_64_data.segname,
                           strnlen(MLC.segment_command_64_data.segname,
                                   sizeof(MLC.segment_command_64_data.segname)));
       break;
     default:
       continue;
     }

     if (Segname == "__LINKEDIT") {
       // We update the __LINKEDIT segment later (in layoutTail).
       assert(LC.Sections.empty() && "__LINKEDIT segment has sections");
       LinkEditLoadCommand = &MLC;
       continue;
     }

     // Update file offsets and sizes of sections.
     uint64_t SegOffset = Offset;
     uint64_t SegFileSize = 0;
     uint64_t VMSize = 0;
     for (std::unique_ptr<Section> &Sec : LC.Sections) {
       assert(SegmentVmAddr <= Sec->Addr &&
              "Section's address cannot be smaller than Segment's one");
       uint32_t SectOffset = Sec->Addr - SegmentVmAddr;
       if (IsObjectFile) {
         if (!Sec->hasValidOffset()) {
           Sec->Offset = 0;
         } else {
           uint64_t PaddingSize =
               offsetToAlignment(SegFileSize, Align(1ull << Sec->Align));
           Sec->Offset = SegOffset + SegFileSize + PaddingSize;
           Sec->Size = Sec->Content.size();
           SegFileSize += PaddingSize + Sec->Size;
         }
       } else {
         if (!Sec->hasValidOffset()) {
           Sec->Offset = 0;
         } else {
           Sec->Offset = SegOffset + SectOffset;
           Sec->Size = Sec->Content.size();
           SegFileSize = std::max(SegFileSize, SectOffset + Sec->Size);
         }
       }
       VMSize = std::max(VMSize, SectOffset + Sec->Size);
     }

     if (IsObjectFile) {
       Offset += SegFileSize;
     } else {
       Offset = alignTo(Offset + SegFileSize, PageSize);
       SegFileSize = alignTo(SegFileSize, PageSize);
       // Use the original vmsize if the segment is __PAGEZERO.
       VMSize =
           Segname == "__PAGEZERO" ? SegmentVmSize : alignTo(VMSize, PageSize);
     }

     switch (MLC.load_command_data.cmd) {
     case MachO::LC_SEGMENT:
       MLC.segment_command_data.cmdsize =
           sizeof(MachO::segment_command) +
           sizeof(MachO::section) * LC.Sections.size();
       MLC.segment_command_data.nsects = LC.Sections.size();
       MLC.segment_command_data.fileoff = SegOffset;
       MLC.segment_command_data.vmsize = VMSize;
       MLC.segment_command_data.filesize = SegFileSize;
       break;
     case MachO::LC_SEGMENT_64:
       MLC.segment_command_64_data.cmdsize =
           sizeof(MachO::segment_command_64) +
           sizeof(MachO::section_64) * LC.Sections.size();
       MLC.segment_command_64_data.nsects = LC.Sections.size();
       MLC.segment_command_64_data.fileoff = SegOffset;
       MLC.segment_command_64_data.vmsize = VMSize;
       MLC.segment_command_64_data.filesize = SegFileSize;
       break;
     }
   }

   return Offset;
 }

 uint64_t MachOLayoutBuilder::layoutRelocations(uint64_t Offset) {
   for (LoadCommand &LC : O.LoadCommands)
     for (std::unique_ptr<Section> &Sec : LC.Sections) {
       Sec->RelOff = Sec->Relocations.empty() ? 0 : Offset;
       Sec->NReloc = Sec->Relocations.size();
       Offset += sizeof(MachO::any_relocation_info) * Sec->NReloc;
     }

   return Offset;
 }

 Error MachOLayoutBuilder::layoutTail(uint64_t Offset) {
   // If we are building the layout of an executable or dynamic library
   // which does not have any segments other than __LINKEDIT,
   // the Offset can be equal to zero by this time. It happens because of the
   // convention that in such cases the file offsets specified by LC_SEGMENT
   // start with zero (unlike the case of a relocatable object file).
   const uint64_t HeaderSize =
       Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
   assert((!(O.Header.FileType == MachO::HeaderFileType::MH_OBJECT) ||
           Offset >= HeaderSize + O.Header.SizeOfCmds) &&
          "Incorrect tail offset");
   Offset = std::max(Offset, HeaderSize + O.Header.SizeOfCmds);

   // The order of LINKEDIT elements is as follows:
   // rebase info, binding info, weak binding info, lazy binding info, export
   // trie, data-in-code, symbol table, indirect symbol table, symbol table
   // strings, code signature.
   uint64_t NListSize = Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
   uint64_t StartOfLinkEdit = Offset;
   uint64_t StartOfRebaseInfo = StartOfLinkEdit;
   uint64_t StartOfBindingInfo = StartOfRebaseInfo + O.Rebases.Opcodes.size();
   uint64_t StartOfWeakBindingInfo = StartOfBindingInfo + O.Binds.Opcodes.size();
   uint64_t StartOfLazyBindingInfo =
       StartOfWeakBindingInfo + O.WeakBinds.Opcodes.size();
   uint64_t StartOfExportTrie =
       StartOfLazyBindingInfo + O.LazyBinds.Opcodes.size();
   uint64_t StartOfFunctionStarts = StartOfExportTrie + O.Exports.Trie.size();
   uint64_t StartOfDataInCode =
       StartOfFunctionStarts + O.FunctionStarts.Data.size();
   uint64_t StartOfSymbols = StartOfDataInCode + O.DataInCode.Data.size();
   uint64_t StartOfIndirectSymbols =
       StartOfSymbols + NListSize * O.SymTable.Symbols.size();
   uint64_t StartOfSymbolStrings =
       StartOfIndirectSymbols +
       sizeof(uint32_t) * O.IndirectSymTable.Symbols.size();
   uint64_t StartOfCodeSignature =
       StartOfSymbolStrings + StrTableBuilder.getSize();
   if (O.CodeSignatureCommandIndex)
     StartOfCodeSignature = alignTo(StartOfCodeSignature, 16);
   uint64_t LinkEditSize =
       (StartOfCodeSignature + O.CodeSignature.Data.size()) - StartOfLinkEdit;

   // Now we have determined the layout of the contents of the __LINKEDIT
   // segment. Update its load command.
   if (LinkEditLoadCommand) {
     MachO::macho_load_command *MLC = LinkEditLoadCommand;
     switch (LinkEditLoadCommand->load_command_data.cmd) {
     case MachO::LC_SEGMENT:
       MLC->segment_command_data.cmdsize = sizeof(MachO::segment_command);
       MLC->segment_command_data.fileoff = StartOfLinkEdit;
       MLC->segment_command_data.vmsize = alignTo(LinkEditSize, PageSize);
       MLC->segment_command_data.filesize = LinkEditSize;
       break;
     case MachO::LC_SEGMENT_64:
       MLC->segment_command_64_data.cmdsize = sizeof(MachO::segment_command_64);
       MLC->segment_command_64_data.fileoff = StartOfLinkEdit;
       MLC->segment_command_64_data.vmsize = alignTo(LinkEditSize, PageSize);
       MLC->segment_command_64_data.filesize = LinkEditSize;
       break;
     }
   }

   for (LoadCommand &LC : O.LoadCommands) {
     auto &MLC = LC.MachOLoadCommand;
     auto cmd = MLC.load_command_data.cmd;
     switch (cmd) {
     case MachO::LC_CODE_SIGNATURE:
       MLC.linkedit_data_command_data.dataoff = StartOfCodeSignature;
       MLC.linkedit_data_command_data.datasize = O.CodeSignature.Data.size();
       break;
     case MachO::LC_SYMTAB:
       MLC.symtab_command_data.symoff = StartOfSymbols;
       MLC.symtab_command_data.nsyms = O.SymTable.Symbols.size();
       MLC.symtab_command_data.stroff = StartOfSymbolStrings;
       MLC.symtab_command_data.strsize = StrTableBuilder.getSize();
       break;
     case MachO::LC_DYSYMTAB: {
       if (MLC.dysymtab_command_data.ntoc != 0 ||
           MLC.dysymtab_command_data.nmodtab != 0 ||
           MLC.dysymtab_command_data.nextrefsyms != 0 ||
           MLC.dysymtab_command_data.nlocrel != 0 ||
           MLC.dysymtab_command_data.nextrel != 0)
         return createStringError(llvm::errc::not_supported,
                                  "shared library is not yet supported");

       if (!O.IndirectSymTable.Symbols.empty()) {
         MLC.dysymtab_command_data.indirectsymoff = StartOfIndirectSymbols;
         MLC.dysymtab_command_data.nindirectsyms =
             O.IndirectSymTable.Symbols.size();
       }

       updateDySymTab(MLC);
       break;
     }
     case MachO::LC_DATA_IN_CODE:
       MLC.linkedit_data_command_data.dataoff = StartOfDataInCode;
       MLC.linkedit_data_command_data.datasize = O.DataInCode.Data.size();
       break;
     case MachO::LC_FUNCTION_STARTS:
       MLC.linkedit_data_command_data.dataoff = StartOfFunctionStarts;
       MLC.linkedit_data_command_data.datasize = O.FunctionStarts.Data.size();
       break;
     case MachO::LC_DYLD_INFO:
     case MachO::LC_DYLD_INFO_ONLY:
       MLC.dyld_info_command_data.rebase_off =
           O.Rebases.Opcodes.empty() ? 0 : StartOfRebaseInfo;
       MLC.dyld_info_command_data.rebase_size = O.Rebases.Opcodes.size();
       MLC.dyld_info_command_data.bind_off =
           O.Binds.Opcodes.empty() ? 0 : StartOfBindingInfo;
       MLC.dyld_info_command_data.bind_size = O.Binds.Opcodes.size();
       MLC.dyld_info_command_data.weak_bind_off =
           O.WeakBinds.Opcodes.empty() ? 0 : StartOfWeakBindingInfo;
       MLC.dyld_info_command_data.weak_bind_size = O.WeakBinds.Opcodes.size();
       MLC.dyld_info_command_data.lazy_bind_off =
           O.LazyBinds.Opcodes.empty() ? 0 : StartOfLazyBindingInfo;
       MLC.dyld_info_command_data.lazy_bind_size = O.LazyBinds.Opcodes.size();
       MLC.dyld_info_command_data.export_off =
           O.Exports.Trie.empty() ? 0 : StartOfExportTrie;
       MLC.dyld_info_command_data.export_size = O.Exports.Trie.size();
       break;
     // Note that LC_ENCRYPTION_INFO.cryptoff despite its name and the comment in
     // <mach-o/loader.h> is not an offset in the binary file, instead, it is a
     // relative virtual address. At the moment modification of the __TEXT
     // segment of executables isn't supported anyway (e.g. data in code entries
     // are not recalculated). Moreover, in general
     // LC_ENCRYPT_INFO/LC_ENCRYPTION_INFO_64 are nontrivial to update because
     // without making additional assumptions (e.g. that the entire __TEXT
     // segment should be encrypted) we do not know how to recalculate the
     // boundaries of the encrypted part. For now just copy over these load
     // commands until we encounter a real world usecase where
     // LC_ENCRYPT_INFO/LC_ENCRYPTION_INFO_64 need to be adjusted.
     case MachO::LC_ENCRYPTION_INFO:
     case MachO::LC_ENCRYPTION_INFO_64:
     case MachO::LC_LOAD_DYLINKER:
     case MachO::LC_MAIN:
     case MachO::LC_RPATH:
     case MachO::LC_SEGMENT:
     case MachO::LC_SEGMENT_64:
     case MachO::LC_VERSION_MIN_MACOSX:
     case MachO::LC_VERSION_MIN_IPHONEOS:
     case MachO::LC_VERSION_MIN_TVOS:
     case MachO::LC_VERSION_MIN_WATCHOS:
     case MachO::LC_BUILD_VERSION:
     case MachO::LC_ID_DYLIB:
     case MachO::LC_LOAD_DYLIB:
     case MachO::LC_LOAD_WEAK_DYLIB:
     case MachO::LC_UUID:
     case MachO::LC_SOURCE_VERSION:
       // Nothing to update.
       break;
     default:
       // Abort if it's unsupported in order to prevent corrupting the object.
       return createStringError(llvm::errc::not_supported,
                                "unsupported load command (cmd=0x%x)", cmd);
     }
   }

   return Error::success();
 }

 Error MachOLayoutBuilder::layout() {
   O.Header.NCmds = O.LoadCommands.size();
   O.Header.SizeOfCmds = computeSizeOfCmds();
   constructStringTable();
   updateSymbolIndexes();
   uint64_t Offset = layoutSegments();
   Offset = layoutRelocations(Offset);
   return layoutTail(Offset);
 }

 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm
	//===- MachOLayoutBuilder.cpp ------------------------------------ C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "MachOLayoutBuilder.h"
	#include "llvm/Support/Alignment.h"
	#include "llvm/Support/Errc.h"
	#include "llvm/Support/ErrorHandling.h"

	namespace llvm {
	namespace objcopy {
	namespace macho {

	StringTableBuilder::Kind
	MachOLayoutBuilder::getStringTableBuilderKind(const Object &O, bool Is64Bit) {
	if (O.Header.FileType == MachO::HeaderFileType::MH_OBJECT)
	return Is64Bit ? StringTableBuilder::MachO64 : StringTableBuilder::MachO;
	return Is64Bit ? StringTableBuilder::MachO64Linked
	: StringTableBuilder::MachOLinked;
	}

	uint32_t MachOLayoutBuilder::computeSizeOfCmds() const {
	uint32_t Size = 0;
	for (const LoadCommand &LC : O.LoadCommands) {
	const MachO::macho_load_command &MLC = LC.MachOLoadCommand;
	auto cmd = MLC.load_command_data.cmd;
	switch (cmd) {
	case MachO::LC_SEGMENT:
	Size += sizeof(MachO::segment_command) +
	sizeof(MachO::section) * LC.Sections.size();
	continue;
	case MachO::LC_SEGMENT_64:
	Size += sizeof(MachO::segment_command_64) +
	sizeof(MachO::section_64) * LC.Sections.size();
	continue;
	}

	switch (cmd) {
	#define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct) \
	case MachO::LCName: \
	Size += sizeof(MachO::LCStruct) + LC.Payload.size(); \
	break;
	#include "llvm/BinaryFormat/MachO.def"
	#undef HANDLE_LOAD_COMMAND
	}
	}

	return Size;
	}

	void MachOLayoutBuilder::constructStringTable() {
	for (std::unique_ptr<SymbolEntry> &Sym : O.SymTable.Symbols)
	StrTableBuilder.add(Sym->Name);
	StrTableBuilder.finalize();
	}

	void MachOLayoutBuilder::updateSymbolIndexes() {
	uint32_t Index = 0;
	for (auto &Symbol : O.SymTable.Symbols)
	Symbol->Index = Index++;
	}

	// Updates the index and the number of local/external/undefined symbols.
	void MachOLayoutBuilder::updateDySymTab(MachO::macho_load_command &MLC) {
	assert(MLC.load_command_data.cmd == MachO::LC_DYSYMTAB);
	// Make sure that nlist entries in the symbol table are sorted by the those
	// types. The order is: local < defined external < undefined external.
	assert(llvm::is_sorted(O.SymTable.Symbols,
	[](const std::unique_ptr<SymbolEntry> &A,
	const std::unique_ptr<SymbolEntry> &B) {
	bool AL = A->isLocalSymbol(),
	BL = B->isLocalSymbol();
	if (AL != BL)
	return AL;
	return !AL && !A->isUndefinedSymbol() &&
	B->isUndefinedSymbol();
	}) &&
	"Symbols are not sorted by their types.");

	uint32_t NumLocalSymbols = 0;
	auto Iter = O.SymTable.Symbols.begin();
	auto End = O.SymTable.Symbols.end();
	for (; Iter != End; ++Iter) {
	if ((*Iter)->isExternalSymbol())
	break;

	++NumLocalSymbols;
	}

	uint32_t NumExtDefSymbols = 0;
	for (; Iter != End; ++Iter) {
	if ((*Iter)->isUndefinedSymbol())
	break;

	++NumExtDefSymbols;
	}

	MLC.dysymtab_command_data.ilocalsym = 0;
	MLC.dysymtab_command_data.nlocalsym = NumLocalSymbols;
	MLC.dysymtab_command_data.iextdefsym = NumLocalSymbols;
	MLC.dysymtab_command_data.nextdefsym = NumExtDefSymbols;
	MLC.dysymtab_command_data.iundefsym = NumLocalSymbols + NumExtDefSymbols;
	MLC.dysymtab_command_data.nundefsym =
	O.SymTable.Symbols.size() - (NumLocalSymbols + NumExtDefSymbols);
	}

	// Recomputes and updates offset and size fields in load commands and sections
	// since they could be modified.
	uint64_t MachOLayoutBuilder::layoutSegments() {
	auto HeaderSize =
	Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
	const bool IsObjectFile =
	O.Header.FileType == MachO::HeaderFileType::MH_OBJECT;
	uint64_t Offset = IsObjectFile ? (HeaderSize + O.Header.SizeOfCmds) : 0;
	for (LoadCommand &LC : O.LoadCommands) {
	auto &MLC = LC.MachOLoadCommand;
	StringRef Segname;
	uint64_t SegmentVmAddr;
	uint64_t SegmentVmSize;
	switch (MLC.load_command_data.cmd) {
	case MachO::LC_SEGMENT:
	SegmentVmAddr = MLC.segment_command_data.vmaddr;
	SegmentVmSize = MLC.segment_command_data.vmsize;
	Segname = StringRef(MLC.segment_command_data.segname,
	strnlen(MLC.segment_command_data.segname,
	sizeof(MLC.segment_command_data.segname)));
	break;
	case MachO::LC_SEGMENT_64:
	SegmentVmAddr = MLC.segment_command_64_data.vmaddr;
	SegmentVmSize = MLC.segment_command_64_data.vmsize;
	Segname = StringRef(MLC.segment_command_64_data.segname,
	strnlen(MLC.segment_command_64_data.segname,
	sizeof(MLC.segment_command_64_data.segname)));
	break;
	default:
	continue;
	}

	if (Segname == "__LINKEDIT") {
	// We update the __LINKEDIT segment later (in layoutTail).
	assert(LC.Sections.empty() && "__LINKEDIT segment has sections");
	LinkEditLoadCommand = &MLC;
	continue;
	}

	// Update file offsets and sizes of sections.
	uint64_t SegOffset = Offset;
	uint64_t SegFileSize = 0;
	uint64_t VMSize = 0;
	for (std::unique_ptr<Section> &Sec : LC.Sections) {
	assert(SegmentVmAddr <= Sec->Addr &&
	"Section's address cannot be smaller than Segment's one");
	uint32_t SectOffset = Sec->Addr - SegmentVmAddr;
	if (IsObjectFile) {
	if (!Sec->hasValidOffset()) {
	Sec->Offset = 0;
	} else {
	uint64_t PaddingSize =
	offsetToAlignment(SegFileSize, Align(1ull << Sec->Align));
	Sec->Offset = SegOffset + SegFileSize + PaddingSize;
	Sec->Size = Sec->Content.size();
	SegFileSize += PaddingSize + Sec->Size;
	}
	} else {
	if (!Sec->hasValidOffset()) {
	Sec->Offset = 0;
	} else {
	Sec->Offset = SegOffset + SectOffset;
	Sec->Size = Sec->Content.size();
	SegFileSize = std::max(SegFileSize, SectOffset + Sec->Size);
	}
	}
	VMSize = std::max(VMSize, SectOffset + Sec->Size);
	}

	if (IsObjectFile) {
	Offset += SegFileSize;
	} else {
	Offset = alignTo(Offset + SegFileSize, PageSize);
	SegFileSize = alignTo(SegFileSize, PageSize);
	// Use the original vmsize if the segment is __PAGEZERO.
	VMSize =
	Segname == "__PAGEZERO" ? SegmentVmSize : alignTo(VMSize, PageSize);
	}

	switch (MLC.load_command_data.cmd) {
	case MachO::LC_SEGMENT:
	MLC.segment_command_data.cmdsize =
	sizeof(MachO::segment_command) +
	sizeof(MachO::section) * LC.Sections.size();
	MLC.segment_command_data.nsects = LC.Sections.size();
	MLC.segment_command_data.fileoff = SegOffset;
	MLC.segment_command_data.vmsize = VMSize;
	MLC.segment_command_data.filesize = SegFileSize;
	break;
	case MachO::LC_SEGMENT_64:
	MLC.segment_command_64_data.cmdsize =
	sizeof(MachO::segment_command_64) +
	sizeof(MachO::section_64) * LC.Sections.size();
	MLC.segment_command_64_data.nsects = LC.Sections.size();
	MLC.segment_command_64_data.fileoff = SegOffset;
	MLC.segment_command_64_data.vmsize = VMSize;
	MLC.segment_command_64_data.filesize = SegFileSize;
	break;
	}
	}

	return Offset;
	}

	uint64_t MachOLayoutBuilder::layoutRelocations(uint64_t Offset) {
	for (LoadCommand &LC : O.LoadCommands)
	for (std::unique_ptr<Section> &Sec : LC.Sections) {
	Sec->RelOff = Sec->Relocations.empty() ? 0 : Offset;
	Sec->NReloc = Sec->Relocations.size();
	Offset += sizeof(MachO::any_relocation_info) * Sec->NReloc;
	}

	return Offset;
	}

	Error MachOLayoutBuilder::layoutTail(uint64_t Offset) {
	// If we are building the layout of an executable or dynamic library
	// which does not have any segments other than __LINKEDIT,
	// the Offset can be equal to zero by this time. It happens because of the
	// convention that in such cases the file offsets specified by LC_SEGMENT
	// start with zero (unlike the case of a relocatable object file).
	const uint64_t HeaderSize =
	Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
	assert((!(O.Header.FileType == MachO::HeaderFileType::MH_OBJECT) \|\|
	Offset >= HeaderSize + O.Header.SizeOfCmds) &&
	"Incorrect tail offset");
	Offset = std::max(Offset, HeaderSize + O.Header.SizeOfCmds);

	// The order of LINKEDIT elements is as follows:
	// rebase info, binding info, weak binding info, lazy binding info, export
	// trie, data-in-code, symbol table, indirect symbol table, symbol table
	// strings, code signature.
	uint64_t NListSize = Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
	uint64_t StartOfLinkEdit = Offset;
	uint64_t StartOfRebaseInfo = StartOfLinkEdit;
	uint64_t StartOfBindingInfo = StartOfRebaseInfo + O.Rebases.Opcodes.size();
	uint64_t StartOfWeakBindingInfo = StartOfBindingInfo + O.Binds.Opcodes.size();
	uint64_t StartOfLazyBindingInfo =
	StartOfWeakBindingInfo + O.WeakBinds.Opcodes.size();
	uint64_t StartOfExportTrie =
	StartOfLazyBindingInfo + O.LazyBinds.Opcodes.size();
	uint64_t StartOfFunctionStarts = StartOfExportTrie + O.Exports.Trie.size();
	uint64_t StartOfDataInCode =
	StartOfFunctionStarts + O.FunctionStarts.Data.size();
	uint64_t StartOfSymbols = StartOfDataInCode + O.DataInCode.Data.size();
	uint64_t StartOfIndirectSymbols =
	StartOfSymbols + NListSize * O.SymTable.Symbols.size();
	uint64_t StartOfSymbolStrings =
	StartOfIndirectSymbols +
	sizeof(uint32_t) * O.IndirectSymTable.Symbols.size();
	uint64_t StartOfCodeSignature =
	StartOfSymbolStrings + StrTableBuilder.getSize();
	if (O.CodeSignatureCommandIndex)
	StartOfCodeSignature = alignTo(StartOfCodeSignature, 16);
	uint64_t LinkEditSize =
	(StartOfCodeSignature + O.CodeSignature.Data.size()) - StartOfLinkEdit;

	// Now we have determined the layout of the contents of the __LINKEDIT
	// segment. Update its load command.
	if (LinkEditLoadCommand) {
	MachO::macho_load_command *MLC = LinkEditLoadCommand;
	switch (LinkEditLoadCommand->load_command_data.cmd) {
	case MachO::LC_SEGMENT:
	MLC->segment_command_data.cmdsize = sizeof(MachO::segment_command);
	MLC->segment_command_data.fileoff = StartOfLinkEdit;
	MLC->segment_command_data.vmsize = alignTo(LinkEditSize, PageSize);
	MLC->segment_command_data.filesize = LinkEditSize;
	break;
	case MachO::LC_SEGMENT_64:
	MLC->segment_command_64_data.cmdsize = sizeof(MachO::segment_command_64);
	MLC->segment_command_64_data.fileoff = StartOfLinkEdit;
	MLC->segment_command_64_data.vmsize = alignTo(LinkEditSize, PageSize);
	MLC->segment_command_64_data.filesize = LinkEditSize;
	break;
	}
	}

	for (LoadCommand &LC : O.LoadCommands) {
	auto &MLC = LC.MachOLoadCommand;
	auto cmd = MLC.load_command_data.cmd;
	switch (cmd) {
	case MachO::LC_CODE_SIGNATURE:
	MLC.linkedit_data_command_data.dataoff = StartOfCodeSignature;
	MLC.linkedit_data_command_data.datasize = O.CodeSignature.Data.size();
	break;
	case MachO::LC_SYMTAB:
	MLC.symtab_command_data.symoff = StartOfSymbols;
	MLC.symtab_command_data.nsyms = O.SymTable.Symbols.size();
	MLC.symtab_command_data.stroff = StartOfSymbolStrings;
	MLC.symtab_command_data.strsize = StrTableBuilder.getSize();
	break;
	case MachO::LC_DYSYMTAB: {
	if (MLC.dysymtab_command_data.ntoc != 0 \|\|
	MLC.dysymtab_command_data.nmodtab != 0 \|\|
	MLC.dysymtab_command_data.nextrefsyms != 0 \|\|
	MLC.dysymtab_command_data.nlocrel != 0 \|\|
	MLC.dysymtab_command_data.nextrel != 0)
	return createStringError(llvm::errc::not_supported,
	"shared library is not yet supported");

	if (!O.IndirectSymTable.Symbols.empty()) {
	MLC.dysymtab_command_data.indirectsymoff = StartOfIndirectSymbols;
	MLC.dysymtab_command_data.nindirectsyms =
	O.IndirectSymTable.Symbols.size();
	}

	updateDySymTab(MLC);
	break;
	}
	case MachO::LC_DATA_IN_CODE:
	MLC.linkedit_data_command_data.dataoff = StartOfDataInCode;
	MLC.linkedit_data_command_data.datasize = O.DataInCode.Data.size();
	break;
	case MachO::LC_FUNCTION_STARTS:
	MLC.linkedit_data_command_data.dataoff = StartOfFunctionStarts;
	MLC.linkedit_data_command_data.datasize = O.FunctionStarts.Data.size();
	break;
	case MachO::LC_DYLD_INFO:
	case MachO::LC_DYLD_INFO_ONLY:
	MLC.dyld_info_command_data.rebase_off =
	O.Rebases.Opcodes.empty() ? 0 : StartOfRebaseInfo;
	MLC.dyld_info_command_data.rebase_size = O.Rebases.Opcodes.size();
	MLC.dyld_info_command_data.bind_off =
	O.Binds.Opcodes.empty() ? 0 : StartOfBindingInfo;
	MLC.dyld_info_command_data.bind_size = O.Binds.Opcodes.size();
	MLC.dyld_info_command_data.weak_bind_off =
	O.WeakBinds.Opcodes.empty() ? 0 : StartOfWeakBindingInfo;
	MLC.dyld_info_command_data.weak_bind_size = O.WeakBinds.Opcodes.size();
	MLC.dyld_info_command_data.lazy_bind_off =
	O.LazyBinds.Opcodes.empty() ? 0 : StartOfLazyBindingInfo;
	MLC.dyld_info_command_data.lazy_bind_size = O.LazyBinds.Opcodes.size();
	MLC.dyld_info_command_data.export_off =
	O.Exports.Trie.empty() ? 0 : StartOfExportTrie;
	MLC.dyld_info_command_data.export_size = O.Exports.Trie.size();
	break;
	// Note that LC_ENCRYPTION_INFO.cryptoff despite its name and the comment in
	// <mach-o/loader.h> is not an offset in the binary file, instead, it is a
	// relative virtual address. At the moment modification of the __TEXT
	// segment of executables isn't supported anyway (e.g. data in code entries
	// are not recalculated). Moreover, in general
	// LC_ENCRYPT_INFO/LC_ENCRYPTION_INFO_64 are nontrivial to update because
	// without making additional assumptions (e.g. that the entire __TEXT
	// segment should be encrypted) we do not know how to recalculate the
	// boundaries of the encrypted part. For now just copy over these load
	// commands until we encounter a real world usecase where
	// LC_ENCRYPT_INFO/LC_ENCRYPTION_INFO_64 need to be adjusted.
	case MachO::LC_ENCRYPTION_INFO:
	case MachO::LC_ENCRYPTION_INFO_64:
	case MachO::LC_LOAD_DYLINKER:
	case MachO::LC_MAIN:
	case MachO::LC_RPATH:
	case MachO::LC_SEGMENT:
	case MachO::LC_SEGMENT_64:
	case MachO::LC_VERSION_MIN_MACOSX:
	case MachO::LC_VERSION_MIN_IPHONEOS:
	case MachO::LC_VERSION_MIN_TVOS:
	case MachO::LC_VERSION_MIN_WATCHOS:
	case MachO::LC_BUILD_VERSION:
	case MachO::LC_ID_DYLIB:
	case MachO::LC_LOAD_DYLIB:
	case MachO::LC_LOAD_WEAK_DYLIB:
	case MachO::LC_UUID:
	case MachO::LC_SOURCE_VERSION:
	// Nothing to update.
	break;
	default:
	// Abort if it's unsupported in order to prevent corrupting the object.
	return createStringError(llvm::errc::not_supported,
	"unsupported load command (cmd=0x%x)", cmd);
	}
	}

	return Error::success();
	}

	Error MachOLayoutBuilder::layout() {
	O.Header.NCmds = O.LoadCommands.size();
	O.Header.SizeOfCmds = computeSizeOfCmds();
	constructStringTable();
	updateSymbolIndexes();
	uint64_t Offset = layoutSegments();
	Offset = layoutRelocations(Offset);
	return layoutTail(Offset);
	}

	} // end namespace macho
	} // end namespace objcopy
	} // end namespace llvm