Rollup merge of #144529 - beetrees:pass-indirectly-attr, r=bjorn3

Add `#[rustc_pass_indirectly_in_non_rustic_abis]`
This PR adds an internal `#[rustc_pass_indirectly_in_non_rustic_abis]` attribute that can be applied to structs. Structs marked with this attribute will always be passed using `PassMode::Indirect { on_stack: false, .. }` when being passed by value to functions with non-Rustic calling conventions. This is needed by #141980; see that PR for further details.
cc `@joshtriplett`

Author: Zalathar

compiler/rustc_abi/src/layout/ty.rs

@@ -172,6 +172,8 @@ pub trait TyAbiInterface<'a, C>: Sized + std::fmt::Debug {
 fnis_tuple(this:TyAndLayout<'a,Self>) -> bool;
 fnis_unit(this:TyAndLayout<'a,Self>) -> bool;
 fnis_transparent(this:TyAndLayout<'a,Self>) -> bool;
+/// See [`TyAndLayout::pass_indirectly_in_non_rustic_abis`] for details.
+fnis_pass_indirectly_in_non_rustic_abis_flag_set(this:TyAndLayout<'a,Self>) -> bool;
 }
 
 impl<'a,Ty>TyAndLayout<'a,Ty>{
@@ -269,6 +271,30 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
 Ty::is_transparent(self)
 }
 
+/// If this method returns `true`, then this type should always have a `PassMode` of
+/// `Indirect { on_stack: false, .. }` when being used as the argument type of a function with a
+/// non-Rustic ABI (this is true for structs annotated with the
+/// `#[rustc_pass_indirectly_in_non_rustic_abis]` attribute).
+///
+/// This is used to replicate some of the behaviour of C array-to-pointer decay; however unlike
+/// C any changes the caller makes to the passed value will not be reflected in the callee, so
+/// the attribute is only useful for types where observing the value in the caller after the
+/// function call isn't allowed (a.k.a. `va_list`).
+///
+/// This function handles transparent types automatically.
+pubfnpass_indirectly_in_non_rustic_abis<C>(mutself,cx:&C) -> bool
+where
+Ty:TyAbiInterface<'a,C> + Copy,
+{
+whileself.is_transparent()
+ && letSome((_, field)) = self.non_1zst_field(cx)
+{
+self = field;
+}
+
+Ty::is_pass_indirectly_in_non_rustic_abis_flag_set(self)
+}
+
 /// Finds the one field that is not a 1-ZST.
 /// Returns `None` if there are multiple non-1-ZST fields or only 1-ZST-fields.
 pubfnnon_1zst_field<C>(&self,cx:&C) -> Option<(FieldIdx,Self)>

compiler/rustc_abi/src/lib.rs

@@ -88,14 +88,17 @@ bitflags! {
 constIS_C = 1 << 0;
 constIS_SIMD = 1 << 1;
 constIS_TRANSPARENT = 1 << 2;
-// Internal only for now. If true, don't reorder fields.
-// On its own it does not prevent ABI optimizations.
+/// Internal only for now. If true, don't reorder fields.
+/// On its own it does not prevent ABI optimizations.
 constIS_LINEAR = 1 << 3;
-// If true, the type's crate has opted into layout randomization.
-// Other flags can still inhibit reordering and thus randomization.
-// The seed stored in `ReprOptions.field_shuffle_seed`.
+/// If true, the type's crate has opted into layout randomization.
+/// Other flags can still inhibit reordering and thus randomization.
+/// The seed stored in `ReprOptions.field_shuffle_seed`.
 constRANDOMIZE_LAYOUT = 1 << 4;
-// Any of these flags being set prevent field reordering optimisation.
+/// If true, the type is always passed indirectly by non-Rustic ABIs.
+/// See [`TyAndLayout::pass_indirectly_in_non_rustic_abis`] for details.
+constPASS_INDIRECTLY_IN_NON_RUSTIC_ABIS = 1 << 5;
+/// Any of these flags being set prevent field reordering optimisation.
 constFIELD_ORDER_UNOPTIMIZABLE = ReprFlags::IS_C.bits()
  | ReprFlags::IS_SIMD.bits()
  | ReprFlags::IS_LINEAR.bits();

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -676,3 +676,12 @@ impl<S: Stage> SingleAttributeParser<S> for SanitizeParser {
 Some(AttributeKind::Sanitize{ on_set, off_set,span: cx.attr_span})
 }
 }
+
+pub(crate)structRustcPassIndirectlyInNonRusticAbisParser;
+
+impl<S:Stage>NoArgsAttributeParser<S>forRustcPassIndirectlyInNonRusticAbisParser{
+constPATH:&[Symbol] = &[sym::rustc_pass_indirectly_in_non_rustic_abis];
+constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::Error;
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
+constCREATE:fn(Span) -> AttributeKind = AttributeKind::RustcPassIndirectlyInNonRusticAbis;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -20,8 +20,9 @@ use crate::attributes::allow_unstable::{
 usecrate::attributes::body::CoroutineParser;
 usecrate::attributes::codegen_attrs::{
 ColdParser,CoverageParser,ExportNameParser,ForceTargetFeatureParser,NakedParser,
-NoMangleParser,ObjcClassParser,ObjcSelectorParser,OptimizeParser,SanitizeParser,
-TargetFeatureParser,TrackCallerParser,UsedParser,
+NoMangleParser,ObjcClassParser,ObjcSelectorParser,OptimizeParser,
+RustcPassIndirectlyInNonRusticAbisParser,SanitizeParser,TargetFeatureParser,
+TrackCallerParser,UsedParser,
 };
 usecrate::attributes::confusables::ConfusablesParser;
 usecrate::attributes::crate_level::{
@@ -243,6 +244,7 @@ attribute_parsers!(
 Single<WithoutArgs<PubTransparentParser>>,
 Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
 Single<WithoutArgs<RustcMainParser>>,
+Single<WithoutArgs<RustcPassIndirectlyInNonRusticAbisParser>>,
 Single<WithoutArgs<SpecializationTraitParser>>,
 Single<WithoutArgs<StdInternalSymbolParser>>,
 Single<WithoutArgs<TrackCallerParser>>,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -657,6 +657,12 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
  template!(Word,"https://doc.rust-lang.org/reference/attributes/codegen.html#the-naked-attribute"),
 WarnFollowing,EncodeCrossCrate::No
 ),
+// See `TyAndLayout::pass_indirectly_in_non_rustic_abis` for details.
+rustc_attr!(
+ rustc_pass_indirectly_in_non_rustic_abis,Normal, template!(Word),ErrorFollowing,
+EncodeCrossCrate::No,
+"types marked with `#[rustc_pass_indirectly_in_non_rustic_abis]` are always passed indirectly by non-Rustic abis."
+),
 
 // Limits:
 ungated!(

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -679,6 +679,9 @@ pub enum AttributeKind {
 /// Represents `#[rustc_object_lifetime_default]`.
 RustcObjectLifetimeDefault,
 
+/// Represents `#[rustc_pass_indirectly_in_non_rustic_abis]`
+RustcPassIndirectlyInNonRusticAbis(Span),
+
 /// Represents `#[rustc_simd_monomorphize_lane_limit = "N"]`.
 RustcSimdMonomorphizeLaneLimit(Limit),
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -91,6 +91,7 @@ impl AttributeKind {
 RustcLayoutScalarValidRangeStart(..) => Yes,
 RustcMain => No,
 RustcObjectLifetimeDefault => No,
+RustcPassIndirectlyInNonRusticAbis(..) => No,
 RustcSimdMonomorphizeLaneLimit(..) => Yes,// Affects layout computation, which needs to work cross-crate
 Sanitize{ .. } => No,
 ShouldPanic{ .. } => No,

compiler/rustc_middle/src/ty/layout.rs

@@ -3,7 +3,7 @@ use std::{cmp, fmt};
 
 use rustc_abi::{
 AddressSpace,Align,ExternAbi,FieldIdx,FieldsShape,HasDataLayout,LayoutData,PointeeInfo,
-PointerKind,Primitive,ReprOptions,Scalar,Size,TagEncoding,TargetDataLayout,
+PointerKind,Primitive,ReprFlags,ReprOptions,Scalar,Size,TagEncoding,TargetDataLayout,
 TyAbiInterface,VariantIdx,Variants,
 };
 use rustc_error_messages::DiagMessage;
@@ -1173,6 +1173,11 @@ where
 fnis_transparent(this:TyAndLayout<'tcx>) -> bool{
 matches!(this.ty.kind(), ty::Adt(def, _)if def.repr().transparent())
 }
+
+/// See [`TyAndLayout::pass_indirectly_in_non_rustic_abis`] for details.
+fnis_pass_indirectly_in_non_rustic_abis_flag_set(this:TyAndLayout<'tcx>) -> bool{
+matches!(this.ty.kind(), ty::Adt(def, _)if def.repr().flags.contains(ReprFlags::PASS_INDIRECTLY_IN_NON_RUSTIC_ABIS))
+}
 }
 
 /// Calculates whether a function's ABI can unwind or not.

compiler/rustc_middle/src/ty/mod.rs

@@ -1573,6 +1573,14 @@ impl<'tcx> TyCtxt<'tcx> {
  flags.insert(ReprFlags::IS_LINEAR);
 }
 
+// See `TyAndLayout::pass_indirectly_in_non_rustic_abis` for details.
+iffind_attr!(
+self.get_all_attrs(did),
+AttributeKind::RustcPassIndirectlyInNonRusticAbis(..)
+){
+ flags.insert(ReprFlags::PASS_INDIRECTLY_IN_NON_RUSTIC_ABIS);
+}
+
 ReprOptions{int: size,align: max_align,pack: min_pack, flags, field_shuffle_seed }
 }
 

compiler/rustc_passes/src/check_attr.rs

@@ -284,6 +284,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
  | AttributeKind::RustcCoherenceIsCore(..)
  | AttributeKind::DebuggerVisualizer(..)
  | AttributeKind::RustcMain
+ | AttributeKind::RustcPassIndirectlyInNonRusticAbis(..)
  | AttributeKind::PinV2(..),
 ) => {/* do nothing */}
 Attribute::Unparsed(attr_item) => {
@@ -1770,6 +1771,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
 target: target.to_string(),
 });
 }
+// Error on `#[repr(transparent)]` in combination with
+// `#[rustc_pass_indirectly_in_non_rustic_abis]`
+if is_transparent
+ && letSome(&pass_indirectly_span) =
+find_attr!(attrs,AttributeKind::RustcPassIndirectlyInNonRusticAbis(span) => span)
+{
+self.dcx().emit_err(errors::TransparentIncompatible{
+hint_spans:vec![span, pass_indirectly_span],
+target: target.to_string(),
+});
+}
 if is_explicit_rust && (int_reprs > 0 || is_c || is_simd){
 let hint_spans = hint_spans.clone().collect();
 self.dcx().emit_err(errors::ReprConflicting{ hint_spans });