AbleOS/holey-bytes
4
4
Fork 5
Code Issues2 Pull requests1 Packages Projects Releases Wiki Activity

fixing incompatibility

Browse source 
Signed-off-by: Jakub Doka <jakub.doka2@gmail.com>
This commit is contained in:
Jakub Doka 2025-02-19 11:36:46 +01:00
parent 3c5f5dea95
commit 7fcd652a65
No known key found for this signature in database
GPG key ID: C6E9A89936B8C143
8 changed files with 87 additions and 41 deletions
cranelift-backend/src
lib.rs
depell/wasm-rt/src
lib.rs
lang-rework/src/utils
bitset.rs
lang/src
backend/hbvm
regalloc.rs
lib.rsnodes.rsson.rsutils.rs

39
cranelift-backend/src/lib.rs
View file

@ -289,8 +289,8 @@ impl hblang::backend::Backend for Backend {
self.ctx.func.name = self.ctx.func.name =
cir::UserFuncName::User(cir::UserExternalName { namespace: 0, index: id.index() as _ }); cir::UserFuncName::User(cir::UserExternalName { namespace: 0, index: id.index() as _ });
//if files[tys.ins.funcs[id].file].ident_str(tys.ins.funcs[id].name) == "reverse" { //if files[tys.ins.funcs[id].file].ident_str(tys.ins.funcs[id].name) == "" {
// // std::eprintln!("{}", self.ctx.func.display()); //std::eprintln!("{}", self.ctx.func.display());
//} //}
self.ctx.compile(isa, &mut self.ctrl_plane).unwrap(); self.ctx.compile(isa, &mut self.ctrl_plane).unwrap();
@ -341,7 +341,7 @@ impl FuncBuilder<'_, '_> {
let mut arg_vals = &self.bl.block_params(entry).to_vec()[..]; let mut arg_vals = &self.bl.block_params(entry).to_vec()[..];
if self.stack_ret { if self.stack_ret {
let ret_ptr = *arg_vals.take_first().unwrap(); let ret_ptr = *arg_vals.split_off_first().unwrap();
self.values[hbnodes::Nid::MEM.index()] = Some(Ok(ret_ptr)); self.values[hbnodes::Nid::MEM.index()] = Some(Ok(ret_ptr));
} }
@ -360,7 +360,7 @@ impl FuncBuilder<'_, '_> {
size: self.tys.size_of(ty), size: self.tys.size_of(ty),
align_shift: self.tys.align_of(ty).ilog2() as _, align_shift: self.tys.align_of(ty).ilog2() as _,
}); });
let loc = arg_vals.take(..abi_meta.arg_count).unwrap(); let loc = arg_vals.split_off(..abi_meta.arg_count).unwrap();
assert!(loc.len() <= 2, "NEED handling"); assert!(loc.len() <= 2, "NEED handling");
let align = let align =
loc.iter().map(|&p| self.bl.func.dfg.value_type(p).bytes()).max().unwrap(); loc.iter().map(|&p| self.bl.func.dfg.value_type(p).bytes()).max().unwrap();
@ -372,7 +372,7 @@ impl FuncBuilder<'_, '_> {
self.values[arg.index()] = self.values[arg.index()] =
Some(Ok(self.bl.ins().stack_addr(cir::types::I64, slot, 0))) Some(Ok(self.bl.ins().stack_addr(cir::types::I64, slot, 0)))
} else { } else {
let loc = arg_vals.take(..abi_meta.arg_count).unwrap(); let loc = arg_vals.split_off(..abi_meta.arg_count).unwrap();
debug_assert_eq!(loc.len(), 1); debug_assert_eq!(loc.len(), 1);
self.values[arg.index()] = Some(Ok(loc[0])); self.values[arg.index()] = Some(Ok(loc[0]));
} }
@ -507,6 +507,8 @@ impl FuncBuilder<'_, '_> {
let align = loc.iter().map(|&p| p.value_type.bytes()).max().unwrap(); let align = loc.iter().map(|&p| p.value_type.bytes()).max().unwrap();
let mut offset = 0i32; let mut offset = 0i32;
let src = self.value_of(self.nodes[arg].inputs[1]); let src = self.value_of(self.nodes[arg].inputs[1]);
let off = self.value_of(self.nodes[arg].inputs[2]);
let src = self.bl.ins().iadd(src, off);
debug_assert!(self.nodes[arg].kind == Kind::Load); debug_assert!(self.nodes[arg].kind == Kind::Load);
for &v in &loc { for &v in &loc {
ir_args.push(self.bl.ins().load( ir_args.push(self.bl.ins().load(
@ -519,6 +521,8 @@ impl FuncBuilder<'_, '_> {
} }
} else if self.stack_ret { } else if self.stack_ret {
let src = self.value_of(self.nodes[arg].inputs[1]); let src = self.value_of(self.nodes[arg].inputs[1]);
let off = self.value_of(self.nodes[arg].inputs[2]);
let src = self.bl.ins().iadd(src, off);
let dest = self.value_of(Nid::MEM); let dest = self.value_of(Nid::MEM);
self.bl.emit_small_memory_copy( self.bl.emit_small_memory_copy(
self.isa.frontend_config(), self.isa.frontend_config(),
@ -530,7 +534,7 @@ impl FuncBuilder<'_, '_> {
false, false,
MemFlags::new(), MemFlags::new(),
); );
} else { } else if !self.bl.func.signature.returns.is_empty() {
self.ensure_truncated(self.bl.func.signature.returns[0], arg); self.ensure_truncated(self.bl.func.signature.returns[0], arg);
ir_args.push(self.value_of(arg)); ir_args.push(self.value_of(arg));
} }
@ -610,11 +614,13 @@ impl FuncBuilder<'_, '_> {
} }
let &arg = args.next().unwrap(); let &arg = args.next().unwrap();
if !abi_meta.trough_mem && ty.is_aggregate(self.tys) { if !abi_meta.trough_mem && ty.is_aggregate(self.tys) {
let loc = params.take(..abi_meta.arg_count).unwrap(); let loc = params.split_off(..abi_meta.arg_count).unwrap();
assert!(loc.len() <= 2, "NEED handling"); assert!(loc.len() <= 2, "NEED handling");
let align = loc.iter().map(|&p| p.value_type.bytes()).max().unwrap(); let align = loc.iter().map(|&p| p.value_type.bytes()).max().unwrap();
let mut offset = 0i32; let mut offset = 0i32;
let src = self.value_of(self.nodes[arg].inputs[1]); let src = self.value_of(self.nodes[arg].inputs[1]);
let off = self.value_of(self.nodes[arg].inputs[2]);
let src = self.bl.ins().iadd(src, off);
debug_assert!(self.nodes[arg].kind == Kind::Load); debug_assert!(self.nodes[arg].kind == Kind::Load);
for &v in loc { for &v in loc {
ir_args.push(self.bl.ins().load( ir_args.push(self.bl.ins().load(
@ -625,8 +631,14 @@ impl FuncBuilder<'_, '_> {
)); ));
offset += align as i32; offset += align as i32;
} }
} else if ty.is_aggregate(self.tys) {
let src = self.value_of(self.nodes[arg].inputs[1]);
let off = self.value_of(self.nodes[arg].inputs[2]);
let src = self.bl.ins().iadd(src, off);
ir_args.push(src);
} else { } else {
let loc = params.take(..abi_meta.arg_count).unwrap(); let loc = params.split_off(..abi_meta.arg_count).unwrap();
debug_assert!(!params.is_empty() || !stack_ret);
debug_assert_eq!(loc.len(), 1); debug_assert_eq!(loc.len(), 1);
ir_args.push(self.value_of(arg)); ir_args.push(self.value_of(arg));
} }
@ -654,6 +666,7 @@ impl FuncBuilder<'_, '_> {
self.bl.ins().store(MemFlags::new(), v, slot, offset); self.bl.ins().store(MemFlags::new(), v, slot, offset);
offset += align as i32; offset += align as i32;
} }
self.values[nid.index()] = Some(Ok(slot));
} }
} }
for &o in node.outputs.iter().rev() { for &o in node.outputs.iter().rev() {
@ -693,7 +706,8 @@ impl FuncBuilder<'_, '_> {
.tys .tys
.inner_of(self.nodes[lhs].ty) .inner_of(self.nodes[lhs].ty)
.is_some_and(|v| v.is_pointer()) .is_some_and(|v| v.is_pointer())
|| self.nodes[lhs].ty == hbty::Id::BOOL)); || self.nodes[lhs].ty == hbty::Id::BOOL))
|| self.nodes[lhs].kind == Kind::Stck;
let is_float_op = node.ty.is_float() let is_float_op = node.ty.is_float()
|| (node.ty == hbty::Id::BOOL && self.nodes[lhs].ty.is_float()); || (node.ty == hbty::Id::BOOL && self.nodes[lhs].ty.is_float());
@ -748,7 +762,12 @@ impl FuncBuilder<'_, '_> {
) )
}) })
} }
Kind::RetVal => Ok(self.value_of(node.inputs[0])), Kind::RetVal => {
if self.tys.size_of(node.ty) == 0 {
return;
}
Ok(self.value_of(node.inputs[0]))
}
Kind::UnOp { op } => { Kind::UnOp { op } => {
let oper = self.value_of(node.inputs[1]); let oper = self.value_of(node.inputs[1]);
let dst = node.ty; let dst = node.ty;

2
depell/wasm-rt/src/lib.rs
View file

@ -152,7 +152,7 @@ pub struct Write<'a>(pub &'a mut [u8]);
impl core::fmt::Write for Write<'_> { impl core::fmt::Write for Write<'_> {
fn write_str(&mut self, s: &str) -> core::fmt::Result { fn write_str(&mut self, s: &str) -> core::fmt::Result {
if let Some(m) = self.0.take_mut(..s.len()) { if let Some(m) = self.0.split_off_mut(..s.len()) {
m.copy_from_slice(s.as_bytes()); m.copy_from_slice(s.as_bytes());
Ok(()) Ok(())
} else { } else {

2
lang-rework/src/utils/bitset.rs
View file

@ -262,7 +262,7 @@ impl Iterator for BitSetIter<'_> {
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
while self.current == 0 { while self.current == 0 {
self.current = *self.remining.take_first()?; self.current = *self.remining.split_off_first()?;
self.index += 1; self.index += 1;
} }

2
lang/src/backend/hbvm/regalloc.rs
View file

@ -27,7 +27,7 @@ impl HbvmBackend {
let tail = FunctionBuilder::build(nodes, tys, &mut self.ralloc, sig); let tail = FunctionBuilder::build(nodes, tys, &mut self.ralloc, sig);
let strip_load = |value| match nodes[value].kind { let strip_load = |value| match nodes[value].kind {
Kind::Load { .. } if nodes[value].ty.loc(tys) == Loc::Stack => { Kind::Load if nodes[value].ty.loc(tys) == Loc::Stack => {
(nodes[value].inputs[1], nodes[value].inputs[2]) (nodes[value].inputs[1], nodes[value].inputs[2])
} }
_ => (value, Nid::VOID), _ => (value, Nid::VOID),

2
lang/src/lib.rs
View file

@ -424,7 +424,7 @@ fn endoce_string(
} }
pub fn quad_sort<T>(mut slice: &mut [T], mut cmp: impl FnMut(&T, &T) -> core::cmp::Ordering) { pub fn quad_sort<T>(mut slice: &mut [T], mut cmp: impl FnMut(&T, &T) -> core::cmp::Ordering) {
while let Some(it) = slice.take_first_mut() { while let Some(it) = slice.split_off_first_mut() {
for ot in &mut *slice { for ot in &mut *slice {
if cmp(it, ot) == core::cmp::Ordering::Greater { if cmp(it, ot) == core::cmp::Ordering::Greater {
core::mem::swap(it, ot); core::mem::swap(it, ot);

10
lang/src/nodes.rs
View file

@ -574,7 +574,7 @@ impl Nodes {
a a
} }
fn graphviz_low(&self, disp: ty::Display, out: &mut String) -> core::fmt::Result { pub fn graphviz_low(&self, disp: ty::Display, out: &mut String) -> core::fmt::Result {
use core::fmt::Write; use core::fmt::Write;
writeln!(out)?; writeln!(out)?;
@ -794,7 +794,11 @@ impl Nodes {
!self.is_locked(target) !self.is_locked(target)
} }
pub fn remove(&mut self, target: Nid) -> bool { pub fn remove(&mut self, _: Nid) -> bool {
return false;
}
pub fn remove_really(&mut self, target: Nid) -> bool {
if !self[target].outputs.is_empty() if !self[target].outputs.is_empty()
|| self.is_locked(target) || self.is_locked(target)
|| self[target].kind == Kind::Arg || self[target].kind == Kind::Arg
@ -847,7 +851,7 @@ impl Nodes {
self.push_adjacent_nodes(node, stack); self.push_adjacent_nodes(node, stack);
} }
if self.remove(node) { if self.remove_really(node) {
continue; continue;
} }

69
lang/src/son.rs
View file

@ -625,7 +625,24 @@ impl<'a> Codegen<'a> {
stck stck
} }
fn store_mem(&mut self, region: Nid, offset: impl IntoOffset, ty: ty::Id, value: Nid) -> Nid { fn store_mem(
&mut self,
region: Nid,
offset: impl IntoOffset,
ty: ty::Id,
mut value: Value,
) -> Nid {
self.strip_offset(&mut value);
self.store_mem_low(region, offset, ty, value.id)
}
fn store_mem_low(
&mut self,
region: Nid,
offset: impl IntoOffset,
ty: ty::Id,
value: Nid,
) -> Nid {
if value == Nid::NEVER { if value == Nid::NEVER {
return Nid::NEVER; return Nid::NEVER;
} }
@ -753,7 +770,7 @@ impl<'a> Codegen<'a> {
let OptLayout { flag_ty, flag_offset, .. } = self.tys.opt_layout(ty); let OptLayout { flag_ty, flag_offset, .. } = self.tys.opt_layout(ty);
let stack = self.new_stack(pos, oty); let stack = self.new_stack(pos, oty);
let value = self.ci.nodes.new_const(flag_ty, 0); let value = self.ci.nodes.new_const(flag_ty, 0);
self.store_mem(stack, flag_offset, flag_ty, value); self.store_mem_low(stack, flag_offset, flag_ty, value);
Some(Value::ptr(stack).ty(oty)) Some(Value::ptr(stack).ty(oty))
} }
} }
@ -847,7 +864,7 @@ impl<'a> Codegen<'a> {
let slc = self.tys.make_array(ty::Id::U8, ArrayLen::MAX); let slc = self.tys.make_array(ty::Id::U8, ArrayLen::MAX);
let mem = self.new_stack(pos, slc); let mem = self.new_stack(pos, slc);
for (off, value) in [(0u32, Value::ptr(global).ty(ty)), (8, len)] { for (off, value) in [(0u32, Value::ptr(global).ty(ty)), (8, len)] {
self.store_mem(mem, off, value.ty, value.id); self.store_mem(mem, off, value.ty, value);
} }
Some(Value::ptr(mem).ty(slc)) Some(Value::ptr(mem).ty(slc))
} }
@ -913,7 +930,7 @@ impl<'a> Codegen<'a> {
self.tys, self.tys,
); );
if value.ty.loc(self.tys) == Loc::Stack { if value.ty.loc(self.tys) == Loc::Stack {
self.store_mem(ret_val.id, 0, value.ty, value.id); self.store_mem(ret_val.id, 0, value.ty, value);
} else { } else {
ret_val.id = self.ci.nodes.new_node( ret_val.id = self.ci.nodes.new_node(
value.ty, value.ty,
@ -983,7 +1000,7 @@ impl<'a> Codegen<'a> {
} }
let stack = self.new_stack(pos, val.ty); let stack = self.new_stack(pos, val.ty);
self.store_mem(stack, 0, val.ty, val.id); self.store_mem(stack, 0, val.ty, val);
Some(Value::new(stack).ty(self.tys.make_ptr(val.ty))) Some(Value::new(stack).ty(self.tys.make_ptr(val.ty)))
} }
@ -1090,14 +1107,14 @@ impl<'a> Codegen<'a> {
if var.ptr { if var.ptr {
let val = var.value(); let val = var.value();
let ty = var.ty; let ty = var.ty;
self.store_mem(val, Nid::ZERO, ty, value.id); self.store_mem(val, Nid::ZERO, ty, value);
} else { } else {
self.strip_offset(&mut value); self.strip_offset(&mut value);
let var = &mut self.ci.scope.vars[u16::MAX as usize - dest.id.index()]; let var = &mut self.ci.scope.vars[u16::MAX as usize - dest.id.index()];
var.set_value_remove(value.id, &mut self.ci.nodes); var.set_value_remove(value.id, &mut self.ci.nodes);
} }
} else if dest.ptr { } else if dest.ptr {
self.store_mem(dest.id, dest.offset, dest.ty, value.id); self.store_mem(dest.id, dest.offset, dest.ty, value);
} else { } else {
self.error(pos, "cannot assign to this expression"); self.error(pos, "cannot assign to this expression");
} }
@ -1280,10 +1297,10 @@ impl<'a> Codegen<'a> {
let mem = self.new_stack(pos, ty); let mem = self.new_stack(pos, ty);
let (off, value) = (SLICE_PTR_OFF, ptr); let (off, value) = (SLICE_PTR_OFF, ptr);
self.store_mem(mem, off, value.ty, value.id); self.store_mem(mem, off, value.ty, value);
let (off, value) = (SLICE_LEN_OFF, len); let (off, value) = (SLICE_LEN_OFF, len);
self.store_mem(mem, off, value.ty, value.id); self.store_mem(mem, off, value.ty, value);
len_id.remove(&mut self.ci.nodes); len_id.remove(&mut self.ci.nodes);
ptr_id.remove(&mut self.ci.nodes); ptr_id.remove(&mut self.ci.nodes);
@ -1417,7 +1434,7 @@ impl<'a> Codegen<'a> {
for (off, value) in for (off, value) in
[(SLICE_PTR_OFF, Value::ptr(global).ty(ty)), (SLICE_LEN_OFF, len)] [(SLICE_PTR_OFF, Value::ptr(global).ty(ty)), (SLICE_LEN_OFF, len)]
{ {
self.store_mem(mem, off, value.ty, value.id); self.store_mem(mem, off, value.ty, value);
} }
Some(Value::ptr(mem).ty(slc)) Some(Value::ptr(mem).ty(slc))
} }
@ -1737,7 +1754,7 @@ impl<'a> Codegen<'a> {
let mut offs = OffsetIter::new(tupl, self.tys); let mut offs = OffsetIter::new(tupl, self.tys);
for value in values { for value in values {
let (ty, offset) = offs.next_ty(self.tys).unwrap(); let (ty, offset) = offs.next_ty(self.tys).unwrap();
self.store_mem(mem, offset, ty, value.get()); self.store_mem_low(mem, offset, ty, value.get());
} }
Some(Value::ptr(mem).ty(tupl.into())) Some(Value::ptr(mem).ty(tupl.into()))
@ -1758,7 +1775,8 @@ impl<'a> Codegen<'a> {
(expr, mem) (expr, mem)
} }
}; };
self.store_mem(mem, offset, elem.ty, elem.id);
self.store_mem(mem, offset, elem.ty, elem);
offset += self.tys.size_of(elem.ty); offset += self.tys.size_of(elem.ty);
} }
@ -1782,7 +1800,7 @@ impl<'a> Codegen<'a> {
}; };
let value = self.checked_expr(field, ty, "tuple field")?; let value = self.checked_expr(field, ty, "tuple field")?;
self.store_mem(mem, offset, ty, value.id); self.store_mem(mem, offset, ty, value);
} }
let field_list = offs let field_list = offs
@ -1829,7 +1847,7 @@ impl<'a> Codegen<'a> {
fields.iter().zip((0u32..).step_by(elem_size as usize)) fields.iter().zip((0u32..).step_by(elem_size as usize))
{ {
let value = self.checked_expr(field, elem, "array value")?; let value = self.checked_expr(field, elem, "array value")?;
self.store_mem(mem, offset, elem, value.id); self.store_mem(mem, offset, elem, value);
} }
Some(Value::ptr(mem).ty(aty)) Some(Value::ptr(mem).ty(aty))
@ -1847,7 +1865,7 @@ impl<'a> Codegen<'a> {
}; };
let value = self.checked_expr(field, ty, "tuple field")?; let value = self.checked_expr(field, ty, "tuple field")?;
self.store_mem(mem, offset, ty, value.id); self.store_mem(mem, offset, ty, value);
} }
Some(Value::ptr(mem).ty(tupl.into())) Some(Value::ptr(mem).ty(tupl.into()))
@ -1893,7 +1911,7 @@ impl<'a> Codegen<'a> {
let (ty, offset) = (field.ty, 0); let (ty, offset) = (field.ty, 0);
let value = self.checked_expr(&value, ty, fa!("field {}", name))?; let value = self.checked_expr(&value, ty, fa!("field {}", name))?;
self.store_mem(mem, offset, ty, value.id); self.store_mem(mem, offset, ty, value);
Some(Value::ptr(mem).ty(sty)) Some(Value::ptr(mem).ty(sty))
} }
@ -1926,7 +1944,7 @@ impl<'a> Codegen<'a> {
let value = let value =
self.checked_expr(&field.value, ty, fa!("field {}", field.name))?; self.checked_expr(&field.value, ty, fa!("field {}", field.name))?;
self.store_mem(mem, offset, ty, value.id); self.store_mem(mem, offset, ty, value);
} }
for (i, &mut (ref mut ty, offset)) in for (i, &mut (ref mut ty, offset)) in
@ -1939,7 +1957,7 @@ impl<'a> Codegen<'a> {
let field = &self.tys.ins.struct_fields[i]; let field = &self.tys.ins.struct_fields[i];
let Some(deva) = field.default_value else { continue }; let Some(deva) = field.default_value else { continue };
let value = self.gen_const(deva, Ctx::default().with_ty(*ty))?; let value = self.gen_const(deva, Ctx::default().with_ty(*ty))?;
self.store_mem(mem, offset, *ty, value.id); self.store_mem(mem, offset, *ty, value);
*ty = ty::Id::UNDECLARED; *ty = ty::Id::UNDECLARED;
} }
@ -2501,7 +2519,8 @@ impl<'a> Codegen<'a> {
fn spill(&mut self, pos: Pos, value: &mut Value) { fn spill(&mut self, pos: Pos, value: &mut Value) {
debug_assert!(!value.ptr); debug_assert!(!value.ptr);
let stck = self.new_stack(pos, value.ty); let stck = self.new_stack(pos, value.ty);
self.store_mem(stck, 0, value.ty, value.id); self.strip_offset(value);
self.store_mem_low(stck, 0, value.ty, value.id);
value.id = stck; value.id = stck;
value.ptr = true; value.ptr = true;
} }
@ -2779,6 +2798,7 @@ impl<'a> Codegen<'a> {
} }
self.assert_ty(func.pos(), caller, ty, "caller"); self.assert_ty(func.pos(), caller, ty, "caller");
self.strip_offset(caller);
self.ci.scope.vars.push(Variable::new( self.ci.scope.vars.push(Variable::new(
carg.id, carg.id,
ty, ty,
@ -2803,6 +2823,7 @@ impl<'a> Codegen<'a> {
debug_assert_ne!(self.ci.nodes[value.id].kind, Kind::Stre); debug_assert_ne!(self.ci.nodes[value.id].kind, Kind::Stre);
debug_assert_ne!(value.id, Nid::VOID); debug_assert_ne!(value.id, Nid::VOID);
self.assert_ty(arg.pos(), &mut value, ty, fa!("argument {}", carg.name)); self.assert_ty(arg.pos(), &mut value, ty, fa!("argument {}", carg.name));
self.strip_offset(&mut value);
Variable::new(carg.id, ty, value.ptr, value.id, &mut self.ci.nodes) Variable::new(carg.id, ty, value.ptr, value.id, &mut self.ci.nodes)
} }
}; };
@ -2818,7 +2839,7 @@ impl<'a> Codegen<'a> {
let prev_ret = self.ci.ret.replace(sig.ret); let prev_ret = self.ci.ret.replace(sig.ret);
let prev_file = mem::replace(&mut self.ci.file, file); let prev_file = mem::replace(&mut self.ci.file, file);
let prev_parent = mem::replace(&mut self.ci.parent, parent); let prev_parent = mem::replace(&mut self.ci.parent, parent);
let prev_ctrl = self.ci.ctrl.get(); //let prev_ctrl = self.ci.ctrl.get();
if self.expr(body).is_some() { if self.expr(body).is_some() {
if sig.ret == ty::Id::VOID { if sig.ret == ty::Id::VOID {
@ -3015,7 +3036,7 @@ impl<'a> Codegen<'a> {
[Nid::VOID, lhs, rhs], [Nid::VOID, lhs, rhs],
self.tys, self.tys,
); );
self.store_mem(dst.id, dst.offset, ty, res); self.store_mem_low(dst.id, dst.offset, ty, res);
} }
ty::Kind::Struct(is) => { ty::Kind::Struct(is) => {
if !self.struct_op(pos, op, is, dst, lhs, rhs) { if !self.struct_op(pos, op, is, dst, lhs, rhs) {
@ -3282,6 +3303,7 @@ impl<'a> Codegen<'a> {
[Nid::VOID, value.id, value.offset], [Nid::VOID, value.id, value.offset],
self.tys, self.tys,
); );
value.offset = Nid::ZERO;
self.ci.nodes[value.id].aclass = self.ci.nodes[prev].aclass; self.ci.nodes[value.id].aclass = self.ci.nodes[prev].aclass;
} }
} }
@ -3641,11 +3663,12 @@ impl<'a> Codegen<'a> {
Loc::Stack => { Loc::Stack => {
let stack = self.new_stack(pos, oty); let stack = self.new_stack(pos, oty);
let fill = self.ci.nodes.new_const(flag_ty, 1); let fill = self.ci.nodes.new_const(flag_ty, 1);
self.store_mem(stack, 0, flag_ty, fill); self.store_mem_low(stack, 0, flag_ty, fill);
self.store_mem(stack, payload_offset, val.ty, val.id); self.store_mem(stack, payload_offset, val.ty, *val);
val.id = stack; val.id = stack;
val.ptr = true; val.ptr = true;
val.ty = oty; val.ty = oty;
val.offset = Nid::ZERO;
} }
} }
} }

2
lang/src/utils.rs
View file

@ -366,7 +366,7 @@ impl Iterator for BitSetIter<'_> {
fn next(&mut self) -> Option<Self::Item> { fn next(&mut self) -> Option<Self::Item> {
while self.current == 0 { while self.current == 0 {
self.current = *self.remining.take_first()?; self.current = *self.remining.split_off_first()?;
self.index += 1; self.index += 1;
} }