Skip to content

Commit e4bf113

Browse files
nnethercotennethercote
committed
Box CastTarget within PassMode.
Because `PassMode::Cast` is by far the largest variant, but is relatively rare. This requires making `PassMode` not impl `Copy`, and `Clone` is no longer necessary. This causes lots of sigil adjusting, but nothing very notable.
1 parent 263c426 commit e4bf113

File tree

11 files changed

+57
-57
lines changed

11 files changed

+57
-57
lines changed

‎compiler/rustc_codegen_cranelift/src/abi/comments.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ pub(super) fn add_arg_comment<'tcx>(
2424
local: Option<mir::Local>,
2525
local_field: Option<usize>,
2626
params: &[Value],
27-
arg_abi_mode: PassMode,
27+
arg_abi_mode: &PassMode,
2828
arg_layout: TyAndLayout<'tcx>,
2929
) {
3030
if !fx.clif_comments.enabled() {

‎compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ fn apply_arg_attrs_to_abi_param(mut param: AbiParam, arg_attrs: ArgAttributes) -
3838
param
3939
}
4040

41-
fn cast_target_to_abi_params(cast: CastTarget) -> SmallVec<[AbiParam; 2]> {
41+
fn cast_target_to_abi_params(cast: &CastTarget) -> SmallVec<[AbiParam; 2]> {
4242
let (rest_count, rem_bytes) = if cast.rest.unit.size.bytes() == 0 {
4343
(0, 0)
4444
} else {
@@ -100,7 +100,7 @@ impl<'tcx> ArgAbiExt<'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
100100
}
101101
_ => unreachable!("{:?}", self.layout.abi),
102102
},
103-
PassMode::Cast(cast) => cast_target_to_abi_params(cast),
103+
PassMode::Cast(ref cast) => cast_target_to_abi_params(cast),
104104
PassMode::Indirect { attrs, extra_attrs: None, on_stack } => {
105105
if on_stack {
106106
// Abi requires aligning struct size to pointer size
@@ -145,7 +145,9 @@ impl<'tcx> ArgAbiExt<'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
145145
}
146146
_ => unreachable!("{:?}", self.layout.abi),
147147
},
148-
PassMode::Cast(cast) => (None, cast_target_to_abi_params(cast).into_iter().collect()),
148+
PassMode::Cast(ref cast) => {
149+
(None, cast_target_to_abi_params(cast).into_iter().collect())
150+
}
149151
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack } => {
150152
assert!(!on_stack);
151153
(Some(AbiParam::special(pointer_ty(tcx), ArgumentPurpose::StructReturn)), vec![])
@@ -160,7 +162,7 @@ impl<'tcx> ArgAbiExt<'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
160162
pub(super) fn to_casted_value<'tcx>(
161163
fx: &mut FunctionCx<'_, '_, 'tcx>,
162164
arg: CValue<'tcx>,
163-
cast: CastTarget,
165+
cast: &CastTarget,
164166
) -> SmallVec<[Value; 2]> {
165167
let (ptr, meta) = arg.force_stack(fx);
166168
assert!(meta.is_none());
@@ -179,7 +181,7 @@ pub(super) fn from_casted_value<'tcx>(
179181
fx: &mut FunctionCx<'_, '_, 'tcx>,
180182
block_params: &[Value],
181183
layout: TyAndLayout<'tcx>,
182-
cast: CastTarget,
184+
cast: &CastTarget,
183185
) -> CValue<'tcx> {
184186
let abi_params = cast_target_to_abi_params(cast);
185187
let abi_param_size: u32 = abi_params.iter().map(|param| param.value_type.bytes()).sum();
@@ -224,7 +226,7 @@ pub(super) fn adjust_arg_for_abi<'tcx>(
224226
let (a, b) = arg.load_scalar_pair(fx);
225227
smallvec![a, b]
226228
}
227-
PassMode::Cast(cast) => to_casted_value(fx, arg, cast),
229+
PassMode::Cast(ref cast) => to_casted_value(fx, arg, cast),
228230
PassMode::Indirect { .. } => {
229231
if is_owned {
230232
match arg.force_stack(fx) {
@@ -268,7 +270,7 @@ pub(super) fn cvalue_for_param<'tcx>(
268270
local,
269271
local_field,
270272
&block_params,
271-
arg_abi.mode,
273+
&arg_abi.mode,
272274
arg_abi.layout,
273275
);
274276

@@ -282,7 +284,9 @@ pub(super) fn cvalue_for_param<'tcx>(
282284
assert_eq!(block_params.len(), 2, "{:?}", block_params);
283285
Some(CValue::by_val_pair(block_params[0], block_params[1], arg_abi.layout))
284286
}
285-
PassMode::Cast(cast) => Some(from_casted_value(fx, &block_params, arg_abi.layout, cast)),
287+
PassMode::Cast(ref cast) => {
288+
Some(from_casted_value(fx, &block_params, arg_abi.layout, cast))
289+
}
286290
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => {
287291
assert_eq!(block_params.len(), 1, "{:?}", block_params);
288292
Some(CValue::by_ref(Pointer::new(block_params[0]), arg_abi.layout))

‎compiler/rustc_codegen_cranelift/src/abi/returning.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ pub(super) fn codegen_return_param<'tcx>(
4444
Some(RETURN_PLACE),
4545
None,
4646
&ret_param,
47-
fx.fn_abi.as_ref().unwrap().ret.mode,
47+
&fx.fn_abi.as_ref().unwrap().ret.mode,
4848
fx.fn_abi.as_ref().unwrap().ret.layout,
4949
);
5050

@@ -92,7 +92,7 @@ pub(super) fn codegen_with_call_return_arg<'tcx>(
9292
ret_place
9393
.write_cvalue(fx, CValue::by_val_pair(ret_val_a, ret_val_b, ret_arg_abi.layout));
9494
}
95-
PassMode::Cast(cast) => {
95+
PassMode::Cast(ref cast) => {
9696
let results =
9797
fx.bcx.inst_results(call_inst).iter().copied().collect::<SmallVec<[Value; 2]>>();
9898
let result =
@@ -131,7 +131,7 @@ pub(crate) fn codegen_return(fx: &mut FunctionCx<'_, '_, '_>) {
131131
let (ret_val_a, ret_val_b) = place.to_cvalue(fx).load_scalar_pair(fx);
132132
fx.bcx.ins().return_(&[ret_val_a, ret_val_b]);
133133
}
134-
PassMode::Cast(cast) => {
134+
PassMode::Cast(ref cast) => {
135135
let place = fx.get_local_place(RETURN_PLACE);
136136
let ret_val = place.to_cvalue(fx);
137137
let ret_vals = super::pass_mode::to_casted_value(fx, ret_val, cast);

‎compiler/rustc_codegen_gcc/src/abi.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -133,7 +133,7 @@ impl<'gcc, 'tcx> FnAbiGccExt<'gcc, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
133133
match self.ret.mode {
134134
PassMode::Ignore => cx.type_void(),
135135
PassMode::Direct(_) | PassMode::Pair(..) => self.ret.layout.immediate_gcc_type(cx),
136-
PassMode::Cast(cast) => cast.gcc_type(cx),
136+
PassMode::Cast(ref cast) => cast.gcc_type(cx),
137137
PassMode::Indirect { .. } => {
138138
argument_tys.push(cx.type_ptr_to(self.ret.memory_ty(cx)));
139139
cx.type_void()
@@ -157,7 +157,7 @@ impl<'gcc, 'tcx> FnAbiGccExt<'gcc, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
157157
PassMode::Indirect { extra_attrs: Some(_), .. } => {
158158
unimplemented!();
159159
}
160-
PassMode::Cast(cast) => cast.gcc_type(cx),
160+
PassMode::Cast(ref cast) => cast.gcc_type(cx),
161161
PassMode::Indirect { extra_attrs: None, on_stack: true, .. } => {
162162
on_stack_param_indices.insert(argument_tys.len());
163163
arg.memory_ty(cx)

‎compiler/rustc_codegen_gcc/src/intrinsic/mod.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -130,7 +130,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
130130
sym::volatile_load | sym::unaligned_volatile_load => {
131131
let tp_ty = substs.type_at(0);
132132
let mut ptr = args[0].immediate();
133-
if let PassMode::Cast(ty) = fn_abi.ret.mode {
133+
if let PassMode::Cast(ty) = &fn_abi.ret.mode {
134134
ptr = self.pointercast(ptr, self.type_ptr_to(ty.gcc_type(self)));
135135
}
136136
let load = self.volatile_load(ptr.get_type(), ptr);
@@ -320,7 +320,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
320320
};
321321

322322
if !fn_abi.ret.is_ignore() {
323-
if let PassMode::Cast(ty) = fn_abi.ret.mode {
323+
if let PassMode::Cast(ty) = &fn_abi.ret.mode {
324324
let ptr_llty = self.type_ptr_to(ty.gcc_type(self));
325325
let ptr = self.pointercast(result.llval, ptr_llty);
326326
self.store(llval, ptr, result.align);
@@ -416,7 +416,7 @@ impl<'gcc, 'tcx> ArgAbiExt<'gcc, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
416416
else if self.is_unsized_indirect() {
417417
bug!("unsized `ArgAbi` must be handled through `store_fn_arg`");
418418
}
419-
else if let PassMode::Cast(cast) = self.mode {
419+
else if let PassMode::Cast(ref cast) = self.mode {
420420
// FIXME(eddyb): Figure out when the simpler Store is safe, clang
421421
// uses it for i16 -> {i8, i8}, but not for i24 -> {i8, i8, i8}.
422422
let can_store_through_cast_ptr = false;

‎compiler/rustc_codegen_llvm/src/abi.rs

Lines changed: 21 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -213,7 +213,7 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
213213
OperandValue::Ref(val, None, self.layout.align.abi).store(bx, dst)
214214
} else if self.is_unsized_indirect() {
215215
bug!("unsized `ArgAbi` must be handled through `store_fn_arg`");
216-
} else if let PassMode::Cast(cast) = self.mode {
216+
} else if let PassMode::Cast(cast) = &self.mode {
217217
// FIXME(eddyb): Figure out when the simpler Store is safe, clang
218218
// uses it for i16 -> {i8, i8}, but not for i24 -> {i8, i8, i8}.
219219
let can_store_through_cast_ptr = false;
@@ -335,7 +335,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
335335
if let PassMode::Indirect { .. } = self.ret.mode { 1 } else { 0 } + args_capacity,
336336
);
337337

338-
let llreturn_ty = match self.ret.mode {
338+
let llreturn_ty = match &self.ret.mode {
339339
PassMode::Ignore => cx.type_void(),
340340
PassMode::Direct(_) | PassMode::Pair(..) => self.ret.layout.immediate_llvm_type(cx),
341341
PassMode::Cast(cast) => cast.llvm_type(cx),
@@ -351,7 +351,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
351351
llargument_tys.push(ty.llvm_type(cx));
352352
}
353353

354-
let llarg_ty = match arg.mode {
354+
let llarg_ty = match &arg.mode {
355355
PassMode::Ignore => continue,
356356
PassMode::Direct(_) => arg.layout.immediate_llvm_type(cx),
357357
PassMode::Pair(..) => {
@@ -426,11 +426,11 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
426426
i += 1;
427427
i - 1
428428
};
429-
match self.ret.mode {
430-
PassMode::Direct(ref attrs) => {
429+
match &self.ret.mode {
430+
PassMode::Direct(attrs) => {
431431
attrs.apply_attrs_to_llfn(llvm::AttributePlace::ReturnValue, cx, llfn);
432432
}
433-
PassMode::Indirect { ref attrs, extra_attrs: _, on_stack } => {
433+
PassMode::Indirect { attrs, extra_attrs: _, on_stack } => {
434434
assert!(!on_stack);
435435
let i = apply(attrs);
436436
let sret = llvm::CreateStructRetAttr(cx.llcx, self.ret.layout.llvm_type(cx));
@@ -445,23 +445,23 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
445445
if arg.pad.is_some() {
446446
apply(&ArgAttributes::new());
447447
}
448-
match arg.mode {
448+
match &arg.mode {
449449
PassMode::Ignore => {}
450-
PassMode::Indirect { ref attrs, extra_attrs: None, on_stack: true } => {
450+
PassMode::Indirect { attrs, extra_attrs: None, on_stack: true } => {
451451
let i = apply(attrs);
452452
let byval = llvm::CreateByValAttr(cx.llcx, arg.layout.llvm_type(cx));
453453
attributes::apply_to_llfn(llfn, llvm::AttributePlace::Argument(i), &[byval]);
454454
}
455-
PassMode::Direct(ref attrs)
456-
| PassMode::Indirect { ref attrs, extra_attrs: None, on_stack: false } => {
455+
PassMode::Direct(attrs)
456+
| PassMode::Indirect { attrs, extra_attrs: None, on_stack: false } => {
457457
apply(attrs);
458458
}
459-
PassMode::Indirect { ref attrs, extra_attrs: Some(ref extra_attrs), on_stack } => {
459+
PassMode::Indirect { attrs, extra_attrs: Some(extra_attrs), on_stack } => {
460460
assert!(!on_stack);
461461
apply(attrs);
462462
apply(extra_attrs);
463463
}
464-
PassMode::Pair(ref a, ref b) => {
464+
PassMode::Pair(a, b) => {
465465
apply(a);
466466
apply(b);
467467
}
@@ -488,11 +488,11 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
488488
i += 1;
489489
i - 1
490490
};
491-
match self.ret.mode {
492-
PassMode::Direct(ref attrs) => {
491+
match &self.ret.mode {
492+
PassMode::Direct(attrs) => {
493493
attrs.apply_attrs_to_callsite(llvm::AttributePlace::ReturnValue, bx.cx, callsite);
494494
}
495-
PassMode::Indirect { ref attrs, extra_attrs: _, on_stack } => {
495+
PassMode::Indirect { attrs, extra_attrs: _, on_stack } => {
496496
assert!(!on_stack);
497497
let i = apply(bx.cx, attrs);
498498
let sret = llvm::CreateStructRetAttr(bx.cx.llcx, self.ret.layout.llvm_type(bx));
@@ -521,9 +521,9 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
521521
if arg.pad.is_some() {
522522
apply(bx.cx, &ArgAttributes::new());
523523
}
524-
match arg.mode {
524+
match &arg.mode {
525525
PassMode::Ignore => {}
526-
PassMode::Indirect { ref attrs, extra_attrs: None, on_stack: true } => {
526+
PassMode::Indirect { attrs, extra_attrs: None, on_stack: true } => {
527527
let i = apply(bx.cx, attrs);
528528
let byval = llvm::CreateByValAttr(bx.cx.llcx, arg.layout.llvm_type(bx));
529529
attributes::apply_to_callsite(
@@ -532,19 +532,15 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
532532
&[byval],
533533
);
534534
}
535-
PassMode::Direct(ref attrs)
536-
| PassMode::Indirect { ref attrs, extra_attrs: None, on_stack: false } => {
535+
PassMode::Direct(attrs)
536+
| PassMode::Indirect { attrs, extra_attrs: None, on_stack: false } => {
537537
apply(bx.cx, attrs);
538538
}
539-
PassMode::Indirect {
540-
ref attrs,
541-
extra_attrs: Some(ref extra_attrs),
542-
on_stack: _,
543-
} => {
539+
PassMode::Indirect { attrs, extra_attrs: Some(extra_attrs), on_stack: _ } => {
544540
apply(bx.cx, attrs);
545541
apply(bx.cx, extra_attrs);
546542
}
547-
PassMode::Pair(ref a, ref b) => {
543+
PassMode::Pair(a, b) => {
548544
apply(bx.cx, a);
549545
apply(bx.cx, b);
550546
}

‎compiler/rustc_codegen_llvm/src/intrinsic.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -161,7 +161,7 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
161161
sym::volatile_load | sym::unaligned_volatile_load => {
162162
let tp_ty = substs.type_at(0);
163163
let ptr = args[0].immediate();
164-
let load = if let PassMode::Cast(ty) = fn_abi.ret.mode {
164+
let load = if let PassMode::Cast(ty) = &fn_abi.ret.mode {
165165
let llty = ty.llvm_type(self);
166166
let ptr = self.pointercast(ptr, self.type_ptr_to(llty));
167167
self.volatile_load(llty, ptr)
@@ -374,7 +374,7 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
374374
};
375375

376376
if !fn_abi.ret.is_ignore() {
377-
if let PassMode::Cast(ty) = fn_abi.ret.mode {
377+
if let PassMode::Cast(ty) = &fn_abi.ret.mode {
378378
let ptr_llty = self.type_ptr_to(ty.llvm_type(self));
379379
let ptr = self.pointercast(result.llval, ptr_llty);
380380
self.store(llval, ptr, result.align);

‎compiler/rustc_codegen_ssa/src/mir/block.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -324,7 +324,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
324324
bx.unreachable();
325325
return;
326326
}
327-
let llval = match self.fn_abi.ret.mode {
327+
let llval = match &self.fn_abi.ret.mode {
328328
PassMode::Ignore | PassMode::Indirect { .. } => {
329329
bx.ret_void();
330330
return;
@@ -360,7 +360,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
360360
llval
361361
}
362362
};
363-
let ty = bx.cast_backend_type(&cast_ty);
363+
let ty = bx.cast_backend_type(cast_ty);
364364
let addr = bx.pointercast(llslot, bx.type_ptr_to(ty));
365365
bx.load(ty, addr, self.fn_abi.ret.layout.align.abi)
366366
}
@@ -1222,8 +1222,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
12221222

12231223
if by_ref && !arg.is_indirect() {
12241224
// Have to load the argument, maybe while casting it.
1225-
if let PassMode::Cast(ty) = arg.mode {
1226-
let llty = bx.cast_backend_type(&ty);
1225+
if let PassMode::Cast(ty) = &arg.mode {
1226+
let llty = bx.cast_backend_type(ty);
12271227
let addr = bx.pointercast(llval, bx.type_ptr_to(llty));
12281228
llval = bx.load(llty, addr, align.min(arg.layout.align.abi));
12291229
} else {

‎compiler/rustc_codegen_ssa/src/mir/intrinsic.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -597,8 +597,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
597597
};
598598

599599
if !fn_abi.ret.is_ignore() {
600-
if let PassMode::Cast(ty) = fn_abi.ret.mode {
601-
let ptr_llty = bx.type_ptr_to(bx.cast_backend_type(&ty));
600+
if let PassMode::Cast(ty) = &fn_abi.ret.mode {
601+
let ptr_llty = bx.type_ptr_to(bx.cast_backend_type(ty));
602602
let ptr = bx.pointercast(result.llval, ptr_llty);
603603
bx.store(llval, ptr, result.align);
604604
} else {

‎compiler/rustc_const_eval/src/interpret/terminator.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -218,7 +218,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
218218
// Padding must be fully equal.
219219
let pad_compat = || caller_abi.pad == callee_abi.pad;
220220
// When comparing the PassMode, we have to be smart about comparing the attributes.
221-
let arg_attr_compat = |a1: ArgAttributes, a2: ArgAttributes| {
221+
let arg_attr_compat = |a1: &ArgAttributes, a2: &ArgAttributes| {
222222
// There's only one regular attribute that matters for the call ABI: InReg.
223223
// Everything else is things like noalias, dereferencable, nonnull, ...
224224
// (This also applies to pointee_size, pointee_align.)
@@ -233,7 +233,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
233233
}
234234
return true;
235235
};
236-
let mode_compat = || match (caller_abi.mode, callee_abi.mode) {
236+
let mode_compat = || match (&caller_abi.mode, &callee_abi.mode) {
237237
(PassMode::Ignore, PassMode::Ignore) => true,
238238
(PassMode::Direct(a1), PassMode::Direct(a2)) => arg_attr_compat(a1, a2),
239239
(PassMode::Pair(a1, b1), PassMode::Pair(a2, b2)) => {

‎compiler/rustc_target/src/abi/call/mod.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ mod x86;
2626
mod x86_64;
2727
mod x86_win64;
2828

29-
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
29+
#[derive(PartialEq, Eq, Hash, Debug, HashStable_Generic)]
3030
pub enum PassMode {
3131
/// Ignore the argument.
3232
///
@@ -42,7 +42,7 @@ pub enum PassMode {
4242
Pair(ArgAttributes, ArgAttributes),
4343
/// Pass the argument after casting it, to either
4444
/// a single uniform or a pair of registers.
45-
Cast(CastTarget),
45+
Cast(Box<CastTarget>),
4646
/// Pass the argument indirectly via a hidden pointer.
4747
/// The `extra_attrs` value, if any, is for the extra data (vtable or length)
4848
/// which indicates that it refers to an unsized rvalue.
@@ -548,7 +548,7 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
548548
}
549549

550550
pub fn cast_to<T: Into<CastTarget>>(&mut self, target: T) {
551-
self.mode = PassMode::Cast(target.into());
551+
self.mode = PassMode::Cast(Box::new(target.into()));
552552
}
553553

554554
pub fn pad_with(&mut self, reg: Reg) {
@@ -737,6 +737,6 @@ mod size_asserts {
737737
use super::*;
738738
use rustc_data_structures::static_assert_size;
739739
// These are in alphabetical order, which is easy to maintain.
740-
static_assert_size!(ArgAbi<'_, usize>, 208);
741-
static_assert_size!(FnAbi<'_, usize>, 248);
740+
static_assert_size!(ArgAbi<'_, usize>, 72);
741+
static_assert_size!(FnAbi<'_, usize>, 112);
742742
}

0 commit comments

Comments
 (0)