abi layout: remove #[repr(SIMD)] hack

Author: Firestar99

crates/rustc_codegen_spirv/src/abi.rs

@@ -8,12 +8,10 @@ use itertools::Itertools;
 use rspirv::spirv::{Dim, ImageFormat, StorageClass, Word};
 use rustc_abi::ExternAbi as Abi;
 use rustc_abi::{
-    Align, BackendRepr, FieldIdx, FieldsShape, HasDataLayout as _, LayoutData, Primitive,
-    ReprFlags, ReprOptions, Scalar, Size, TagEncoding, VariantIdx, Variants,
+    Align, BackendRepr, FieldIdx, FieldsShape, Primitive, Scalar, Size, VariantIdx, Variants,
 };
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
-use rustc_hashes::Hash64;
 use rustc_index::Idx;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, TyAndLayout};
@@ -98,267 +96,6 @@ pub(crate) fn provide(providers: &mut Providers) {
         Ok(readjust_fn_abi(tcx, result?))
     };
 
-    // FIXME(eddyb) remove this by deriving `Clone` for `LayoutData` upstream.
-    fn clone_layout<FieldIdx: Idx, VariantIdx: Idx>(
-        layout: &LayoutData<FieldIdx, VariantIdx>,
-    ) -> LayoutData<FieldIdx, VariantIdx> {
-        let LayoutData {
-            ref fields,
-            ref variants,
-            backend_repr,
-            largest_niche,
-            uninhabited,
-            align,
-            size,
-            max_repr_align,
-            unadjusted_abi_align,
-            randomization_seed,
-        } = *layout;
-        LayoutData {
-            fields: match *fields {
-                FieldsShape::Primitive => FieldsShape::Primitive,
-                FieldsShape::Union(count) => FieldsShape::Union(count),
-                FieldsShape::Array { stride, count } => FieldsShape::Array { stride, count },
-                FieldsShape::Arbitrary {
-                    ref offsets,
-                    ref memory_index,
-                } => FieldsShape::Arbitrary {
-                    offsets: offsets.clone(),
-                    memory_index: memory_index.clone(),
-                },
-            },
-            variants: match *variants {
-                Variants::Empty => Variants::Empty,
-                Variants::Single { index } => Variants::Single { index },
-                Variants::Multiple {
-                    tag,
-                    ref tag_encoding,
-                    tag_field,
-                    ref variants,
-                } => Variants::Multiple {
-                    tag,
-                    tag_encoding: match *tag_encoding {
-                        TagEncoding::Direct => TagEncoding::Direct,
-                        TagEncoding::Niche {
-                            untagged_variant,
-                            ref niche_variants,
-                            niche_start,
-                        } => TagEncoding::Niche {
-                            untagged_variant,
-                            niche_variants: niche_variants.clone(),
-                            niche_start,
-                        },
-                    },
-                    tag_field,
-                    variants: variants.clone(),
-                },
-            },
-            backend_repr,
-            largest_niche,
-            uninhabited,
-            align,
-            size,
-            max_repr_align,
-            unadjusted_abi_align,
-            randomization_seed,
-        }
-    }
-
-    providers.layout_of = |tcx, key| {
-        // HACK(eddyb) to special-case any types at all, they must be normalized,
-        // but when normalization would be needed, `layout_of`'s default provider
-        // recurses (supposedly for caching reasons), i.e. its calls `layout_of`
-        // w/ the normalized type in input, which once again reaches this hook,
-        // without ever needing any explicit normalization here.
-        let ty = key.value;
-
-        // HACK(eddyb) bypassing upstream `#[repr(simd)]` changes (see also
-        // the later comment above `check_well_formed`, for more details).
-        let reimplement_old_style_repr_simd = match ty.kind() {
-            ty::Adt(def, args) if def.repr().simd() && !def.repr().packed() && def.is_struct() => {
-                Some(def.non_enum_variant()).and_then(|v| {
-                    let (count, e_ty) = v
-                        .fields
-                        .iter()
-                        .map(|f| f.ty(tcx, args))
-                        .dedup_with_count()
-                        .exactly_one()
-                        .ok()?;
-                    let e_len = u64::try_from(count).ok().filter(|&e_len| e_len > 1)?;
-                    Some((def, e_ty, e_len))
-                })
-            }
-            _ => None,
-        };
-
-        // HACK(eddyb) tweaked copy of the old upstream logic for `#[repr(simd)]`:
-        // https://github.com/rust-lang/rust/blob/1.86.0/compiler/rustc_ty_utils/src/layout.rs#L464-L590
-        if let Some((adt_def, e_ty, e_len)) = reimplement_old_style_repr_simd {
-            let cx = rustc_middle::ty::layout::LayoutCx::new(
-                tcx,
-                key.typing_env.with_post_analysis_normalized(tcx),
-            );
-            let dl = cx.data_layout();
-
-            // Compute the ABI of the element type:
-            let e_ly = cx.layout_of(e_ty)?;
-            let BackendRepr::Scalar(e_repr) = e_ly.backend_repr else {
-                // This error isn't caught in typeck, e.g., if
-                // the element type of the vector is generic.
-                tcx.dcx().span_fatal(
-                    tcx.def_span(adt_def.did()),
-                    format!(
-                        "SIMD type `{ty}` with a non-primitive-scalar \
-                     (integer/float/pointer) element type `{}`",
-                        e_ly.ty
-                    ),
-                );
-            };
-
-            // Compute the size and alignment of the vector:
-            let size = e_ly.size.checked_mul(e_len, dl).unwrap();
-            let align = dl.llvmlike_vector_align(size);
-            let size = size.align_to(align.abi);
-
-            let layout = tcx.mk_layout(LayoutData {
-                variants: Variants::Single {
-                    index: rustc_abi::FIRST_VARIANT,
-                },
-                fields: FieldsShape::Array {
-                    stride: e_ly.size,
-                    count: e_len,
-                },
-                backend_repr: BackendRepr::SimdVector {
-                    element: e_repr,
-                    count: e_len,
-                },
-                largest_niche: e_ly.largest_niche,
-                uninhabited: false,
-                size,
-                align,
-                max_repr_align: None,
-                unadjusted_abi_align: align.abi,
-                randomization_seed: e_ly.randomization_seed.wrapping_add(Hash64::new(e_len)),
-            });
-
-            return Ok(TyAndLayout { ty, layout });
-        }
-
-        let TyAndLayout { ty, mut layout } =
-            (rustc_interface::DEFAULT_QUERY_PROVIDERS.layout_of)(tcx, key)?;
-
-        #[allow(clippy::match_like_matches_macro)]
-        let hide_niche = match ty.kind() {
-            ty::Bool => {
-                // HACK(eddyb) we can't bypass e.g. `Option<bool>` being a byte,
-                // due to `core` PR https://github.com/rust-lang/rust/pull/138881
-                // (which adds a new `transmute`, from `ControlFlow<bool>` to `u8`).
-                let libcore_needs_bool_niche = true;
-
-                !libcore_needs_bool_niche
-            }
-            _ => false,
-        };
-
-        if hide_niche {
-            layout = tcx.mk_layout(LayoutData {
-                largest_niche: None,
-                ..clone_layout(layout.0.0)
-            });
-        }
-
-        Ok(TyAndLayout { ty, layout })
-    };
-
-    // HACK(eddyb) work around https://github.com/rust-lang/rust/pull/129403
-    // banning "struct-style" `#[repr(simd)]` (in favor of "array-newtype-style"),
-    // by simply bypassing "type definition WF checks" for affected types, which:
-    // - can only really be sound for types with trivial field types, that are
-    //   either completely non-generic (covering most `#[repr(simd)]` `struct`s),
-    //   or *at most* one generic type parameter with no bounds/where clause
-    // - relies on upstream `layout_of` not having had the non-array logic removed
-    //
-    // FIXME(eddyb) remove this once migrating beyond `#[repr(simd)]` becomes
-    // an option (may require Rust-GPU distinguishing between "SPIR-V interface"
-    // and "Rust-facing" types, which is even worse when the `OpTypeVector`s
-    // may be e.g. nested in `struct`s/arrays/etc. - at least buffers are easy).
-    //
-    // FIXME(eddyb) maybe using `#[spirv(vector)]` and `BackendRepr::Memory`,
-    // no claims at `rustc`-understood SIMD whatsoever, would be enough?
-    // (i.e. only SPIR-V caring about such a type vs a struct/array)
-    providers.check_well_formed = |tcx, def_id| {
-        let trivial_struct = match tcx.hir_node_by_def_id(def_id) {
-            rustc_hir::Node::Item(item) => match item.kind {
-                rustc_hir::ItemKind::Struct(
-                    _,
-                    &rustc_hir::Generics {
-                        params:
-                            &[]
-                            | &[
-                                rustc_hir::GenericParam {
-                                    kind:
-                                        rustc_hir::GenericParamKind::Type {
-                                            default: None,
-                                            synthetic: false,
-                                        },
-                                    ..
-                                },
-                            ],
-                        predicates: &[],
-                        has_where_clause_predicates: false,
-                        where_clause_span: _,
-                        span: _,
-                    },
-                    _,
-                ) => Some(tcx.adt_def(def_id)),
-                _ => None,
-            },
-            _ => None,
-        };
-        let valid_non_array_simd_struct = trivial_struct.is_some_and(|adt_def| {
-            let ReprOptions {
-                int: None,
-                align: None,
-                pack: None,
-                flags: ReprFlags::IS_SIMD,
-                field_shuffle_seed: _,
-            } = adt_def.repr()
-            else {
-                return false;
-            };
-            if adt_def.destructor(tcx).is_some() {
-                return false;
-            }
-
-            let field_types = adt_def
-                .non_enum_variant()
-                .fields
-                .iter()
-                .map(|f| tcx.type_of(f.did).instantiate_identity());
-            field_types.dedup().exactly_one().is_ok_and(|elem_ty| {
-                matches!(
-                    elem_ty.kind(),
-                    ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Param(_)
-                )
-            })
-        });
-
-        if valid_non_array_simd_struct {
-            tcx.dcx()
-                .struct_span_warn(
-                    tcx.def_span(def_id),
-                    "[Rust-GPU] temporarily re-allowing old-style `#[repr(simd)]` (with fields)",
-                )
-                .with_note("removed upstream by https://github.com/rust-lang/rust/pull/129403")
-                .with_note("in favor of the new `#[repr(simd)] struct TxN([T; N]);` style")
-                .with_note("(taking effect since `nightly-2024-09-12` / `1.83.0` stable)")
-                .emit();
-            return Ok(());
-        }
-
-        (rustc_interface::DEFAULT_QUERY_PROVIDERS.check_well_formed)(tcx, def_id)
-    };
-
     // HACK(eddyb) work around https://github.com/rust-lang/rust/pull/132173
     // (and further changes from https://github.com/rust-lang/rust/pull/132843)
     // starting to ban SIMD ABI misuse (or at least starting to warn about it).