AbleOS/holey-bytes
3
3
Fork 5
Code Issues 2 Pull requests Packages Projects Releases Wiki Activity

Compare commits

base: AbleOS:cdc8cb35f7d0e187883a87f283caab756208c55c
Branches Tags
AbleOS:trunk
AbleOS:hbcb
AbleOS:soft-float
..
compare: AbleOS:59705c062dbd0eeeaf2feb4a76230a393672c646
Branches Tags
AbleOS:trunk
AbleOS:hbcb
AbleOS:soft-float

No commits in common. "cdc8cb35f7d0e187883a87f283caab756208c55c" and "59705c062dbd0eeeaf2feb4a76230a393672c646" have entirely different histories.
cdc8cb35f7 ... 59705c062d

2 changed files with 75 additions and 159 deletions
Show stats Expand all files Collapse all files

231
hblang/src/codegen.rs
View file

@ -372,11 +372,11 @@ pub mod ty {
const FLAG_OFFSET: u32 = std::mem::size_of::<Id>() as u32 * 8 - Self::FLAG_BITS; const FLAG_OFFSET: u32 = std::mem::size_of::<Id>() as u32 * 8 - Self::FLAG_BITS;
const INDEX_MASK: u32 = (1 << (32 - Self::FLAG_BITS)) - 1; const INDEX_MASK: u32 = (1 << (32 - Self::FLAG_BITS)) - 1;
$vis fn from_ty(ty: Id) -> Self { $vis const fn from_ty(ty: Id) -> Self {
let (flag, index) = (ty.repr() >> Self::FLAG_OFFSET, ty.repr() & Self::INDEX_MASK); let (flag, index) = (ty.repr() >> Self::FLAG_OFFSET, ty.repr() & Self::INDEX_MASK);
match flag { match flag {
$(${index(0)} => Self::$variant(index),)* $(${index(0)} => Self::$variant(index),)*
i => unreachable!("{i}"), _ => unreachable!(),
} }
} }
@ -480,8 +480,6 @@ struct Reloc {
offset: Offset, offset: Offset,
sub_offset: u8, sub_offset: u8,
width: u8, width: u8,
#[cfg(debug_assertions)]
shifted: bool,
} }
impl Reloc { impl Reloc {
@ -490,18 +488,6 @@ impl Reloc {
offset, offset,
sub_offset, sub_offset,
width, width,
#[cfg(debug_assertions)]
shifted: false,
}
}
fn shifted(offset: u32, sub_offset: u8, width: u8) -> Self {
Self {
offset,
sub_offset,
width,
#[cfg(debug_assertions)]
shifted: true,
} }
} }
@ -525,11 +511,13 @@ impl Reloc {
} }
fn write_offset(&self, code: &mut [u8], offset: i64) { fn write_offset(&self, code: &mut [u8], offset: i64) {
#[cfg(debug_assertions)]
assert!(self.shifted);
let bytes = offset.to_ne_bytes(); let bytes = offset.to_ne_bytes();
let slice = &mut code[self.offset as usize + self.sub_offset as usize..]; let slice =
slice[..self.width as usize].copy_from_slice(&bytes[..self.width as usize]); &mut code[self.offset as usize + self.sub_offset as usize..][..self.width as usize];
slice.copy_from_slice(&bytes[..self.width as usize]);
if slice.contains(&0x83) {
panic!()
}
} }
} }
@ -563,7 +551,9 @@ impl Value {
fn ty(ty: ty::Id) -> Self { fn ty(ty: ty::Id) -> Self {
Self { Self {
ty: ty::TYPE.into(), ty: ty::TYPE.into(),
loc: Loc::ct((ty.repr() as u64).to_ne_bytes()), loc: Loc::Ct {
value: (ty.repr() as u64).to_ne_bytes(),
},
} }
} }
} }
@ -629,11 +619,9 @@ impl Loc {
} }
fn imm(value: u64) -> Self { fn imm(value: u64) -> Self {
Self::ct(value.to_ne_bytes()) Self::Ct {
} value: value.to_ne_bytes(),
}
fn ct(value: [u8; 8]) -> Self {
Self::Ct { value }
} }
fn ty(ty: ty::Id) -> Self { fn ty(ty: ty::Id) -> Self {
@ -759,29 +747,14 @@ impl ItemCtx {
// } // }
fn finalize(&mut self, output: &mut Output) { fn finalize(&mut self, output: &mut Output) {
let len = output.code.len() as Offset;
let base = self.snap.code as Offset;
for reloc in output
.reloc_iter_mut(&self.snap)
.chain(&mut self.ret_relocs)
{
#[cfg(debug_assertions)]
{
if std::mem::replace(&mut reloc.shifted, true) {
panic!("reloc visited twice");
}
}
reloc.offset += base;
debug_assert!(reloc.offset < len);
}
self.stack.finalize_leaked(); self.stack.finalize_leaked();
for rel in self.stack_relocs.drain(..) { for rel in self.stack_relocs.drain(..) {
rel.apply_stack_offset(&mut output.code[base as usize..], &self.stack) rel.apply_stack_offset(&mut output.code[self.snap.code..], &self.stack)
} }
let ret_offset = output.code.len() - self.snap.code;
for rel in self.ret_relocs.drain(..) { for rel in self.ret_relocs.drain(..) {
rel.apply_jump(&mut output.code, len); rel.apply_jump(&mut output.code[self.snap.code..], ret_offset as _);
} }
self.finalize_frame(output); self.finalize_frame(output);
@ -825,6 +798,9 @@ impl ItemCtx {
fn write_reloc(doce: &mut [u8], offset: usize, value: i64, size: u16) { fn write_reloc(doce: &mut [u8], offset: usize, value: i64, size: u16) {
let value = value.to_ne_bytes(); let value = value.to_ne_bytes();
doce[offset..offset + size as usize].copy_from_slice(&value[..size as usize]); doce[offset..offset + size as usize].copy_from_slice(&value[..size as usize]);
if value.contains(&131) {
panic!();
}
} }
#[derive(PartialEq, Eq, Hash)] #[derive(PartialEq, Eq, Hash)]
@ -850,7 +826,6 @@ struct Sig {
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
struct Func { struct Func {
file: FileId,
expr: ExprRef, expr: ExprRef,
sig: Option<Sig>, sig: Option<Sig>,
offset: Offset, offset: Offset,
@ -996,7 +971,7 @@ struct FTask {
id: ty::Func, id: ty::Func,
} }
#[derive(Default, Clone, Copy, PartialEq, Eq, Debug)] #[derive(Default, Clone, Copy)]
pub struct Snapshot { pub struct Snapshot {
code: usize, code: usize,
funcs: usize, funcs: usize,
@ -1025,18 +1000,18 @@ impl Output {
} }
fn emit(&mut self, (len, instr): (usize, [u8; instrs::MAX_SIZE])) { fn emit(&mut self, (len, instr): (usize, [u8; instrs::MAX_SIZE])) {
let name = instrs::NAMES[instr[0] as usize]; // let name = instrs::NAMES[instr[0] as usize];
log::dbg!( // log::dbg!(
"{:08x}: {}: {}", // "{:08x}: {}: {}",
self.code.len(), // self.code.len(),
name, // name,
instr // instr
.iter() // .iter()
.take(len) // .take(len)
.skip(1) // .skip(1)
.map(|b| format!("{:02x}", b)) // .map(|b| format!("{:02x}", b))
.collect::<String>() // .collect::<String>()
); // );
self.code.extend_from_slice(&instr[..len]); self.code.extend_from_slice(&instr[..len]);
} }
@ -1067,36 +1042,15 @@ impl Output {
} }
fn pop(&mut self, stash: &mut Self, snap: &Snapshot) { fn pop(&mut self, stash: &mut Self, snap: &Snapshot) {
// for rel in self.reloc_iter_mut(snap) { for rel in self.reloc_iter_mut(snap) {
// debug_assert!(snap.code < rel.offset as usize); rel.offset -= snap.code as Offset;
// rel.offset -= snap.code as Offset; rel.offset += stash.code.len() as Offset;
// rel.offset += stash.code.len() as Offset; }
// }
let init_code = stash.code.len();
stash.code.extend(self.code.drain(snap.code..)); stash.code.extend(self.code.drain(snap.code..));
stash.funcs.extend( stash.funcs.extend(self.funcs.drain(snap.funcs..));
self.funcs.drain(snap.funcs..).inspect(|(_, rel)| { stash.globals.extend(self.globals.drain(snap.globals..));
debug_assert!(rel.offset as usize + init_code < stash.code.len()) stash.strings.extend(self.strings.drain(snap.strings..));
}),
);
stash
.globals
.extend(self.globals.drain(snap.globals..).inspect(|(_, rel)| {
log::dbg!(
"reloc: {rel:?} {init_code} {} {} {}",
stash.code.len(),
self.code.len(),
snap.code
);
debug_assert!(rel.offset as usize + init_code < stash.code.len())
}));
stash
.strings
.extend(self.strings.drain(snap.strings..).inspect(|str| {
debug_assert!(str.reloc.offset as usize + init_code < stash.code.len())
}));
} }
fn trunc(&mut self, snap: &Snapshot) { fn trunc(&mut self, snap: &Snapshot) {
@ -1120,6 +1074,12 @@ impl Output {
strings: self.strings.len(), strings: self.strings.len(),
} }
} }
fn emit_call(&mut self, func_id: ty::Func) {
let reloc = Reloc::new(self.code.len() as _, 3, 4);
self.funcs.push((func_id, reloc));
self.emit(jal(RET_ADDR, ZERO, 0));
}
} }
#[derive(Default, Debug)] #[derive(Default, Debug)]
@ -1262,7 +1222,6 @@ struct StringReloc {
reloc: Reloc, reloc: Reloc,
range: std::ops::Range<u32>, range: std::ops::Range<u32>,
} }
impl StringReloc { impl StringReloc {
fn range(&self) -> std::ops::Range<usize> { fn range(&self) -> std::ops::Range<usize> {
self.range.start as _..self.range.end as _ self.range.start as _..self.range.end as _
@ -1291,7 +1250,7 @@ impl Codegen {
} }
pub fn dump(mut self, out: &mut impl std::io::Write) -> std::io::Result<()> { pub fn dump(mut self, out: &mut impl std::io::Write) -> std::io::Result<()> {
let reloc = Reloc::shifted(0, 3, 4); let reloc = Reloc::new(0, 3, 4);
self.output.funcs.push((0, reloc)); self.output.funcs.push((0, reloc));
self.link(); self.link();
out.write_all(&self.output.code) out.write_all(&self.output.code)
@ -1504,7 +1463,7 @@ impl Codegen {
self.report(pos, "string literal must end with null byte (for now)"); self.report(pos, "string literal must end with null byte (for now)");
} }
let reloc = Reloc::new(self.local_offset() as _, 3, 4); let reloc = Reloc::new(self.output.code.len() as _, 3, 4);
let start = self.string_data.len(); let start = self.string_data.len();
let report = |s: &Codegen, bytes: &std::str::Bytes, message| { let report = |s: &Codegen, bytes: &std::str::Bytes, message| {
@ -1598,7 +1557,7 @@ impl Codegen {
return Some(Value { ty, loc }); return Some(Value { ty, loc });
} }
E::Field { target, field } => { E::Field { target, field } => {
let checkpoint = self.local_snap(); let checkpoint = self.output.code.len();
let mut tal = self.expr(target)?; let mut tal = self.expr(target)?;
if let ty::Kind::Ptr(ty) = tal.ty.expand() { if let ty::Kind::Ptr(ty) = tal.ty.expand() {
@ -1617,14 +1576,13 @@ impl Codegen {
}) })
} }
ty::Kind::Builtin(ty::TYPE) => { ty::Kind::Builtin(ty::TYPE) => {
self.ci.free_loc(tal.loc); self.output.code.truncate(checkpoint);
self.pop_local_snap(checkpoint);
match ty::Kind::from_ty(self.ty(target)) { match ty::Kind::from_ty(self.ty(target)) {
ty::Kind::Module(idx) => Some(Value::ty( ty::Kind::Module(idx) => Some(Value::ty(
self.find_or_declare(target.pos(), idx, Err(field), "") self.find_or_declare(target.pos(), idx, Err(field), "")
.compress(), .compress(),
)), )),
e => unimplemented!("{e:?}"), _ => unimplemented!(),
} }
} }
smh => self.report( smh => self.report(
@ -1712,14 +1670,13 @@ impl Codegen {
E::Call { E::Call {
func: fast, args, .. func: fast, args, ..
} => { } => {
log::dbg!("call {fast}");
let func_ty = self.ty(fast); let func_ty = self.ty(fast);
let ty::Kind::Func(mut func_id) = func_ty.expand() else { let ty::Kind::Func(mut func_id) = func_ty.expand() else {
self.report(fast.pos(), "can't call this, maybe in the future"); self.report(fast.pos(), "can't call this, maybe in the future");
}; };
let func = self.tys.funcs[func_id as usize]; let func = self.tys.funcs[func_id as usize];
let ast = self.files[func.file as usize].clone(); let ast = self.cfile().clone();
let E::BinOp { let E::BinOp {
right: right:
&E::Closure { &E::Closure {
@ -1773,7 +1730,6 @@ impl Codegen {
let ct = || { let ct = || {
let func_id = self.tys.funcs.len(); let func_id = self.tys.funcs.len();
self.tys.funcs.push(Func { self.tys.funcs.push(Func {
file: func.file,
offset: task::id(func_id), offset: task::id(func_id),
sig: Some(Sig { args, ret }), sig: Some(Sig { args, ret }),
expr: func.expr, expr: func.expr,
@ -1816,11 +1772,7 @@ impl Codegen {
log::dbg!("call ctx: {ctx:?}"); log::dbg!("call ctx: {ctx:?}");
let loc = self.alloc_ret(sig.ret, ctx); let loc = self.alloc_ret(sig.ret, ctx);
self.output.emit_call(func_id);
let reloc = Reloc::new(self.local_offset(), 3, 4);
self.output.funcs.push((func_id, reloc));
self.output.emit(jal(RET_ADDR, ZERO, 0));
self.load_ret(sig.ret, &loc); self.load_ret(sig.ret, &loc);
return Some(Value { ty: sig.ret, loc }); return Some(Value { ty: sig.ret, loc });
} }
@ -1874,9 +1826,8 @@ impl Codegen {
}; };
self.expr_ctx(val, Ctx::default().with_ty(self.ci.ret).with_loc(loc))?; self.expr_ctx(val, Ctx::default().with_ty(self.ci.ret).with_loc(loc))?;
} }
self.ci let off = self.local_offset();
.ret_relocs self.ci.ret_relocs.push(Reloc::new(off, 1, 4));
.push(Reloc::new(self.local_offset(), 1, 4));
self.output.emit(jmp(0)); self.output.emit(jmp(0));
None None
} }
@ -1967,9 +1918,8 @@ impl Codegen {
Some(Value::void()) Some(Value::void())
} }
E::Break { .. } => { E::Break { .. } => {
self.ci let offset = self.local_offset();
.loop_relocs self.ci.loop_relocs.push(Reloc::new(offset, 1, 4));
.push(Reloc::shifted(self.local_offset(), 1, 4));
self.output.emit(jmp(0)); self.output.emit(jmp(0));
None None
} }
@ -2264,10 +2214,10 @@ impl Codegen {
fn handle_global(&mut self, id: ty::Global) -> Option<Value> { fn handle_global(&mut self, id: ty::Global) -> Option<Value> {
let ptr = self.ci.regs.allocate(); let ptr = self.ci.regs.allocate();
let reloc = Reloc::new(self.local_offset(), 3, 4);
let global = &mut self.tys.globals[id as usize]; let global = &mut self.tys.globals[id as usize];
let reloc = Reloc::new(self.output.code.len() as u32, 3, 4);
self.output.globals.push((id, reloc)); self.output.globals.push((id, reloc));
log::dbg!("{}", self.output.globals.len() - self.ci.snap.globals);
self.output.emit(instrs::lra(ptr.get(), 0, 0)); self.output.emit(instrs::lra(ptr.get(), 0, 0));
Some(Value { Some(Value {
@ -2603,9 +2553,7 @@ impl Codegen {
fn stack_reloc(&mut self, stack: &stack::Id, off: Offset, sub_offset: u8) -> u64 { fn stack_reloc(&mut self, stack: &stack::Id, off: Offset, sub_offset: u8) -> u64 {
log::dbg!("whaaaaatahack: {:b}", stack.repr()); log::dbg!("whaaaaatahack: {:b}", stack.repr());
let offset = self.local_offset(); let offset = self.local_offset();
self.ci self.ci.stack_relocs.push(Reloc::new(offset, sub_offset, 8));
.stack_relocs
.push(Reloc::shifted(offset, sub_offset, 8));
Reloc::pack_srel(stack, off) Reloc::pack_srel(stack, off)
} }
@ -2668,7 +2616,6 @@ impl Codegen {
let mut ci = ItemCtx { let mut ci = ItemCtx {
file: self.ci.file, file: self.ci.file,
id: self.ci.id, id: self.ci.id,
ret: ty::TYPE.into(),
..self.pool.cis.pop().unwrap_or_default() ..self.pool.cis.pop().unwrap_or_default()
}; };
ci.vars.append(&mut self.ci.vars); ci.vars.append(&mut self.ci.vars);
@ -2676,16 +2623,9 @@ impl Codegen {
let loc = self.ct_eval(ci, |s, prev| { let loc = self.ct_eval(ci, |s, prev| {
s.output.emit_prelude(); s.output.emit_prelude();
if s.expr_ctx( let ctx = Ctx::default().with_ty(ty::TYPE);
&Expr::Return { let Some(ret) = s.expr_ctx(expr, ctx) else {
pos: 0, s.report(expr.pos(), "type cannot be unreachable");
val: Some(expr),
},
Ctx::default().with_ty(ty::TYPE),
)
.is_some()
{
s.report(expr.pos(), "we fucked up");
}; };
let stash = s.complete_call_graph(); let stash = s.complete_call_graph();
@ -2695,11 +2635,18 @@ impl Codegen {
s.ci.finalize(&mut s.output); s.ci.finalize(&mut s.output);
s.output.emit(tx()); s.output.emit(tx());
Ok(1) let loc = match ret.loc {
Loc::Rt { ref reg, .. } => Ok(reg.get()),
Loc::Ct { value } => Err(value),
};
s.ci.free_loc(ret.loc);
loc
}); });
ty::Id::from(match loc { ty::Id::from(match loc {
Ok(reg) | Err(reg) => self.ct.vm.read_reg(reg).cast::<u64>().to_ne_bytes(), Ok(reg) => self.ct.vm.read_reg(reg).cast::<u64>().to_ne_bytes(),
Err(ct) => ct,
}) })
} }
@ -2778,9 +2725,8 @@ impl Codegen {
} => { } => {
let id = self.tys.funcs.len() as _; let id = self.tys.funcs.len() as _;
let func = Func { let func = Func {
file,
offset: task::id(self.tasks.len()), offset: task::id(self.tasks.len()),
sig: 'b: { sig: 'b: {
let arg_base = self.tys.args.len(); let arg_base = self.tys.args.len();
for arg in args { for arg in args {
let sym = find_symbol(&self.files[file as usize].symbols, arg.id); let sym = find_symbol(&self.files[file as usize].symbols, arg.id);
@ -2798,7 +2744,7 @@ impl Codegen {
let ret = self.ty(ret); let ret = self.ty(ret);
Some(Sig { args, ret }) Some(Sig { args, ret })
}, },
expr: ExprRef::new(expr), expr: ExprRef::new(expr),
}; };
self.tys.funcs.push(func); self.tys.funcs.push(func);
@ -2886,12 +2832,10 @@ impl Codegen {
ci: ItemCtx, ci: ItemCtx,
compile: impl FnOnce(&mut Self, &mut ItemCtx) -> Result<T, E>, compile: impl FnOnce(&mut Self, &mut ItemCtx) -> Result<T, E>,
) -> Result<T, E> { ) -> Result<T, E> {
log::dbg!("eval");
let stash = self.pop_stash(); let stash = self.pop_stash();
let mut prev_ci = std::mem::replace(&mut self.ci, ci); let mut prev_ci = std::mem::replace(&mut self.ci, ci);
self.ci.snap = self.output.snap(); self.ci.snap = self.output.snap();
debug_assert_eq!(self.ci.snap, prev_ci.snap);
self.ci.task_base = self.tasks.len(); self.ci.task_base = self.tasks.len();
self.ci.regs.init(); self.ci.regs.init();
@ -2899,9 +2843,8 @@ impl Codegen {
if ret.is_ok() { if ret.is_ok() {
self.link(); self.link();
log::dbg!("{} {}", self.output.code.len(), self.ci.snap.code);
let entry = &mut self.output.code[self.ci.snap.code] as *mut _ as _; let entry = &mut self.output.code[self.ci.snap.code] as *mut _ as _;
let prev_pc = std::mem::replace(&mut self.ct.vm.pc, hbvm::mem::Address::new(entry)); self.ct.vm.pc = hbvm::mem::Address::new(entry);
loop { loop {
match self.ct.vm.run().unwrap() { match self.ct.vm.run().unwrap() {
hbvm::VmRunOk::End => break, hbvm::VmRunOk::End => break,
@ -2910,17 +2853,13 @@ impl Codegen {
hbvm::VmRunOk::Breakpoint => unreachable!(), hbvm::VmRunOk::Breakpoint => unreachable!(),
} }
} }
self.ct.vm.pc = prev_pc;
} }
self.output.trunc(&self.ci.snap); self.output.trunc(&self.ci.snap);
self.pool.cis.push(std::mem::replace(&mut self.ci, prev_ci)); self.pool.cis.push(std::mem::replace(&mut self.ci, prev_ci));
self.ci.snap = self.output.snap(); self.ci.snap = self.output.snap();
debug_assert_eq!(self.pool.cis.last().unwrap().snap, self.ci.snap);
self.push_stash(stash); self.push_stash(stash);
log::dbg!("eval-end");
ret ret
} }
@ -2957,26 +2896,6 @@ impl Codegen {
(self.output.code.len() - self.ci.snap.code) as u32 (self.output.code.len() - self.ci.snap.code) as u32
} }
fn local_snap(&self) -> Snapshot {
Snapshot {
code: self.output.code.len() - self.ci.snap.code,
funcs: self.output.funcs.len() - self.ci.snap.funcs,
globals: self.output.globals.len() - self.ci.snap.globals,
strings: self.output.strings.len() - self.ci.snap.strings,
}
}
fn pop_local_snap(&mut self, snap: Snapshot) {
self.output.code.truncate(snap.code + self.ci.snap.code);
self.output.funcs.truncate(snap.funcs + self.ci.snap.funcs);
self.output
.globals
.truncate(snap.globals + self.ci.snap.globals);
self.output
.strings
.truncate(snap.strings + self.ci.snap.strings);
}
fn pack_args(&mut self, pos: Pos, arg_base: usize) -> ty::Tuple { fn pack_args(&mut self, pos: Pos, arg_base: usize) -> ty::Tuple {
let needle = &self.tys.args[arg_base..]; let needle = &self.tys.args[arg_base..];
if needle.is_empty() { if needle.is_empty() {

3
hblang/tests/codegen_tests_c_strings.txt
View file

@ -1,3 +0,0 @@
code size: 202
ret: 13
status: Ok(())