language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-10-01 15:51:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

stop special casing on list and str. They are just large structs

Browse source
This commit is contained in:
Brendan Hansknecht 2022-03-11 18:43:31 -08:00
parent de68e55aca
commit d9c3601ec4
2 changed files with 14 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

9
compiler/gen_dev/src/generic64/storage.rs
View file

@ -733,15 +733,6 @@ impl<
let reg = self.load_to_float_reg(buf, sym); let reg = self.load_to_float_reg(buf, sym);
ASM::mov_base32_freg64(buf, to_offset, reg); ASM::mov_base32_freg64(buf, to_offset, reg);
} }
Layout::Builtin(Builtin::Str | Builtin::List(_)) => {
let (from_offset, _) = self.stack_offset_and_size(sym);
self.with_tmp_general_reg(buf, |_storage_manager, buf, reg| {
ASM::mov_reg64_base32(buf, reg, from_offset);
ASM::mov_base32_reg64(buf, to_offset, reg);
ASM::mov_reg64_base32(buf, reg, from_offset + 8);
ASM::mov_base32_reg64(buf, to_offset + 8, reg);
});
}
_ if layout.stack_size(self.target_info) == 0 => {} _ if layout.stack_size(self.target_info) == 0 => {}
_ if layout.safe_to_memcpy() && layout.stack_size(self.target_info) > 8 => { _ if layout.safe_to_memcpy() && layout.stack_size(self.target_info) > 8 => {
let (from_offset, size) = self.stack_offset_and_size(sym); let (from_offset, size) = self.stack_offset_and_size(sym);

76
compiler/gen_dev/src/generic64/x86_64.rs
View file

@ -200,7 +200,7 @@ impl CallConv<X86_64GeneralReg, X86_64FloatReg, X86_64Assembler> for X86_64Syste
#[inline(always)] #[inline(always)]
fn load_args<'a>( fn load_args<'a>(
buf: &mut Vec<'a, u8>, _buf: &mut Vec<'a, u8>,
storage_manager: &mut StorageManager< storage_manager: &mut StorageManager<
'a, 'a,
X86_64GeneralReg, X86_64GeneralReg,
@ -239,19 +239,6 @@ impl CallConv<X86_64GeneralReg, X86_64FloatReg, X86_64Assembler> for X86_64Syste
arg_offset += 8; arg_offset += 8;
} }
} }
Layout::Builtin(Builtin::Str | Builtin::List(_)) => {
if general_i + 1 < Self::GENERAL_PARAM_REGS.len() {
// Load the value from the param reg into a useable base offset.
let src1 = Self::GENERAL_PARAM_REGS[general_i];
let src2 = Self::GENERAL_PARAM_REGS[general_i + 1];
let base_offset = storage_manager.claim_stack_area(sym, 16);
X86_64Assembler::mov_base32_reg64(buf, base_offset, src1);
X86_64Assembler::mov_base32_reg64(buf, base_offset + 8, src2);
general_i += 2;
} else {
todo!("loading lists and strings args on the stack");
}
}
_ if stack_size == 0 => { _ if stack_size == 0 => {
storage_manager.no_data_arg(sym); storage_manager.no_data_arg(sym);
} }
@ -347,37 +334,25 @@ impl CallConv<X86_64GeneralReg, X86_64FloatReg, X86_64Assembler> for X86_64Syste
tmp_stack_offset += 8; tmp_stack_offset += 8;
} }
} }
Layout::Builtin(Builtin::Str | Builtin::List(_)) => {
if general_i + 1 < Self::GENERAL_PARAM_REGS.len() {
let (base_offset, _size) = storage_manager.stack_offset_and_size(sym);
debug_assert_eq!(base_offset % 8, 0);
X86_64Assembler::mov_reg64_base32(
buf,
Self::GENERAL_PARAM_REGS[general_i],
base_offset,
);
X86_64Assembler::mov_reg64_base32(
buf,
Self::GENERAL_PARAM_REGS[general_i + 1],
base_offset + 8,
);
general_i += 2;
} else {
todo!("calling functions with strings on the stack");
}
}
x if x.stack_size(TARGET_INFO) == 0 => {} x if x.stack_size(TARGET_INFO) == 0 => {}
x if x.stack_size(TARGET_INFO) > 16 => { x if x.stack_size(TARGET_INFO) > 16 => {
// TODO: Double check this. // TODO: Double check this.
// Just copy onto the stack. // Just copy onto the stack.
// Use return reg as buffer because it will be empty right now.
let (base_offset, size) = storage_manager.stack_offset_and_size(sym); let (base_offset, size) = storage_manager.stack_offset_and_size(sym);
debug_assert_eq!(base_offset % 8, 0); debug_assert_eq!(base_offset % 8, 0);
storage_manager.with_tmp_general_reg(buf, |_storage_manager, buf, reg| { for i in (0..size as i32).step_by(8) {
for i in (0..size as i32).step_by(8) { X86_64Assembler::mov_reg64_base32(
X86_64Assembler::mov_reg64_base32(buf, reg, base_offset + i); buf,
X86_64Assembler::mov_stack32_reg64(buf, tmp_stack_offset + i, reg); Self::GENERAL_RETURN_REGS[0],
} base_offset + i,
}); );
X86_64Assembler::mov_stack32_reg64(
buf,
tmp_stack_offset + i,
Self::GENERAL_RETURN_REGS[0],
);
}
tmp_stack_offset += size as i32; tmp_stack_offset += size as i32;
} }
x => { x => {
@ -404,16 +379,6 @@ impl CallConv<X86_64GeneralReg, X86_64FloatReg, X86_64Assembler> for X86_64Syste
single_register_layouts!() => { single_register_layouts!() => {
internal_error!("single register layouts are not complex symbols"); internal_error!("single register layouts are not complex symbols");
} }
Layout::Builtin(Builtin::Str | Builtin::List(_)) => {
let (base_offset, _size) = storage_manager.stack_offset_and_size(sym);
debug_assert_eq!(base_offset % 8, 0);
X86_64Assembler::mov_reg64_base32(buf, Self::GENERAL_RETURN_REGS[0], base_offset);
X86_64Assembler::mov_reg64_base32(
buf,
Self::GENERAL_RETURN_REGS[1],
base_offset + 8,
);
}
x if x.stack_size(TARGET_INFO) == 0 => {} x if x.stack_size(TARGET_INFO) == 0 => {}
x if !Self::returns_via_arg_pointer(x) => { x if !Self::returns_via_arg_pointer(x) => {
let (base_offset, size) = storage_manager.stack_offset_and_size(sym); let (base_offset, size) = storage_manager.stack_offset_and_size(sym);
@ -470,11 +435,6 @@ impl CallConv<X86_64GeneralReg, X86_64FloatReg, X86_64Assembler> for X86_64Syste
single_register_layouts!() => { single_register_layouts!() => {
internal_error!("single register layouts are not complex symbols"); internal_error!("single register layouts are not complex symbols");
} }
Layout::Builtin(Builtin::Str | Builtin::List(_)) => {
let offset = storage_manager.claim_stack_area(sym, 16);
X86_64Assembler::mov_base32_reg64(buf, offset, Self::GENERAL_RETURN_REGS[0]);
X86_64Assembler::mov_base32_reg64(buf, offset + 8, Self::GENERAL_RETURN_REGS[1]);
}
x if x.stack_size(TARGET_INFO) == 0 => {} x if x.stack_size(TARGET_INFO) == 0 => {}
x if !Self::returns_via_arg_pointer(x) => { x if !Self::returns_via_arg_pointer(x) => {
let size = layout.stack_size(TARGET_INFO); let size = layout.stack_size(TARGET_INFO);
@ -670,10 +630,6 @@ impl CallConv<X86_64GeneralReg, X86_64FloatReg, X86_64Assembler> for X86_64Windo
storage_manager.float_reg_arg(sym, Self::FLOAT_PARAM_REGS[i]); storage_manager.float_reg_arg(sym, Self::FLOAT_PARAM_REGS[i]);
i += 1; i += 1;
} }
Layout::Builtin(Builtin::Str) => {
// I think this just needs to be passed on the stack, so not a huge deal.
todo!("Passing str args with Windows fast call");
}
x if x.stack_size(TARGET_INFO) == 0 => {} x if x.stack_size(TARGET_INFO) == 0 => {}
x => { x => {
todo!("Loading args with layout {:?}", x); todo!("Loading args with layout {:?}", x);
@ -760,10 +716,6 @@ impl CallConv<X86_64GeneralReg, X86_64FloatReg, X86_64Assembler> for X86_64Windo
tmp_stack_offset += 8; tmp_stack_offset += 8;
} }
} }
Layout::Builtin(Builtin::Str | Builtin::List(_)) => {
// I think this just needs to be passed on the stack, so not a huge deal.
todo!("Passing str args with Windows fast call");
}
x if x.stack_size(TARGET_INFO) == 0 => {} x if x.stack_size(TARGET_INFO) == 0 => {}
x => { x => {
todo!("calling with arg type, {:?}", x); todo!("calling with arg type, {:?}", x);