belka/elna
1
0
Fork 0
Code Issues 2 Pull Requests Releases Activity
elna/source/elna/elf.d

1061 lines
28 KiB
D
Raw Blame History

module elna.elf;
import elna.extended;
import elna.result;
import std.algorithm;
import tanya.container.array;
import tanya.container.hashtable;
import tanya.container.string;
/// Unsigned program address.
alias Elf64_Addr = ulong;
/// Unsigned file offset.
alias Elf64_Off = ulong;
/// Unsigned medium integer.
alias Elf64_Half = ushort;
/// Unsigned integer.
alias Elf64_Word = uint;
/// Signed integer.
alias Elf64_Sword = int;
/// Unsigned long integer.
alias Elf64_Xword = ulong;
/// Signed long integer.
alias Elf64_Sxword = long;
/// Unsigned program address.
alias Elf32_Addr = uint;
/// Unsigned file offset.
alias Elf32_Off = uint;
/// Unsigned medium integer.
alias Elf32_Half = ushort;
/// Unsigned integer.
alias Elf32_Word = uint;
/// Signed integer.
alias Elf32_Sword = int;
enum : size_t
{
/// File identification.
EI_MAG0 = 0,
/// File identification.
EI_MAG1 = 1,
/// File identification.
EI_MAG2 = 2,
/// File identification.
EI_MAG3 = 3,
/// File class.
EI_CLASS = 4,
/// Data encoding.
EI_DATA = 5,
/// File version.
EI_VERSION = 6,
/// Start of padding bytes.
EI_PAD = 7,
/// Size of e_ident[]
EI_NIDENT = 16
}
enum : ubyte
{
/// e_ident[EI_MAG0].
ELFMAG0 = 0x7f,
/// e_ident[EI_MAG1].
ELFMAG1 = 'E',
/// e_ident[EI_MAG2].
ELFMAG2 = 'L',
/// e_ident[EI_MAG3].
ELFMAG3 = 'F'
}
/**
* File header.
*/
struct Elf64_Ehdr
{
/// ELF identification.
ubyte[EI_NIDENT] e_ident;
/// Object file type.
Elf64_Half e_type;
/// Machine type.
Elf64_Half e_machine;
/// Object file version
Elf64_Word e_version;
/// Entry point address.
Elf64_Addr e_entry;
/// Program header offset.
Elf64_Off e_phoff;
/// Section header offset.
Elf64_Off e_shoff;
/// Processor-specific flags.
Elf64_Word e_flags;
/// ELF header size.
Elf64_Half e_ehsize;
/// Size of program header entry.
Elf64_Half e_phentsize;
/// Number of program header entries.
Elf64_Half e_phnum;
/// Size of section header entry.
Elf64_Half e_shentsize;
/// Number of section header entries.
Elf64_Half e_shnum;
/// Section name string table index.
Elf64_Half e_shstrndx;
}
/**
* File header.
*/
struct Elf32_Ehdr {
/// ELF identification.
ubyte[EI_NIDENT] e_ident;
/// Object file type.
Elf32_Half e_type;
/// Machine type.
Elf32_Half e_machine;
/// Object file version
Elf32_Word e_version;
/// Entry point address.
Elf32_Addr e_entry;
/// Program header offset.
Elf32_Off e_phoff;
/// Section header offset.
Elf32_Off e_shoff;
/// Processor-specific flags.
Elf32_Word e_flags;
/// ELF header size.
Elf32_Half e_ehsize;
/// Size of program header entry.
Elf32_Half e_phentsize;
/// Number of program header entries.
Elf32_Half e_phnum;
/// Size of section header entry.
Elf32_Half e_shentsize;
/// Number of section header entries.
Elf32_Half e_shnum;
/// Section name string table index.
Elf32_Half e_shstrndx;
}
/**
* Section header.
*/
struct Elf64_Shdr
{
/// Section name.
Elf64_Word sh_name;
/// Section type.
Elf64_Word sh_type;
/// Section attributes.
Elf64_Xword sh_flags;
/// Virtual address in memory.
Elf64_Addr sh_addr;
/// Offset in file.
Elf64_Off sh_offset;
/// Size of section.
Elf64_Xword sh_size;
/// Link to other section.
Elf64_Word sh_link;
/// Miscellaneous information.
Elf64_Word sh_info;
/// Address alignment boundary.
Elf64_Xword sh_addralign;
/// Size of entries, if section has table.
Elf64_Xword sh_entsize;
}
/**
* Section header.
*/
struct Elf32_Shdr
{
/// Section name.
Elf32_Word sh_name;
/// Section type.
Elf32_Word sh_type;
/// Section attributes.
Elf32_Word sh_flags;
/// Virtual address in memory.
Elf32_Addr sh_addr;
/// Offset in file.
Elf32_Off sh_offset;
/// Size of section.
Elf32_Word sh_size;
/// Link to other section.
Elf32_Word sh_link;
/// Miscellaneous information.
Elf32_Word sh_info;
/// Address alignment boundary.
Elf32_Word sh_addralign;
/// Size of entries, if section has table.
Elf32_Word sh_entsize;
}
/**
* Symbol table entry.
*/
struct Elf64_Sym
{
/// Symbol name.
Elf64_Word st_name;
/// Type and Binding attributes.
ubyte st_info;
/// Reserved.
ubyte st_other;
/// Section table index.
Elf64_Half st_shndx;
/// Symbol value.
Elf64_Addr st_value;
/// Size of object (e.g., common).
Elf64_Xword st_size;
}
/**
* Relocation entry.
*/
struct Elf64_Rel
{
/// Address of reference.
Elf64_Addr r_offset;
/// Symbol index and type of relocation.
Elf64_Xword r_info;
}
/**
* Relocation entry with explicit addend.
*/
struct Elf64_Rela
{
/// Address of reference.
Elf64_Addr r_offset;
/// Symbol index and type of relocation.
Elf64_Xword r_info;
/// Constant part of expression.
Elf64_Sxword r_addend;
}
/**
* Symbol table entry.
*/
struct Elf32_Sym
{
/// Symbol name.
Elf32_Word st_name;
/// Symbol value.
Elf32_Addr st_value;
/// Size of object (e.g., common).
Elf32_Word st_size;
/// Type and Binding attributes.
ubyte st_info;
/// Reserved.
ubyte st_other;
/// Section table index.
Elf32_Half st_shndx;
}
/**
* Relocation entry.
*/
struct Elf32_Rel
{
/// Address of reference.
Elf32_Addr r_offset;
/// Symbol index and type of relocation.
Elf32_Word r_info;
}
/**
* Relocation entry with explicit addend.
*/
struct Elf32_Rela
{
/// Address of reference.
Elf32_Addr r_offset;
/// Symbol index and type of relocation.
Elf32_Word r_info;
/// Constant part of expression.
Elf32_Sword r_addend;
}
/// Section Types, sh_type.
enum : Elf64_Word
{
/// Marks an unused section header.
SHT_NULL = 0,
/// Contains information defined by the program.
SHT_PROGBITS = 1,
/// Contains a linker symbol table.
SHT_SYMTAB = 2,
/// Contains a string table.
SHT_STRTAB = 3,
/// Contains “Rela” type relocation entries.
SHT_RELA = 4,
/// Contains a symbol hash table
SHT_HASH = 5,
/// Contains dynamic linking tables
SHT_DYNAMIC = 6,
/// Contains note information
SHT_NOTE = 7,
/// Contains uninitialized space; does not occupy any space in the file.
SHT_NOBITS = 8,
/// Contains "Rel" type relocation entries.
SHT_REL = 9,
/// Reserved.
SHT_SHLIB = 10,
/// Contains a dynamic loader symbol table.
SHT_DYNSYM = 11,
/// Environment-specific use.
SHT_LOOS = 0x60000000,
SHT_HIOS = 0x6FFFFFFF,
/// Processor-specific use.
SHT_LOPROC = 0x70000000,
SHT_HIPROC = 0x7FFFFFFF,
}
/**
* Section Attributes, sh_flags.
*/
enum : Elf64_Xword
{
/// Section contains writable data.
SHF_WRITE = 0x1,
/// Section is allocated in memory image of program.
SHF_ALLOC = 0x2,
/// Section contains executable instructions.
SHF_EXECINSTR = 0x4,
/// Environment-specific use.
SHF_MASKOS = 0x0F000000,
/// Processor-specific use.
SHF_MASKPROC = 0xF0000000,
}
ubyte ELF64_R_SYM(Elf64_Xword i) @nogc nothrow pure @safe
{
return cast(ubyte) (i >> 32);
}
Elf64_Xword ELF64_R_TYPE(Elf64_Xword i) @nogc nothrow pure @safe
{
return i & 0xffffffffL;
}
Elf64_Xword ELF64_R_INFO(Elf64_Xword s, Elf64_Xword t) @nogc nothrow pure @safe
{
return (s << 32) + (t & 0xffffffffL);
}
ubyte ELF32_ST_BIND(ubyte i) @nogc nothrow pure @safe
{
return i >> 4;
}
ubyte ELF32_ST_TYPE(ubyte i) @nogc nothrow pure @safe
{
return i & 0xf;
}
ubyte ELF32_ST_INFO(Elf32_Word b, ubyte t) @nogc nothrow pure @safe
{
return cast(ubyte) ((b << 4) + (t & 0xf));
}
Elf32_Word ELF32_R_SYM(Elf32_Word i) @nogc nothrow pure @safe
{
return i >> 8;
}
ubyte ELF32_R_TYPE(Elf32_Word i) @nogc nothrow pure @safe
{
return cast(ubyte) i;
}
Elf32_Word ELF32_R_INFO(Elf32_Word s, Elf32_Word t) @nogc nothrow pure @safe
{
return (s << 8) + t;
}
enum : uint
{
/// Not visible outside the object file.
STB_LOCAL = 0,
/// Global symbol, visible to all object files.
STB_GLOBAL = 1,
/// Global scope, but with lower precedence than global symbols.
STB_WEAK = 2,
/// Environment-specific use.
STB_LOOS = 10,
STB_HIOS = 12,
/// Processor-specific use.
STB_LOPROC = 13,
STB_HIPROC = 15,
}
enum : uint
{
/// No type specified (e.g., an absolute symbol).
STT_NOTYPE = 0,
/// Data object.
STT_OBJECT = 1,
/// Function entry point.
STT_FUNC = 2,
/// Symbol is associated with a section.
STT_SECTION = 3,
/// Source file associated with the object file.
STT_FILE = 4,
/// Environment-specific use.
STT_LOOS = 10,
STT_HIOS = 12,
/// Processor-specific use.
STT_LOPROC = 13,
STT_HIPROC = 15,
}
/// Special Section Indices.
enum : ushort
{
/// Used to mark an undefined or meaningless section reference.
SHN_UNDEF = 0,
/// This value specifies the lower bound of the range of reserved indexes.
SHN_LORESERVE = 0xff00,
/// Processor-specific use.
SHN_LOPROC = 0xFF00,
SHN_HIPROC = 0xFF1F,
/// Environment-specific use.
SHN_LOOS = 0xFF20,
SHN_HIOS = 0xFF3F,
/// Indicates that the corresponding reference is an absolute value.
SHN_ABS = 0xFFF1,
/**
* Indicates a symbol that has been declared as a common block (Fortran
* COMMON or C tentative declaration).
*/
SHN_COMMON = 0xFFF2,
}
/**
* Object File Classes, e_ident[EI_CLASS].
*/
enum : ubyte
{
/// Invalid class.
ELFCLASSNONE = 0,
/// 32-bit objects.
ELFCLASS32 = 1,
/// 64-bit objects.
ELFCLASS64 = 2
}
enum : ubyte {
/// Invalid version.
EV_NONE = 0,
/// Current version.
EV_CURRENT = 1
}
/**
* Data Encodings, e_ident[EI_DATA].
*/
enum : ubyte
{
/// Object file data structures are little-endian.
ELFDATA2LSB = 1,
/// Object file data structures are big-endian.
ELFDATA2MSB = 2,
}
/**
* Operating System and ABI Identifiers, e_ident[EI_OSABI].
*/
enum EI_OSABI : ubyte
{
/// System V ABI.
ELFOSABI_SYSV = 0,
/// HP-UX operating system.
ELFOSABI_HPUX = 1,
/// Standalone (embedded) application.
ELFOSABI_STANDALONE = 255,
}
enum : Elf64_Half
{
ET_NONE = 0, /// No file type.
ET_REL = 1, /// Relocatable object file.
ET_EXEC = 2, /// Executable file.
ET_DYN = 3, /// Shared object file.
ET_CORE = 4, /// Core file.
ET_LOOS = 0xFE00, /// Environment-specific use.
ET_HIOS = 0xFEFF,
ET_LOPROC = 0xFF00, /// Processor-specific use.
ET_HIPROC = 0xFFFF,
}
enum : ubyte
{
R_RISCV_NONE = 0,
/// 32-bit relocation.
R_RISCV_32 = 1,
/// 64-bit relocation.
R_RISCV_64 = 2,
/// Relocation against a local symbol in a shared object.
R_RISCV_RELATIVE = 3,
/// Must be in executable; not allowed in shared library.
R_RISCV_COPY = 4,
/// Indicates the symbol associated with a PLT entry.
R_RISCV_JUMP_SLOT = 5,
R_RISCV_TLS_DTPMOD32 = 6,
R_RISCV_TLS_DTPMOD64 = 7,
R_RISCV_TLS_DTPREL32 = 8,
R_RISCV_TLS_DTPREL64 = 9,
R_RISCV_TLS_TPREL32 = 10,
R_RISCV_TLS_TPREL64 = 11,
/// 12-bit PC-relative branch offset.
R_RISCV_BRANCH = 16,
/// 20-bit PC-relative jump offset.
R_RISCV_JAL = 17,
/// 32-bit PC-relative function call, macros `call`, `tail`.
R_RISCV_CALL = 18,
/// 32-bit PC-relative function call, macros `call`, `tail` (PIC).
R_RISCV_CALL_PLT = 19,
/// High 20 bits of 32-bit PC-relative GOT access, `%got_pcrel_hi(symbol)`.
R_RISCV_GOT_HI20 = 20,
/// High 20 bits of 32-bit PC-relative TLS IE GOT access, macro `la.tls.ie`.
R_RISCV_TLS_GOT_HI20 = 21,
/// High 20 bits of 32-bit PC-relative TLS GD GOT reference, macro `la.tls.gd`.
R_RISCV_TLS_GD_HI20 = 22,
/// High 20 bits of 32-bit PC-relative reference, `%pcrel_hi(symbol)`.
R_RISCV_PCREL_HI20 = 23,
/// Low 12 bits of a 32-bit PC-relative, `%pcrel_lo(address of %pcrel_hi)`, the addend must be 0.
R_RISCV_PCREL_LO12_I = 24,
/// Low 12 bits of a 32-bit PC-relative, `%pcrel_lo(address of %pcrel_hi)`, the addend must be 0.
R_RISCV_PCREL_LO12_S = 25,
/// High 20 bits of 32-bit absolute address, `%hi(symbol)`.
R_RISCV_HI20 = 26,
/// Low 12 bits of 32-bit absolute address, `%lo(symbol)`.
R_RISCV_LO12_I = 27,
/// Low 12 bits of 32-bit absolute address, `%lo(symbol)`.
R_RISCV_LO12_S = 28,
/// High 20 bits of TLS LE thread pointer offset, `%tprel_hi(symbol)`.
R_RISCV_TPREL_HI20 = 29,
/// Low 12 bits of TLS LE thread pointer offset, `%tprel_lo(symbol)`.
R_RISCV_TPREL_LO12_I = 30,
/// Low 12 bits of TLS LE thread pointer offset, `%tprel_lo(symbol)`.
R_RISCV_TPREL_LO12_S = 31,
/// TLS LE thread pointer usage, `%tprel_add(symbol)`.
R_RISCV_TPREL_ADD = 32,
/// 8-bit label addition.
R_RISCV_ADD8 = 33,
/// 16-bit label addition.
R_RISCV_ADD16 = 34,
/// 32-bit label addition.
R_RISCV_ADD32 = 35,
/// 64-bit label addition.
R_RISCV_ADD64 = 36,
/// 8-bit label subtraction.
R_RISCV_SUB8 = 37,
/// 16-bit label subtraction.
R_RISCV_SUB16 = 38,
/// 32-bit label subtraction.
R_RISCV_SUB32 = 39,
/// 64-bit label subtraction.
R_RISCV_SUB64 = 40,
/// GNU {Cpp} vtable hierarchy.
R_RISCV_GNU_VTINHERIT = 41,
/// GNU {Cpp} vtable member usage.
R_RISCV_GNU_VTENTRY = 42,
/// Alignment statement.
R_RISCV_ALIGN = 43,
/// 8-bit PC-relative branch offset.
R_RISCV_RVC_BRANCH = 44,
/// 11-bit PC-relative jump offset.
R_RISCV_RVC_JUMP = 45,
/// High 6 bits of 18-bit absolute address.
R_RISCV_RVC_LUI = 46,
/// Instruction can be relaxed, paired with a normal relocation at the same address.
R_RISCV_RELAX = 51,
/// Local label subtraction.
R_RISCV_SUB6 = 52,
/// Local label assignment.
R_RISCV_SET6 = 53,
/// Local label assignment.
R_RISCV_SET8 = 54,
/// Local label assignment.
R_RISCV_SET16 = 55,
/// Local label assignment.
R_RISCV_SET32 = 56,
/// 32-bit PC relative.
R_RISCV_32_PCREL = 57,
/// Relocation against a local ifunc symbol in a shared object.
R_RISCV_IRELATIVE = 58
}
auto pad(ubyte elfClass)(size_t value) @nogc
{
static if (elfClass == ELFCLASS32)
{
return cast(Elf32_Word) (value / 4 + 1) * 4;
}
else static if (elfClass == ELFCLASS64)
{
return cast(Elf64_Xword) (value / 8 + 1) * 8;
}
else
{
static assert(false, "Invalid ELF class");
}
}
private struct Relocation(Sym, Rel)
{
Sym symbol;
Array!Rel relocations;
}
struct Elf(ubyte elfClass)
{
static if (elfClass == ELFCLASS32)
{
alias Addr = Elf32_Addr;
alias Off = Elf32_Off;
alias Half = Elf32_Half;
alias Word = Elf32_Word;
alias Sword = Elf32_Sword;
alias Xword = Elf32_Word;
alias Sxword = Elf32_Sword;
alias Ehdr = Elf32_Ehdr;
alias Shdr = Elf32_Shdr;
alias Rel = Elf32_Rel;
alias Rela = Elf32_Rela;
alias Sym = Elf32_Sym;
alias R_SYM = ELF32_R_SYM;
alias R_TYPE = ELF32_R_TYPE;
alias R_INFO = ELF32_R_INFO;
alias ST_BIND = ELF32_ST_BIND;
alias ST_TYPE = ELF32_ST_TYPE;
alias ST_INFO = ELF32_ST_INFO;
}
else static if (elfClass == ELFCLASS64)
{
alias Addr = Elf64_Addr;
alias Off = Elf64_Off;
alias Half = Elf64_Half;
alias Word = Elf64_Word;
alias Sword = Elf64_Sword;
alias Xword = Elf64_Xword;
alias Sxword = Elf64_Sxword;
alias Ehdr = Elf64_Ehdr;
alias Shdr = Elf64_Shdr;
alias Rel = Elf64_Rel;
alias Rela = Elf64_Rela;
alias Sym = Elf64_Sym;
alias R_SYM = ELF64_R_SYM;
alias R_TYPE = ELF64_R_TYPE;
alias R_INFO = ELF64_R_INFO;
alias ST_BIND = ELF64_ST_BIND;
alias ST_TYPE = ELF64_ST_TYPE;
alias ST_INFO = ELF64_ST_INFO;
}
else
{
static assert(false, "Invalid ELF class");
}
private alias Relocation = .Relocation!(Sym, Rela);
private Array!Shdr sectionHeaders;
private Off currentOffset = Elf32_Ehdr.sizeof;
static immutable char[52] sections =
"\0.symtab\0.strtab\0.shstrtab\0.text\0.rodata\0.rela.text\0";
private String strings;
private File output;
private Array!ubyte readOnly;
private HashTable!(String, Relocation) symbolTable;
private enum HeaderName
{
text = 0x1b,
roData = 0x21,
string_ = 0x09,
headerString = 0x11,
symbol = 0x01,
rela = 0x29
}
static Elf opCall(File output) @nogc
{
Elf elf = Elf.init;
elf.initializeSectionHeaders();
elf.output = move(output);
elf.output.seek(Ehdr.sizeof, File.Whence.set);
elf.makeTextHeader();
elf.makeRoDataHeader();
elf.makeSymbolHeader();
elf.makeRelaHeader();
elf.makeStringHeader!(HeaderName.string_)();
elf.makeStringHeader!(HeaderName.headerString)();
return elf;
}
@disable this(this);
void finish() @nogc
{
writeRoDataTable();
writeSymbolTable();
writeStringTables();
// End writing data, start writing headers.
output.write((cast(ubyte*) this.sectionHeaders.get)[0 .. Shdr.sizeof * this.sectionHeaders.length]);
writeFileHeader();
}
private Sym initializeSymbols() @nogc
{
// Zero symbol
Sym symbol;
symbol.st_name = 0; // Word
symbol.st_value = 0; // Addr
symbol.st_size = 0; // Word
symbol.st_info = 0; // char
symbol.st_other = 0; // char
symbol.st_shndx = 0; // Half word
return symbol;
}
private void makeStringHeader(HeaderName position)() @nogc
{
Shdr table;
table.sh_name = position;
table.sh_type = SHT_STRTAB;
table.sh_flags = 0;
table.sh_addr = 0;
table.sh_offset = 0;
table.sh_size = 0;
table.sh_link = SHN_UNDEF;
table.sh_info = 0;
table.sh_addralign = 1;
table.sh_entsize = 0;
this.sectionHeaders.insertBack(table);
}
private void writeStringTables() @nogc
{
auto stringIndex = findHeader!(HeaderName.string_);
assert(stringIndex != -1);
this.sectionHeaders[stringIndex].sh_offset = this.currentOffset;
this.sectionHeaders[stringIndex].sh_size = cast(Word) strings.length;
output.write(cast(ubyte[]) this.strings.toStringz[0 .. this.strings.length + 1]);
this.currentOffset += this.strings.length + 1;
auto headerStringIndex = findHeader!(HeaderName.headerString);
assert(stringIndex != -1);
this.sectionHeaders[headerStringIndex].sh_offset = this.currentOffset;
this.sectionHeaders[headerStringIndex].sh_size = cast(Word) sections.length;
output.write(cast(const(ubyte)[]) this.sections);
this.currentOffset += this.sections.length;
auto alignment = pad!ELFCLASS32(this.strings.length + 1 + this.sections.length);
const(ubyte)[4] padding = 0;
output.write(padding[0 .. alignment - this.strings.length - 1 - this.sections.length]);
this.currentOffset += alignment - this.strings.length - 1 - this.sections.length;
}
private void makeSymbolHeader() @nogc
{
Shdr symbolTableHeader;
symbolTableHeader.sh_name = HeaderName.symbol;
symbolTableHeader.sh_type = SHT_SYMTAB;
symbolTableHeader.sh_flags = 0;
symbolTableHeader.sh_addr = 0;
symbolTableHeader.sh_offset = 0;
symbolTableHeader.sh_size = 0;
// String table used by entries in this section.
symbolTableHeader.sh_link = 0;
symbolTableHeader.sh_info = 0;
symbolTableHeader.sh_addralign = 4;
symbolTableHeader.sh_entsize = Sym.sizeof;
this.sectionHeaders.insertBack(symbolTableHeader);
}
private void writeSymbolTable() @nogc
{
const index = findHeader!(HeaderName.symbol)();
const stringIndex = findHeader!(HeaderName.string_)();
const relaIndex = findHeader!(HeaderName.rela);
const textIndex = findHeader!(HeaderName.text)();
assert(index != -1);
assert(stringIndex != -1);
assert(relaIndex != -1);
assert(textIndex != -1);
this.sectionHeaders[index].sh_offset = this.currentOffset;
this.sectionHeaders[index].sh_link = cast(Word) stringIndex;
this.sectionHeaders[index].sh_size = cast(Word) ((1 + symbolTable.length) * Sym.sizeof);
this.sectionHeaders[relaIndex].sh_link = cast(Word) index;
this.sectionHeaders[relaIndex].sh_info = cast(Word) textIndex;
this.sectionHeaders[relaIndex].sh_offset = this.sectionHeaders[index].sh_offset
+ this.sectionHeaders[index].sh_size;
auto initialSymbol = initializeSymbols();
output.write((cast(ubyte*) &initialSymbol)[0 .. Sym.sizeof]);
this.currentOffset += Sym.sizeof;
int i = 1;
Array!Relocation symbols = Array!Relocation(this.symbolTable.byValue());
auto rightRange = symbols[].partition!(symbol => ST_BIND(symbol.symbol.st_info) != STB_GLOBAL);
// Greater than last local symbol.
this.sectionHeaders[index].sh_info = cast(Word) (symbols.length - rightRange.length + 1);
foreach (ref symbol; symbols[])
{
this.output.seek(this.sectionHeaders[relaIndex].sh_offset + this.sectionHeaders[relaIndex].sh_size,
File.Whence.set);
if (!symbol.relocations.empty)
{
foreach (ref relocation; symbol.relocations[])
{
relocation.r_info = R_INFO(i, R_TYPE(relocation.r_info));
}
this.sectionHeaders[relaIndex].sh_flags = SHF_ALLOC;
const size = cast(Word) (Rela.sizeof * symbol.relocations.length);
this.output.write((cast(ubyte*) symbol.relocations.get)[0 .. size]);
this.sectionHeaders[relaIndex].sh_size += size;
this.currentOffset += size;
}
this.output.seek(this.sectionHeaders[index].sh_offset + i * Sym.sizeof, File.Whence.set);
output.write((cast(ubyte*) &symbol)[0 .. Sym.sizeof]);
this.currentOffset += Sym.sizeof;
++i;
}
this.output.seek(0, File.Whence.end);
}
void addCode(String name, ref Array!ubyte text)
@nogc
{
this.output.write(text.get);
auto textHeaderIndex = findHeader!(HeaderName.text)();
assert(textHeaderIndex != -1);
this.strings.insertBack("\0");
Sym symbol;
// Main function
symbol.st_name = cast(Word) this.strings.length;
symbol.st_value = 0;
symbol.st_size = cast(Word) text.length;
symbol.st_info = ST_INFO(STB_GLOBAL, STT_FUNC);
symbol.st_other = 0; // char
// .text header index, half word
symbol.st_shndx = cast(Half) textHeaderIndex;
this.symbolTable[name] = Relocation(symbol);
this.strings.insertBack(name[]);
this.sectionHeaders[textHeaderIndex].sh_size += text.length;
this.currentOffset += text.length;
}
void addReadOnlyData(String name, ref Array!ubyte data) @nogc
{
auto roDataIndex = findHeader!(HeaderName.roData)();
assert(roDataIndex != -1);
this.strings.insertBack("\0");
Sym symbol;
// Main function
symbol.st_name = cast(Word) this.strings.length;
symbol.st_value = 0;
symbol.st_size = cast(Word) data.length;
symbol.st_info = ST_INFO(STB_LOCAL, STT_NOTYPE);
symbol.st_other = 0; // char
// .text header index, half word
symbol.st_shndx = cast(Half) roDataIndex;
this.symbolTable[name] = Relocation(symbol);
this.strings.insertBack(name[]);
this.readOnly.insertBack(data[]);
}
void addExternSymbol(String name) @nogc
{
Sym usedSymbolEntry;
this.strings.insertBack("\0");
usedSymbolEntry.st_name = cast(Word) this.strings.length;
usedSymbolEntry.st_value = 0;
usedSymbolEntry.st_size = 0;
usedSymbolEntry.st_info = ST_INFO(STB_GLOBAL, STT_NOTYPE);
usedSymbolEntry.st_other = 0;
usedSymbolEntry.st_shndx = SHN_UNDEF;
this.strings.insertBack(name[]);
this.strings.insertBack("\0");
this.symbolTable[name] = Relocation(usedSymbolEntry);
}
void relocate(String name, Rela[] usedSymbols...) @nogc
{
foreach (usedSymbol; usedSymbols)
{
Rela relocationEntry = usedSymbol;
relocationEntry.r_info = usedSymbol.r_info;
this.symbolTable[name].relocations.insertBack(relocationEntry);
}
}
private ptrdiff_t findHeader(HeaderName position)()
{
return countUntil!(header => header.sh_name == position)(this.sectionHeaders[]);
}
private void makeTextHeader() @nogc
{
Shdr textHeader;
textHeader.sh_name = HeaderName.text;
textHeader.sh_type = SHT_PROGBITS;
textHeader.sh_flags = SHF_EXECINSTR | SHF_ALLOC;
textHeader.sh_addr = 0;
textHeader.sh_offset = this.currentOffset;
textHeader.sh_size = 0;
textHeader.sh_link = SHN_UNDEF;
textHeader.sh_info = 0;
textHeader.sh_addralign = 1;
textHeader.sh_entsize = 0;
this.sectionHeaders.insertBack(textHeader);
}
private void initializeSectionHeaders() @nogc
{
Shdr table;
table.sh_name = 0;
table.sh_type = SHT_NULL;
table.sh_flags = 0;
table.sh_addr = 0;
table.sh_offset = 0;
table.sh_size = 0;
table.sh_link = SHN_UNDEF;
table.sh_info = 0;
table.sh_addralign = 0;
table.sh_entsize = 0;
this.sectionHeaders.insertBack(table);
}
private void writeFileHeader() @nogc
{
Ehdr fileHeader;
auto headerStringIndex = findHeader!(HeaderName.headerString)();
assert(headerStringIndex != -1);
// Magic number.
fileHeader.e_ident[0] = '\x7f';
fileHeader.e_ident[1] = 'E';
fileHeader.e_ident[2] = 'L';
fileHeader.e_ident[3] = 'F';
fileHeader.e_ident[4] = ELFCLASS32;
fileHeader.e_ident[5] = ELFDATA2LSB;
fileHeader.e_ident[6] = EV_CURRENT;
fileHeader.e_ident[7] = EI_OSABI.ELFOSABI_SYSV;
fileHeader.e_ident[8] = 0;
fileHeader.e_type = ET_REL;
fileHeader.e_machine = 0xf3; // EM_RISCV
fileHeader.e_version = EV_CURRENT;
fileHeader.e_entry = 0;
fileHeader.e_phoff = 0;
fileHeader.e_shoff = this.currentOffset;
fileHeader.e_flags = 0;
fileHeader.e_ehsize = Elf32_Ehdr.sizeof;
fileHeader.e_phentsize = 0;
fileHeader.e_phnum = 0;
fileHeader.e_shentsize = Elf32_Shdr.sizeof;
fileHeader.e_shnum = cast(Elf32_Half) this.sectionHeaders.length;
// String table is the last one
fileHeader.e_shstrndx = cast(Half) headerStringIndex;
output.seek(0, File.Whence.set);
output.write((cast(ubyte*) &fileHeader)[0 .. fileHeader.sizeof]);
}
private void makeRoDataHeader() @nogc
{
Shdr table;
table.sh_name = HeaderName.roData;
table.sh_type = SHT_PROGBITS;
table.sh_flags = SHF_ALLOC;
table.sh_addr = 0;
table.sh_offset = 0;
table.sh_size = 0;
table.sh_link = SHN_UNDEF;
table.sh_info = 0;
table.sh_addralign = 4;
table.sh_entsize = 0;
this.sectionHeaders.insertBack(table);
}
private void writeRoDataTable() @nogc
{
auto index = findHeader!(HeaderName.roData)();
assert(index != -1);
this.sectionHeaders[index].sh_offset = this.currentOffset;
this.sectionHeaders[index].sh_size = cast(Xword) this.readOnly.length;
output.write(this.readOnly.get);
this.currentOffset += this.readOnly.length;
}
private void makeRelaHeader() @nogc
{
Shdr table;
table.sh_name = HeaderName.rela;
table.sh_type = SHT_RELA;
table.sh_flags = 0;
table.sh_addr = 0;
table.sh_offset = 0;
table.sh_size = 0;
table.sh_link = SHN_UNDEF;
table.sh_info = 0;
table.sh_addralign = 4;
table.sh_entsize = Rela.sizeof;
this.sectionHeaders.insertBack(table);
}
}
Reference in New Issue View Git Blame Copy Permalink