112 lines
3.0 KiB
Rust
112 lines
3.0 KiB
Rust
use super::{program::Addr, LinkedProgram};
|
|
|
|
#[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,
|
|
}
|
|
|
|
// this is currently specialized for riscv64; obviously add params later
|
|
pub fn create(program: &[u8], start_offset: Addr) -> Vec<u8> {
|
|
let addr_start = 0x1000;
|
|
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 + addr_start;
|
|
let program_header = ProgramHeader {
|
|
ty: 0x1, // LOAD
|
|
flags: 0b101, // executable, readable
|
|
offset: 0x0,
|
|
vaddr: addr_start,
|
|
paddr: addr_start,
|
|
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: 0x2, // executable
|
|
machine: 0xf3, // risc-v
|
|
e_version: 0x1,
|
|
entry: addr_start + program_pos + start_offset.val(),
|
|
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();
|
|
unsafe {
|
|
bytes.extend(as_u8_slice(&header));
|
|
bytes.extend(as_u8_slice(&program_header));
|
|
bytes.extend(program);
|
|
}
|
|
bytes
|
|
}
|
|
|
|
unsafe fn as_u8_slice<T: Sized>(p: &T) -> &[u8] {
|
|
core::slice::from_raw_parts((p as *const T) as *const u8, size_of::<T>())
|
|
}
|
|
|
|
impl LinkedProgram {
|
|
pub fn to_elf(&self) -> Vec<u8> {
|
|
create(&self.code, self.start.expect("no start found"))
|
|
}
|
|
}
|