NoAction = 0,

RegisterFunction = 1,

UnregisterFunction = 2

JITCodeEntry* next { };

JITCodeEntry* prev { };

uint8_t* symfileAddr { };

uint64_t symfileSize { };

uint32_t version { };

uint32_t actionFlag { };

JITCodeEntry* relevantEntry { };

JITCodeEntry* firstEntry { };

static Ref<Writer> LEGACY_NODELETE create(DebugObject* obj)

{

return adoptRef(*new Writer(obj));

}

uintptr_t LEGACY_NODELETE position() const { return m_position; }

template<typename T>

class Slot {

public:

Slot(WeakPtr<Writer> writer, uintptr_t offset)

: m_writer(writer)

, m_offset(offset)

{

}

T* operator->() { return m_writer->template rawSlotAt<T>(m_offset); }

T operator*() { return *m_writer->template rawSlotAt<T>(m_offset); }

void set(const T& value)

{

writeUnalignedValue(m_writer->template addressAt<T>(m_offset), value);

}

Slot<T> at(int i) { return Slot<T>(m_writer, m_offset + sizeof(T) * i); }

private:

WeakPtr<Writer> m_writer;

uintptr_t m_offset;

};

template<typename T>

void write(const T& val)

{

ensure(m_position + sizeof(T));

writeUnalignedValue(addressAt<T>(m_position), val);

m_position += sizeof(T);

}

template<typename T>

Slot<T> slotAt(uintptr_t offset) LIFETIME_BOUND

{

ensure(offset + sizeof(T));

return Slot<T>(*this, offset);

}

template<typename T>

Slot<T> createSlotHere() LIFETIME_BOUND

{

return createSlotsHere<T>(1);

}

template<typename T>

Slot<T> createSlotsHere(uint32_t count) LIFETIME_BOUND

{

uintptr_t slotPosition = m_position;

m_position += sizeof(T) * count;

ensure(m_position);

return slotAt<T>(slotPosition);

}

void ensure(uintptr_t pos)

{

if (m_buffer.size() < pos)

m_buffer.grow(pos);

}

DebugObject* LEGACY_NODELETE debugObject() { return m_debugObject; }

uint8_t* LEGACY_NODELETE buffer() LIFETIME_BOUND { return &m_buffer[0]; }

void align(uintptr_t align)

{

uintptr_t delta = m_position % align;

if (!delta)

return;

uintptr_t padding = align - delta;

ensure(m_position += padding);

ASSERT(m_position % align == 0);

}

void writeULEB128(uintptr_t value)

{

do {

uint8_t byte = value & 0x7F;

value >>= 7;

if (value)

byte |= 0x80;

write<uint8_t>(byte);

} while (value);

}

void writeSLEB128(intptr_t value)

{

bool more = true;

while (more) {

int8_t byte = value & 0x7F;

bool byteSign = byte & 0x40;

value >>= 7;

if ((!value && !byteSign) || (value == -1 && byteSign))

more = false;

else

byte |= 0x80;

write<int8_t>(byte);

}

}

template<typename T>

friend class Slot;

template<typename T>

uint8_t* LEGACY_NODELETE addressAt(uintptr_t offset) LIFETIME_BOUND

{

ASSERT(offset < m_buffer.size() && offset + sizeof(T) <= m_buffer.size());

return &m_buffer[offset];

}

template<typename T>

T* LEGACY_NODELETE rawSlotAt(uintptr_t offset) LIFETIME_BOUND

{

ASSERT(offset < m_buffer.size() && offset + sizeof(T) <= m_buffer.size());

return reinterpret_cast<T*>(&m_buffer[offset]);

}

Writer(DebugObject* debugObject)

: m_debugObject(debugObject)

, m_position(0)

{

}

DebugObject* m_debugObject;

uintptr_t m_position;

Vector<uint8_t> m_buffer;

const UTF8CString& LEGACY_NODELETE name() const LIFETIME_BOUND { return m_name; }

