adding destination semantics for expressions

This commit is contained in:
mlokr 2024-05-13 11:05:35 +02:00
parent 2226a47aaa
commit b28baa86f7
2 changed files with 166 additions and 134 deletions

View file

@ -29,6 +29,37 @@ impl Drop for LinReg {
}
}
enum CowReg {
Lin(LinReg),
Reg(Reg),
}
impl CowReg {
fn get(&self) -> Reg {
match *self {
Self::Lin(LinReg(reg)) => reg,
Self::Reg(reg) => reg,
}
}
}
#[derive(Default)]
enum Ctx {
#[default]
None,
Inferred(Type),
Dest(Value),
}
impl Ctx {
fn ty(&self) -> Option<Type> {
Some(match self {
Self::Inferred(ty) => *ty,
Self::Dest(Value { ty, .. }) => *ty,
_ => return None,
})
}
}
pub mod bt {
use super::*;
@ -229,6 +260,13 @@ impl RegAlloc {
std::mem::forget(reg);
}
fn free_cow(&mut self, reg: CowReg) {
match reg {
CowReg::Lin(reg) => self.free(reg),
CowReg::Reg(_) => {}
}
}
fn pushed_size(&self) -> usize {
(self.max_used as usize - RET_ADDR as usize + 1) * 8
}
@ -401,7 +439,7 @@ impl<'a> Codegen<'a> {
self.ret = fn_label.ret;
log::dbg!("fn-body");
if self.expr(body, None).is_some() {
if self.expr(body).is_some() {
self.report(body.pos(), "expected all paths in the fucntion to return");
}
self.vars.clear();
@ -490,6 +528,7 @@ impl<'a> Codegen<'a> {
self.code.encode(instrs::cp(reg.0, rr));
reg
}
Loc::Return => todo!(),
Loc::Reg(reg) => reg,
Loc::Deref(dreg, offset) => {
let reg = self.gpa.allocate();
@ -563,55 +602,35 @@ impl<'a> Codegen<'a> {
}
}
fn expr(&mut self, expr: &'a parser::Expr<'a>, expeted: Option<Type>) -> Option<Value> {
match *expr {
fn expr(&mut self, expr: &'a parser::Expr<'a>) -> Option<Value> {
self.expr_ctx(expr, Ctx::default())
}
fn expr_ctx(&mut self, expr: &'a parser::Expr<'a>, ctx: Ctx) -> Option<Value> {
let value = match *expr {
E::Bool { value, .. } => Some(Value {
ty: bt::BOOL,
loc: Loc::Imm(value as u64),
}),
E::Ctor { ty, fields } => {
let ty = self.ty(&ty);
let TypeKind::Struct(idx) = TypeKind::from_ty(ty) else {
self.report(
expr.pos(),
format_args!("expected struct, got {}", self.display_ty(ty)),
);
let size = self.size_of(ty);
let loc = match ctx {
Ctx::Dest(dest) => dest.loc,
_ => Loc::Stack(self.alloc_stack(size as u32)),
};
let mut field_values = fields
.iter()
.map(|(name, field)| self.expr(field, None).map(|v| (*name, v)))
.collect::<Option<Vec<_>>>()?;
let size = self.size_of(ty);
let stack = self.alloc_stack(size as u32);
let decl_fields = self.records[idx as usize].fields.clone();
let mut offset = 0;
for &(ref name, ty) in decl_fields.as_ref() {
let index = field_values
.iter()
.position(|(n, _)| *n == name.as_ref())
.unwrap();
let (_, value) = field_values.remove(index);
self.assert_ty(expr.pos(), ty, value.ty);
log::dbg!("ctor: {} {} {:?}", stack, offset, value.loc);
self.assign(
Value {
ty: value.ty,
loc: Loc::Stack(stack + offset),
},
value,
);
offset += self.size_of(ty);
for (name, field) in fields {
let (offset, ty) = self.offset_of(expr.pos(), ty, name);
let loc = loc.offset_ref(offset);
self.expr_ctx(field, Ctx::Dest(Value { ty, loc }))?;
}
Some(Value {
ty,
loc: Loc::Stack(stack),
})
return Some(Value { ty, loc });
}
E::Field { target, field } => {
let mut tal = self.expr(target, None)?;
let mut tal = self.expr(target)?;
if let TypeKind::Pointer(ty) = TypeKind::from_ty(tal.ty) {
tal.ty = self.pointers[ty as usize];
tal.loc = match tal.loc {
@ -640,28 +659,38 @@ impl<'a> Codegen<'a> {
val,
pos,
} => {
let val = self.expr(val, None)?;
match val.loc {
let val = self.expr(val)?;
let loc = match val.loc {
Loc::StackRef(off) => {
let reg = self.gpa.allocate();
self.code.encode(instrs::addi64(reg.0, STACK_PTR, off));
Some(Value {
ty: self.alloc_pointer(val.ty),
loc: Loc::Reg(reg),
})
Loc::Reg(reg)
}
Loc::Deref(r, off) => {
self.code.encode(instrs::addi64(r.0, r.0, off));
Loc::Reg(r)
}
Loc::DerefRef(r, off) => {
let reg = self.gpa.allocate();
self.code.encode(instrs::addi64(reg.0, r, off));
Loc::Reg(reg)
}
l => self.report(
pos,
format_args!("cant take pointer of {} ({:?})", self.display_ty(val.ty), l),
),
}
};
Some(Value {
ty: self.alloc_pointer(val.ty),
loc,
})
}
E::UnOp {
op: T::Star,
val,
pos,
} => {
let val = self.expr(val, None)?;
let val = self.expr(val)?;
let reg = self.loc_to_reg(val.loc);
match TypeKind::from_ty(val.ty) {
TypeKind::Pointer(ty) => Some(Value {
@ -679,7 +708,7 @@ impl<'a> Codegen<'a> {
op: T::Decl,
right,
} => {
let val = self.expr(right, None)?;
let val = self.expr(right)?;
let loc = self.make_loc_owned(val.loc, val.ty);
let loc = self.ensure_spilled(loc);
self.vars.push(Variable {
@ -696,7 +725,7 @@ impl<'a> Codegen<'a> {
let fn_label = self.labels[func as usize].clone();
let mut parama = 3..12;
for (earg, &ty) in args.iter().zip(fn_label.args.iter()) {
let arg = self.expr(earg, Some(ty))?;
let arg = self.expr_ctx(earg, Ctx::Inferred(ty))?;
self.assert_ty(earg.pos(), ty, arg.ty);
self.pass_arg(arg, &mut parama);
}
@ -705,18 +734,19 @@ impl<'a> Codegen<'a> {
let loc = match size {
0 => Loc::Imm(0),
8 => Loc::RegRef(1),
16 => {
let stack = self.alloc_stack(16);
Loc::Stack(stack)
}
16 => match ctx {
Ctx::Dest(dest) => dest.loc,
_ => Loc::Stack(self.alloc_stack(size as u32)),
},
24..=u64::MAX => {
let stack = self.alloc_stack(size as u32);
let reg = self.gpa.allocate();
self.code
.encode(instrs::addi64(reg.0, STACK_PTR, stack as u64));
self.code.encode(instrs::cp(1, reg.0));
self.gpa.free(reg);
Loc::Stack(stack)
let val = match ctx {
Ctx::Dest(dest) => dest.loc,
_ => Loc::Stack(self.alloc_stack(size as u32)),
};
let (ptr, off) = val.ref_to_ptr(size);
self.code.encode(instrs::cp(1, ptr));
self.code.encode(instrs::addi64(1, ptr, off));
val
}
s => todo!("call return size: {}", s),
};
@ -735,10 +765,10 @@ impl<'a> Codegen<'a> {
s => todo!("call return size: {}", s),
}
Some(Value {
return Some(Value {
ty: fn_label.ret,
loc,
})
});
}
E::Ident { name, id, .. } => {
let Some(var) = self.vars.iter().find(|v| v.id == id) else {
@ -751,29 +781,9 @@ impl<'a> Codegen<'a> {
}
E::Return { val, pos } => {
if let Some(val) = val {
let val = self.expr(val, Some(self.ret))?;
let val = self.expr_ctx(val, Ctx::Inferred(self.ret))?;
self.assert_ty(pos, self.ret, val.ty);
let size = self.size_of(val.ty);
match size {
8 => {
let val = self.loc_to_reg(val.loc);
self.code.encode(instrs::cp(1, val.0));
self.gpa.free(val);
}
16 => {
let (ptr, off) = self.loc_to_ptr(val.loc);
self.code.encode(instrs::ld(1, ptr.0, off, 16));
self.gpa.free(ptr);
}
24..=u64::MAX => {
let (ptr, off) = self.loc_to_ptr(val.loc);
self.code.encode(instrs::addi64(ptr.0, ptr.0, off));
self.code
.encode(instrs::bmc(ptr.0, 1, size.try_into().unwrap()));
self.gpa.free(ptr);
}
s => todo!("return size: {}", s),
};
self.assign(self.ret, Loc::Return, val.loc);
}
self.ret_relocs.push(RetReloc {
offset: self.code.code.len() as u32,
@ -785,28 +795,28 @@ impl<'a> Codegen<'a> {
}
E::Block { stmts, .. } => {
for stmt in stmts {
if let Loc::Reg(reg) = self.expr(stmt, None)?.loc {
if let Loc::Reg(reg) = self.expr(stmt)?.loc {
self.gpa.free(reg);
}
}
Some(Value::VOID)
}
E::Number { value, .. } => Some(Value {
ty: expeted.unwrap_or(bt::INT),
ty: ctx.ty().unwrap_or(bt::INT),
loc: Loc::Imm(value),
}),
E::If {
cond, then, else_, ..
} => 'b: {
log::dbg!("if-cond");
let cond = self.expr(cond, Some(bt::BOOL))?;
let cond = self.expr_ctx(cond, Ctx::Inferred(bt::BOOL))?;
let reg = self.loc_to_reg(cond.loc);
let jump_offset = self.code.code.len() as u32;
self.code.encode(instrs::jeq(reg.0, 0, 0));
self.gpa.free(reg);
log::dbg!("if-then");
let then_unreachable = self.expr(then, None).is_none();
let then_unreachable = self.expr(then).is_none();
let mut else_unreachable = false;
let mut jump = self.code.code.len() as i16 - jump_offset as i16;
@ -819,7 +829,7 @@ impl<'a> Codegen<'a> {
jump = self.code.code.len() as i16 - jump_offset as i16;
}
else_unreachable = self.expr(else_, None).is_none();
else_unreachable = self.expr(else_).is_none();
if !then_unreachable {
let jump = self.code.code.len() as i32 - else_jump_offset as i32;
@ -846,7 +856,7 @@ impl<'a> Codegen<'a> {
offset: loop_start,
relocs: Default::default(),
});
let body_unreachable = self.expr(body, None).is_none();
let body_unreachable = self.expr(body).is_none();
log::dbg!("loop-end");
if !body_unreachable {
@ -894,14 +904,14 @@ impl<'a> Codegen<'a> {
}
E::BinOp { left, op, right } => {
if op == T::Assign {
let left = self.expr(left, expeted)?;
let right = self.expr(right, Some(left.ty))?;
return self.assign(left, right);
let left = self.expr(left)?;
let right = self.expr_ctx(right, Ctx::Inferred(left.ty))?;
return self.assign(left.ty, left.loc, right.loc);
}
let left = self.expr(left, expeted)?;
let left = self.expr(left)?;
let lhs = self.loc_to_reg(left.loc);
let right = self.expr(right, Some(left.ty))?;
let right = self.expr_ctx(right, Ctx::Inferred(left.ty))?;
let rhs = self.loc_to_reg(right.loc);
let op = match op {
@ -940,16 +950,23 @@ impl<'a> Codegen<'a> {
})
}
ast => unimplemented!("{:#?}", ast),
}?;
if let Ctx::Dest(dest) = ctx {
self.assign(dest.ty, dest.loc, value.loc);
Some(Value::VOID)
} else {
Some(value)
}
}
fn assign(&mut self, right: Value, left: Value) -> Option<Value> {
let size = self.size_of(left.ty);
fn assign(&mut self, ty: Type, right: Loc, left: Loc) -> Option<Value> {
let size = self.size_of(ty);
match size {
8 => {
let lhs = self.loc_to_reg(left.loc);
match right.loc {
let lhs = self.loc_to_reg(left);
match right {
Loc::Deref(reg, off) => {
self.code.encode(instrs::st(lhs.0, reg.0, off, 8));
self.gpa.free(reg);
@ -958,13 +975,20 @@ impl<'a> Codegen<'a> {
Loc::StackRef(offset) | Loc::Stack(offset) => {
self.store_stack(lhs.0, offset, 8)
}
Loc::Return => self.code.encode(instrs::cp(1, lhs.0)),
l => unimplemented!("{:?}", l),
}
self.gpa.free(lhs);
}
16 if matches!(right, Loc::Return) => {
let (lhs, loff) = left.to_ptr(size);
self.code.encode(instrs::st(1, lhs.get(), loff, 16));
self.gpa.free_cow(lhs);
}
16..=u64::MAX => {
let (rhs, roff) = self.loc_to_ptr(right.loc);
let (lhs, loff) = self.loc_to_ptr(left.loc);
let (rhs, roff) = right.to_ptr(size);
let (lhs, loff) = left.to_ptr(size);
let (rhs, lhs) = (self.to_owned(rhs), self.to_owned(lhs));
self.code.encode(instrs::addi64(rhs.0, rhs.0, roff));
self.code.encode(instrs::addi64(lhs.0, lhs.0, loff));
@ -980,20 +1004,14 @@ impl<'a> Codegen<'a> {
Some(Value::VOID)
}
fn loc_to_ptr(&mut self, loc: Loc) -> (LinReg, u64) {
fn to_owned(&mut self, loc: CowReg) -> LinReg {
match loc {
Loc::Deref(reg, off) => (reg, off),
Loc::DerefRef(reg, off) => {
let dreg = self.gpa.allocate();
self.code.encode(instrs::cp(dreg.0, reg));
(dreg, off)
CowReg::Lin(reg) => reg,
CowReg::Reg(reg) => {
let new = self.gpa.allocate();
self.code.encode(instrs::cp(new.0, reg));
new
}
Loc::Stack(offset) | Loc::StackRef(offset) => {
let reg = self.gpa.allocate();
self.code.encode(instrs::cp(reg.0, STACK_PTR));
(reg, offset)
}
l => panic!("expected stack location, got {:?}", l),
}
}
@ -1085,16 +1103,7 @@ impl<'a> Codegen<'a> {
Loc::StackRef(off) => {
let size = self.size_of(ty);
let stack = self.alloc_stack(size as u32);
self.assign(
Value {
ty,
loc: Loc::Stack(stack),
},
Value {
ty,
loc: Loc::StackRef(off),
},
);
self.assign(ty, Loc::Stack(stack), Loc::StackRef(off));
Loc::Stack(stack)
}
l => l,
@ -1121,6 +1130,7 @@ impl<'a> Codegen<'a> {
Loc::RegRef(reg) => {
self.code.encode(instrs::cp(p, reg));
}
Loc::Return => todo!(),
Loc::Deref(reg, off) => {
self.code.encode(instrs::ld(p, reg.0, off, size as _));
self.gpa.free(reg);
@ -1155,16 +1165,7 @@ impl<'a> Codegen<'a> {
24..=u64::MAX => {
let ptr = parama.next().unwrap();
let stack = self.alloc_stack(size as u32);
self.assign(
Value {
ty,
loc: Loc::StackRef(stack),
},
Value {
ty,
loc: Loc::DerefRef(ptr, 0),
},
);
self.assign(ty, Loc::StackRef(stack), Loc::DerefRef(ptr, 0));
Loc::Stack(stack)
}
blah => todo!("{blah:?}"),
@ -1214,6 +1215,7 @@ impl Value {
enum Loc {
Reg(LinReg),
RegRef(Reg),
Return,
Deref(LinReg, u64),
DerefRef(Reg, u64),
Imm(u64),
@ -1228,6 +1230,36 @@ impl Loc {
un => unreachable!("{:?}", un),
}
}
fn to_ptr(self, size: u64) -> (CowReg, u64) {
match self {
Loc::Return if size > 16 => (CowReg::Reg(1), 0),
Loc::Deref(reg, off) => (CowReg::Lin(reg), off),
Loc::DerefRef(reg, off) => (CowReg::Reg(reg), off),
Loc::Stack(offset) | Loc::StackRef(offset) => (CowReg::Reg(STACK_PTR), offset),
l => panic!("expected stack location, got {:?}", l),
}
}
fn ref_to_ptr(&self, size: u64) -> (Reg, u64) {
match *self {
Loc::Return if size > 16 => (1, 0),
Loc::Deref(LinReg(reg), off) => (reg, off),
Loc::DerefRef(reg, off) => (reg, off),
Loc::Stack(offset) | Loc::StackRef(offset) => (STACK_PTR, offset),
ref l => panic!("expected stack location, got {:?}", l),
}
}
fn offset_ref(&self, offset: u64) -> Loc {
match *self {
Self::Deref(LinReg(r), off) => Self::DerefRef(r, off + offset),
Self::DerefRef(r, off) => Self::DerefRef(r, off + offset),
Self::Stack(off) => Self::Stack(off + offset),
Self::StackRef(off) => Self::StackRef(off + offset),
ref un => unreachable!("{:?}", un),
}
}
}
#[cfg(test)]

View file

@ -1,3 +1,3 @@
code size: 691
code size: 596
ret: 3
status: Ok(())