1use crate::mmu::align_up;
2use crate::{JitResult, PAGE_SIZE, PagePerms};
3
4use goblin::elf::{
5 Elf,
6 header::EM_RISCV,
7 program_header::{PF_R, PF_W, PF_X, PT_LOAD, PT_PHDR},
8};
9
10use std::{collections::BTreeMap, io};
11
12#[derive(Debug, Clone)]
13pub struct LoadSegment {
14 pub vaddr: u64,
15 pub mem_size: u64,
16 pub file_size: u64,
17 pub perms: PagePerms,
18 pub bytes: Vec<u8>,
19}
20
21#[derive(Debug, Clone)]
22pub struct ProgramSymbol {
23 pub name: String,
24 pub value: u64,
25}
26
27#[derive(Debug, Clone)]
28pub struct ProgramImage {
29 pub entry_pc: u64,
30 pub segments: Vec<LoadSegment>,
31 pub symbols: BTreeMap<String, ProgramSymbol>,
32 pub interp: Option<String>,
33 pub brk_base: u64,
34 pub elf_phdr_addr: Option<u64>,
35 pub elf_phent_size: u16,
36 pub elf_phnum: u16,
37}
38
39impl ProgramImage {
40 pub fn from_elf_bytes(bytes: &[u8]) -> JitResult<Self> {
41 if bytes.len() as u64 > crate::MAX_GUEST_MEMORY {
42 return Err(io::Error::other("ELF exceeds guest memory limit!!").into());
43 }
44
45 let elf = Elf::parse(bytes)?;
46
47 if !elf.is_64 || !elf.little_endian || elf.header.e_machine != EM_RISCV {
48 return Err(io::Error::other("expected a little-endian RISC-V ELF64 file").into());
49 }
50
51 let mut load_size = 0u64;
52 let mut segments = Vec::new();
53 let mut headers_in_load = None;
54 let mut brk_base = 0;
55
56 for ph in elf.program_headers.iter().filter(|ph| ph.p_type == PT_LOAD) {
57 load_size = load_size
58 .checked_add(ph.p_memsz)
59 .filter(|size| *size <= crate::MAX_GUEST_MEMORY)
60 .ok_or_else(|| io::Error::other("ELF exceeds guest memory limit"))?;
61
62 let file_end =
63 ph.p_offset.checked_add(ph.p_filesz).ok_or_else(|| io::Error::other("ELF file range overflow"))?;
64
65 let memory_end =
66 ph.p_vaddr.checked_add(ph.p_memsz).ok_or_else(|| io::Error::other("ELF memory range overflow"))?;
67
68 if ph.p_filesz > ph.p_memsz || memory_end > u64::MAX - (PAGE_SIZE as u64 - 1) {
69 return Err(io::Error::other("invalid ELF load segment").into());
70 }
71
72 let data = bytes
73 .get(usize::try_from(ph.p_offset)?..usize::try_from(file_end)?)
74 .ok_or_else(|| io::Error::other("truncated ELF segment"))?;
75
76 let mut perms = PagePerms::empty();
77
78 for (flag, perm) in [(PF_R, PagePerms::READ), (PF_W, PagePerms::WRITE), (PF_X, PagePerms::EXEC)] {
79 if ph.p_flags & flag != 0 {
80 perms |= perm;
81 }
82 }
83
84 if headers_in_load.is_none() && (ph.p_offset..file_end).contains(&elf.header.e_phoff) {
86 headers_in_load = ph.p_vaddr.checked_add(elf.header.e_phoff - ph.p_offset);
87 }
88
89 brk_base = brk_base
90 .max(align_up(memory_end, PAGE_SIZE as u64).ok_or_else(|| io::Error::other("ELF address overflow"))?);
91
92 segments.push(LoadSegment {
93 vaddr: ph.p_vaddr,
94 mem_size: ph.p_memsz,
95 file_size: ph.p_filesz,
96 perms,
97 bytes: data.to_vec(),
98 });
99 }
100
101 let elf_phdr_addr = elf
102 .program_headers
103 .iter()
104 .find(|ph| ph.p_type == PT_PHDR)
105 .map(|ph| ph.p_vaddr)
106 .or(headers_in_load)
107 .ok_or_else(|| io::Error::other("ELF program headers are not mapped"))?;
108
109 let mut symbols = BTreeMap::<String, ProgramSymbol>::new();
110
111 for (table, strings) in [(&elf.syms, &elf.strtab), (&elf.dynsyms, &elf.dynstrtab)] {
112 for symbol in table.iter().filter(|symbol| symbol.st_shndx != 0) {
113 let Some(name) = strings.get_at(symbol.st_name).filter(|name| !name.is_empty()) else {
114 continue;
115 };
116
117 let entry = symbols
118 .entry(name.to_owned())
119 .or_insert_with(|| ProgramSymbol { name: name.to_owned(), value: symbol.st_value });
120
121 if entry.value == 0 {
122 entry.value = symbol.st_value;
123 }
124 }
125 }
126
127 Ok(Self {
128 entry_pc: elf.entry,
129 segments,
130 symbols,
131 interp: elf.interpreter.map(str::to_owned),
132 brk_base,
133 elf_phdr_addr: Some(elf_phdr_addr),
134 elf_phent_size: elf.header.e_phentsize,
135 elf_phnum: elf.header.e_phnum,
136 })
137 }
138
139 pub fn find_symbol(&self, name: &str) -> Option<&ProgramSymbol> {
140 self.symbols.get(name)
141 }
142
143 pub fn symbol_at(&self, address: u64) -> Option<&ProgramSymbol> {
144 if !self
145 .segments
146 .iter()
147 .any(|segment| address >= segment.vaddr && address < segment.vaddr.saturating_add(segment.mem_size))
148 {
149 return None;
150 }
151
152 self.symbols.values().filter(|symbol| symbol.value <= address).max_by_key(|symbol| symbol.value)
153 }
154}