language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-04 04:08:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

fix bug in copying small bits of data (e.g. 3 bytes)

Browse source
This commit is contained in:
Folkert 2023-10-07 15:05:30 +02:00
parent 66db1ce206
commit 42d324299d
No known key found for this signature in database
GPG key ID: 1F17F6FFD112B97C
1 changed files with 16 additions and 124 deletions
Download patch file Download diff file Expand all files Collapse all files

140
crates/compiler/gen_dev/src/generic64/x86_64.rs
View file

@ -601,7 +601,7 @@ where
size
}
pub(crate) fn copy_to_base_offset<GeneralReg, FloatReg, ASM>(
fn copy_to_base_offset<GeneralReg, FloatReg, ASM>(
buf: &mut Vec<'_, u8>,
dst_base_offset: i32,
stack_size: u32,
@ -727,14 +727,12 @@ impl X64_64SystemVStoreArgs {
lambda_set.runtime_representation(),
),
LayoutRepr::Struct { .. } => {
let stack_size = layout_interner.stack_size(in_layout);
if stack_size <= 8 {
self.store_arg_64bit(buf, storage_manager, sym);
} else if stack_size <= 16 {
self.store_arg_128bit(buf, storage_manager, sym);
} else {
unreachable!("covered by earlier branch");
}
let stack_offset = self.tmp_stack_offset;
let size =
copy_symbol_to_stack_offset(buf, storage_manager, sym, tmp_reg, stack_offset);
self.tmp_stack_offset += size as i32;
}
LayoutRepr::Union(UnionLayout::NonRecursive(_)) => {
let stack_offset = self.tmp_stack_offset;
@ -776,66 +774,6 @@ impl X64_64SystemVStoreArgs {
}
}
fn store_arg_64bit<'a>(
&mut self,
buf: &mut Vec<'a, u8>,
storage_manager: &mut X86_64StorageManager<'a, '_, X86_64SystemV>,
sym: Symbol,
) {
type ASM = X86_64Assembler;
let (offset, _) = storage_manager.stack_offset_and_size(&sym);
match Self::GENERAL_PARAM_REGS.get(self.general_i) {
Some(reg) => {
ASM::mov_reg64_base32(buf, *reg, offset);
self.general_i += 1;
}
None => {
// Copy to stack using return reg as buffer.
let reg = X86_64GeneralReg::RAX;
ASM::mov_reg64_base32(buf, reg, offset);
ASM::mov_stack32_reg64(buf, self.tmp_stack_offset, reg);
self.tmp_stack_offset += 8;
}
}
}
fn store_arg_128bit<'a>(
&mut self,
buf: &mut Vec<'a, u8>,
storage_manager: &mut X86_64StorageManager<'a, '_, X86_64SystemV>,
sym: Symbol,
) {
type ASM = X86_64Assembler;
let (offset, _) = storage_manager.stack_offset_and_size(&sym);
if self.general_i + 1 < Self::GENERAL_PARAM_REGS.len() {
let reg1 = Self::GENERAL_PARAM_REGS[self.general_i];
let reg2 = Self::GENERAL_PARAM_REGS[self.general_i + 1];
ASM::mov_reg64_base32(buf, reg1, offset);
ASM::mov_reg64_base32(buf, reg2, offset + 8);
self.general_i += 2;
} else {
// Copy to stack using return reg as buffer.
let reg = X86_64GeneralReg::RAX;
ASM::mov_reg64_base32(buf, reg, offset);
ASM::mov_stack32_reg64(buf, self.tmp_stack_offset, reg);
ASM::mov_reg64_base32(buf, reg, offset + 8);
ASM::mov_stack32_reg64(buf, self.tmp_stack_offset + 8, reg);
self.tmp_stack_offset += 16;
}
}
fn store_arg_float<'a>(
&mut self,
buf: &mut Vec<'a, u8>,
@ -1042,8 +980,6 @@ impl X64_64SystemVLoadArgs {
sym: Symbol,
in_layout: InLayout<'a>,
) {
use Builtin::{Decimal, Int};
let stack_size = layout_interner.stack_size(in_layout);
match layout_interner.get_repr(in_layout) {
single_register_integers!() => self.load_arg_general(storage_manager, sym),
@ -1065,28 +1001,15 @@ impl X64_64SystemVLoadArgs {
lambda_set.runtime_representation(),
),
LayoutRepr::Struct { .. } => {
if stack_size <= 8 {
self.load_arg_general_64bit(
buf,
storage_manager,
layout_interner,
sym,
in_layout,
);
} else if stack_size <= 16 {
self.load_arg_general_128bit(
buf,
storage_manager,
layout_interner,
sym,
in_layout,
);
} else {
unreachable!("covered by an earlier branch")
}
// for now, just also store this on the stack
storage_manager.complex_stack_arg(&sym, self.argument_offset, stack_size);
self.argument_offset += stack_size as i32;
}
LayoutRepr::Builtin(Int(IntWidth::U128 | IntWidth::I128) | Decimal) => {
self.load_arg_general_128bit(buf, storage_manager, layout_interner, sym, in_layout);
LayoutRepr::Builtin(Builtin::Int(IntWidth::U128 | IntWidth::I128)) => {
self.load_arg_general_128bit(buf, storage_manager, sym);
}
LayoutRepr::Builtin(Builtin::Decimal) => {
self.load_arg_general_128bit(buf, storage_manager, sym);
}
LayoutRepr::Union(UnionLayout::NonRecursive(_)) => {
// for now, just also store this on the stack
@ -1116,41 +1039,11 @@ impl X64_64SystemVLoadArgs {
}
}
fn load_arg_general_64bit(
&mut self,
buf: &mut Vec<u8>,
storage_manager: &mut X86_64StorageManager<'_, '_, X86_64SystemV>,
layout_interner: &mut STLayoutInterner<'_>,
sym: Symbol,
in_layout: InLayout<'_>,
) {
type ASM = X86_64Assembler;
let reg1 = X86_64SystemV::GENERAL_PARAM_REGS.get(self.general_i);
match reg1 {
Some(reg1) => {
let offset =
storage_manager.claim_stack_area_layout(layout_interner, sym, in_layout);
ASM::mov_base32_reg64(buf, offset, *reg1);
self.general_i += 2;
}
None => {
storage_manager.complex_stack_arg(&sym, self.argument_offset, 8);
self.argument_offset += 8;
}
}
}
fn load_arg_general_128bit(
&mut self,
buf: &mut Vec<u8>,
storage_manager: &mut X86_64StorageManager<'_, '_, X86_64SystemV>,
layout_interner: &mut STLayoutInterner<'_>,
sym: Symbol,
in_layout: InLayout<'_>,
) {
type ASM = X86_64Assembler;
@ -1159,8 +1052,7 @@ impl X64_64SystemVLoadArgs {
match (reg1, reg2) {
(Some(reg1), Some(reg2)) => {
let offset =
storage_manager.claim_stack_area_layout(layout_interner, sym, in_layout);
let offset = storage_manager.claim_stack_area_with_alignment(sym, 16, 16);
ASM::mov_base32_reg64(buf, offset, *reg1);
ASM::mov_base32_reg64(buf, offset + 8, *reg2);