This commit is contained in:
Nilton Constantino
2026-01-31 23:49:24 +00:00
parent ff4dcad5dc
commit 239d7251c3
5 changed files with 61 additions and 34 deletions
+296
View File
@@ -0,0 +1,296 @@
use crate::v0::{BytecodeModule, DebugInfo, ConstantPoolEntry, FunctionMeta};
use crate::opcode::OpCode;
use std::collections::HashMap;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum LinkError {
UnresolvedSymbol(String),
DuplicateExport(String),
}
pub struct Linker;
/// Internal representation for linking process
#[derive(Debug)]
pub struct LinkedProgram {
pub rom: Vec<u8>,
pub constant_pool: Vec<ConstantPoolEntry>,
pub functions: Vec<FunctionMeta>,
pub debug_info: Option<DebugInfo>,
pub exports: HashMap<String, u32>,
}
impl Linker {
pub fn link(modules: &[BytecodeModule]) -> Result<LinkedProgram, LinkError> {
let mut combined_code = Vec::new();
let mut combined_functions = Vec::new();
let mut combined_constants = Vec::new();
let mut combined_debug_pc_to_span = Vec::new();
let mut combined_debug_function_names = Vec::new();
let mut exports = HashMap::new();
// Offset mapping for each module
let mut module_code_offsets = Vec::with_capacity(modules.len());
let mut module_function_offsets = Vec::with_capacity(modules.len());
// First pass: collect exports and calculate offsets
for module in modules {
let code_offset = combined_code.len() as u32;
let function_offset = combined_functions.len() as u32;
module_code_offsets.push(code_offset);
module_function_offsets.push(function_offset);
for export in &module.exports {
if exports.contains_key(&export.symbol) {
return Err(LinkError::DuplicateExport(export.symbol.clone()));
}
exports.insert(export.symbol.clone(), (function_offset + export.func_idx) as u32);
}
combined_code.extend_from_slice(&module.code);
for func in &module.functions {
let mut linked_func = func.clone();
linked_func.code_offset += code_offset;
combined_functions.push(linked_func);
}
}
// Second pass: resolve imports and relocate constants/code
for (i, module) in modules.iter().enumerate() {
let code_offset = module_code_offsets[i] as usize;
let const_base = combined_constants.len() as u32;
// Relocate constant pool entries for this module
for entry in &module.const_pool {
combined_constants.push(entry.clone());
}
// Patch relocations for imports
for import in &module.imports {
let target_func_idx = exports.get(&import.symbol)
.ok_or_else(|| LinkError::UnresolvedSymbol(import.symbol.clone()))?;
for &reloc_pc in &import.relocation_pcs {
let absolute_pc = code_offset + reloc_pc as usize;
// CALL opcode is 2 bytes, immediate is next 4 bytes
let imm_offset = absolute_pc + 2;
if imm_offset + 4 <= combined_code.len() {
let bytes = target_func_idx.to_le_bytes();
combined_code[imm_offset..imm_offset+4].copy_from_slice(&bytes);
}
}
}
// Relocate PUSH_CONST instructions
if const_base > 0 {
let mut pos = code_offset;
let end = code_offset + module.code.len();
while pos < end {
if pos + 2 > end { break; }
let op_val = u16::from_le_bytes([combined_code[pos], combined_code[pos+1]]);
let opcode = match OpCode::try_from(op_val) {
Ok(op) => op,
Err(_) => {
pos += 2;
continue;
}
};
pos += 2;
match opcode {
OpCode::PushConst => {
if pos + 4 <= end {
let old_idx = u32::from_le_bytes(combined_code[pos..pos+4].try_into().unwrap());
let new_idx = old_idx + const_base;
combined_code[pos..pos+4].copy_from_slice(&new_idx.to_le_bytes());
pos += 4;
}
}
OpCode::PushI32 | OpCode::PushBounded | OpCode::Jmp | OpCode::JmpIfFalse | OpCode::JmpIfTrue
| OpCode::GetGlobal | OpCode::SetGlobal | OpCode::GetLocal | OpCode::SetLocal
| OpCode::PopN | OpCode::Syscall | OpCode::GateLoad | OpCode::GateStore | OpCode::Call => {
pos += 4;
}
OpCode::PushI64 | OpCode::PushF64 | OpCode::Alloc => {
pos += 8;
}
OpCode::PushBool => {
pos += 1;
}
_ => {}
}
}
}
// Handle debug info
if let Some(debug_info) = &module.debug_info {
for (pc, span) in &debug_info.pc_to_span {
combined_debug_pc_to_span.push((pc + module_code_offsets[i], span.clone()));
}
for (func_idx, name) in &debug_info.function_names {
combined_debug_function_names.push((func_idx + module_function_offsets[i], name.clone()));
}
}
}
let debug_info = if !combined_debug_pc_to_span.is_empty() {
Some(DebugInfo {
pc_to_span: combined_debug_pc_to_span,
function_names: combined_debug_function_names,
})
} else {
None
};
Ok(LinkedProgram {
rom: combined_code,
constant_pool: combined_constants,
functions: combined_functions,
debug_info,
exports,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::v0::{BytecodeModule, FunctionMeta, Export, Import};
use crate::opcode::OpCode;
#[test]
fn test_linker_basic() {
// Module 1: defines 'foo', calls 'bar'
let mut code1 = Vec::new();
// Function 'foo' at offset 0
code1.extend_from_slice(&(OpCode::Call as u16).to_le_bytes());
code1.extend_from_slice(&0u32.to_le_bytes()); // placeholder for 'bar'
code1.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
let m1 = BytecodeModule {
version: 0,
const_pool: vec![],
functions: vec![FunctionMeta {
code_offset: 0,
code_len: code1.len() as u32,
..Default::default()
}],
code: code1,
debug_info: None,
exports: vec![Export { symbol: "foo".to_string(), func_idx: 0 }],
imports: vec![Import { symbol: "bar".to_string(), relocation_pcs: vec![0] }],
};
// Module 2: defines 'bar'
let mut code2 = Vec::new();
code2.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
let m2 = BytecodeModule {
version: 0,
const_pool: vec![],
functions: vec![FunctionMeta {
code_offset: 0,
code_len: code2.len() as u32,
..Default::default()
}],
code: code2,
debug_info: None,
exports: vec![Export { symbol: "bar".to_string(), func_idx: 0 }],
imports: vec![],
};
let result = Linker::link(&[m1, m2]).unwrap();
assert_eq!(result.functions.len(), 2);
// 'foo' is func 0, 'bar' is func 1
assert_eq!(result.functions[0].code_offset, 0);
assert_eq!(result.functions[1].code_offset, 8);
// Let's check patched code
let patched_func_id = u32::from_le_bytes(result.rom[2..6].try_into().unwrap());
assert_eq!(patched_func_id, 1); // Points to 'bar'
}
#[test]
fn test_linker_unresolved() {
let m1 = BytecodeModule {
version: 0,
const_pool: vec![],
functions: vec![],
code: vec![],
debug_info: None,
exports: vec![],
imports: vec![Import { symbol: "missing".to_string(), relocation_pcs: vec![] }],
};
let result = Linker::link(&[m1]);
assert_eq!(result.unwrap_err(), LinkError::UnresolvedSymbol("missing".to_string()));
}
#[test]
fn test_linker_duplicate_export() {
let m1 = BytecodeModule {
version: 0,
const_pool: vec![],
functions: vec![],
code: vec![],
debug_info: None,
exports: vec![Export { symbol: "dup".to_string(), func_idx: 0 }],
imports: vec![],
};
let m2 = m1.clone();
let result = Linker::link(&[m1, m2]);
assert_eq!(result.unwrap_err(), LinkError::DuplicateExport("dup".to_string()));
}
#[test]
fn test_linker_const_relocation() {
// Module 1: uses constants
let mut code1 = Vec::new();
code1.extend_from_slice(&(OpCode::PushConst as u16).to_le_bytes());
code1.extend_from_slice(&0u32.to_le_bytes()); // Index 0
code1.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
let m1 = BytecodeModule {
version: 0,
const_pool: vec![ConstantPoolEntry::Int32(42)],
functions: vec![FunctionMeta { code_offset: 0, code_len: code1.len() as u32, ..Default::default() }],
code: code1,
debug_info: None,
exports: vec![],
imports: vec![],
};
// Module 2: also uses constants
let mut code2 = Vec::new();
code2.extend_from_slice(&(OpCode::PushConst as u16).to_le_bytes());
code2.extend_from_slice(&0u32.to_le_bytes()); // Index 0 (local to module 2)
code2.extend_from_slice(&(OpCode::Ret as u16).to_le_bytes());
let m2 = BytecodeModule {
version: 0,
const_pool: vec![ConstantPoolEntry::Int32(99)],
functions: vec![FunctionMeta { code_offset: 0, code_len: code2.len() as u32, ..Default::default() }],
code: code2,
debug_info: None,
exports: vec![],
imports: vec![],
};
let result = Linker::link(&[m1, m2]).unwrap();
assert_eq!(result.constant_pool.len(), 2);
assert_eq!(result.constant_pool[0], ConstantPoolEntry::Int32(42));
assert_eq!(result.constant_pool[1], ConstantPoolEntry::Int32(99));
// Code for module 1 (starts at 0)
let idx1 = u32::from_le_bytes(result.rom[2..6].try_into().unwrap());
assert_eq!(idx1, 0);
// Code for module 2 (starts at 8)
let idx2 = u32::from_le_bytes(result.rom[10..14].try_into().unwrap());
assert_eq!(idx2, 1);
}
}
+2
View File
@@ -1,3 +1,5 @@
pub mod linker;
use crate::opcode::OpCode;
use crate::abi::SourceSpan;