Viewing file:  MachOBuilder.h (19.35 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
//===------------ MachOBuilder.h -- Build MachO Objects ---------*- 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
//
//===----------------------------------------------------------------------===//
//
// Build MachO object files for interaction with the ObjC runtime and debugger.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_EXECUTIONENGINE_ORC_MACHOBUILDER_H
#define LLVM_EXECUTIONENGINE_ORC_MACHOBUILDER_H
#include "llvm/BinaryFormat/MachO.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/MathExtras.h"
#include <list>
#include <map>
#include <vector>
namespace llvm {
namespace orc {
template <typename MachOStruct>
size_t writeMachOStruct(MutableArrayRef<char> Buf, size_t Offset, MachOStruct S,
bool SwapStruct) {
if (SwapStruct)
MachO::swapStruct(S);
assert(Offset + sizeof(MachOStruct) <= Buf.size() && "Buffer overflow");
memcpy(&Buf[Offset], reinterpret_cast<const char *>(&S), sizeof(MachOStruct));
return Offset + sizeof(MachOStruct);
}
/// Base type for MachOBuilder load command wrappers.
struct MachOBuilderLoadCommandBase {
virtual ~MachOBuilderLoadCommandBase() {}
virtual size_t size() const = 0;
virtual size_t write(MutableArrayRef<char> Buf, size_t Offset,
bool SwapStruct) = 0;
};
/// MachOBuilder load command wrapper type.
template <MachO::LoadCommandType LCType> struct MachOBuilderLoadCommandImplBase;
#define HANDLE_LOAD_COMMAND(Name, Value, LCStruct) \
template <> \
struct MachOBuilderLoadCommandImplBase<MachO::Name> \
: public MachO::LCStruct, public MachOBuilderLoadCommandBase { \
using CmdStruct = LCStruct; \
MachOBuilderLoadCommandImplBase() { \
memset(&rawStruct(), 0, sizeof(CmdStruct)); \
cmd = Value; \
cmdsize = sizeof(CmdStruct); \
} \
template <typename... ArgTs> \
MachOBuilderLoadCommandImplBase(ArgTs &&...Args) \
: CmdStruct{Value, sizeof(CmdStruct), std::forward<ArgTs>(Args)...} {} \
CmdStruct &rawStruct() { return static_cast<CmdStruct &>(*this); } \
size_t size() const override { return cmdsize; } \
size_t write(MutableArrayRef<char> Buf, size_t Offset, \
bool SwapStruct) override { \
return writeMachOStruct(Buf, Offset, rawStruct(), SwapStruct); \
} \
};
#include "llvm/BinaryFormat/MachO.def"
#undef HANDLE_LOAD_COMMAND
template <MachO::LoadCommandType LCType>
struct MachOBuilderLoadCommand
: public MachOBuilderLoadCommandImplBase<LCType> {
public:
MachOBuilderLoadCommand() = default;
template <typename... ArgTs>
MachOBuilderLoadCommand(ArgTs &&...Args)
: MachOBuilderLoadCommandImplBase<LCType>(std::forward<ArgTs>(Args)...) {}
};
template <>
struct MachOBuilderLoadCommand<MachO::LC_ID_DYLIB>
: public MachOBuilderLoadCommandImplBase<MachO::LC_ID_DYLIB> {
MachOBuilderLoadCommand(std::string Name, uint32_t Timestamp,
uint32_t CurrentVersion,
uint32_t CompatibilityVersion)
: MachOBuilderLoadCommandImplBase(
MachO::dylib{24, Timestamp, CurrentVersion, CompatibilityVersion}),
Name(std::move(Name)) {
cmdsize += (this->Name.size() + 1 + 3) & ~0x3;
}
size_t write(MutableArrayRef<char> Buf, size_t Offset,
bool SwapStruct) override {
Offset = writeMachOStruct(Buf, Offset, rawStruct(), SwapStruct);
strcpy(Buf.data() + Offset, Name.data());
return Offset + ((Name.size() + 1 + 3) & ~0x3);
}
std::string Name;
};
template <>
struct MachOBuilderLoadCommand<MachO::LC_LOAD_DYLIB>
: public MachOBuilderLoadCommandImplBase<MachO::LC_LOAD_DYLIB> {
MachOBuilderLoadCommand(std::string Name, uint32_t Timestamp,
uint32_t CurrentVersion,
uint32_t CompatibilityVersion)
: MachOBuilderLoadCommandImplBase(
MachO::dylib{24, Timestamp, CurrentVersion, CompatibilityVersion}),
Name(std::move(Name)) {
cmdsize += (this->Name.size() + 1 + 3) & ~0x3;
}
size_t write(MutableArrayRef<char> Buf, size_t Offset,
bool SwapStruct) override {
Offset = writeMachOStruct(Buf, Offset, rawStruct(), SwapStruct);
strcpy(Buf.data() + Offset, Name.data());
return Offset + ((Name.size() + 1 + 3) & ~0x3);
}
std::string Name;
};
template <>
struct MachOBuilderLoadCommand<MachO::LC_RPATH>
: public MachOBuilderLoadCommandImplBase<MachO::LC_RPATH> {
MachOBuilderLoadCommand(std::string Path)
: MachOBuilderLoadCommandImplBase(12u), Path(std::move(Path)) {
cmdsize += (this->Path.size() + 1 + 3) & ~0x3;
}
size_t write(MutableArrayRef<char> Buf, size_t Offset,
bool SwapStruct) override {
Offset = writeMachOStruct(Buf, Offset, rawStruct(), SwapStruct);
strcpy(Buf.data() + Offset, Path.data());
return Offset + ((Path.size() + 1 + 3) & ~0x3);
}
std::string Path;
};
// Builds MachO objects.
template <typename MachOTraits> class MachOBuilder {
private:
struct SymbolContainer {
size_t SymbolIndexBase = 0;
std::vector<typename MachOTraits::NList> Symbols;
};
struct StringTableEntry {
StringRef S;
size_t Offset;
};
using StringTable = std::vector<StringTableEntry>;
static bool swapStruct() {
return MachOTraits::Endianness != llvm::endianness::native;
}
public:
using StringId = size_t;
struct Section;
// Points to either an nlist entry (as a (symbol-container, index) pair), or
// a section.
class RelocTarget {
public:
RelocTarget(const Section &S) : S(&S), Idx(~0U) {}
RelocTarget(SymbolContainer &SC, size_t Idx) : SC(&SC), Idx(Idx) {}
bool isSymbol() { return Idx != ~0U; }
uint32_t getSymbolNum() {
assert(isSymbol() && "Target is not a symbol");
return SC->SymbolIndexBase + Idx;
}
uint32_t getSectionId() {
assert(!isSymbol() && "Target is not a section");
return S->SectionNumber;
}
typename MachOTraits::NList &nlist() {
assert(isSymbol() && "Target is not a symbol");
return SC->Symbols[Idx];
}
private:
union {
const Section *S;
SymbolContainer *SC;
};
size_t Idx;
};
struct Reloc : public MachO::relocation_info {
RelocTarget Target;
Reloc(int32_t Offset, RelocTarget Target, bool PCRel, unsigned Length,
unsigned Type)
: Target(Target) {
assert(Type < 16 && "Relocation type out of range");
r_address = Offset; // Will slide to account for sec addr during layout
r_symbolnum = 0;
r_pcrel = PCRel;
r_length = Length;
r_extern = Target.isSymbol();
r_type = Type;
}
MachO::relocation_info &rawStruct() {
return static_cast<MachO::relocation_info &>(*this);
}
};
struct SectionContent {
const char *Data = nullptr;
size_t Size = 0;
};
struct Section : public MachOTraits::Section, public RelocTarget {
MachOBuilder &Builder;
SectionContent Content;
size_t SectionNumber = 0;
SymbolContainer SC;
std::vector<Reloc> Relocs;
Section(MachOBuilder &Builder, StringRef SecName, StringRef SegName)
: RelocTarget(*this), Builder(Builder) {
memset(&rawStruct(), 0, sizeof(typename MachOTraits::Section));
assert(SecName.size() <= 16 && "SecName too long");
assert(SegName.size() <= 16 && "SegName too long");
memcpy(this->sectname, SecName.data(), SecName.size());
memcpy(this->segname, SegName.data(), SegName.size());
}
RelocTarget addSymbol(int32_t Offset, StringRef Name, uint8_t Type,
uint16_t Desc) {
StringId SI = Builder.addString(Name);
typename MachOTraits::NList Sym;
Sym.n_strx = SI;
Sym.n_type = Type | MachO::N_SECT;
Sym.n_sect = MachO::NO_SECT; // Will be filled in later.
Sym.n_desc = Desc;
Sym.n_value = Offset;
SC.Symbols.push_back(Sym);
return {SC, SC.Symbols.size() - 1};
}
void addReloc(int32_t Offset, RelocTarget Target, bool PCRel,
unsigned Length, unsigned Type) {
Relocs.push_back({Offset, Target, PCRel, Length, Type});
}
auto &rawStruct() {
return static_cast<typename MachOTraits::Section &>(*this);
}
};
struct Segment : public MachOBuilderLoadCommand<MachOTraits::SegmentCmd> {
MachOBuilder &Builder;
std::vector<std::unique_ptr<Section>> Sections;
Segment(MachOBuilder &Builder, StringRef SegName)
: MachOBuilderLoadCommand<MachOTraits::SegmentCmd>(), Builder(Builder) {
assert(SegName.size() <= 16 && "SegName too long");
memcpy(this->segname, SegName.data(), SegName.size());
this->maxprot =
MachO::VM_PROT_READ | MachO::VM_PROT_WRITE | MachO::VM_PROT_EXECUTE;
this->initprot = this->maxprot;
}
Section &addSection(StringRef SecName, StringRef SegName) {
Sections.push_back(std::make_unique<Section>(Builder, SecName, SegName));
return *Sections.back();
}
size_t write(MutableArrayRef<char> Buf, size_t Offset,
bool SwapStruct) override {
Offset = MachOBuilderLoadCommand<MachOTraits::SegmentCmd>::write(
Buf, Offset, SwapStruct);
for (auto &Sec : Sections)
Offset = writeMachOStruct(Buf, Offset, Sec->rawStruct(), SwapStruct);
return Offset;
}
};
MachOBuilder(size_t PageSize) : PageSize(PageSize) {
memset((char *)&Header, 0, sizeof(Header));
Header.magic = MachOTraits::Magic;
}
template <MachO::LoadCommandType LCType, typename... ArgTs>
MachOBuilderLoadCommand<LCType> &addLoadCommand(ArgTs &&...Args) {
static_assert(LCType != MachOTraits::SegmentCmd,
"Use addSegment to add segment load command");
auto LC = std::make_unique<MachOBuilderLoadCommand<LCType>>(
std::forward<ArgTs>(Args)...);
auto &Tmp = *LC;
LoadCommands.push_back(std::move(LC));
return Tmp;
}
StringId addString(StringRef Str) {
if (Strings.empty() && !Str.empty())
addString("");
return Strings.insert(std::make_pair(Str, Strings.size())).first->second;
}
Segment &addSegment(StringRef SegName) {
Segments.push_back(Segment(*this, SegName));
return Segments.back();
}
RelocTarget addSymbol(StringRef Name, uint8_t Type, uint8_t Sect,
uint16_t Desc, typename MachOTraits::UIntPtr Value) {
StringId SI = addString(Name);
typename MachOTraits::NList Sym;
Sym.n_strx = SI;
Sym.n_type = Type;
Sym.n_sect = Sect;
Sym.n_desc = Desc;
Sym.n_value = Value;
SC.Symbols.push_back(Sym);
return {SC, SC.Symbols.size() - 1};
}
// Call to perform layout on the MachO. Returns the total size of the
// resulting file.
// This method will automatically insert some load commands (e.g.
// LC_SYMTAB) and fill in load command fields.
size_t layout() {
// Build symbol table and add LC_SYMTAB command.
makeStringTable();
MachOBuilderLoadCommand<MachOTraits::SymTabCmd> *SymTabLC = nullptr;
if (!StrTab.empty())
SymTabLC = &addLoadCommand<MachOTraits::SymTabCmd>();
// Lay out header, segment load command, and other load commands.
size_t Offset = sizeof(Header);
for (auto &Seg : Segments) {
Seg.cmdsize +=
Seg.Sections.size() * sizeof(typename MachOTraits::Section);
Seg.nsects = Seg.Sections.size();
Offset += Seg.cmdsize;
}
for (auto &LC : LoadCommands)
Offset += LC->size();
Header.sizeofcmds = Offset - sizeof(Header);
// Lay out content, set segment / section addrs and offsets.
size_t SegVMAddr = 0;
for (auto &Seg : Segments) {
Seg.vmaddr = SegVMAddr;
Seg.fileoff = Offset;
for (auto &Sec : Seg.Sections) {
Offset = alignTo(Offset, 1ULL << Sec->align);
if (Sec->Content.Size)
Sec->offset = Offset;
Sec->size = Sec->Content.Size;
Sec->addr = SegVMAddr + Sec->offset - Seg.fileoff;
Offset += Sec->Content.Size;
}
size_t SegContentSize = Offset - Seg.fileoff;
Seg.filesize = SegContentSize;
Seg.vmsize = Header.filetype == MachO::MH_OBJECT
? SegContentSize
: alignTo(SegContentSize, PageSize);
SegVMAddr += Seg.vmsize;
}
// Set string table offsets for non-section symbols.
for (auto &Sym : SC.Symbols)
Sym.n_strx = StrTab[Sym.n_strx].Offset;
// Number sections, set symbol section numbers and string table offsets,
// count relocations.
size_t NumSymbols = SC.Symbols.size();
size_t SectionNumber = 0;
for (auto &Seg : Segments) {
for (auto &Sec : Seg.Sections) {
++SectionNumber;
Sec->SectionNumber = SectionNumber;
Sec->SC.SymbolIndexBase = NumSymbols;
NumSymbols += Sec->SC.Symbols.size();
for (auto &Sym : Sec->SC.Symbols) {
Sym.n_sect = SectionNumber;
Sym.n_strx = StrTab[Sym.n_strx].Offset;
Sym.n_value += Sec->addr;
}
}
}
// Handle relocations
bool OffsetAlignedForRelocs = false;
for (auto &Seg : Segments) {
for (auto &Sec : Seg.Sections) {
if (!Sec->Relocs.empty()) {
if (!OffsetAlignedForRelocs) {
Offset = alignTo(Offset, sizeof(MachO::relocation_info));
OffsetAlignedForRelocs = true;
}
Sec->reloff = Offset;
Sec->nreloc = Sec->Relocs.size();
Offset += Sec->Relocs.size() * sizeof(MachO::relocation_info);
for (auto &R : Sec->Relocs)
R.r_symbolnum = R.Target.isSymbol() ? R.Target.getSymbolNum()
: R.Target.getSectionId();
}
}
}
// Calculate offset to start of nlist and update symtab command.
if (NumSymbols > 0) {
Offset = alignTo(Offset, sizeof(typename MachOTraits::NList));
SymTabLC->symoff = Offset;
SymTabLC->nsyms = NumSymbols;
// Calculate string table bounds and update symtab command.
if (!StrTab.empty()) {
Offset += NumSymbols * sizeof(typename MachOTraits::NList);
size_t StringTableSize =
StrTab.back().Offset + StrTab.back().S.size() + 1;
SymTabLC->stroff = Offset;
SymTabLC->strsize = StringTableSize;
Offset += StringTableSize;
}
}
return Offset;
}
void write(MutableArrayRef<char> Buffer) {
size_t Offset = 0;
Offset = writeHeader(Buffer, Offset);
Offset = writeSegments(Buffer, Offset);
Offset = writeLoadCommands(Buffer, Offset);
Offset = writeSectionContent(Buffer, Offset);
Offset = writeRelocations(Buffer, Offset);
Offset = writeSymbols(Buffer, Offset);
Offset = writeStrings(Buffer, Offset);
}
typename MachOTraits::Header Header;
private:
void makeStringTable() {
if (Strings.empty())
return;
StrTab.resize(Strings.size());
for (auto &KV : Strings)
StrTab[KV.second] = {KV.first, 0};
size_t Offset = 0;
for (auto &Elem : StrTab) {
Elem.Offset = Offset;
Offset += Elem.S.size() + 1;
}
}
size_t writeHeader(MutableArrayRef<char> Buf, size_t Offset) {
Header.ncmds = Segments.size() + LoadCommands.size();
return writeMachOStruct(Buf, Offset, Header, swapStruct());
}
size_t writeSegments(MutableArrayRef<char> Buf, size_t Offset) {
for (auto &Seg : Segments)
Offset = Seg.write(Buf, Offset, swapStruct());
return Offset;
}
size_t writeLoadCommands(MutableArrayRef<char> Buf, size_t Offset) {
for (auto &LC : LoadCommands)
Offset = LC->write(Buf, Offset, swapStruct());
return Offset;
}
size_t writeSectionContent(MutableArrayRef<char> Buf, size_t Offset) {
for (auto &Seg : Segments) {
for (auto &Sec : Seg.Sections) {
if (!Sec->Content.Data) {
assert(Sec->Relocs.empty() &&
"Cant' have relocs for zero-fill segment");
continue;
}
while (Offset != Sec->offset)
Buf[Offset++] = '\0';
assert(Offset + Sec->Content.Size <= Buf.size() && "Buffer overflow");
memcpy(&Buf[Offset], Sec->Content.Data, Sec->Content.Size);
Offset += Sec->Content.Size;
}
}
return Offset;
}
size_t writeRelocations(MutableArrayRef<char> Buf, size_t Offset) {
for (auto &Seg : Segments) {
for (auto &Sec : Seg.Sections) {
if (!Sec->Relocs.empty()) {
while (Offset % sizeof(MachO::relocation_info))
Buf[Offset++] = '\0';
}
for (auto &R : Sec->Relocs) {
assert(Offset + sizeof(MachO::relocation_info) <= Buf.size() &&
"Buffer overflow");
memcpy(&Buf[Offset], reinterpret_cast<const char *>(&R.rawStruct()),
sizeof(MachO::relocation_info));
Offset += sizeof(MachO::relocation_info);
}
}
}
return Offset;
}
size_t writeSymbols(MutableArrayRef<char> Buf, size_t Offset) {
// Count symbols.
size_t NumSymbols = SC.Symbols.size();
for (auto &Seg : Segments)
for (auto &Sec : Seg.Sections)
NumSymbols += Sec->SC.Symbols.size();
// If none then return.
if (NumSymbols == 0)
return Offset;
// Align to nlist entry size.
while (Offset % sizeof(typename MachOTraits::NList))
Buf[Offset++] = '\0';
// Write non-section symbols.
for (auto &Sym : SC.Symbols)
Offset = writeMachOStruct(Buf, Offset, Sym, swapStruct());
// Write section symbols.
for (auto &Seg : Segments) {
for (auto &Sec : Seg.Sections) {
for (auto &Sym : Sec->SC.Symbols) {
Offset = writeMachOStruct(Buf, Offset, Sym, swapStruct());
}
}
}
return Offset;
}
size_t writeStrings(MutableArrayRef<char> Buf, size_t Offset) {
for (auto &Elem : StrTab) {
assert(Offset + Elem.S.size() + 1 <= Buf.size() && "Buffer overflow");
memcpy(&Buf[Offset], Elem.S.data(), Elem.S.size());
Offset += Elem.S.size();
Buf[Offset++] = '\0';
}
return Offset;
}
size_t PageSize;
std::list<Segment> Segments;
std::vector<std::unique_ptr<MachOBuilderLoadCommandBase>> LoadCommands;
SymbolContainer SC;
// Maps strings to their "id" (addition order).
std::map<StringRef, size_t> Strings;
StringTable StrTab;
};
struct MachO64LE {
using UIntPtr = uint64_t;
using Header = MachO::mach_header_64;
using Section = MachO::section_64;
using NList = MachO::nlist_64;
using Relocation = MachO::relocation_info;
static constexpr llvm::endianness Endianness = llvm::endianness::little;
static constexpr uint32_t Magic = MachO::MH_MAGIC_64;
static constexpr MachO::LoadCommandType SegmentCmd = MachO::LC_SEGMENT_64;
static constexpr MachO::LoadCommandType SymTabCmd = MachO::LC_SYMTAB;
};
} // namespace orc
} // namespace llvm
#endif // LLVM_EXECUTIONENGINE_ORC_MACHOBUILDER_H
|