13#ifndef LLVM_EXECUTIONENGINE_ORC_MACHOBUILDER_H
14#define LLVM_EXECUTIONENGINE_ORC_MACHOBUILDER_H
27template <
typename MachOStruct>
33 memcpy(&Buf[
Offset],
reinterpret_cast<const char *
>(&S),
sizeof(MachOStruct));
34 return Offset +
sizeof(MachOStruct);
40 virtual size_t size()
const = 0;
48#define HANDLE_LOAD_COMMAND(Name, Value, LCStruct) \
50 struct MachOBuilderLoadCommand<MachO::Name> \
51 : public MachO::LCStruct, public MachOBuilderLoadCommandBase { \
52 using CmdStruct = LCStruct; \
53 MachOBuilderLoadCommand() { \
54 memset(&rawStruct(), 0, sizeof(CmdStruct)); \
56 cmdsize = sizeof(CmdStruct); \
58 template <typename... ArgTs> \
59 MachOBuilderLoadCommand(ArgTs &&...Args) \
60 : CmdStruct{Value, sizeof(CmdStruct), std::forward<ArgTs>(Args)...} {} \
61 CmdStruct &rawStruct() { return static_cast<CmdStruct &>(*this); } \
62 size_t size() const override { return cmdsize; } \
63 size_t write(MutableArrayRef<char> Buf, size_t Offset, \
64 bool SwapStruct) override { \
65 return writeMachOStruct(Buf, Offset, rawStruct(), SwapStruct); \
69#include "llvm/BinaryFormat/MachO.def"
71#undef HANDLE_LOAD_COMMAND
76 struct SymbolContainer {
77 size_t SymbolIndexBase = 0;
78 std::vector<typename MachOTraits::NList> Symbols;
81 struct StringTableEntry {
86 using StringTable = std::vector<StringTableEntry>;
88 static bool swapStruct() {
108 return SC->SymbolIndexBase + Idx;
116 typename MachOTraits::NList &
nlist() {
118 return SC->Symbols[Idx];
135 assert(
Type < 16 &&
"Relocation type out of range");
163 memset(&
rawStruct(), 0,
sizeof(
typename MachOTraits::Section));
164 assert(SecName.
size() <= 16 &&
"SecName too long");
165 assert(SegName.
size() <= 16 &&
"SegName too long");
166 memcpy(this->sectname, SecName.
data(), SecName.
size());
167 memcpy(this->segname, SegName.
data(), SegName.
size());
173 typename MachOTraits::NList
Sym;
179 SC.Symbols.push_back(
Sym);
180 return {
SC,
SC.Symbols.size() - 1};
189 return static_cast<typename MachOTraits::Section &
>(*this);
199 assert(SegName.
size() <= 16 &&
"SegName too long");
200 memcpy(this->segname, SegName.
data(), SegName.
size());
203 this->initprot = this->maxprot;
207 Sections.push_back(std::make_unique<Section>(
Builder, SecName, SegName));
212 bool SwapStruct)
override {
223 Header.magic = MachOTraits::Magic;
228 static_assert(LCType != MachOTraits::SegmentCmd,
229 "Use addSegment to add segment load command");
230 auto LC = std::make_unique<MachOBuilderLoadCommand<LCType>>(
231 std::forward<ArgTs>(Args)...);
233 LoadCommands.push_back(std::move(LC));
238 if (Strings.empty() && !Str.empty())
240 return Strings.insert(std::make_pair(Str, Strings.size())).first->second;
244 Segments.push_back(
Segment(*
this, SegName));
245 return Segments.back();
251 typename MachOTraits::NList
Sym;
257 SC.Symbols.push_back(
Sym);
258 return {SC, SC.Symbols.size() - 1};
271 SymTabLC = &addLoadCommand<MachOTraits::SymTabCmd>();
275 for (
auto &Seg : Segments) {
277 Seg.Sections.size() *
sizeof(
typename MachOTraits::Section);
278 Seg.nsects = Seg.Sections.size();
281 for (
auto &LC : LoadCommands)
287 size_t SegVMAddr = 0;
288 for (
auto &Seg : Segments) {
289 Seg.vmaddr = SegVMAddr;
291 for (
auto &Sec : Seg.Sections) {
293 if (Sec->Content.Size)
295 Sec->size = Sec->Content.Size;
296 Sec->addr = SegVMAddr + Sec->offset - Seg.fileoff;
297 Offset += Sec->Content.Size;
299 size_t SegContentSize =
Offset - Seg.fileoff;
300 Seg.filesize = SegContentSize;
303 :
alignTo(SegContentSize, PageSize);
304 SegVMAddr += Seg.vmsize;
308 for (
auto &
Sym : SC.Symbols)
309 Sym.n_strx = StrTab[
Sym.n_strx].Offset;
313 size_t NumSymbols = SC.Symbols.size();
314 size_t SectionNumber = 0;
315 for (
auto &Seg : Segments) {
316 for (
auto &Sec : Seg.Sections) {
318 Sec->SectionNumber = SectionNumber;
319 Sec->SC.SymbolIndexBase = NumSymbols;
320 NumSymbols += Sec->SC.Symbols.size();
321 for (
auto &
Sym : Sec->SC.Symbols) {
322 Sym.n_sect = SectionNumber;
323 Sym.n_strx = StrTab[
Sym.n_strx].Offset;
324 Sym.n_value += Sec->addr;
330 bool OffsetAlignedForRelocs =
false;
331 for (
auto &Seg : Segments) {
332 for (
auto &Sec : Seg.Sections) {
333 if (!Sec->Relocs.empty()) {
334 if (!OffsetAlignedForRelocs) {
336 OffsetAlignedForRelocs =
true;
339 Sec->nreloc = Sec->Relocs.size();
341 for (
auto &R : Sec->Relocs)
342 R.r_symbolnum = R.Target.isSymbol() ? R.Target.getSymbolNum()
343 : R.Target.getSectionId();
349 if (NumSymbols > 0) {
351 SymTabLC->symoff =
Offset;
352 SymTabLC->nsyms = NumSymbols;
355 if (!StrTab.empty()) {
356 Offset += NumSymbols *
sizeof(
typename MachOTraits::NList);
357 size_t StringTableSize =
358 StrTab.back().Offset + StrTab.back().S.size() + 1;
360 SymTabLC->stroff =
Offset;
361 SymTabLC->strsize = StringTableSize;
362 Offset += StringTableSize;
383 void makeStringTable() {
387 StrTab.resize(Strings.size());
388 for (
auto &KV : Strings)
389 StrTab[KV.second] = {KV.first, 0};
391 for (
auto &Elem : StrTab) {
393 Offset += Elem.S.size() + 1;
398 Header.ncmds = Segments.size() + LoadCommands.size();
403 for (
auto &Seg : Segments)
408 size_t writeLoadCommands(MutableArrayRef<char> Buf,
size_t Offset) {
409 for (
auto &LC : LoadCommands)
414 size_t writeSectionContent(MutableArrayRef<char> Buf,
size_t Offset) {
415 for (
auto &Seg : Segments) {
416 for (
auto &Sec : Seg.Sections) {
417 if (!Sec->Content.Data) {
418 assert(Sec->Relocs.empty() &&
419 "Cant' have relocs for zero-fill segment");
422 while (
Offset != Sec->offset)
425 assert(
Offset + Sec->Content.Size <= Buf.size() &&
"Buffer overflow");
426 memcpy(&Buf[
Offset], Sec->Content.Data, Sec->Content.Size);
427 Offset += Sec->Content.Size;
433 size_t writeRelocations(MutableArrayRef<char> Buf,
size_t Offset) {
434 for (
auto &Seg : Segments) {
435 for (
auto &Sec : Seg.Sections) {
436 if (!Sec->Relocs.empty()) {
437 while (
Offset %
sizeof(MachO::relocation_info))
440 for (
auto &R : Sec->Relocs) {
441 assert(
Offset +
sizeof(MachO::relocation_info) <= Buf.size() &&
443 memcpy(&Buf[
Offset],
reinterpret_cast<const char *
>(&
R.rawStruct()),
444 sizeof(MachO::relocation_info));
445 Offset +=
sizeof(MachO::relocation_info);
452 size_t writeSymbols(MutableArrayRef<char> Buf,
size_t Offset) {
455 size_t NumSymbols = SC.Symbols.size();
456 for (
auto &Seg : Segments)
457 for (
auto &Sec : Seg.Sections)
458 NumSymbols += Sec->SC.Symbols.size();
465 while (
Offset %
sizeof(
typename MachOTraits::NList))
469 for (
auto &
Sym : SC.Symbols)
473 for (
auto &Seg : Segments) {
474 for (
auto &Sec : Seg.Sections) {
475 for (
auto &
Sym : Sec->SC.Symbols) {
483 size_t writeStrings(MutableArrayRef<char> Buf,
size_t Offset) {
484 for (
auto &Elem : StrTab) {
485 assert(
Offset + Elem.S.size() + 1 <= Buf.size() &&
"Buffer overflow");
486 memcpy(&Buf[
Offset], Elem.S.data(), Elem.S.size());
495 std::vector<std::unique_ptr<MachOBuilderLoadCommandBase>> LoadCommands;
499 std::map<StringRef, size_t> Strings;
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
size_t size() const
size - Get the array size.
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
StringRef - Represent a constant reference to a string, i.e.
constexpr size_t size() const
size - Get the string size.
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Target - Wrapper for Target specific information.
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM Value Representation.
RelocTarget(SymbolContainer &SC, size_t Idx)
MachOTraits::NList & nlist()
RelocTarget(const Section &S)
MachOBuilderLoadCommand< LCType > & addLoadCommand(ArgTs &&...Args)
void write(MutableArrayRef< char > Buffer)
RelocTarget addSymbol(StringRef Name, uint8_t Type, uint8_t Sect, uint16_t Desc, typename MachOTraits::UIntPtr Value)
StringId addString(StringRef Str)
MachOBuilder(size_t PageSize)
Segment & addSegment(StringRef SegName)
MachOTraits::Header Header
void swapStruct(fat_header &mh)
size_t writeMachOStruct(MutableArrayRef< char > Buf, size_t Offset, MachOStruct S, bool SwapStruct)
This is an optimization pass for GlobalISel generic memory operations.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Description of the encoding of one expression Op.
static constexpr uint32_t Magic
static constexpr llvm::endianness Endianness
static constexpr MachO::LoadCommandType SymTabCmd
static constexpr MachO::LoadCommandType SegmentCmd
Base type for MachOBuilder load command wrappers.
virtual size_t size() const =0
virtual size_t write(MutableArrayRef< char > Buf, size_t Offset, bool SwapStruct)=0
virtual ~MachOBuilderLoadCommandBase()
MachOBuilder load command wrapper type.
Reloc(int32_t Offset, RelocTarget Target, bool PCRel, unsigned Length, unsigned Type)
MachO::relocation_info & rawStruct()
void addReloc(int32_t Offset, RelocTarget Target, bool PCRel, unsigned Length, unsigned Type)
std::vector< Reloc > Relocs
Section(MachOBuilder &Builder, StringRef SecName, StringRef SegName)
RelocTarget addSymbol(int32_t Offset, StringRef Name, uint8_t Type, uint16_t Desc)
Segment(MachOBuilder &Builder, StringRef SegName)
Section & addSection(StringRef SecName, StringRef SegName)
std::vector< std::unique_ptr< Section > > Sections
size_t write(MutableArrayRef< char > Buf, size_t Offset, bool SwapStruct) override