bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

clarify PassMode::Indirect as well

Browse source
This commit is contained in:
Ralf Jung 2023-09-08 08:48:41 +02:00
parent 7740476a43
commit 89139d4c46
9 changed files with 62 additions and 56 deletions
Download patch file Download diff file Expand all files Collapse all files

14
compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs
View file

@ -104,7 +104,7 @@ impl<'tcx> ArgAbiExt<'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
assert!(!pad_i32, "padding support not yet implemented"); assert!(!pad_i32, "padding support not yet implemented");
cast_target_to_abi_params(cast) cast_target_to_abi_params(cast)
} }
PassMode::Indirect { attrs, extra_attrs: None, on_stack } => { PassMode::Indirect { attrs, meta_attrs: None, on_stack } => {
if on_stack { if on_stack {
// Abi requires aligning struct size to pointer size // Abi requires aligning struct size to pointer size
let size = self.layout.size.align_to(tcx.data_layout.pointer_align.abi); let size = self.layout.size.align_to(tcx.data_layout.pointer_align.abi);
@ -117,11 +117,11 @@ impl<'tcx> ArgAbiExt<'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
smallvec![apply_arg_attrs_to_abi_param(AbiParam::new(pointer_ty(tcx)), attrs)] smallvec![apply_arg_attrs_to_abi_param(AbiParam::new(pointer_ty(tcx)), attrs)]
} }
} }
PassMode::Indirect { attrs, extra_attrs: Some(extra_attrs), on_stack } => { PassMode::Indirect { attrs, meta_attrs: Some(meta_attrs), on_stack } => {
assert!(!on_stack); assert!(!on_stack);
smallvec![ smallvec![
apply_arg_attrs_to_abi_param(AbiParam::new(pointer_ty(tcx)), attrs), apply_arg_attrs_to_abi_param(AbiParam::new(pointer_ty(tcx)), attrs),
apply_arg_attrs_to_abi_param(AbiParam::new(pointer_ty(tcx)), extra_attrs), apply_arg_attrs_to_abi_param(AbiParam::new(pointer_ty(tcx)), meta_attrs),
] ]
} }
} }
@ -151,11 +151,11 @@ impl<'tcx> ArgAbiExt<'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
PassMode::Cast(ref cast, _) => { PassMode::Cast(ref cast, _) => {
(None, cast_target_to_abi_params(cast).into_iter().collect()) (None, cast_target_to_abi_params(cast).into_iter().collect())
} }
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack } => { PassMode::Indirect { attrs: _, meta_attrs: None, on_stack } => {
assert!(!on_stack); assert!(!on_stack);
(Some(AbiParam::special(pointer_ty(tcx), ArgumentPurpose::StructReturn)), vec![]) (Some(AbiParam::special(pointer_ty(tcx), ArgumentPurpose::StructReturn)), vec![])
} }
PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
unreachable!("unsized return value") unreachable!("unsized return value")
} }
} }
@ -290,11 +290,11 @@ pub(super) fn cvalue_for_param<'tcx>(
PassMode::Cast(ref cast, _) => { PassMode::Cast(ref cast, _) => {
Some(from_casted_value(fx, &block_params, arg_abi.layout, cast)) Some(from_casted_value(fx, &block_params, arg_abi.layout, cast))
} }
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ } => {
assert_eq!(block_params.len(), 1, "{:?}", block_params); assert_eq!(block_params.len(), 1, "{:?}", block_params);
Some(CValue::by_ref(Pointer::new(block_params[0]), arg_abi.layout)) Some(CValue::by_ref(Pointer::new(block_params[0]), arg_abi.layout))
} }
PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
assert_eq!(block_params.len(), 2, "{:?}", block_params); assert_eq!(block_params.len(), 2, "{:?}", block_params);
Some(CValue::by_ref_unsized( Some(CValue::by_ref_unsized(
Pointer::new(block_params[0]), Pointer::new(block_params[0]),

16
compiler/rustc_codegen_cranelift/src/abi/returning.rs
View file

@ -26,7 +26,7 @@ pub(super) fn codegen_return_param<'tcx>(
smallvec![], smallvec![],
) )
} }
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ } => {
let ret_param = block_params_iter.next().unwrap(); let ret_param = block_params_iter.next().unwrap();
assert_eq!(fx.bcx.func.dfg.value_type(ret_param), fx.pointer_type); assert_eq!(fx.bcx.func.dfg.value_type(ret_param), fx.pointer_type);
( (
@ -34,7 +34,7 @@ pub(super) fn codegen_return_param<'tcx>(
smallvec![ret_param], smallvec![ret_param],
) )
} }
PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
unreachable!("unsized return value") unreachable!("unsized return value")
} }
}; };
@ -62,7 +62,7 @@ pub(super) fn codegen_with_call_return_arg<'tcx>(
) { ) {
let (ret_temp_place, return_ptr) = match ret_arg_abi.mode { let (ret_temp_place, return_ptr) = match ret_arg_abi.mode {
PassMode::Ignore => (None, None), PassMode::Ignore => (None, None),
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ } => {
if let Some(ret_ptr) = ret_place.try_to_ptr() { if let Some(ret_ptr) = ret_place.try_to_ptr() {
// This is an optimization to prevent unnecessary copies of the return value when // This is an optimization to prevent unnecessary copies of the return value when
// the return place is already a memory place as opposed to a register. // the return place is already a memory place as opposed to a register.
@ -73,7 +73,7 @@ pub(super) fn codegen_with_call_return_arg<'tcx>(
(Some(place), Some(place.to_ptr().get_addr(fx))) (Some(place), Some(place.to_ptr().get_addr(fx)))
} }
} }
PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
unreachable!("unsized return value") unreachable!("unsized return value")
} }
PassMode::Direct(_) | PassMode::Pair(_, _) | PassMode::Cast(..) => (None, None), PassMode::Direct(_) | PassMode::Pair(_, _) | PassMode::Cast(..) => (None, None),
@ -100,14 +100,14 @@ pub(super) fn codegen_with_call_return_arg<'tcx>(
super::pass_mode::from_casted_value(fx, &results, ret_place.layout(), cast); super::pass_mode::from_casted_value(fx, &results, ret_place.layout(), cast);
ret_place.write_cvalue(fx, result); ret_place.write_cvalue(fx, result);
} }
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ } => {
if let Some(ret_temp_place) = ret_temp_place { if let Some(ret_temp_place) = ret_temp_place {
// If ret_temp_place is None, it is not necessary to copy the return value. // If ret_temp_place is None, it is not necessary to copy the return value.
let ret_temp_value = ret_temp_place.to_cvalue(fx); let ret_temp_value = ret_temp_place.to_cvalue(fx);
ret_place.write_cvalue(fx, ret_temp_value); ret_place.write_cvalue(fx, ret_temp_value);
} }
} }
PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
unreachable!("unsized return value") unreachable!("unsized return value")
} }
} }
@ -116,10 +116,10 @@ pub(super) fn codegen_with_call_return_arg<'tcx>(
/// Codegen a return instruction with the right return value(s) if any. /// Codegen a return instruction with the right return value(s) if any.
pub(crate) fn codegen_return(fx: &mut FunctionCx<'_, '_, '_>) { pub(crate) fn codegen_return(fx: &mut FunctionCx<'_, '_, '_>) {
match fx.fn_abi.as_ref().unwrap().ret.mode { match fx.fn_abi.as_ref().unwrap().ret.mode {
PassMode::Ignore | PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => { PassMode::Ignore | PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ } => {
fx.bcx.ins().return_(&[]); fx.bcx.ins().return_(&[]);
} }
PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
unreachable!("unsized return value") unreachable!("unsized return value")
} }
PassMode::Direct(_) => { PassMode::Direct(_) => {

6
compiler/rustc_codegen_gcc/src/abi.rs
View file

@ -129,7 +129,7 @@ impl<'gcc, 'tcx> FnAbiGccExt<'gcc, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
argument_tys.push(arg.layout.scalar_pair_element_gcc_type(cx, 1)); argument_tys.push(arg.layout.scalar_pair_element_gcc_type(cx, 1));
continue; continue;
} }
PassMode::Indirect { extra_attrs: Some(_), .. } => { PassMode::Indirect { meta_attrs: Some(_), .. } => {
unimplemented!(); unimplemented!();
} }
PassMode::Cast(ref cast, pad_i32) => { PassMode::Cast(ref cast, pad_i32) => {
@ -139,11 +139,11 @@ impl<'gcc, 'tcx> FnAbiGccExt<'gcc, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
} }
cast.gcc_type(cx) cast.gcc_type(cx)
} }
PassMode::Indirect { extra_attrs: None, on_stack: true, .. } => { PassMode::Indirect { meta_attrs: None, on_stack: true, .. } => {
on_stack_param_indices.insert(argument_tys.len()); on_stack_param_indices.insert(argument_tys.len());
arg.memory_ty(cx) arg.memory_ty(cx)
}, },
PassMode::Indirect { extra_attrs: None, on_stack: false, .. } => cx.type_ptr_to(arg.memory_ty(cx)), PassMode::Indirect { meta_attrs: None, on_stack: false, .. } => cx.type_ptr_to(arg.memory_ty(cx)),
}; };
argument_tys.push(arg_ty); argument_tys.push(arg_ty);
} }

