vec3: SIMD to C, directly calling the rust layout function is easier

Author: Firestar99

crates/rustc_codegen_spirv/src/abi.rs

@@ -6,19 +6,19 @@ use crate::codegen_cx::CodegenCx;
 use crate::spirv_type::SpirvType;
 use itertools::Itertools;
 use rspirv::spirv::{Dim, ImageFormat, StorageClass, Word};
-use rustc_abi::ExternAbi as Abi;
 use rustc_abi::{
     Align, BackendRepr, FieldIdx, FieldsShape, LayoutData, Primitive, ReprFlags, ReprOptions,
     Scalar, Size, TagEncoding, VariantIdx, Variants,
 };
+use rustc_abi::{ExternAbi as Abi, Integer};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::query::Providers;
-use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, TyAndLayout};
+use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, LayoutCx, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{
-    self, Const, CoroutineArgs, CoroutineArgsExt as _, FieldDef, FloatTy, IntTy, PolyFnSig, Ty,
-    TyCtxt, TyKind, UintTy, VariantDef,
+    self, Const, CoroutineArgs, CoroutineArgsExt as _, FloatTy, IntTy, PolyFnSig, Ty, TyCtxt,
+    TyKind, UintTy,
 };
 use rustc_middle::ty::{GenericArgsRef, ScalarInt};
 use rustc_middle::{bug, span_bug};
@@ -167,14 +167,17 @@ pub(crate) fn provide(providers: &mut Providers) {
 
     fn layout_of<'tcx>(
         tcx: TyCtxt<'tcx>,
-        mut key: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>,
+        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`
         // w/ the normalized type in input, which once again reaches this hook,
         // without ever needing any explicit normalization here.
-        let ty = key.value;
+        let ty::PseudoCanonicalInput {
+            typing_env,
+            value: ty,
+        } = key;
 
         // HACK(eddyb) bypassing upstream `#[repr(simd)]` changes (see also
         // the later comment above `check_well_formed`, for more details).
@@ -183,42 +186,56 @@ pub(crate) fn provide(providers: &mut Providers) {
                 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(|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()
-                    },
+                // HACK(firestar99) we don't special case SIMD anymore for glam
+                // we now want it to behave like `#[repr(C)]`. But to not break
+                // old versions of glam immediately, I made this hack to remap
+                // SIMD to C.
+                let mut repr = def.repr();
+                repr.flags.remove(ReprFlags::IS_SIMD);
+                repr.flags.insert(ReprFlags::IS_C);
+
+                // Much of the following is copied from `rustc_ty_utils::layout::layout_of_uncached` and simplified
+                let cx = LayoutCx::new(tcx, typing_env);
+
+                // Cache the field layouts, copied
+                let variants = def
+                    .variants()
+                    .iter()
+                    .map(|v| {
+                        v.fields
+                            .iter()
+                            .map(|field| cx.layout_of(field.ty(tcx, args)))
+                            .collect::<Result<IndexVec<_, _>, _>>()
+                    })
+                    .collect::<Result<IndexVec<VariantIdx, _>, _>>()?;
+
+                let result = cx.calc.layout_of_struct_or_enum(
+                    &repr,
+                    &variants,
+                    // no enum
+                    false,
+                    // does not contain UnsafeCell and variants
+                    false,
+                    // copied
+                    tcx.layout_scalar_valid_range(def.did()),
+                    // ignored, enum only
+                    |_, _| (Integer::I32, false),
+                    // ignored, enum only
+                    std::iter::empty(),
+                    // ignored, enum only
+                    false,
+                    // we are always sized
+                    true,
                 );
-                key.value = Ty::new_adt(tcx, def_c, args);
+
+                let layout = match result {
+                    Ok(layout_data) => tcx.mk_layout(layout_data),
+                    Err(e) => cx
+                        .tcx()
+                        .dcx()
+                        .fatal(format!("SIMD to C repr remap failed: {e:?}")),
+                };
+                return Ok(TyAndLayout { ty, layout });
             }
             _ => (),
         };