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

removing more repetative patterns

Browse source 
Signed-off-by: Jakub Doka <jakub.doka2@gmail.com>
This commit is contained in:
Jakub Doka 2024-12-17 00:02:00 +01:00
parent 127fdb3cc5
commit ec9bb886f8
No known key found for this signature in database
GPG key ID: C6E9A89936B8C143
1 changed files with 51 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

107
lang/src/son.rs
View file

@ -3103,10 +3103,7 @@ impl<'a> Codegen<'a> {
self.ci.inline_ret.take() self.ci.inline_ret.take()
{ {
if value.ty.loc(self.tys) == Loc::Stack { if value.ty.loc(self.tys) == Loc::Stack {
let stck = self.new_stack(pos, value.ty); self.spill(pos, &mut value);
self.store_mem(stck, value.ty, value.id);
value.id = stck;
value.ptr = true;
} }
debug_assert!( debug_assert!(
@ -3141,10 +3138,7 @@ impl<'a> Codegen<'a> {
self.ci.inline_ret = Some((pv, ctrl, scope, aclass)); self.ci.inline_ret = Some((pv, ctrl, scope, aclass));
} else { } else {
if value.ty.loc(self.tys) == Loc::Stack { if value.ty.loc(self.tys) == Loc::Stack {
let stck = self.new_stack(pos, value.ty); self.spill(pos, &mut value);
self.store_mem(stck, value.ty, value.id);
value.id = stck;
value.ptr = true;
} }
for (i, aclass) in self.ci.scope.aclasses[..2].iter_mut().enumerate() { for (i, aclass) in self.ci.scope.aclasses[..2].iter_mut().enumerate() {
@ -3271,10 +3265,7 @@ impl<'a> Codegen<'a> {
let mut right = self.expr(right)?; let mut right = self.expr(right)?;
if right.ty.loc(self.tys) == Loc::Stack { if right.ty.loc(self.tys) == Loc::Stack {
let stck = self.new_stack(pos, right.ty); self.spill(pos, &mut right);
self.store_mem(stck, right.ty, right.id);
right.id = stck;
right.ptr = true;
} }
self.assign_pattern(left, right); self.assign_pattern(left, right);
Some(Value::VOID) Some(Value::VOID)
@ -3332,13 +3323,34 @@ impl<'a> Codegen<'a> {
self.implicit_unwrap(left.pos(), &mut lhs); self.implicit_unwrap(left.pos(), &mut lhs);
match lhs.ty.expand() { match lhs.ty.expand() {
_ if lhs.ty.is_pointer() ty::Kind::Struct(s) if op.is_homogenous() => {
|| lhs.ty.is_integer() debug_assert!(lhs.ptr);
|| lhs.ty == ty::Id::BOOL self.ci.nodes.lock(lhs.id);
|| (lhs.ty == ty::Id::TYPE let rhs = self.ptr_expr_ctx(right, Ctx::default().with_ty(lhs.ty));
&& matches!(op, TokenKind::Eq | TokenKind::Ne)) self.ci.nodes.unlock(lhs.id);
|| (lhs.ty.is_float() && op.is_supported_float_op()) => let mut rhs = rhs?;
{ debug_assert!(rhs.ptr);
self.assert_ty(pos, &mut rhs, lhs.ty, "struct operand");
let dst = self.new_stack(pos, lhs.ty);
self.struct_op(left.pos(), op, s, dst, lhs.id, rhs.id);
Some(Value::ptr(dst).ty(lhs.ty))
}
ty::Kind::Struct(s) if op.is_compatison() => {
let binding_op = match op {
TokenKind::Eq => TokenKind::Band,
_ => TokenKind::Bor,
};
self.ci.nodes.lock(lhs.id);
let rhs = self.ptr_expr_ctx(right, Ctx::default().with_ty(lhs.ty));
self.ci.nodes.unlock(lhs.id);
let mut rhs = rhs?;
self.assert_ty(pos, &mut rhs, lhs.ty, "struct operand");
self.struct_fold_op(left.pos(), op, binding_op, s, lhs.id, rhs.id)
.or(Value::NEVER)
}
_ if op.is_scalar_op(lhs.ty) => {
self.strip_ptr(&mut lhs); self.strip_ptr(&mut lhs);
self.ci.nodes.lock(lhs.id); self.ci.nodes.lock(lhs.id);
let rhs = self.expr_ctx(right, Ctx::default().with_ty(lhs.ty)); let rhs = self.expr_ctx(right, Ctx::default().with_ty(lhs.ty));
@ -3370,33 +3382,6 @@ impl<'a> Codegen<'a> {
self.ci.nodes.pass_aclass(aclass, bop.id); self.ci.nodes.pass_aclass(aclass, bop.id);
Some(bop) Some(bop)
} }
ty::Kind::Struct(s) if op.is_homogenous() => {
debug_assert!(lhs.ptr);
self.ci.nodes.lock(lhs.id);
let rhs = self.ptr_expr_ctx(right, Ctx::default().with_ty(lhs.ty));
self.ci.nodes.unlock(lhs.id);
let mut rhs = rhs?;
debug_assert!(rhs.ptr);
self.assert_ty(pos, &mut rhs, lhs.ty, "struct operand");
let dst = self.new_stack(pos, lhs.ty);
self.struct_op(left.pos(), op, s, dst, lhs.id, rhs.id);
Some(Value::ptr(dst).ty(lhs.ty))
}
ty::Kind::Struct(s) if op.is_compatison() => {
let binding_op = match op {
TokenKind::Eq => TokenKind::Band,
_ => TokenKind::Bor,
};
self.ci.nodes.lock(lhs.id);
let rhs = self.ptr_expr_ctx(right, Ctx::default().with_ty(lhs.ty));
self.ci.nodes.unlock(lhs.id);
let mut rhs = rhs?;
self.assert_ty(pos, &mut rhs, lhs.ty, "struct operand");
self.struct_fold_op(left.pos(), op, binding_op, s, lhs.id, rhs.id)
.or(Value::NEVER)
}
_ => self _ => self
.error(pos, fa!("'{} {op} _' is not supported", self.ty_display(lhs.ty))), .error(pos, fa!("'{} {op} _' is not supported", self.ty_display(lhs.ty))),
} }
@ -3519,12 +3504,7 @@ impl<'a> Codegen<'a> {
match ty.loc(self.tys) { match ty.loc(self.tys) {
Loc::Reg if mem::take(&mut val.ptr) => val.id = self.load_mem(val.id, ty), Loc::Reg if mem::take(&mut val.ptr) => val.id = self.load_mem(val.id, ty),
Loc::Stack if !val.ptr => { Loc::Stack if !val.ptr => self.spill(pos, &mut val),
let stack = self.new_stack(pos, ty);
self.store_mem(stack, val.ty, val.id);
val.id = stack;
val.ptr = true;
}
_ => {} _ => {}
} }
@ -4364,6 +4344,14 @@ impl<'a> Codegen<'a> {
} }
} }
fn spill(&mut self, pos: Pos, value: &mut Value) {
debug_assert!(!value.ptr);
let stck = self.new_stack(pos, value.ty);
self.store_mem(stck, value.ty, value.id);
value.id = stck;
value.ptr = true;
}
fn checked_expr( fn checked_expr(
&mut self, &mut self,
expr: &Expr, expr: &Expr,
@ -5029,10 +5017,7 @@ impl<'a> Codegen<'a> {
if parser::find_symbol(&self.file().symbols, id).flags & idfl::REFERENCED != 0 if parser::find_symbol(&self.file().symbols, id).flags & idfl::REFERENCED != 0
&& !right.ptr && !right.ptr
{ {
let stack = self.new_stack(pos, right.ty); self.spill(pos, &mut right);
self.store_mem(stack, right.ty, right.id);
right.id = stack;
right.ptr = true;
} }
self.ci.scope.vars.push(Variable::new( self.ci.scope.vars.push(Variable::new(
id, id,
@ -6061,6 +6046,16 @@ impl<'a> Codegen<'a> {
} }
} }
impl TokenKind {
fn is_scalar_op(self, ty: ty::Id) -> bool {
ty.is_pointer()
|| ty.is_integer()
|| ty == ty::Id::BOOL
|| (ty == ty::Id::TYPE && matches!(self, TokenKind::Eq | TokenKind::Ne))
|| (ty.is_float() && self.is_supported_float_op())
}
}
#[derive(Clone, Copy, Default)] #[derive(Clone, Copy, Default)]
struct TyScope { struct TyScope {
file: Module, file: Module,