4
compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
View file

@ -511,10 +511,10 @@ impl<'gcc, 'tcx> ArgAbiExt<'gcc, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
PassMode::Pair(..) => { PassMode::Pair(..) => {
OperandValue::Pair(next(), next()).store(bx, dst); OperandValue::Pair(next(), next()).store(bx, dst);
}, },
PassMode::Indirect { extra_attrs: Some(_), .. } => { PassMode::Indirect { meta_attrs: Some(_), .. } => {
OperandValue::Ref(next(), Some(next()), self.layout.align.abi).store(bx, dst); OperandValue::Ref(next(), Some(next()), self.layout.align.abi).store(bx, dst);
}, },
PassMode::Direct(_) | PassMode::Indirect { extra_attrs: None, .. } | PassMode::Cast(..) => { PassMode::Direct(_) | PassMode::Indirect { meta_attrs: None, .. } | PassMode::Cast(..) => {
let next_arg = next(); let next_arg = next();
self.store(bx, next_arg, dst); self.store(bx, next_arg, dst);
}, },

35
compiler/rustc_codegen_llvm/src/abi.rs
View file

@ -274,11 +274,11 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
PassMode::Pair(..) => { PassMode::Pair(..) => {
OperandValue::Pair(next(), next()).store(bx, dst); OperandValue::Pair(next(), next()).store(bx, dst);
} }
PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
OperandValue::Ref(next(), Some(next()), self.layout.align.abi).store(bx, dst); OperandValue::Ref(next(), Some(next()), self.layout.align.abi).store(bx, dst);
} }
PassMode::Direct(_) PassMode::Direct(_)
| PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } | PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ }
| PassMode::Cast { .. } => { | PassMode::Cast { .. } => {
let next_arg = next(); let next_arg = next();
self.store(bx, next_arg, dst); self.store(bx, next_arg, dst);
@ -378,8 +378,10 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
llargument_tys.push(arg.layout.scalar_pair_element_llvm_type(cx, 1, true)); llargument_tys.push(arg.layout.scalar_pair_element_llvm_type(cx, 1, true));
continue; continue;
} }
PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } => { PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack } => {
assert!(arg.layout.is_unsized()); // `Indirect` with metadata is only for unsized types, and doesn't work with
// on-stack passing.
assert!(arg.layout.is_unsized() && !on_stack);
// Construct the type of a (wide) pointer to `ty`, and pass its two fields. // Construct the type of a (wide) pointer to `ty`, and pass its two fields.
// Any two ABI-compatible unsized types have the same metadata type and // Any two ABI-compatible unsized types have the same metadata type and
// moreover the same metadata value leads to the same dynamic size and // moreover the same metadata value leads to the same dynamic size and
@ -390,6 +392,10 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
llargument_tys.push(ptr_layout.scalar_pair_element_llvm_type(cx, 1, true)); llargument_tys.push(ptr_layout.scalar_pair_element_llvm_type(cx, 1, true));
continue; continue;
} }
PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ } => {
assert!(arg.layout.is_sized());
cx.type_ptr()
}
PassMode::Cast { cast, pad_i32 } => { PassMode::Cast { cast, pad_i32 } => {
// `Cast` means "transmute to `CastType`"; that only makes sense for sized types. // `Cast` means "transmute to `CastType`"; that only makes sense for sized types.
assert!(arg.layout.is_sized()); assert!(arg.layout.is_sized());
@ -401,7 +407,6 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
// We assume here that ABI-compatible Rust types have the same cast type. // We assume here that ABI-compatible Rust types have the same cast type.
cast.llvm_type(cx) cast.llvm_type(cx)
} }
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => cx.type_ptr(),
}; };
llargument_tys.push(llarg_ty); llargument_tys.push(llarg_ty);
} }
@ -444,7 +449,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
PassMode::Direct(attrs) => { PassMode::Direct(attrs) => {
attrs.apply_attrs_to_llfn(llvm::AttributePlace::ReturnValue, cx, llfn); attrs.apply_attrs_to_llfn(llvm::AttributePlace::ReturnValue, cx, llfn);
} }
PassMode::Indirect { attrs, extra_attrs: _, on_stack } => { PassMode::Indirect { attrs, meta_attrs: _, on_stack } => {
assert!(!on_stack); assert!(!on_stack);
let i = apply(attrs); let i = apply(attrs);
let sret = llvm::CreateStructRetAttr(cx.llcx, self.ret.layout.llvm_type(cx)); let sret = llvm::CreateStructRetAttr(cx.llcx, self.ret.layout.llvm_type(cx));
@ -458,19 +463,19 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
for arg in self.args.iter() { for arg in self.args.iter() {
match &arg.mode { match &arg.mode {
PassMode::Ignore => {} PassMode::Ignore => {}
PassMode::Indirect { attrs, extra_attrs: None, on_stack: true } => { PassMode::Indirect { attrs, meta_attrs: None, on_stack: true } => {
let i = apply(attrs); let i = apply(attrs);
let byval = llvm::CreateByValAttr(cx.llcx, arg.layout.llvm_type(cx)); let byval = llvm::CreateByValAttr(cx.llcx, arg.layout.llvm_type(cx));
attributes::apply_to_llfn(llfn, llvm::AttributePlace::Argument(i), &[byval]); attributes::apply_to_llfn(llfn, llvm::AttributePlace::Argument(i), &[byval]);
} }
PassMode::Direct(attrs) PassMode::Direct(attrs)
| PassMode::Indirect { attrs, extra_attrs: None, on_stack: false } => { | PassMode::Indirect { attrs, meta_attrs: None, on_stack: false } => {
apply(attrs); apply(attrs);
} }
PassMode::Indirect { attrs, extra_attrs: Some(extra_attrs), on_stack } => { PassMode::Indirect { attrs, meta_attrs: Some(meta_attrs), on_stack } => {
assert!(!on_stack); assert!(!on_stack);
apply(attrs); apply(attrs);
apply(extra_attrs); apply(meta_attrs);
} }
PassMode::Pair(a, b) => { PassMode::Pair(a, b) => {
apply(a); apply(a);
@ -506,7 +511,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
PassMode::Direct(attrs) => { PassMode::Direct(attrs) => {
attrs.apply_attrs_to_callsite(llvm::AttributePlace::ReturnValue, bx.cx, callsite); attrs.apply_attrs_to_callsite(llvm::AttributePlace::ReturnValue, bx.cx, callsite);
} }
PassMode::Indirect { attrs, extra_attrs: _, on_stack } => { PassMode::Indirect { attrs, meta_attrs: _, on_stack } => {
assert!(!on_stack); assert!(!on_stack);
let i = apply(bx.cx, attrs); let i = apply(bx.cx, attrs);
let sret = llvm::CreateStructRetAttr(bx.cx.llcx, self.ret.layout.llvm_type(bx)); let sret = llvm::CreateStructRetAttr(bx.cx.llcx, self.ret.layout.llvm_type(bx));
@ -534,7 +539,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
for arg in self.args.iter() { for arg in self.args.iter() {
match &arg.mode { match &arg.mode {
PassMode::Ignore => {} PassMode::Ignore => {}
PassMode::Indirect { attrs, extra_attrs: None, on_stack: true } => { PassMode::Indirect { attrs, meta_attrs: None, on_stack: true } => {
let i = apply(bx.cx, attrs); let i = apply(bx.cx, attrs);
let byval = llvm::CreateByValAttr(bx.cx.llcx, arg.layout.llvm_type(bx)); let byval = llvm::CreateByValAttr(bx.cx.llcx, arg.layout.llvm_type(bx));
attributes::apply_to_callsite( attributes::apply_to_callsite(
@ -544,12 +549,12 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
); );
} }
PassMode::Direct(attrs) PassMode::Direct(attrs)
| PassMode::Indirect { attrs, extra_attrs: None, on_stack: false } => { | PassMode::Indirect { attrs, meta_attrs: None, on_stack: false } => {
apply(bx.cx, attrs); apply(bx.cx, attrs);
} }
PassMode::Indirect { attrs, extra_attrs: Some(extra_attrs), on_stack: _ } => { PassMode::Indirect { attrs, meta_attrs: Some(meta_attrs), on_stack: _ } => {
apply(bx.cx, attrs); apply(bx.cx, attrs);
apply(bx.cx, extra_attrs); apply(bx.cx, meta_attrs);
} }
PassMode::Pair(a, b) => { PassMode::Pair(a, b) => {
apply(bx.cx, a); apply(bx.cx, a);

2
compiler/rustc_codegen_ssa/src/mir/block.rs
View file

@ -1322,7 +1322,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
} }
_ => bug!("codegen_argument: {:?} invalid for pair argument", op), _ => bug!("codegen_argument: {:?} invalid for pair argument", op),
}, },
PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } => match op.val { PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => match op.val {
Ref(a, Some(b), _) => { Ref(a, Some(b), _) => {
llargs.push(a); llargs.push(a);
llargs.push(b); llargs.push(b);

33
compiler/rustc_target/src/abi/call/mod.rs
View file

@ -49,12 +49,13 @@ pub enum PassMode {
/// indicates if a `Reg::i32()` dummy argument is emitted before the real argument. /// indicates if a `Reg::i32()` dummy argument is emitted before the real argument.
Cast { pad_i32: bool, cast: Box<CastTarget> }, Cast { pad_i32: bool, cast: Box<CastTarget> },
/// Pass the argument indirectly via a hidden pointer. /// Pass the argument indirectly via a hidden pointer.
/// The `extra_attrs` value, if any, is for the extra data (vtable or length) /// The `meta_attrs` value, if any, is for the metadata (vtable or length) of an unsized
/// which indicates that it refers to an unsized rvalue. /// argument. (This is the only mode that supports unsized arguments.)
/// `on_stack` defines that the value should be passed at a fixed /// `on_stack` defines that the value should be passed at a fixed stack offset in accordance to
/// stack offset in accordance to the ABI rather than passed using a /// the ABI rather than passed using a pointer. This corresponds to the `byval` LLVM argument
/// pointer. This corresponds to the `byval` LLVM argument attribute. /// attribute (using the Rust type of this argument). `on_stack` cannot be true for unsized
Indirect { attrs: ArgAttributes, extra_attrs: Option<ArgAttributes>, on_stack: bool }, /// arguments, i.e., when `meta_attrs` is `Some`.
Indirect { attrs: ArgAttributes, meta_attrs: Option<ArgAttributes>, on_stack: bool },
} }
impl PassMode { impl PassMode {
@ -71,12 +72,12 @@ impl PassMode {
PassMode::Cast { cast: c2, pad_i32: pad2 }, PassMode::Cast { cast: c2, pad_i32: pad2 },
) => c1.eq_abi(c2) && pad1 == pad2, ) => c1.eq_abi(c2) && pad1 == pad2,
( (
PassMode::Indirect { attrs: a1, extra_attrs: None, on_stack: s1 }, PassMode::Indirect { attrs: a1, meta_attrs: None, on_stack: s1 },
PassMode::Indirect { attrs: a2, extra_attrs: None, on_stack: s2 }, PassMode::Indirect { attrs: a2, meta_attrs: None, on_stack: s2 },
) => a1.eq_abi(a2) && s1 == s2, ) => a1.eq_abi(a2) && s1 == s2,
( (
PassMode::Indirect { attrs: a1, extra_attrs: Some(e1), on_stack: s1 }, PassMode::Indirect { attrs: a1, meta_attrs: Some(e1), on_stack: s1 },
PassMode::Indirect { attrs: a2, extra_attrs: Some(e2), on_stack: s2 }, PassMode::Indirect { attrs: a2, meta_attrs: Some(e2), on_stack: s2 },
) => a1.eq_abi(a2) && e1.eq_abi(e2) && s1 == s2, ) => a1.eq_abi(a2) && e1.eq_abi(e2) && s1 == s2,
_ => false, _ => false,
} }
@ -565,15 +566,15 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
attrs.pointee_size = layout.size; attrs.pointee_size = layout.size;
attrs.pointee_align = Some(layout.align.abi); attrs.pointee_align = Some(layout.align.abi);
let extra_attrs = layout.is_unsized().then_some(ArgAttributes::new()); let meta_attrs = layout.is_unsized().then_some(ArgAttributes::new());
PassMode::Indirect { attrs, extra_attrs, on_stack: false } PassMode::Indirect { attrs, meta_attrs, on_stack: false }
} }
pub fn make_indirect(&mut self) { pub fn make_indirect(&mut self) {
match self.mode { match self.mode {
PassMode::Direct(_) | PassMode::Pair(_, _) => {} PassMode::Direct(_) | PassMode::Pair(_, _) => {}
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: false } => return, PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: false } => return,
_ => panic!("Tried to make {:?} indirect", self.mode), _ => panic!("Tried to make {:?} indirect", self.mode),
} }
@ -583,7 +584,7 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
pub fn make_indirect_byval(&mut self, byval_align: Option<Align>) { pub fn make_indirect_byval(&mut self, byval_align: Option<Align>) {
self.make_indirect(); self.make_indirect();
match self.mode { match self.mode {
PassMode::Indirect { ref mut attrs, extra_attrs: _, ref mut on_stack } => { PassMode::Indirect { ref mut attrs, meta_attrs: _, ref mut on_stack } => {
*on_stack = true; *on_stack = true;
// Some platforms, like 32-bit x86, change the alignment of the type when passing // Some platforms, like 32-bit x86, change the alignment of the type when passing
@ -628,11 +629,11 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
} }
pub fn is_sized_indirect(&self) -> bool { pub fn is_sized_indirect(&self) -> bool {
matches!(self.mode, PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ }) matches!(self.mode, PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ })
} }
pub fn is_unsized_indirect(&self) -> bool { pub fn is_unsized_indirect(&self) -> bool {
matches!(self.mode, PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ }) matches!(self.mode, PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ })
} }
pub fn is_ignore(&self) -> bool { pub fn is_ignore(&self) -> bool {

4
compiler/rustc_target/src/abi/call/x86.rs
View file

@ -142,12 +142,12 @@ where
for arg in fn_abi.args.iter_mut() { for arg in fn_abi.args.iter_mut() {
let attrs = match arg.mode { let attrs = match arg.mode {
PassMode::Ignore PassMode::Ignore
| PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => { | PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _ } => {
continue; continue;
} }
PassMode::Direct(ref mut attrs) => attrs, PassMode::Direct(ref mut attrs) => attrs,
PassMode::Pair(..) PassMode::Pair(..)
| PassMode::Indirect { attrs: _, extra_attrs: Some(_), on_stack: _ } | PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ }
| PassMode::Cast { .. } => { | PassMode::Cast { .. } => {
unreachable!("x86 shouldn't be passing arguments by {:?}", arg.mode) unreachable!("x86 shouldn't be passing arguments by {:?}", arg.mode)
} }

4
tests/ui/abi/debug.stderr
View file

@ -450,7 +450,7 @@ error: ABIs are not compatible
Align(1 bytes), Align(1 bytes),
), ),
}, },
extra_attrs: None, meta_attrs: None,
on_stack: false, on_stack: false,
}, },
}, },
@ -521,7 +521,7 @@ error: ABIs are not compatible
Align(4 bytes), Align(4 bytes),
), ),
}, },
extra_attrs: None, meta_attrs: None,
on_stack: false, on_stack: false,
}, },
}, },