const void* LEGACY_NODELETE codeStart() const { return reinterpret_cast<const void*>(m_codeRegion.data()); }

const void* LEGACY_NODELETE codeEnd() const { return reinterpret_cast<const void*>(std::to_address(m_codeRegion.end())); }

uintptr_t LEGACY_NODELETE codeSize() const { return m_codeRegion.size(); }

std::span<const uint8_t> LEGACY_NODELETE region() { return m_codeRegion; }

static Ref<CodeDescription> LEGACY_NODELETE create(const UTF8CString& name, std::span<const uint8_t> region)

{

return adoptRef(*new CodeDescription(name, region));

}

CodeDescription(const UTF8CString& name, std::span<const uint8_t> region)

: m_name(name)

, m_codeRegion(region)

{

}

UTF8CString m_name;

std::span<const uint8_t> m_codeRegion;

{

entry->next = __jit_debug_descriptor.firstEntry;

if (entry->next)

entry->next->prev = entry;

__jit_debug_descriptor.firstEntry = __jit_debug_descriptor.relevantEntry = entry;

__jit_debug_descriptor.actionFlag = RegisterFunction;

__jit_debug_register_code();

{

if (entry->prev)

entry->prev->next = entry->next;

else

__jit_debug_descriptor.firstEntry = entry->next;

if (entry->next)

entry->next->prev = entry->prev;

__jit_debug_descriptor.relevantEntry = entry;

__jit_debug_descriptor.actionFlag = UnregisterFunction;

__jit_debug_register_code();

WTF_DEPRECATED_MAKE_FAST_ALLOCATED(DebugSectionBase);

virtual ~DebugSectionBase() = default;

virtual void writeBody(Writer::Slot<THeader> header, Ref<Writer> writer)

{

uint64_t start = writer->position();

if (writeBodyInternal(writer)) {

header->offset = static_cast<uint32_t>(start);

uint64_t end = writer->position();

header->size = std::max(end - start, static_cast<uint64_t>(header->size));

}

}

virtual bool writeBodyInternal(Ref<Writer>) { return false; }

using Header = THeader;

char sectname[16];

char segname[16];

uint64_t addr;

uint64_t size;

uint32_t offset;

uint32_t align;

uint32_t reloff;

uint32_t nreloc;

uint32_t flags;

uint32_t reserved1;

uint32_t reserved2;

uint32_t reserved3;

enum Type {

Regular = 0x0u,

AttrCoalesced = 0xBu,

AttrSomeInstructions = 0x400u,

AttrDebug = 0x02000000u,

AttrPureInstructions = 0x80000000u

};

MachOSection(const ASCIICString& name, const ASCIICString& segment, uint32_t align, const void* addr, size_t size, uint32_t flags)

: m_name(name)

, m_segment(segment)

, m_align(align)

, m_addr(addr)

, m_size(size)

, m_flags(flags)

{

if (m_align) {

ASSERT(WTF::isPowerOfTwo(align));

m_align = WTF::fastLog2(align);

}

}

~MachOSection() override = default;

virtual void populateHeader(Writer::Slot<Header> header)

{

header->addr = reinterpret_cast<uintptr_t>(m_addr);

header->size = m_size;

header->offset = 0;

header->align = m_align;

header->reloff = 0;

header->nreloc = 0;

header->flags = m_flags;

header->reserved1 = 0;

header->reserved2 = 0;

header->reserved3 = 0;

memset(header->sectname, 0, sizeof(header->sectname));

memset(header->segname, 0, sizeof(header->segname));

ASSERT(m_name.length() < sizeof(header->sectname));

ASSERT(m_segment.length() < sizeof(header->segname));

strncpy(header->sectname, m_name.data(), sizeof(header->sectname));

strncpy(header->segname, m_segment.data(), sizeof(header->segname));

}

const void* LEGACY_NODELETE addr() const { return m_addr; }

size_t LEGACY_NODELETE size() const { return m_size; }

ASCIICString m_name;

ASCIICString m_segment;

uint32_t m_align;

const void* m_addr;

size_t m_size;

uint32_t m_flags;

uint32_t name;

uint32_t type;

uintptr_t flags;

const void* address;

uintptr_t offset;

uintptr_t size;

uint32_t link;

uint32_t info;

uintptr_t alignment;

uintptr_t entrySize;

enum Type {

TypeNull = 0,

TypeProgBits = 1,

TypeSymTab = 2,

TypeStrTab = 3,

TypeRela = 4,

TypeHash = 5,

TypeDynamic = 6,

TypeNote = 7,

TypeNoBits = 8,

TypeRel = 9,

TypeShLib = 10,

TypeDynSym = 11,

TypeLoProc = 0x70000000,

TypeX86_64Unwind = 0x70000001,

TypeHiProc = 0x7FFFFFFF,

TypeLoUser = 0x80000000,

TypeHiUser = 0xFFFFFFFF

};

enum Flags {

FlagWrite = 1,

FlagAlloc = 2,

FlagExec = 4

};

enum SpecialIndexes {

IndexAbsolute = 0xFFF1

};

ELFSection(const ASCIICString& name, Type type, uintptr_t align)

: m_type(type)

, m_name(name)

, m_align(align)

{

}

~ELFSection() override = default;

void populateHeader(Writer::Slot<Header>, ELFStringTable* strtab);

void writeBody(Writer::Slot<Header> header, Ref<Writer> writer) override

{

uintptr_t start = writer->position();

if (writeBodyInternal(writer)) {

uintptr_t end = writer->position();

header->offset = start;

header->size = end - start;

}

}

bool writeBodyInternal(Ref<Writer>) override { return false; }

uint16_t index() const { return m_index; }

void setIndex(uint16_t index) { m_index = index; }

const Type m_type;

virtual void populateHeader(Writer::Slot<Header> header)

{

header->flags = 0;

header->address = 0;

header->offset = 0;

header->size = 0;

header->link = 0;

header->info = 0;

header->entrySize = 0;

}

ASCIICString m_name;

uintptr_t m_align;

uint16_t m_index;

MachOTextSection(uint32_t align, const void* codeAddr, uintptr_t codeSize)

: MachOSection("__text"_s, "__TEXT"_s, align, codeAddr, codeSize, MachOSection::Regular | MachOSection::AttrSomeInstructions | MachOSection::AttrPureInstructions)

, m_codeAddr(reinterpret_cast<const uint64_t*>(codeAddr))

, m_codeSize(codeSize)

{

}

bool writeBodyInternal(Ref<Writer> writer) override

{

for (auto* ptr = m_codeAddr; ptr < m_codeAddr + m_codeSize / sizeof(uint64_t); ++ptr)

writer->write<uint64_t>(*ptr);

return true;

}

const uint64_t* m_codeAddr;

const size_t m_codeSize;

FullHeaderELFSection(const ASCIICString& name, Type type, uintptr_t align, const void* addr, uintptr_t offset, uintptr_t size, uintptr_t flags)

: ELFSection(name, type, align)

, m_addr(addr)

, m_offset(offset)

, m_size(size)

, m_flags(flags)

{

}

void populateHeader(Writer::Slot<Header> header) override

{

ELFSection::populateHeader(header);

header->address = m_addr;

header->offset = m_offset;

header->size = m_size;

header->flags = m_flags;

}

const void* m_addr;

uintptr_t m_offset;

uintptr_t m_size;

uintptr_t m_flags;

explicit ELFStringTable(const ASCIICString& name)

: ELFSection(name, TypeStrTab, 1)

, m_writer(nullptr)

, m_offset(0)

, m_size(0)

{

}

template<typename CharacterType> uintptr_t add(const CString<CharacterType>& str)

{

if (str.isEmpty())

return 0;

uintptr_t offset = m_size;

writeString(str);

return offset;

}

void attachWriter(Ref<Writer> w)

{

m_writer = w.ptr();

m_offset = m_writer->position();

// First entry in the string table should be an empty string.

writeString(ASCIICString { });

}

void detachWriter()

{

m_writer = nullptr;

}

void writeBody(Writer::Slot<Header> header, Ref<Writer>) override

{

ASSERT(!m_writer);

header->offset = m_offset;

header->size = m_size;

}

template<typename CharacterType> void writeString(const CString<CharacterType>& str)

{

for (auto c : str.span())

m_writer->write(c);

m_writer->write('\0');

m_size += str.length() + 1;

}

RefPtr<Writer> m_writer;

uintptr_t m_offset;

uintptr_t m_size;

{

header->name = static_cast<uint32_t>(strtab->add(m_name));

header->type = m_type;

header->alignment = m_align;

populateHeader(header);

WTF_DEPRECATED_MAKE_FAST_ALLOCATED(MachO);

size_t addSection(std::unique_ptr<MachOSection> section)

{

m_sections.append(WTF::move(section));

return m_sections.size() - 1;

}

void write(Ref<Writer> w, const UTF8CString& name, uintptr_t codeStart, uintptr_t)

{

Writer::Slot<MachOHeader> header = writeHeader(w);

uintptr_t loadCommandStart = w->position();

Vector<Writer::Slot<MachOSegmentCommand>> segmentCommands;

Vector<Writer::Slot<MachOSection::Header>> sectionHeadersForSegments;

for (auto& section : m_sections) {

segmentCommands.append(writeSegmentCommand(w, reinterpret_cast<uintptr_t>(section->addr()), section->size()));

sectionHeadersForSegments.append(w->createSlotHere<MachOSection::Header>());

}

auto symtabCmd = writeSymtabCommand(w, name);

header->sizeOfCommands = static_cast<uint32_t>(w->position() - loadCommandStart);

for (unsigned i = 0; i < m_sections.size(); ++i) {

auto segmentCmd = segmentCommands[i];

auto sectionHeader = sectionHeadersForSegments[i];

segmentCmd->fileOff = w->position();

m_sections[i]->populateHeader(sectionHeader);

m_sections[i]->writeBody(sectionHeader, w);

segmentCmd->fileSize = w->position() - segmentCmd->fileOff;

segmentCmd->vmSize = sectionHeader->size;

}

writeNList(w, symtabCmd, codeStart);

writeStringTable(w, name, symtabCmd);

}

struct MachOHeader {

uint32_t magic;

uint32_t cpuType;

uint32_t cpuSubtype;

uint32_t fileType;

uint32_t numCommands;

uint32_t sizeOfCommands;

uint32_t flags;

uint32_t reserved;

} __attribute__((packed,aligned(1)));

struct MachOSegmentCommand {

uint32_t cmd;

uint32_t cmdSize;

char segname[16];

uint64_t vmAddr;

uint64_t vmSize;

uint64_t fileOff;

uint64_t fileSize;

uint32_t maxProt;

uint32_t initProt;

uint32_t numSects;

uint32_t flags;

} __attribute__((packed,aligned(1)));

struct MachOSymtabCommand {

uint32_t cmd;

uint32_t cmdSize;

uint32_t symFileOff;

uint32_t numSyms;

uint32_t strFileOff;

uint32_t stringBytes;

} __attribute__((packed,aligned(1)));

enum MachOLoadCommandCmd {

LCSegment32 = 0x00000001u,

LCSymTab = 0x00000002u,

LCSegment64 = 0x00000019u,

};

enum NListType {

NAbs = 0x2,

NSect = 0xe,

};

enum NListDescription {

ReferenceFlagDefined = 0x2,

};

struct __attribute__((packed)) NList64 {

uint32_t index;

uint8_t type;

uint8_t section;

uint16_t desc;

uint64_t value;

};

Writer::Slot<MachOHeader> writeHeader(Ref<Writer> writer)

{

ASSERT(!writer->position());

Writer::Slot<MachOHeader> header = writer->createSlotHere<MachOHeader>();

#if CPU(ARM64)

header->magic = 0xFEEDFACFu;

header->cpuType = 0x0000000C | 0x01000000; // ARM | 64-bit ABI

header->cpuSubtype = 0x00000000; // All

header->reserved = 0;

#elif CPU(X86_64)

header->magic = 0xFEEDFACFu;

header->cpuType = 7 | 0x01000000; // i386 | 64-bit ABI

header->cpuSubtype = 3;

header->reserved = 0;

#else

#error Unsupported target architecture.

#endif

header->fileType = 0x1; // MH_OBJECT

header->numCommands = 3;

header->sizeOfCommands = 0;

header->flags = 0;

return header;

}

Writer::Slot<MachOSegmentCommand> writeSegmentCommand(Ref<Writer> writer, uintptr_t codeStart, uintptr_t codeSize)

{

auto cmd = writer->createSlotHere<MachOSegmentCommand>();

cmd->cmd = LCSegment64;

cmd->vmAddr = codeStart;

cmd->vmSize = codeSize;

cmd->fileOff = 0;

cmd->fileSize = 0;

cmd->maxProt = 7;

cmd->initProt = 7;

cmd->flags = 0;

cmd->numSects = 1;

memset(cmd->segname, 0, 16);

cmd->cmdSize = sizeof(MachOSegmentCommand) + sizeof(MachOSection::Header) * cmd->numSects;

return cmd;

}

Writer::Slot<MachOSymtabCommand> writeSymtabCommand(Ref<Writer> writer, const UTF8CString& name)

{

auto cmd = writer->createSlotHere<MachOSymtabCommand>();

cmd->cmd = LCSymTab;

cmd->symFileOff = 0;

cmd->numSyms = 1;

cmd->strFileOff = 0;

cmd->stringBytes = name.length() + 1;

cmd->cmdSize = sizeof(MachOSymtabCommand);

return cmd;

}

void writeNList(Ref<Writer> writer, Writer::Slot<MachOSymtabCommand> cmd, uintptr_t codeStart)

{

cmd->symFileOff = writer->position();

auto slot = writer->createSlotHere<NList64>();

slot->index = 1;

slot->type = NSect;

slot->section = 2;

slot->desc = 0;

slot->value = codeStart;

}

void writeStringTable(Ref<Writer> writer, const UTF8CString& name, Writer::Slot<MachOSymtabCommand> cmd)

{

cmd->strFileOff = writer->position();

writer->write<char>('\0'); // Index 0

for (auto c : name.span())

writer->write(c);

writer->write<char>('\0');

}

Vector<std::unique_ptr<MachOSection>> m_sections { };

explicit ELF()

{

m_sections.append(WTF::makeUnique<ELFSection>(""_s, ELFSection::TypeNull, 0));

m_sections.append(WTF::makeUnique<ELFStringTable>(".shstrtab"_s));

}

void write(Ref<Writer> writer)

{

writeHeader(writer);

writeSectionTable(writer);

writeSections(writer);

}

ELFSection* SectionAt(uint32_t index) { return m_sections[index].get(); }

size_t addSection(std::unique_ptr<ELFSection> section)

{

section->setIndex(m_sections.size());

m_sections.append(WTF::move(section));

return m_sections.size() - 1;

}

struct ELFHeader {

uint8_t ident[16];

uint16_t type;

uint16_t machine;

uint32_t version;

uintptr_t entry;

uintptr_t phtOffset;

uintptr_t shtOffset;

uint32_t flags;

uint16_t headerSize;

uint16_t phtEntrySize;

uint16_t phtEntryNum;

uint16_t shtEntrySize;

uint16_t shtEntryNum;

uint16_t shtStrTabIndex;

} __attribute__((packed,aligned(1)));

void writeHeader(Ref<Writer> writer)

{

ASSERT(!writer->position());

Writer::Slot<ELFHeader> header = writer->createSlotHere<ELFHeader>();

#if CPU(X86_64) || CPU(ARM64) || CPU(RISCV64)

const uint8_t ident[16] = {

0x7F, 'E', 'L', 'F', 2, 1, 1, 0,

0, 0, 0, 0, 0, 0, 0, 0

};

#else

#error Unsupported target architecture.

#endif

memcpy(header->ident, ident, 16);

header->type = 1;

#if CPU(X86_64)

// Processor identification value for x64 is 62 as defined in

// System V ABI, AMD64 Supplement

// http://www.x86-64.org/documentation/abi.pdf

header->machine = 62;

#elif CPU(ARM64)

// AARCH64

header->machine = 0xB7;

#elif CPU(RISCV64)

// RISC-V 64

header->machine = 0xF3;

#else

#error Unsupported target architecture.

#endif

header->version = 1;

header->entry = 0;

header->phtOffset = 0;

header->shtOffset = sizeof(ELFHeader); // Section table follows header.

header->flags = 0;

header->headerSize = sizeof(ELFHeader);

header->phtEntrySize = 0;

header->phtEntryNum = 0;

header->shtEntrySize = sizeof(ELFSection::Header);

header->shtEntryNum = m_sections.size();

header->shtStrTabIndex = 1;

}

void writeSectionTable(Ref<Writer> writer)

{

// Section headers table immediately follows file header.

ASSERT(writer->position() == sizeof(ELFHeader));

Writer::Slot<ELFSection::Header> headers = writer->createSlotsHere<ELFSection::Header>(

static_cast<uint32_t>(m_sections.size()));

// String table for section table is the first section.

ELFStringTable* strtab = static_cast<ELFStringTable*>(SectionAt(1));

ASSERT(strtab->m_type == ELFSection::TypeStrTab);

strtab->attachWriter(writer);

uint32_t index = 0;

for (auto& section : m_sections) {

section->populateHeader(headers.at(index), strtab);

index++;

}

strtab->detachWriter();

}

void writeSections(Ref<Writer> writer)

{

Writer::Slot<ELFSection::Header> headers = writer->slotAt<ELFSection::Header>(sizeof(ELFHeader));

uint32_t index = 0;

for (auto& section : m_sections) {

section->writeBody(headers.at(index), writer);

index++;

}

}

Vector<std::unique_ptr<ELFSection>> m_sections;

enum Type {

TypeNone = 0,

TypeObject = 1,

TypeFunction = 2,

TypeSection = 3,

TypeFile = 4,

TypeLoProc = 13,

TypeHiProc = 15

};

enum Binding {

BindLocal = 0,

BindGlobal = 1,

BindWeak = 2,

BindLoProc = 13,

BindHiProc = 15

};

ELFSymbol(const UTF8CString& name, uintptr_t value, uintptr_t size, Binding binding, Type type, uint16_t section)

: m_name(name)

, m_value(value)

, m_size(size)

, m_info((binding << 4) | type)

, m_other(0)

, m_section(section)

{

}

Binding binding() const { return static_cast<Binding>(m_info >> 4); }

#if CPU(X86_64) || CPU(ARM64) || CPU(RISCV64)

struct SerializedLayout {

SerializedLayout(uint32_t name, uintptr_t value, uintptr_t size, Binding binding, Type type, uint16_t section)

: m_name(name)

, m_info((binding << 4) | type)

, m_other(0)

, m_section(section)

, m_value(value)

, m_size(size)

{

}

uint32_t m_name;

uint8_t m_info;

uint8_t m_other;

uint16_t m_section;

uintptr_t m_value;

uintptr_t m_size;

} __attribute__((packed,aligned(1)));

#endif

void write(Writer::Slot<SerializedLayout> slot, ELFStringTable* table) const

{

// Convert symbol names from strings to indexes in the string table.

slot->m_name = static_cast<uint32_t>(table->add(m_name));

slot->m_value = m_value;

slot->m_size = m_size;

slot->m_info = m_info;

slot->m_other = m_other;

slot->m_section = m_section;

}

UTF8CString m_name;

uintptr_t m_value;

uintptr_t m_size;

uint8_t m_info;

uint8_t m_other;

uint16_t m_section;