pe work

src/backend/container/elf.rs

@@ -0,0 +1,129 @@
+use crate::backend::{Addr, LinkedProgram, container::as_u8_slice};
+
+#[repr(C)]
+pub struct ELF64Header {
+    magic: u32,
+    class: u8,
+    endianness: u8,
+    ei_version: u8,
+    os_abi: u8,
+    os_abi_ver: u8,
+    pad: [u8; 7],
+    ty: u16,
+    machine: u16,
+    e_version: u32,
+    entry: u64,
+    program_header_offset: u64,
+    section_header_offset: u64,
+    flags: u32,
+    header_size: u16,
+    program_header_entry_size: u16,
+    program_header_num: u16,
+    section_header_entry_size: u16,
+    section_header_num: u16,
+    section_header_str_idx: u16,
+}
+
+#[repr(C)]
+pub struct ProgramHeader {
+    ty: u32,
+    flags: u32,
+    offset: u64,
+    vaddr: u64,
+    paddr: u64,
+    filesz: u64,
+    memsz: u64,
+    align: u64,
+}
+
+#[repr(C)]
+pub struct SectionHeader {
+    name_idx: u32,
+    ty: u32,
+    flags: u64,
+    addr: u64,
+    offset: u64,
+    size: u64,
+    link: u32,
+    info: u32,
+    addr_align: u64,
+    entry_size: u64,
+}
+
+pub enum Arch {
+    X86_64,
+    Riscv,
+}
+
+impl Arch {
+    pub fn machine(&self) -> u16 {
+        match self {
+            Arch::X86_64 => 0x3e,
+            Arch::Riscv => 0xf3,
+        }
+    }
+}
+
+#[repr(u8)]
+pub enum EType {
+    None = 0,
+    Rel = 1,
+    Exec = 2,
+    Dyn = 3,
+    Core = 4,
+}
+
+// this is currently specialized for x86_64; obviously add params later
+pub fn create(program: &[u8], start_offset: u64) -> Vec<u8> {
+    let pie = true;
+    let addr_start = if pie { 0 } else { 0x400000 };
+    let page_size = 0x1000;
+    // I don't know if I have to add addr_start here, idk how it maps the memory
+    let program_size = std::mem::size_of_val(program) as u64;
+    let program_header = ProgramHeader {
+        ty: 0x1,      // LOAD
+        flags: 0b101, // executable, readable
+        offset: 0x0,
+        vaddr: addr_start,
+        paddr: 0x0,
+        filesz: program_size,
+        memsz: program_size,
+        align: page_size,
+    };
+    let header_len = (size_of::<ELF64Header>() + size_of::<ProgramHeader>()) as u64;
+    let program_pos = header_len;
+    let header = ELF64Header {
+        magic: 0x7f_45_4c_46u32.swap_bytes(),
+        class: 0x2,      // 64 bit
+        endianness: 0x1, // little endian
+        ei_version: 0x1,
+        os_abi: 0x0, // system-v
+        os_abi_ver: 0x0,
+        pad: [0x0; 7],
+        ty: if pie { EType::Dyn } else { EType::Exec } as u16,
+        machine: Arch::X86_64.machine(),
+        e_version: 0x1,
+        entry: addr_start + program_pos + start_offset as u64,
+        program_header_offset: size_of::<ELF64Header>() as u64,
+        section_header_offset: 0x0,
+        // C ABI (16 bit instruction align) + double precision floats
+        flags: 0x1 | 0x4,
+        header_size: size_of::<ELF64Header>() as u16,
+        program_header_entry_size: size_of::<ProgramHeader>() as u16,
+        program_header_num: 0x1,
+        section_header_entry_size: size_of::<SectionHeader>() as u16,
+        section_header_num: 0x0,
+        section_header_str_idx: 0x0,
+    };
+    let mut bytes: Vec<u8> = Vec::new();
+    bytes.extend(as_u8_slice(&header));
+    bytes.extend(as_u8_slice(&program_header));
+    bytes.extend(program);
+    bytes
+}
+
+impl LinkedProgram<u64> {
+    pub fn to_elf(&self) -> Vec<u8> {
+        create(&self.code, self.entry.expect("no start"))
+    }
+}