diff --git a/lang/src/son.rs b/lang/src/son.rs index 37b49a4..62ed383 100644 --- a/lang/src/son.rs +++ b/lang/src/son.rs @@ -9,7 +9,7 @@ use { idfl::{self}, CtorField, Expr, FileId, Pos, }, - task, + reg, task, ty::{self, Arg, ArrayLen, Loc, Tuple}, vc::{BitSet, Vc}, FTask, Func, Global, Ident, Offset, OffsetIter, Reloc, Sig, StringRef, SymKey, TypeParser, @@ -375,7 +375,8 @@ impl Nodes { to: &mut Scope, from: &mut Scope, ) { - for (i, (to_value, from_value)) in to.iter_mut().zip(from.iter_mut()).enumerate() { + for (i, (to_value, from_value)) in to.vars.iter_mut().zip(from.vars.iter_mut()).enumerate() + { debug_assert_eq!(to_value.ty, from_value.ty); if to_value.value() != from_value.value() { self.load_loop_var(i, from_value, loops); @@ -387,8 +388,21 @@ impl Nodes { } } - to.loads.drain(..).for_each(|l| _ = l.remove(self)); - from.loads.drain(..).for_each(|l| _ = l.remove(self)); + for (i, (to_class, from_class)) in + to.aclasses.iter_mut().zip(from.aclasses.iter_mut()).enumerate() + { + if to_class.last_store.get() != from_class.last_store.get() { + self.load_loop_aclass(i, from_class, loops); + self.load_loop_aclass(i, to_class, loops); + if to_class.last_store.get() != from_class.last_store.get() { + let inps = [ctrl.get(), from_class.last_store.get(), to_class.last_store.get()]; + to_class + .last_store + .set_remove(self.new_node(ty::Id::VOID, Kind::Phi, inps), self); + to_class.loads.drain(..).for_each(|d| _ = d.remove(self)); + } + } + } } fn graphviz_low( @@ -1122,29 +1136,16 @@ impl Nodes { } } - fn load_loop_var(&mut self, index: usize, value: &mut Variable, loops: &mut [Loop]) { - self.load_loop_value(&mut |l| l.scope.iter_mut().nth(index).unwrap(), value, loops); - } - - fn load_loop_store(&mut self, value: &mut Variable, loops: &mut [Loop]) { - self.load_loop_value(&mut |l| &mut l.scope.store, value, loops); - } - - fn load_loop_value( - &mut self, - get_lvalue: &mut impl FnMut(&mut Loop) -> &mut Variable, - var: &mut Variable, - loops: &mut [Loop], - ) { + fn load_loop_var(&mut self, index: usize, var: &mut Variable, loops: &mut [Loop]) { if var.value() != VOID { return; } let [loops @ .., loob] = loops else { unreachable!() }; let node = loob.node; - let lvar = get_lvalue(loob); + let lvar = &mut loob.scope.vars[index]; - self.load_loop_value(get_lvalue, lvar, loops); + self.load_loop_var(index, lvar, loops); if !self[lvar.value()].is_lazy_phi(node) { let inps = [node, lvar.value(), VOID]; @@ -1153,6 +1154,24 @@ impl Nodes { var.set_value(lvar.value(), self); } + fn load_loop_aclass(&mut self, index: usize, var: &mut AClass, loops: &mut [Loop]) { + if var.last_store.get() != VOID { + return; + } + + let [loops @ .., loob] = loops else { unreachable!() }; + let node = loob.node; + let lvar = &mut loob.scope.aclasses[index]; + + self.load_loop_aclass(index, lvar, loops); + + if !self[lvar.last_store.get()].is_lazy_phi(node) { + let inps = [node, lvar.last_store.get(), VOID]; + lvar.last_store.set(self.new_node_nop(ty::Id::VOID, Kind::Phi, inps), self); + } + var.last_store.set(lvar.last_store.get(), self); + } + fn check_dominance(&mut self, nd: Nid, min: Nid, check_outputs: bool) { if !cfg!(debug_assertions) { return; @@ -1223,6 +1242,7 @@ impl Nodes { let mut saved = Vc::default(); let mut cursor = last_store; + let mut first_store = last_store; while cursor != MEM && self[cursor].kind == Kind::Stre { let mut contact_point = cursor; let mut region = self[cursor].inputs[2]; @@ -1240,6 +1260,7 @@ impl Nodes { }; unidentifed.remove(index); saved.push(contact_point); + first_store = cursor; cursor = *self[cursor].inputs.get(3).unwrap_or(&MEM); if unidentifed.is_empty() { @@ -1255,6 +1276,19 @@ impl Nodes { { self.modify_input(mcall, self[mcall].inputs.len() - 1, region); } else { + debug_assert_matches!( + self[last_store].kind, + Kind::Stre | Kind::Mem, + "{:?}", + self[last_store] + ); + debug_assert_matches!( + self[first_store].kind, + Kind::Stre | Kind::Mem, + "{:?}", + self[first_store] + ); + if !unidentifed.is_empty() { continue; } @@ -1278,7 +1312,12 @@ impl Nodes { } } - self.replace(dst, *self[dst].inputs.get(3).unwrap_or(&MEM)); + let prev_store = self[dst].inputs[3]; + if prev_store != MEM && first_store != MEM { + self.modify_input(first_store, 3, prev_store); + } + + self.replace(dst, last_store); if self.values[stack as usize].is_ok() { self.lock(stack); } @@ -1413,6 +1452,7 @@ pub struct Node { depth: IDomDepth, lock_rc: LockRc, loop_depth: LoopDepth, + aclass: usize, } impl Node { @@ -1583,30 +1623,47 @@ impl Variable { } } +#[derive(Default, Clone)] +pub struct AClass { + last_store: StrongRef, + loads: Vec, +} + +impl AClass { + fn dup(&self, nodes: &mut Nodes) -> Self { + Self { + last_store: self.last_store.dup(nodes), + loads: self.loads.iter().map(|v| v.dup(nodes)).collect(), + } + } + + fn remove(mut self, nodes: &mut Nodes) { + self.last_store.remove(nodes); + self.loads.drain(..).for_each(|n| _ = n.remove(nodes)); + } + + fn new(nodes: &mut Nodes) -> Self { + Self { last_store: StrongRef::new(MEM, nodes), loads: Default::default() } + } +} + #[derive(Default, Clone)] pub struct Scope { vars: Vec, - loads: Vec, - store: Variable, + aclasses: Vec, } impl Scope { - fn iter_mut(&mut self) -> impl Iterator { - core::iter::once(&mut self.store).chain(self.vars.iter_mut()) - } - fn dup(&self, nodes: &mut Nodes) -> Self { Self { vars: self.vars.iter().map(|v| v.dup(nodes)).collect(), - loads: self.loads.iter().map(|l| l.dup(nodes)).collect(), - store: self.store.dup(nodes), + aclasses: self.aclasses.iter().map(|v| v.dup(nodes)).collect(), } } fn clear(&mut self, nodes: &mut Nodes) { self.vars.drain(..).for_each(|n| n.remove(nodes)); - self.loads.drain(..).for_each(|l| _ = l.remove(nodes)); - mem::take(&mut self.store).remove(nodes); + self.aclasses.drain(..).for_each(|l| l.remove(nodes)); } } @@ -1661,8 +1718,7 @@ impl ItemCtx { let loops = self.nodes.new_node(ty::Id::VOID, Kind::Loops, [VOID]); debug_assert_eq!(loops, LOOPS); self.nodes.lock(loops); - self.scope.store = - Variable::new(Ident::default(), ty::Id::VOID, false, MEM, &mut self.nodes); + self.scope.aclasses.push(AClass::new(&mut self.nodes)); } fn finalize(&mut self, stack: &mut Vec) { @@ -1927,9 +1983,11 @@ impl<'a> Codegen<'a> { ); debug_assert!(self.ci.nodes[region].kind != Kind::Stre); - self.ci.nodes.load_loop_store(&mut self.ci.scope.store, &mut self.ci.loops); - let mut vc = Vc::from([VOID, value, region, self.ci.scope.store.value()]); - for load in self.ci.scope.loads.drain(..) { + let index = self.aclass_index(region); + let aclass = &mut self.ci.scope.aclasses[index]; + self.ci.nodes.load_loop_aclass(index, aclass, &mut self.ci.loops); + let mut vc = Vc::from([VOID, value, region, aclass.last_store.get()]); + for load in aclass.loads.drain(..) { if load.get() == value { load.soft_remove(&mut self.ci.nodes); continue; @@ -1939,9 +1997,9 @@ impl<'a> Codegen<'a> { } } let store = self.ci.nodes.new_node_nop(ty, Kind::Stre, vc); - self.ci.scope.store.set_value(store, &mut self.ci.nodes); + aclass.last_store.set(store, &mut self.ci.nodes); let opted = self.ci.nodes.late_peephole(store).unwrap_or(store); - self.ci.scope.store.set_value_remove(opted, &mut self.ci.nodes); + aclass.last_store.set_remove(opted, &mut self.ci.nodes); opted } @@ -1959,13 +2017,26 @@ impl<'a> Codegen<'a> { self.ty_display(self.ci.nodes[region].ty) ); debug_assert!(self.ci.nodes[region].kind != Kind::Stre); - self.ci.nodes.load_loop_store(&mut self.ci.scope.store, &mut self.ci.loops); - let vc = [VOID, region, self.ci.scope.store.value()]; + let index = self.aclass_index(region); + let aclass = &mut self.ci.scope.aclasses[index]; + self.ci.nodes.load_loop_aclass(index, aclass, &mut self.ci.loops); + let vc = [VOID, region, aclass.last_store.get()]; let load = self.ci.nodes.new_node(ty, Kind::Load, vc); - self.ci.scope.loads.push(StrongRef::new(load, &mut self.ci.nodes)); + aclass.loads.push(StrongRef::new(load, &mut self.ci.nodes)); load } + pub fn aclass_index(&mut self, mut region: Nid) -> usize { + loop { + region = match self.ci.nodes[region].kind { + Kind::BinOp { op: TokenKind::Add | TokenKind::Sub } | Kind::Phi => { + self.ci.nodes[region].inputs[1] + } + _ => break self.ci.nodes[region].aclass, + }; + } + } + pub fn generate(&mut self, entry: FileId) { self.find_type(0, entry, entry, Err("main"), self.files); if self.tys.ins.funcs.is_empty() { @@ -2114,8 +2185,10 @@ impl<'a> Codegen<'a> { if self.ci.inline_depth == 0 { debug_assert_ne!(self.ci.ctrl.get(), VOID); let mut inps = Vc::from([self.ci.ctrl.get(), value.id]); - self.ci.nodes.load_loop_store(&mut self.ci.scope.store, &mut self.ci.loops); - inps.push(self.ci.scope.store.value()); + for (i, aclass) in self.ci.scope.aclasses.iter_mut().enumerate() { + self.ci.nodes.load_loop_aclass(i, aclass, &mut self.ci.loops); + inps.push(aclass.last_store.get()); + } self.ci.ctrl.set( self.ci.nodes.new_node(ty::Id::VOID, Kind::Return, inps), @@ -2453,9 +2526,17 @@ impl<'a> Codegen<'a> { let mut inps = Vc::from([NEVER]); let arg_base = self.tys.tmp.args.len(); let mut has_ptr_arg = false; + let mut clobbered_aliases = vec![]; for arg in args { let value = self.expr(arg)?; - has_ptr_arg |= value.ty.has_pointers(self.tys); + if let Some(base) = self.tys.base_of(value.ty) { + clobbered_aliases.push(self.aclass_index(value.id)); + if base.has_pointers(self.tys) { + clobbered_aliases.push(0); + } + } else if value.ty.has_pointers(self.tys) { + clobbered_aliases.push(0); + } self.tys.tmp.args.push(value.ty); debug_assert_ne!(self.ci.nodes[value.id].kind, Kind::Stre); self.ci.nodes.lock(value.id); @@ -2468,9 +2549,10 @@ impl<'a> Codegen<'a> { self.ci.nodes.unlock(n); } - if has_ptr_arg { - inps.push(self.ci.scope.store.value()); - self.ci.scope.loads.retain_mut(|load| { + for &clobbered in clobbered_aliases.iter() { + let aclass = &mut self.ci.scope.aclasses[clobbered]; + inps.push(aclass.last_store.get()); + aclass.loads.retain_mut(|load| { if inps.contains(&load.get()) { return true; } @@ -2498,10 +2580,6 @@ impl<'a> Codegen<'a> { &mut self.ci.nodes, ); - if has_ptr_arg { - self.store_mem(VOID, ty::Id::VOID, VOID); - } - alt_value.or(Some(Value::new(self.ci.ctrl.get()).ty(ty))) } Expr::Call { func, args, .. } => { @@ -2541,16 +2619,25 @@ impl<'a> Codegen<'a> { let mut cargs = cargs.iter(); let mut args = args.iter(); let mut has_ptr_arg = false; + let mut clobbered_aliases = vec![]; while let Some(ty) = tys.next(self.tys) { let carg = cargs.next().unwrap(); let Some(arg) = args.next() else { break }; let Arg::Value(ty) = ty else { continue }; - has_ptr_arg |= ty.has_pointers(self.tys); let mut value = self.expr_ctx(arg, Ctx::default().with_ty(ty))?; debug_assert_ne!(self.ci.nodes[value.id].kind, Kind::Stre); self.assert_ty(arg.pos(), &mut value, ty, fa!("argument {}", carg.name)); + if let Some(base) = self.tys.base_of(value.ty) { + clobbered_aliases.push(self.aclass_index(value.id)); + if base.has_pointers(self.tys) { + clobbered_aliases.push(0); + } + } else if value.ty.has_pointers(self.tys) { + clobbered_aliases.push(0); + } + self.ci.nodes.lock(value.id); inps.push(value.id); } @@ -2559,9 +2646,10 @@ impl<'a> Codegen<'a> { self.ci.nodes.unlock(n); } - if has_ptr_arg { - inps.push(self.ci.scope.store.value()); - self.ci.scope.loads.retain_mut(|load| { + for &clobbered in clobbered_aliases.iter() { + let aclass = &mut self.ci.scope.aclasses[clobbered]; + inps.push(aclass.last_store.get()); + aclass.loads.retain_mut(|load| { if inps.contains(&load.get()) { return true; } @@ -2589,10 +2677,6 @@ impl<'a> Codegen<'a> { &mut self.ci.nodes, ); - if has_ptr_arg { - self.store_mem(VOID, ty::Id::VOID, VOID); - } - alt_value.or(Some(Value::new(self.ci.ctrl.get()).ty(sig.ret))) } Expr::Directive { name: "inline", args: [func, args @ ..], .. } => { @@ -2893,10 +2977,14 @@ impl<'a> Codegen<'a> { scope: self.ci.scope.dup(&mut self.ci.nodes), }); - for var in &mut self.ci.scope.iter_mut() { + for var in self.ci.scope.vars.iter_mut() { var.set_value(VOID, &mut self.ci.nodes); } + for aclass in self.ci.scope.aclasses.iter_mut() { + aclass.last_store.set(VOID, &mut self.ci.nodes); + } + self.expr(body); let Loop { ctrl: [con, ..], ctrl_scope: [cons, ..], .. } = @@ -2931,7 +3019,9 @@ impl<'a> Codegen<'a> { } let Some(bre) = bre.unwrap(&mut self.ci.nodes) else { - for (loop_var, scope_var) in self.ci.scope.iter_mut().zip(scope.iter_mut()) { + for (loop_var, scope_var) in + self.ci.scope.vars.iter_mut().zip(scope.vars.iter_mut()) + { if self.ci.nodes[scope_var.value()].is_lazy_phi(node) { if loop_var.value() != scope_var.value() { scope_var.set_value( @@ -2950,6 +3040,29 @@ impl<'a> Codegen<'a> { } } } + + for (loop_class, scope_class) in + self.ci.scope.aclasses.iter_mut().zip(scope.aclasses.iter_mut()) + { + if self.ci.nodes[scope_class.last_store.get()].is_lazy_phi(node) { + if loop_class.last_store.get() != scope_class.last_store.get() { + scope_class.last_store.set( + self.ci.nodes.modify_input( + scope_class.last_store.get(), + 2, + loop_class.last_store.get(), + ), + &mut self.ci.nodes, + ); + } else { + let phi = &self.ci.nodes[scope_class.last_store.get()]; + let prev = phi.inputs[1]; + self.ci.nodes.replace(scope_class.last_store.get(), prev); + scope_class.last_store.set(prev, &mut self.ci.nodes); + } + } + } + scope.clear(&mut self.ci.nodes); self.ci.ctrl.set(NEVER, &mut self.ci.nodes); @@ -2965,8 +3078,13 @@ impl<'a> Codegen<'a> { self.ci.nodes.lock(node); - for ((dest_var, scope_var), loop_var) in - self.ci.scope.iter_mut().zip(scope.iter_mut()).zip(bres.iter_mut()) + for ((dest_var, scope_var), loop_var) in self + .ci + .scope + .vars + .iter_mut() + .zip(scope.vars.iter_mut()) + .zip(bres.vars.iter_mut()) { if self.ci.nodes[scope_var.value()].is_lazy_phi(node) { if loop_var.value() != scope_var.value() { @@ -2992,9 +3110,44 @@ impl<'a> Codegen<'a> { debug_assert!(!self.ci.nodes[dest_var.value()].is_lazy_phi(node)); } + for ((dest_class, scope_class), loop_class) in self + .ci + .scope + .aclasses + .iter_mut() + .zip(scope.aclasses.iter_mut()) + .zip(bres.aclasses.iter_mut()) + { + if self.ci.nodes[scope_class.last_store.get()].is_lazy_phi(node) { + if loop_class.last_store.get() != scope_class.last_store.get() { + scope_class.last_store.set( + self.ci.nodes.modify_input( + scope_class.last_store.get(), + 2, + loop_class.last_store.get(), + ), + &mut self.ci.nodes, + ); + } else { + if dest_class.last_store.get() == scope_class.last_store.get() { + dest_class.last_store.set(VOID, &mut self.ci.nodes); + } + let phi = &self.ci.nodes[scope_class.last_store.get()]; + let prev = phi.inputs[1]; + self.ci.nodes.replace(scope_class.last_store.get(), prev); + scope_class.last_store.set(prev, &mut self.ci.nodes); + } + } + + if dest_class.last_store.get() == VOID { + dest_class.last_store.set(scope_class.last_store.get(), &mut self.ci.nodes); + } + + debug_assert!(!self.ci.nodes[dest_class.last_store.get()].is_lazy_phi(node)); + } + scope.clear(&mut self.ci.nodes); bres.clear(&mut self.ci.nodes); - self.ci.scope.loads.drain(..).for_each(|l| _ = l.remove(&mut self.ci.nodes)); self.ci.nodes.unlock(node); let rpl = self.ci.nodes.late_peephole(node).unwrap_or(node); @@ -3029,8 +3182,11 @@ impl<'a> Codegen<'a> { } } - self.ci.nodes.load_loop_store(&mut self.ci.scope.store, &mut self.ci.loops); - let orig_store = self.ci.scope.store.dup(&mut self.ci.nodes); + let mut orig_classes = vec![]; + for (i, aclass) in self.ci.scope.aclasses.iter_mut().enumerate() { + self.ci.nodes.load_loop_aclass(i, aclass, &mut self.ci.loops); + orig_classes.push(aclass.dup(&mut self.ci.nodes)); + } let else_scope = self.ci.scope.dup(&mut self.ci.nodes); self.ci.ctrl.set( @@ -3050,7 +3206,7 @@ impl<'a> Codegen<'a> { self.ci.ctrl.get() }; - orig_store.remove(&mut self.ci.nodes); + orig_classes.into_iter().for_each(|c| c.remove(&mut self.ci.nodes)); if lcntrl == Nid::MAX && rcntrl == Nid::MAX { then_scope.clear(&mut self.ci.nodes); diff --git a/lang/tests/son_tests_arrays.txt b/lang/tests/son_tests_arrays.txt index bdc1c3d..c42ff35 100644 --- a/lang/tests/son_tests_arrays.txt +++ b/lang/tests/son_tests_arrays.txt @@ -1,26 +1,24 @@ main: - ADDI64 r254, r254, -36d - ST r31, r254, 28a, 8h - LI8 r2, 0b - ST r2, r254, 0a, 1h - ST r2, r254, 1a, 1h - LI16 r4, 511h - ST r4, r254, 2a, 1h - LI16 r8, 1h - ST r8, r254, 3a, 1h - LI64 r11, 1d - ADDI64 r2, r254, 4d - ST r11, r254, 4a, 8h - LI64 r3, 2d - ST r3, r254, 12a, 8h - LI64 r6, 4d - ST r6, r254, 20a, 8h + ADDI64 r254, r254, -44d + ST r31, r254, 28a, 16h + LI64 r32, 1d + ADDI64 r2, r254, 0d + ST r32, r254, 0a, 8h + LI64 r8, 2d + ST r8, r254, 8a, 8h + LI64 r11, 4d + ST r11, r254, 16a, 8h JAL r31, r0, :pass - LD r12, r254, 3a, 1h - ANDI r2, r12, 255d - ADD64 r1, r1, r2 - LD r31, r254, 28a, 8h - ADDI64 r254, r254, 36d + LI8 r10, 0b + ST r10, r254, 24a, 1h + ST r10, r254, 25a, 1h + LI16 r12, 511h + ST r12, r254, 26a, 1h + LI16 r4, 1h + ST r4, r254, 27a, 1h + ADD64 r1, r1, r32 + LD r31, r254, 28a, 16h + ADDI64 r254, r254, 44d JALA r0, r31, 0a pass: LD r4, r2, 8a, 8h @@ -31,6 +29,6 @@ pass: LD r1, r10, 0a, 8h ADD64 r1, r1, r9 JALA r0, r31, 0a -code size: 318 +code size: 294 ret: 8 status: Ok(()) diff --git a/lang/tests/son_tests_different_types.txt b/lang/tests/son_tests_different_types.txt index c91b7e0..0ca1fa9 100644 --- a/lang/tests/son_tests_different_types.txt +++ b/lang/tests/son_tests_different_types.txt @@ -1,48 +1,44 @@ main: - ADDI64 r254, r254, -24d - LI8 r3, 255b - ADDI64 r2, r254, 12d - ST r3, r254, 12a, 1h - LI8 r6, 0b - ST r6, r254, 13a, 1h - ST r6, r254, 14a, 1h - ST r3, r254, 15a, 1h - LI32 r11, 0w - ST r11, r254, 16a, 4h - LI32 r3, 2w - ST r3, r254, 20a, 4h - ADDI64 r5, r254, 0d - BMC r2, r5, 12h - LD r8, r254, 8a, 4h - ANDI r8, r8, 4294967295d + ADDI64 r254, r254, -12d + LI8 r1, 255b + ST r1, r254, 0a, 1h + LI8 r4, 0b + ST r4, r254, 1a, 1h + ST r4, r254, 2a, 1h + ST r1, r254, 3a, 1h + LI32 r9, 0w + ST r9, r254, 4a, 4h + LI32 r12, 2w + ST r12, r254, 8a, 4h + LD r3, r254, 8a, 4h ANDI r3, r3, 4294967295d - JEQ r8, r3, :0 + ANDI r12, r12, 4294967295d + JEQ r3, r12, :0 LI64 r1, 0d JMP :1 - 0: LD r2, r254, 4a, 4h - ANDI r2, r2, 4294967295d - ANDI r11, r11, 4294967295d - JEQ r2, r11, :2 + 0: LD r10, r254, 4a, 4h + ANDI r10, r10, 4294967295d + ANDI r9, r9, 4294967295d + JEQ r10, r9, :2 LI64 r1, 64d JMP :1 - 2: LD r11, r254, 0a, 1h - LD r9, r254, 4a, 4h - LD r12, r254, 8a, 4h - LD r5, r254, 1a, 1h - ANDI r4, r11, 255d - ADD32 r3, r12, r9 - LD r11, r254, 2a, 1h - ANDI r10, r5, 255d - ADD32 r9, r3, r4 + 2: LD r4, r254, 0a, 1h + LD r7, r254, 1a, 1h + ANDI r8, r4, 255d + LD r6, r254, 4a, 4h + LD r1, r254, 2a, 1h + ANDI r2, r7, 255d + ADD32 r7, r6, r8 LD r5, r254, 3a, 1h - ANDI r4, r11, 255d - ADD32 r3, r9, r10 + ANDI r6, r1, 255d + ADD32 r11, r7, r2 ANDI r9, r5, 255d - ADD32 r8, r3, r4 - ADD32 r12, r8, r9 - ANDI r1, r12, 4294967295d - 1: ADDI64 r254, r254, 24d + ADD32 r2, r11, r6 + ADD32 r4, r2, r9 + ADD32 r6, r4, r12 + ANDI r1, r6, 4294967295d + 1: ADDI64 r254, r254, 12d JALA r0, r31, 0a -code size: 427 +code size: 387 ret: 512 status: Ok(()) diff --git a/lang/tests/son_tests_inline_test.txt b/lang/tests/son_tests_inline_test.txt index 22526b7..50cc7a6 100644 --- a/lang/tests/son_tests_inline_test.txt +++ b/lang/tests/son_tests_inline_test.txt @@ -23,25 +23,21 @@ scalar_values: JALA r0, r31, 0a structs: ADDI64 r254, r254, -48d - LI64 r1, 0d - ST r1, r254, 40a, 8h - LI64 r4, 20d - ST r4, r254, 0a, 8h - LI64 r7, 5d - ST r7, r254, 8a, 8h - ST r7, r254, 16a, 8h - LD r11, r254, 0a, 8h - LD r1, r254, 8a, 8h - ADD64 r3, r1, r11 - SUB64 r5, r3, r7 - ST r5, r254, 24a, 8h - ST r4, r254, 32a, 8h - LD r9, r254, 40a, 8h - LD r11, r254, 24a, 8h - ADD64 r1, r11, r9 - SUB64 r1, r1, r4 + LI64 r3, 5d + ST r3, r254, 0a, 8h + ST r3, r254, 8a, 8h + LD r7, r254, 0a, 8h + ADDI64 r9, r7, 15d + ST r9, r254, 24a, 8h + LI64 r8, 20d + ST r8, r254, 32a, 8h + LI64 r9, 0d + LD r3, r254, 24a, 8h + ST r8, r254, 16a, 8h + ST r9, r254, 40a, 8h + SUB64 r1, r3, r8 ADDI64 r254, r254, 48d JALA r0, r31, 0a -code size: 373 +code size: 346 ret: 0 status: Ok(()) diff --git a/lang/tests/son_tests_intcast_store.txt b/lang/tests/son_tests_intcast_store.txt index a1d01be..11b0237 100644 --- a/lang/tests/son_tests_intcast_store.txt +++ b/lang/tests/son_tests_intcast_store.txt @@ -1,11 +1,11 @@ main: ADDI64 r254, r254, -24d ST r31, r254, 16a, 8h + ADDI64 r3, r254, 0d ADDI64 r2, r254, 8d LI64 r4, 0d - ST r4, r254, 8a, 8h - ADDI64 r3, r254, 0d ST r4, r254, 0a, 8h + ST r4, r254, 8a, 8h LI64 r4, 1024d JAL r31, r0, :set ANDI r1, r1, 4294967295d