diff --git a/cranelift/codegen/src/isa/aarch64/abi.rs b/cranelift/codegen/src/isa/aarch64/abi.rs index dedff9cf25..180fd22f2d 100644 --- a/cranelift/codegen/src/isa/aarch64/abi.rs +++ b/cranelift/codegen/src/isa/aarch64/abi.rs @@ -29,7 +29,7 @@ pub(crate) type AArch64Caller = Caller; /// This is the limit for the size of argument and return-value areas on the /// stack. We place a reasonable limit here to avoid integer overflow issues /// with 32-bit arithmetic: for now, 128 MB. -static STACK_ARG_RET_SIZE_LIMIT: u64 = 128 * 1024 * 1024; +static STACK_ARG_RET_SIZE_LIMIT: u32 = 128 * 1024 * 1024; impl Into for StackAMode { fn into(self) -> AMode { @@ -94,7 +94,7 @@ impl ABIMachineSpec for AArch64MachineDeps { args_or_rets: ArgsOrRets, add_ret_area_ptr: bool, mut args: ArgsAccumulator<'_>, - ) -> CodegenResult<(i64, Option)> + ) -> CodegenResult<(u32, Option)> where I: IntoIterator, { @@ -116,7 +116,7 @@ impl ABIMachineSpec for AArch64MachineDeps { let mut next_xreg = 0; let mut next_vreg = 0; - let mut next_stack: u64 = 0; + let mut next_stack: u32 = 0; let (max_per_class_reg_vals, mut remaining_reg_vals) = match args_or_rets { ArgsOrRets::Args => (8, 16), // x0-x7 and v0-v7 @@ -152,13 +152,13 @@ impl ABIMachineSpec for AArch64MachineDeps { if let ir::ArgumentPurpose::StructArgument(size) = param.purpose { assert_eq!(args_or_rets, ArgsOrRets::Args); let offset = next_stack as i64; - let size = size as u64; + let size = size; assert!(size % 8 == 0, "StructArgument size is not properly aligned"); next_stack += size; args.push(ABIArg::StructArg { pointer: None, offset, - size, + size: size as u64, purpose: param.purpose, }); continue; @@ -282,7 +282,7 @@ impl ABIMachineSpec for AArch64MachineDeps { // Spill to the stack // Compute the stack slot's size. - let size = (ty_bits(param.value_type) / 8) as u64; + let size = (ty_bits(param.value_type) / 8) as u32; let size = if is_apple_cc || (call_conv.extends_wasmtime() && args_or_rets == ArgsOrRets::Rets) @@ -308,7 +308,7 @@ impl ABIMachineSpec for AArch64MachineDeps { // Build the stack locations from each slot .scan(next_stack, |next_stack, ty| { let slot_offset = *next_stack as i64; - *next_stack += (ty_bits(ty) / 8) as u64; + *next_stack += (ty_bits(ty) / 8) as u32; Some((ty, slot_offset)) }) @@ -358,7 +358,7 @@ impl ABIMachineSpec for AArch64MachineDeps { return Err(CodegenError::ImplLimitExceeded); } - Ok((next_stack as i64, extra_arg)) + Ok((next_stack, extra_arg)) } fn fp_to_arg_offset(_call_conv: isa::CallConv, _flags: &settings::Flags) -> i64 { diff --git a/cranelift/codegen/src/isa/riscv64/abi.rs b/cranelift/codegen/src/isa/riscv64/abi.rs index b5c60ed35b..833a314ab1 100644 --- a/cranelift/codegen/src/isa/riscv64/abi.rs +++ b/cranelift/codegen/src/isa/riscv64/abi.rs @@ -35,7 +35,7 @@ pub(crate) type Riscv64ABICaller = Caller; /// This is the limit for the size of argument and return-value areas on the /// stack. We place a reasonable limit here to avoid integer overflow issues /// with 32-bit arithmetic: for now, 128 MB. -static STACK_ARG_RET_SIZE_LIMIT: u64 = 128 * 1024 * 1024; +static STACK_ARG_RET_SIZE_LIMIT: u32 = 128 * 1024 * 1024; /// Riscv64-specific ABI behavior. This struct just serves as an implementation /// point for the trait; it is never actually instantiated. @@ -63,7 +63,7 @@ impl ABIMachineSpec for Riscv64MachineDeps { args_or_rets: ArgsOrRets, add_ret_area_ptr: bool, mut args: ArgsAccumulator<'_>, - ) -> CodegenResult<(i64, Option)> + ) -> CodegenResult<(u32, Option)> where I: IntoIterator, { @@ -78,14 +78,14 @@ impl ABIMachineSpec for Riscv64MachineDeps { let mut next_x_reg = x_start; let mut next_f_reg = f_start; // Stack space. - let mut next_stack: u64 = 0; + let mut next_stack: u32 = 0; let mut return_one_register_used = false; for param in params { if let ir::ArgumentPurpose::StructArgument(size) = param.purpose { let offset = next_stack; assert!(size % 8 == 0, "StructArgument size is not properly aligned"); - next_stack += size as u64; + next_stack += size; args.push(ABIArg::StructArg { pointer: None, offset: offset as i64, @@ -135,7 +135,7 @@ impl ABIMachineSpec for Riscv64MachineDeps { // // Note that in all cases 16-byte stack alignment happens // separately after all args. - let size = (reg_ty.bits() / 8) as u64; + let size = reg_ty.bits() / 8; let size = if args_or_rets == ArgsOrRets::Rets && call_conv.extends_wasmtime() { size } else { @@ -181,13 +181,13 @@ impl ABIMachineSpec for Riscv64MachineDeps { } else { None }; - next_stack = align_to(next_stack, Self::stack_align(call_conv) as u64); + next_stack = align_to(next_stack, Self::stack_align(call_conv)); // To avoid overflow issues, limit the arg/return size to something // reasonable -- here, 128 MB. if next_stack > STACK_ARG_RET_SIZE_LIMIT { return Err(CodegenError::ImplLimitExceeded); } - CodegenResult::Ok((next_stack as i64, pos)) + CodegenResult::Ok((next_stack, pos)) } fn fp_to_arg_offset(_call_conv: isa::CallConv, _flags: &settings::Flags) -> i64 { diff --git a/cranelift/codegen/src/isa/s390x/abi.rs b/cranelift/codegen/src/isa/s390x/abi.rs index 27c3a94ed6..c66d3ac2a0 100644 --- a/cranelift/codegen/src/isa/s390x/abi.rs +++ b/cranelift/codegen/src/isa/s390x/abi.rs @@ -184,7 +184,7 @@ fn get_vecreg_for_ret(idx: usize) -> Option { /// This is the limit for the size of argument and return-value areas on the /// stack. We place a reasonable limit here to avoid integer overflow issues /// with 32-bit arithmetic: for now, 128 MB. -static STACK_ARG_RET_SIZE_LIMIT: u64 = 128 * 1024 * 1024; +static STACK_ARG_RET_SIZE_LIMIT: u32 = 128 * 1024 * 1024; /// The size of the register save area pub static REG_SAVE_AREA_SIZE: u32 = 160; @@ -228,17 +228,17 @@ impl ABIMachineSpec for S390xMachineDeps { args_or_rets: ArgsOrRets, add_ret_area_ptr: bool, mut args: ArgsAccumulator<'_>, - ) -> CodegenResult<(i64, Option)> + ) -> CodegenResult<(u32, Option)> where I: IntoIterator, { let mut next_gpr = 0; let mut next_fpr = 0; let mut next_vr = 0; - let mut next_stack: u64 = 0; + let mut next_stack: u32 = 0; if args_or_rets == ArgsOrRets::Args { - next_stack = REG_SAVE_AREA_SIZE as u64; + next_stack = REG_SAVE_AREA_SIZE; } // In the SystemV ABI, the return area pointer is the first argument, @@ -307,7 +307,7 @@ impl ABIMachineSpec for S390xMachineDeps { } else { // Compute size. Every argument or return value takes a slot of // at least 8 bytes, except for return values in the Wasmtime ABI. - let size = (ty_bits(param.value_type) / 8) as u64; + let size = (ty_bits(param.value_type) / 8) as u32; let slot_size = if call_conv.extends_wasmtime() && args_or_rets == ArgsOrRets::Rets { size @@ -401,11 +401,11 @@ impl ABIMachineSpec for S390xMachineDeps { match arg { ABIArg::StructArg { offset, size, .. } => { *offset = next_stack as i64; - next_stack += *size; + next_stack += *size as u32; } ABIArg::ImplicitPtrArg { offset, ty, .. } => { *offset = next_stack as i64; - next_stack += (ty_bits(*ty) / 8) as u64; + next_stack += (ty_bits(*ty) / 8) as u32; } _ => {} } @@ -417,7 +417,7 @@ impl ABIMachineSpec for S390xMachineDeps { return Err(CodegenError::ImplLimitExceeded); } - Ok((next_stack as i64, extra_arg)) + Ok((next_stack, extra_arg)) } fn fp_to_arg_offset(_call_conv: isa::CallConv, _flags: &settings::Flags) -> i64 { diff --git a/cranelift/codegen/src/isa/x64/abi.rs b/cranelift/codegen/src/isa/x64/abi.rs index bab5bc8ac1..7a88850c90 100644 --- a/cranelift/codegen/src/isa/x64/abi.rs +++ b/cranelift/codegen/src/isa/x64/abi.rs @@ -18,7 +18,7 @@ use std::convert::TryFrom; /// This is the limit for the size of argument and return-value areas on the /// stack. We place a reasonable limit here to avoid integer overflow issues /// with 32-bit arithmetic: for now, 128 MB. -static STACK_ARG_RET_SIZE_LIMIT: u64 = 128 * 1024 * 1024; +static STACK_ARG_RET_SIZE_LIMIT: u32 = 128 * 1024 * 1024; /// Support for the x64 ABI from the callee side (within a function body). pub(crate) type X64Callee = Callee; @@ -87,7 +87,7 @@ impl ABIMachineSpec for X64ABIMachineSpec { args_or_rets: ArgsOrRets, add_ret_area_ptr: bool, mut args: ArgsAccumulator<'_>, - ) -> CodegenResult<(i64, Option)> + ) -> CodegenResult<(u32, Option)> where I: IntoIterator, { @@ -95,7 +95,7 @@ impl ABIMachineSpec for X64ABIMachineSpec { let mut next_gpr = 0; let mut next_vreg = 0; - let mut next_stack: u64 = 0; + let mut next_stack: u32 = 0; let mut next_param_idx = 0; // Fastcall cares about overall param index if args_or_rets == ArgsOrRets::Args && is_fastcall { @@ -110,13 +110,13 @@ impl ABIMachineSpec for X64ABIMachineSpec { for param in params { if let ir::ArgumentPurpose::StructArgument(size) = param.purpose { let offset = next_stack as i64; - let size = size as u64; + let size = size; assert!(size % 8 == 0, "StructArgument size is not properly aligned"); next_stack += size; args.push(ABIArg::StructArg { pointer: None, offset, - size, + size: size as u64, purpose: param.purpose, }); continue; @@ -197,7 +197,7 @@ impl ABIMachineSpec for X64ABIMachineSpec { // // Note that in all cases 16-byte stack alignment happens // separately after all args. - let size = (reg_ty.bits() / 8) as u64; + let size = reg_ty.bits() / 8; let size = if args_or_rets == ArgsOrRets::Rets && call_conv.extends_wasmtime() { size } else { @@ -251,7 +251,7 @@ impl ABIMachineSpec for X64ABIMachineSpec { return Err(CodegenError::ImplLimitExceeded); } - Ok((next_stack as i64, extra_arg)) + Ok((next_stack, extra_arg)) } fn fp_to_arg_offset(_call_conv: isa::CallConv, _flags: &settings::Flags) -> i64 { diff --git a/cranelift/codegen/src/machinst/abi.rs b/cranelift/codegen/src/machinst/abi.rs index 1d94d4ab9a..487d42d784 100644 --- a/cranelift/codegen/src/machinst/abi.rs +++ b/cranelift/codegen/src/machinst/abi.rs @@ -400,7 +400,7 @@ pub trait ABIMachineSpec { args_or_rets: ArgsOrRets, add_ret_area_ptr: bool, args: ArgsAccumulator<'_>, - ) -> CodegenResult<(i64, Option)> + ) -> CodegenResult<(u32, Option)> where I: IntoIterator; @@ -643,11 +643,13 @@ pub struct SigData { /// This is a index into the `SigSet::abi_args`. rets_end: u32, - /// Space on stack used to store arguments. - sized_stack_arg_space: i64, + /// Space on stack used to store arguments. We're storing the size in u32 to + /// reduce the size of the struct. + sized_stack_arg_space: u32, - /// Space on stack used to store return values. - sized_stack_ret_space: i64, + /// Space on stack used to store return values. We're storing the size in u32 to + /// reduce the size of the struct. + sized_stack_ret_space: u32, /// Index in `args` of the stack-return-value-area argument. stack_ret_arg: Option, @@ -659,12 +661,12 @@ pub struct SigData { impl SigData { /// Get total stack space required for arguments. pub fn sized_stack_arg_space(&self) -> i64 { - self.sized_stack_arg_space + self.sized_stack_arg_space.into() } /// Get total stack space required for return values. pub fn sized_stack_ret_space(&self) -> i64 { - self.sized_stack_ret_space + self.sized_stack_ret_space.into() } /// Get calling convention used. @@ -1920,7 +1922,7 @@ impl Callee { /// Returns the size of arguments expected on the stack. pub fn stack_args_size(&self, sigs: &SigSet) -> u32 { - sigs[self.sig].sized_stack_arg_space as u32 + sigs[self.sig].sized_stack_arg_space } /// Get the spill-slot size. @@ -2324,7 +2326,7 @@ impl Caller { }); } &ABIArgSlot::Stack { offset, ty, .. } => { - let ret_area_base = ctx.sigs()[self.sig].sized_stack_arg_space; + let ret_area_base = ctx.sigs()[self.sig].sized_stack_arg_space(); insts.push(M::gen_load_stack( StackAMode::SPOffset(offset + ret_area_base, ty), *into_reg, @@ -2361,7 +2363,7 @@ impl Caller { let word_type = M::word_type(); if let Some(i) = ctx.sigs()[self.sig].stack_ret_arg { let rd = ctx.alloc_tmp(word_type).only_reg().unwrap(); - let ret_area_base = ctx.sigs()[self.sig].sized_stack_arg_space; + let ret_area_base = ctx.sigs()[self.sig].sized_stack_arg_space(); ctx.emit(M::gen_get_stack_addr( StackAMode::SPOffset(ret_area_base, I8), rd, @@ -2403,6 +2405,6 @@ mod tests { fn sig_data_size() { // The size of `SigData` is performance sensitive, so make sure // we don't regress it unintentionally. - assert_eq!(std::mem::size_of::(), 32); + assert_eq!(std::mem::size_of::(), 24); } }