vec3: SIMD to C, reusing DefId may be a bad idea?

Author: Firestar99

crates/rustc_codegen_spirv/src/abi.rs

@@ -8,18 +8,17 @@ 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, LayoutData, Primitive, ReprFlags, ReprOptions,
+    Scalar, Size, TagEncoding, VariantIdx, Variants,
 };
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
-use rustc_hashes::Hash64;
-use rustc_index::Idx;
+use rustc_index::{Idx, IndexVec};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{
-    self, Const, CoroutineArgs, CoroutineArgsExt as _, FloatTy, IntTy, PolyFnSig, Ty, TyCtxt,
-    TyKind, UintTy,
+    self, Const, CoroutineArgs, CoroutineArgsExt as _, FieldDef, FloatTy, IntTy, PolyFnSig, Ty,
+    TyCtxt, TyKind, UintTy, VariantDef,
 };
 use rustc_middle::ty::{GenericArgsRef, ScalarInt};
 use rustc_middle::{bug, span_bug};
@@ -164,9 +163,12 @@ pub(crate) fn provide(providers: &mut Providers) {
         }
     }
 
-    providers.layout_of = |tcx: TyCtxt<'_>,
-                           key: ty::PseudoCanonicalInput<'_, Ty<'_>>|
-     -> Result<TyAndLayout<'_>, &'_ ty::layout::LayoutError<'_>> {
+    providers.layout_of = layout_of;
+
+    fn layout_of<'tcx>(
+        tcx: TyCtxt<'tcx>,
+        mut key: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>,
+    ) -> Result<TyAndLayout<'tcx>, &'tcx ty::layout::LayoutError<'tcx>> {
         // 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`
@@ -176,76 +178,51 @@ pub(crate) fn provide(providers: &mut Providers) {
 
         // 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() {
+        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
+                let def: &ty::AdtDef<'tcx> = def;
+                let args: &ty::GenericArgs<'tcx> = args;
+
+                let mut repr_flags = def.repr().flags;
+                repr_flags.remove(ReprFlags::IS_SIMD);
+                repr_flags.insert(ReprFlags::IS_C);
+                let def_c = tcx.mk_adt_def(
+                    def.did(),
+                    def.adt_kind(),
+                    def.variants()
                         .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))
-                })
+                        .map(|v| {
+                            VariantDef::new(
+                                v.name,
+                                None,
+                                v.ctor,
+                                v.discr,
+                                v.fields
+                                    .iter()
+                                    .map(|f| FieldDef {
+                                        did: f.did,
+                                        name: f.name,
+                                        vis: f.vis,
+                                        safety: f.safety,
+                                        value: f.value,
+                                    })
+                                    .collect(),
+                                v.def_id,
+                                None,
+                                v.is_field_list_non_exhaustive(),
+                            )
+                        })
+                        .collect(),
+                    ReprOptions {
+                        flags: repr_flags,
+                        ..def.repr()
+                    },
+                );
+                key.value = Ty::new_adt(tcx, def_c, args);
             }
-            _ => 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)?;
 
@@ -270,7 +247,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         }
 
         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"),