0b57cec536
This uses the new layout of the upstream repository, which was recently migrated to GitHub, and converted into a "monorepo". That is, most of the earlier separate sub-projects with their own branches and tags were consolidated into one top-level directory, and are now branched and tagged together. Updating the vendor area to match this layout is next.
591 lines
21 KiB
C++
591 lines
21 KiB
C++
//===- MachOWriter.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 "MachOWriter.h"
|
|
#include "Object.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/BinaryFormat/MachO.h"
|
|
#include "llvm/Object/MachO.h"
|
|
#include "llvm/Support/Errc.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include <memory>
|
|
|
|
namespace llvm {
|
|
namespace objcopy {
|
|
namespace macho {
|
|
|
|
size_t MachOWriter::headerSize() const {
|
|
return Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
|
|
}
|
|
|
|
size_t MachOWriter::loadCommandsSize() const { return O.Header.SizeOfCmds; }
|
|
|
|
size_t MachOWriter::symTableSize() const {
|
|
return O.SymTable.Symbols.size() *
|
|
(Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist));
|
|
}
|
|
|
|
size_t MachOWriter::totalSize() const {
|
|
// Going from tail to head and looking for an appropriate "anchor" to
|
|
// calculate the total size assuming that all the offsets are either valid
|
|
// ("true") or 0 (0 indicates that the corresponding part is missing).
|
|
|
|
SmallVector<size_t, 7> Ends;
|
|
if (O.SymTabCommandIndex) {
|
|
const MachO::symtab_command &SymTabCommand =
|
|
O.LoadCommands[*O.SymTabCommandIndex]
|
|
.MachOLoadCommand.symtab_command_data;
|
|
if (SymTabCommand.symoff) {
|
|
assert((SymTabCommand.nsyms == O.SymTable.Symbols.size()) &&
|
|
"Incorrect number of symbols");
|
|
Ends.push_back(SymTabCommand.symoff + symTableSize());
|
|
}
|
|
if (SymTabCommand.stroff) {
|
|
assert((SymTabCommand.strsize == StrTableBuilder.getSize()) &&
|
|
"Incorrect string table size");
|
|
Ends.push_back(SymTabCommand.stroff + SymTabCommand.strsize);
|
|
}
|
|
}
|
|
if (O.DyLdInfoCommandIndex) {
|
|
const MachO::dyld_info_command &DyLdInfoCommand =
|
|
O.LoadCommands[*O.DyLdInfoCommandIndex]
|
|
.MachOLoadCommand.dyld_info_command_data;
|
|
if (DyLdInfoCommand.rebase_off) {
|
|
assert((DyLdInfoCommand.rebase_size == O.Rebases.Opcodes.size()) &&
|
|
"Incorrect rebase opcodes size");
|
|
Ends.push_back(DyLdInfoCommand.rebase_off + DyLdInfoCommand.rebase_size);
|
|
}
|
|
if (DyLdInfoCommand.bind_off) {
|
|
assert((DyLdInfoCommand.bind_size == O.Binds.Opcodes.size()) &&
|
|
"Incorrect bind opcodes size");
|
|
Ends.push_back(DyLdInfoCommand.bind_off + DyLdInfoCommand.bind_size);
|
|
}
|
|
if (DyLdInfoCommand.weak_bind_off) {
|
|
assert((DyLdInfoCommand.weak_bind_size == O.WeakBinds.Opcodes.size()) &&
|
|
"Incorrect weak bind opcodes size");
|
|
Ends.push_back(DyLdInfoCommand.weak_bind_off +
|
|
DyLdInfoCommand.weak_bind_size);
|
|
}
|
|
if (DyLdInfoCommand.lazy_bind_off) {
|
|
assert((DyLdInfoCommand.lazy_bind_size == O.LazyBinds.Opcodes.size()) &&
|
|
"Incorrect lazy bind opcodes size");
|
|
Ends.push_back(DyLdInfoCommand.lazy_bind_off +
|
|
DyLdInfoCommand.lazy_bind_size);
|
|
}
|
|
if (DyLdInfoCommand.export_off) {
|
|
assert((DyLdInfoCommand.export_size == O.Exports.Trie.size()) &&
|
|
"Incorrect trie size");
|
|
Ends.push_back(DyLdInfoCommand.export_off + DyLdInfoCommand.export_size);
|
|
}
|
|
}
|
|
|
|
// Otherwise, use the last section / reloction.
|
|
for (const auto &LC : O.LoadCommands)
|
|
for (const auto &S : LC.Sections) {
|
|
Ends.push_back(S.Offset + S.Size);
|
|
if (S.RelOff)
|
|
Ends.push_back(S.RelOff +
|
|
S.NReloc * sizeof(MachO::any_relocation_info));
|
|
}
|
|
|
|
if (!Ends.empty())
|
|
return *std::max_element(Ends.begin(), Ends.end());
|
|
|
|
// Otherwise, we have only Mach header and load commands.
|
|
return headerSize() + loadCommandsSize();
|
|
}
|
|
|
|
void MachOWriter::writeHeader() {
|
|
MachO::mach_header_64 Header;
|
|
|
|
Header.magic = O.Header.Magic;
|
|
Header.cputype = O.Header.CPUType;
|
|
Header.cpusubtype = O.Header.CPUSubType;
|
|
Header.filetype = O.Header.FileType;
|
|
Header.ncmds = O.Header.NCmds;
|
|
Header.sizeofcmds = O.Header.SizeOfCmds;
|
|
Header.flags = O.Header.Flags;
|
|
Header.reserved = O.Header.Reserved;
|
|
|
|
if (IsLittleEndian != sys::IsLittleEndianHost)
|
|
MachO::swapStruct(Header);
|
|
|
|
auto HeaderSize =
|
|
Is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
|
|
memcpy(B.getBufferStart(), &Header, HeaderSize);
|
|
}
|
|
|
|
void MachOWriter::updateSymbolIndexes() {
|
|
uint32_t Index = 0;
|
|
for (auto &Symbol : O.SymTable.Symbols) {
|
|
Symbol->Index = Index;
|
|
Index++;
|
|
}
|
|
}
|
|
|
|
void MachOWriter::writeLoadCommands() {
|
|
uint8_t *Begin = B.getBufferStart() + headerSize();
|
|
for (const auto &LC : O.LoadCommands) {
|
|
// Construct a load command.
|
|
MachO::macho_load_command MLC = LC.MachOLoadCommand;
|
|
switch (MLC.load_command_data.cmd) {
|
|
case MachO::LC_SEGMENT:
|
|
if (IsLittleEndian != sys::IsLittleEndianHost)
|
|
MachO::swapStruct(MLC.segment_command_data);
|
|
memcpy(Begin, &MLC.segment_command_data, sizeof(MachO::segment_command));
|
|
Begin += sizeof(MachO::segment_command);
|
|
|
|
for (const auto &Sec : LC.Sections)
|
|
writeSectionInLoadCommand<MachO::section>(Sec, Begin);
|
|
continue;
|
|
case MachO::LC_SEGMENT_64:
|
|
if (IsLittleEndian != sys::IsLittleEndianHost)
|
|
MachO::swapStruct(MLC.segment_command_64_data);
|
|
memcpy(Begin, &MLC.segment_command_64_data,
|
|
sizeof(MachO::segment_command_64));
|
|
Begin += sizeof(MachO::segment_command_64);
|
|
|
|
for (const auto &Sec : LC.Sections)
|
|
writeSectionInLoadCommand<MachO::section_64>(Sec, Begin);
|
|
continue;
|
|
}
|
|
|
|
#define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct) \
|
|
case MachO::LCName: \
|
|
assert(sizeof(MachO::LCStruct) + LC.Payload.size() == \
|
|
MLC.load_command_data.cmdsize); \
|
|
if (IsLittleEndian != sys::IsLittleEndianHost) \
|
|
MachO::swapStruct(MLC.LCStruct##_data); \
|
|
memcpy(Begin, &MLC.LCStruct##_data, sizeof(MachO::LCStruct)); \
|
|
Begin += sizeof(MachO::LCStruct); \
|
|
memcpy(Begin, LC.Payload.data(), LC.Payload.size()); \
|
|
Begin += LC.Payload.size(); \
|
|
break;
|
|
|
|
// Copy the load command as it is.
|
|
switch (MLC.load_command_data.cmd) {
|
|
default:
|
|
assert(sizeof(MachO::load_command) + LC.Payload.size() ==
|
|
MLC.load_command_data.cmdsize);
|
|
if (IsLittleEndian != sys::IsLittleEndianHost)
|
|
MachO::swapStruct(MLC.load_command_data);
|
|
memcpy(Begin, &MLC.load_command_data, sizeof(MachO::load_command));
|
|
Begin += sizeof(MachO::load_command);
|
|
memcpy(Begin, LC.Payload.data(), LC.Payload.size());
|
|
Begin += LC.Payload.size();
|
|
break;
|
|
#include "llvm/BinaryFormat/MachO.def"
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename StructType>
|
|
void MachOWriter::writeSectionInLoadCommand(const Section &Sec, uint8_t *&Out) {
|
|
StructType Temp;
|
|
assert(Sec.Segname.size() <= sizeof(Temp.segname) && "too long segment name");
|
|
assert(Sec.Sectname.size() <= sizeof(Temp.sectname) &&
|
|
"too long section name");
|
|
memset(&Temp, 0, sizeof(StructType));
|
|
memcpy(Temp.segname, Sec.Segname.data(), Sec.Segname.size());
|
|
memcpy(Temp.sectname, Sec.Sectname.data(), Sec.Sectname.size());
|
|
Temp.addr = Sec.Addr;
|
|
Temp.size = Sec.Size;
|
|
Temp.offset = Sec.Offset;
|
|
Temp.align = Sec.Align;
|
|
Temp.reloff = Sec.RelOff;
|
|
Temp.nreloc = Sec.NReloc;
|
|
Temp.flags = Sec.Flags;
|
|
Temp.reserved1 = Sec.Reserved1;
|
|
Temp.reserved2 = Sec.Reserved2;
|
|
|
|
if (IsLittleEndian != sys::IsLittleEndianHost)
|
|
MachO::swapStruct(Temp);
|
|
memcpy(Out, &Temp, sizeof(StructType));
|
|
Out += sizeof(StructType);
|
|
}
|
|
|
|
void MachOWriter::writeSections() {
|
|
for (const auto &LC : O.LoadCommands)
|
|
for (const auto &Sec : LC.Sections) {
|
|
if (Sec.isVirtualSection())
|
|
continue;
|
|
|
|
assert(Sec.Offset && "Section offset can not be zero");
|
|
assert((Sec.Size == Sec.Content.size()) && "Incorrect section size");
|
|
memcpy(B.getBufferStart() + Sec.Offset, Sec.Content.data(),
|
|
Sec.Content.size());
|
|
for (size_t Index = 0; Index < Sec.Relocations.size(); ++Index) {
|
|
auto RelocInfo = Sec.Relocations[Index];
|
|
if (!RelocInfo.Scattered) {
|
|
auto *Info =
|
|
reinterpret_cast<MachO::relocation_info *>(&RelocInfo.Info);
|
|
Info->r_symbolnum = RelocInfo.Symbol->Index;
|
|
}
|
|
|
|
if (IsLittleEndian != sys::IsLittleEndianHost)
|
|
MachO::swapStruct(
|
|
reinterpret_cast<MachO::any_relocation_info &>(RelocInfo.Info));
|
|
memcpy(B.getBufferStart() + Sec.RelOff +
|
|
Index * sizeof(MachO::any_relocation_info),
|
|
&RelocInfo.Info, sizeof(RelocInfo.Info));
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename NListType>
|
|
void writeNListEntry(const SymbolEntry &SE, bool IsLittleEndian, char *&Out,
|
|
uint32_t Nstrx) {
|
|
NListType ListEntry;
|
|
ListEntry.n_strx = Nstrx;
|
|
ListEntry.n_type = SE.n_type;
|
|
ListEntry.n_sect = SE.n_sect;
|
|
ListEntry.n_desc = SE.n_desc;
|
|
ListEntry.n_value = SE.n_value;
|
|
|
|
if (IsLittleEndian != sys::IsLittleEndianHost)
|
|
MachO::swapStruct(ListEntry);
|
|
memcpy(Out, reinterpret_cast<const char *>(&ListEntry), sizeof(NListType));
|
|
Out += sizeof(NListType);
|
|
}
|
|
|
|
void MachOWriter::writeSymbolTable() {
|
|
if (!O.SymTabCommandIndex)
|
|
return;
|
|
const MachO::symtab_command &SymTabCommand =
|
|
O.LoadCommands[*O.SymTabCommandIndex]
|
|
.MachOLoadCommand.symtab_command_data;
|
|
|
|
uint8_t *StrTable = (uint8_t *)B.getBufferStart() + SymTabCommand.stroff;
|
|
StrTableBuilder.write(StrTable);
|
|
}
|
|
|
|
void MachOWriter::writeStringTable() {
|
|
if (!O.SymTabCommandIndex)
|
|
return;
|
|
const MachO::symtab_command &SymTabCommand =
|
|
O.LoadCommands[*O.SymTabCommandIndex]
|
|
.MachOLoadCommand.symtab_command_data;
|
|
|
|
char *SymTable = (char *)B.getBufferStart() + SymTabCommand.symoff;
|
|
for (auto Iter = O.SymTable.Symbols.begin(), End = O.SymTable.Symbols.end();
|
|
Iter != End; Iter++) {
|
|
SymbolEntry *Sym = Iter->get();
|
|
auto Nstrx = StrTableBuilder.getOffset(Sym->Name);
|
|
|
|
if (Is64Bit)
|
|
writeNListEntry<MachO::nlist_64>(*Sym, IsLittleEndian, SymTable, Nstrx);
|
|
else
|
|
writeNListEntry<MachO::nlist>(*Sym, IsLittleEndian, SymTable, Nstrx);
|
|
}
|
|
}
|
|
|
|
void MachOWriter::writeRebaseInfo() {
|
|
if (!O.DyLdInfoCommandIndex)
|
|
return;
|
|
const MachO::dyld_info_command &DyLdInfoCommand =
|
|
O.LoadCommands[*O.DyLdInfoCommandIndex]
|
|
.MachOLoadCommand.dyld_info_command_data;
|
|
char *Out = (char *)B.getBufferStart() + DyLdInfoCommand.rebase_off;
|
|
assert((DyLdInfoCommand.rebase_size == O.Rebases.Opcodes.size()) &&
|
|
"Incorrect rebase opcodes size");
|
|
memcpy(Out, O.Rebases.Opcodes.data(), O.Rebases.Opcodes.size());
|
|
}
|
|
|
|
void MachOWriter::writeBindInfo() {
|
|
if (!O.DyLdInfoCommandIndex)
|
|
return;
|
|
const MachO::dyld_info_command &DyLdInfoCommand =
|
|
O.LoadCommands[*O.DyLdInfoCommandIndex]
|
|
.MachOLoadCommand.dyld_info_command_data;
|
|
char *Out = (char *)B.getBufferStart() + DyLdInfoCommand.bind_off;
|
|
assert((DyLdInfoCommand.bind_size == O.Binds.Opcodes.size()) &&
|
|
"Incorrect bind opcodes size");
|
|
memcpy(Out, O.Binds.Opcodes.data(), O.Binds.Opcodes.size());
|
|
}
|
|
|
|
void MachOWriter::writeWeakBindInfo() {
|
|
if (!O.DyLdInfoCommandIndex)
|
|
return;
|
|
const MachO::dyld_info_command &DyLdInfoCommand =
|
|
O.LoadCommands[*O.DyLdInfoCommandIndex]
|
|
.MachOLoadCommand.dyld_info_command_data;
|
|
char *Out = (char *)B.getBufferStart() + DyLdInfoCommand.weak_bind_off;
|
|
assert((DyLdInfoCommand.weak_bind_size == O.WeakBinds.Opcodes.size()) &&
|
|
"Incorrect weak bind opcodes size");
|
|
memcpy(Out, O.WeakBinds.Opcodes.data(), O.WeakBinds.Opcodes.size());
|
|
}
|
|
|
|
void MachOWriter::writeLazyBindInfo() {
|
|
if (!O.DyLdInfoCommandIndex)
|
|
return;
|
|
const MachO::dyld_info_command &DyLdInfoCommand =
|
|
O.LoadCommands[*O.DyLdInfoCommandIndex]
|
|
.MachOLoadCommand.dyld_info_command_data;
|
|
char *Out = (char *)B.getBufferStart() + DyLdInfoCommand.lazy_bind_off;
|
|
assert((DyLdInfoCommand.lazy_bind_size == O.LazyBinds.Opcodes.size()) &&
|
|
"Incorrect lazy bind opcodes size");
|
|
memcpy(Out, O.LazyBinds.Opcodes.data(), O.LazyBinds.Opcodes.size());
|
|
}
|
|
|
|
void MachOWriter::writeExportInfo() {
|
|
if (!O.DyLdInfoCommandIndex)
|
|
return;
|
|
const MachO::dyld_info_command &DyLdInfoCommand =
|
|
O.LoadCommands[*O.DyLdInfoCommandIndex]
|
|
.MachOLoadCommand.dyld_info_command_data;
|
|
char *Out = (char *)B.getBufferStart() + DyLdInfoCommand.export_off;
|
|
assert((DyLdInfoCommand.export_size == O.Exports.Trie.size()) &&
|
|
"Incorrect export trie size");
|
|
memcpy(Out, O.Exports.Trie.data(), O.Exports.Trie.size());
|
|
}
|
|
|
|
void MachOWriter::writeTail() {
|
|
typedef void (MachOWriter::*WriteHandlerType)(void);
|
|
typedef std::pair<uint64_t, WriteHandlerType> WriteOperation;
|
|
SmallVector<WriteOperation, 7> Queue;
|
|
|
|
if (O.SymTabCommandIndex) {
|
|
const MachO::symtab_command &SymTabCommand =
|
|
O.LoadCommands[*O.SymTabCommandIndex]
|
|
.MachOLoadCommand.symtab_command_data;
|
|
if (SymTabCommand.symoff)
|
|
Queue.push_back({SymTabCommand.symoff, &MachOWriter::writeSymbolTable});
|
|
if (SymTabCommand.stroff)
|
|
Queue.push_back({SymTabCommand.stroff, &MachOWriter::writeStringTable});
|
|
}
|
|
|
|
if (O.DyLdInfoCommandIndex) {
|
|
const MachO::dyld_info_command &DyLdInfoCommand =
|
|
O.LoadCommands[*O.DyLdInfoCommandIndex]
|
|
.MachOLoadCommand.dyld_info_command_data;
|
|
if (DyLdInfoCommand.rebase_off)
|
|
Queue.push_back(
|
|
{DyLdInfoCommand.rebase_off, &MachOWriter::writeRebaseInfo});
|
|
if (DyLdInfoCommand.bind_off)
|
|
Queue.push_back({DyLdInfoCommand.bind_off, &MachOWriter::writeBindInfo});
|
|
if (DyLdInfoCommand.weak_bind_off)
|
|
Queue.push_back(
|
|
{DyLdInfoCommand.weak_bind_off, &MachOWriter::writeWeakBindInfo});
|
|
if (DyLdInfoCommand.lazy_bind_off)
|
|
Queue.push_back(
|
|
{DyLdInfoCommand.lazy_bind_off, &MachOWriter::writeLazyBindInfo});
|
|
if (DyLdInfoCommand.export_off)
|
|
Queue.push_back(
|
|
{DyLdInfoCommand.export_off, &MachOWriter::writeExportInfo});
|
|
}
|
|
|
|
llvm::sort(Queue, [](const WriteOperation &LHS, const WriteOperation &RHS) {
|
|
return LHS.first < RHS.first;
|
|
});
|
|
|
|
for (auto WriteOp : Queue)
|
|
(this->*WriteOp.second)();
|
|
}
|
|
|
|
void MachOWriter::updateSizeOfCmds() {
|
|
auto Size = 0;
|
|
for (const auto &LC : O.LoadCommands) {
|
|
auto &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); \
|
|
break;
|
|
#include "llvm/BinaryFormat/MachO.def"
|
|
#undef HANDLE_LOAD_COMMAND
|
|
}
|
|
}
|
|
|
|
O.Header.SizeOfCmds = Size;
|
|
}
|
|
|
|
// Updates the index and the number of local/external/undefined symbols. Here we
|
|
// assume that MLC is a LC_DYSYMTAB and the nlist entries in the symbol table
|
|
// are already sorted by the those types.
|
|
void MachOWriter::updateDySymTab(MachO::macho_load_command &MLC) {
|
|
uint32_t NumLocalSymbols = 0;
|
|
auto Iter = O.SymTable.Symbols.begin();
|
|
auto End = O.SymTable.Symbols.end();
|
|
for (; Iter != End; Iter++) {
|
|
if ((*Iter)->n_type & (MachO::N_EXT | MachO::N_PEXT))
|
|
break;
|
|
|
|
NumLocalSymbols++;
|
|
}
|
|
|
|
uint32_t NumExtDefSymbols = 0;
|
|
for (; Iter != End; Iter++) {
|
|
if (((*Iter)->n_type & MachO::N_TYPE) == MachO::N_UNDF)
|
|
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.
|
|
Error MachOWriter::layout() {
|
|
auto SizeOfCmds = loadCommandsSize();
|
|
auto Offset = headerSize() + SizeOfCmds;
|
|
O.Header.NCmds = O.LoadCommands.size();
|
|
O.Header.SizeOfCmds = SizeOfCmds;
|
|
|
|
// Lay out sections.
|
|
for (auto &LC : O.LoadCommands) {
|
|
uint64_t FileOff = Offset;
|
|
uint64_t VMSize = 0;
|
|
uint64_t FileOffsetInSegment = 0;
|
|
for (auto &Sec : LC.Sections) {
|
|
if (!Sec.isVirtualSection()) {
|
|
auto FilePaddingSize =
|
|
OffsetToAlignment(FileOffsetInSegment, 1ull << Sec.Align);
|
|
Sec.Offset = Offset + FileOffsetInSegment + FilePaddingSize;
|
|
Sec.Size = Sec.Content.size();
|
|
FileOffsetInSegment += FilePaddingSize + Sec.Size;
|
|
}
|
|
|
|
VMSize = std::max(VMSize, Sec.Addr + Sec.Size);
|
|
}
|
|
|
|
// TODO: Handle the __PAGEZERO segment.
|
|
auto &MLC = LC.MachOLoadCommand;
|
|
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 = FileOff;
|
|
MLC.segment_command_data.vmsize = VMSize;
|
|
MLC.segment_command_data.filesize = FileOffsetInSegment;
|
|
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 = FileOff;
|
|
MLC.segment_command_64_data.vmsize = VMSize;
|
|
MLC.segment_command_64_data.filesize = FileOffsetInSegment;
|
|
break;
|
|
}
|
|
|
|
Offset += FileOffsetInSegment;
|
|
}
|
|
|
|
// Lay out relocations.
|
|
for (auto &LC : O.LoadCommands)
|
|
for (auto &Sec : LC.Sections) {
|
|
Sec.RelOff = Sec.Relocations.empty() ? 0 : Offset;
|
|
Sec.NReloc = Sec.Relocations.size();
|
|
Offset += sizeof(MachO::any_relocation_info) * Sec.NReloc;
|
|
}
|
|
|
|
// Lay out tail stuff.
|
|
auto NListSize = Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
|
|
for (auto &LC : O.LoadCommands) {
|
|
auto &MLC = LC.MachOLoadCommand;
|
|
auto cmd = MLC.load_command_data.cmd;
|
|
switch (cmd) {
|
|
case MachO::LC_SYMTAB:
|
|
MLC.symtab_command_data.nsyms = O.SymTable.Symbols.size();
|
|
MLC.symtab_command_data.strsize = StrTableBuilder.getSize();
|
|
MLC.symtab_command_data.symoff = Offset;
|
|
Offset += NListSize * MLC.symtab_command_data.nsyms;
|
|
MLC.symtab_command_data.stroff = Offset;
|
|
Offset += MLC.symtab_command_data.strsize;
|
|
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 (MLC.dysymtab_command_data.nindirectsyms != 0)
|
|
return createStringError(llvm::errc::not_supported,
|
|
"indirect symbol table is not yet supported");
|
|
|
|
updateDySymTab(MLC);
|
|
break;
|
|
}
|
|
case MachO::LC_SEGMENT:
|
|
case MachO::LC_SEGMENT_64:
|
|
case MachO::LC_VERSION_MIN_MACOSX:
|
|
case MachO::LC_BUILD_VERSION:
|
|
case MachO::LC_ID_DYLIB:
|
|
case MachO::LC_LOAD_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();
|
|
}
|
|
|
|
void MachOWriter::constructStringTable() {
|
|
for (std::unique_ptr<SymbolEntry> &Sym : O.SymTable.Symbols)
|
|
StrTableBuilder.add(Sym->Name);
|
|
StrTableBuilder.finalize();
|
|
}
|
|
|
|
Error MachOWriter::finalize() {
|
|
updateSizeOfCmds();
|
|
constructStringTable();
|
|
|
|
if (auto E = layout())
|
|
return E;
|
|
|
|
return Error::success();
|
|
}
|
|
|
|
Error MachOWriter::write() {
|
|
if (Error E = B.allocate(totalSize()))
|
|
return E;
|
|
memset(B.getBufferStart(), 0, totalSize());
|
|
writeHeader();
|
|
updateSymbolIndexes();
|
|
writeLoadCommands();
|
|
writeSections();
|
|
writeTail();
|
|
return B.commit();
|
|
}
|
|
|
|
} // end namespace macho
|
|
} // end namespace objcopy
|
|
} // end namespace llvm
|