Collapse #[repr(transparent)] newtypes in SPIR-V type translation

Author: novacrazy

crates/rustc_codegen_spirv/src/abi.rs

@@ -3,7 +3,7 @@
 
 use crate::attr::{AggregatedSpirvAttributes, IntrinsicType};
 use crate::codegen_cx::CodegenCx;
-use crate::spirv_type::SpirvType;
+use crate::spirv_type::{SpirvType, name_type_id};
 use itertools::Itertools;
 use rspirv::spirv::{Dim, ImageFormat, StorageClass, Word};
 use rustc_abi::ExternAbi as Abi;
@@ -321,6 +321,33 @@ impl<'tcx> ConvSpirvType<'tcx> for FnAbi<'tcx, Ty<'tcx>> {
     }
 }
 
+/// If `layout` has exactly one non-ZST field positioned at offset 0 with size and
+/// alignment matching the outer layout, returns that field.
+///
+/// This captures the structural shape of a "newtype wrapper" — a single meaningful
+/// field padded out to the outer type, which can be substituted for the outer type
+/// in a SPIR-V type graph as long as the caller has *independently* verified that
+/// the ABIs match (either via `BackendRepr::eq_up_to_validity`, or via
+/// `#[repr(transparent)]`, which guarantees full ABI identity by construction).
+fn sole_structural_newtype_field<'tcx>(
+    cx: &CodegenCx<'tcx>,
+    layout: TyAndLayout<'tcx>,
+) -> Option<TyAndLayout<'tcx>> {
+    let mut non_zst = (0..layout.fields.count()).filter(|&i| !layout.field(cx, i).is_zst());
+    let i = non_zst.next()?;
+    if non_zst.next().is_some() {
+        return None;
+    }
+    let field = layout.field(cx, i);
+    // Only unpack a newtype if the field and the newtype line up
+    // perfectly, in every way that could potentially affect ABI.
+    (layout.fields.offset(i) == Size::ZERO
+        && field.size == layout.size
+        && field.align.abi == layout.align.abi
+        && field.backend_repr.eq_up_to_validity(&layout.backend_repr))
+    .then_some(field)
+}
+
 impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
     fn spirv_type(&self, mut span: Span, cx: &CodegenCx<'tcx>) -> Word {
         if let TyKind::Adt(adt, args) = *self.ty.kind() {
@@ -379,23 +406,8 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
                 //      a new one, offering the `(a, b)` shape `rustc_codegen_ssa`
                 //      expects, while letting noop pointercasts access the sole
                 //      `BackendRepr::ScalarPair` field - this is the approach taken here
-                let mut non_zst_fields = (0..self.fields.count())
-                    .map(|i| (i, self.field(cx, i)))
-                    .filter(|(_, field)| !field.is_zst());
-                let sole_non_zst_field = match (non_zst_fields.next(), non_zst_fields.next()) {
-                    (Some(field), None) => Some(field),
-                    _ => None,
-                };
-                if let Some((i, field)) = sole_non_zst_field {
-                    // Only unpack a newtype if the field and the newtype line up
-                    // perfectly, in every way that could potentially affect ABI.
-                    if self.fields.offset(i) == Size::ZERO
-                        && field.size == self.size
-                        && field.align.abi == self.align.abi
-                        && field.backend_repr.eq_up_to_validity(&self.backend_repr)
-                    {
-                        return field.spirv_type(span, cx);
-                    }
+                if let Some(field) = sole_structural_newtype_field(cx, *self) {
+                    return field.spirv_type(span, cx);
                 }
 
                 // Note: We can't use auto_struct_layout here because the spirv types here might be undefined due to
@@ -447,7 +459,24 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
                 .tcx
                 .dcx()
                 .fatal("scalable vectors are not supported in SPIR-V backend"),
-            BackendRepr::Memory { sized: _ } => trans_aggregate(cx, span, *self),
+            BackendRepr::Memory { sized: _ } => {
+                // For `#[repr(transparent)]` newtypes, reuse the single non-ZST
+                // field's SPIR-V type directly instead of wrapping it in an
+                // `OpTypeStruct`, if the type is `#[repr(transparent)]`.
+                // Otherwise, we're manipulating the abi too much and the
+                // format args decompiler fails.
+                if let TyKind::Adt(adt, _) = self.ty.kind()
+                    && adt.repr().transparent()
+                    && let Some(field) = sole_structural_newtype_field(cx, *self)
+                {
+                    let inner_id = field.spirv_type(span, cx);
+                    // Preserve the wrapper's name as an `OpName` alias on the
+                    // inner SPIR-V type so disassembly still shows it.
+                    name_type_id(cx, inner_id, TyLayoutNameKey::from(*self));
+                    return inner_id;
+                }
+                trans_aggregate(cx, span, *self)
+            }
         }
     }
 }

crates/rustc_codegen_spirv/src/spirv_type.rs

@@ -92,6 +92,17 @@ pub enum SpirvType<'tcx> {
     RayQueryKhr,
 }
 
+/// Emit an `OpName` for a type `id`, deduplicated per `(id, name_key)` pair.
+/// Unlike [`SpirvType::def_with_name`], this operates on an existing `id` - useful
+/// for types reused across multiple Rust types (e.g. `#[repr(transparent)]`
+/// newtype collapse, where the wrapper's name is attached to the inner's id).
+pub fn name_type_id<'tcx>(cx: &CodegenCx<'tcx>, id: Word, name_key: TyLayoutNameKey<'tcx>) {
+    let mut type_names = cx.type_cache.type_names.borrow_mut();
+    if type_names.entry(id).or_default().insert(name_key) {
+        cx.emit_global().name(id, name_key.to_string());
+    }
+}
+
 impl SpirvType<'_> {
     /// Note: `Builder::type_*` should be called *nowhere else* but here, to ensure
     /// `CodegenCx::type_defs` stays up-to-date
@@ -266,13 +277,7 @@ impl SpirvType<'_> {
         name_key: TyLayoutNameKey<'tcx>,
     ) -> Word {
         let id = self.def(def_span, cx);
-
-        // Only emit `OpName` if this is the first time we see this name.
-        let mut type_names = cx.type_cache.type_names.borrow_mut();
-        if type_names.entry(id).or_default().insert(name_key) {
-            cx.emit_global().name(id, name_key.to_string());
-        }
-
+        name_type_id(cx, id, name_key);
         id
     }
 

tests/compiletests/ui/lang/abi/transparent.stderr

@@ -1,101 +1,100 @@
 OpCapability Shader
 OpMemoryModel Logical Simple
 OpEntryPoint Vertex %1 "main" %2 %3 %4 %5 %6 %7 %8 %9 %10 %11
-OpName %13 "B"
-OpMemberName %13 0 "0"
-OpName %14 "SomeStruct"
-OpMemberName %14 0 "a"
-OpMemberName %14 1 "b"
-OpMemberName %14 2 "c"
-OpName %15 "C"
-OpMemberName %15 0 "0"
+OpName %13 "BTrans"
+OpName %14 "B"
+OpMemberName %14 0 "0"
+OpName %15 "SomeStruct"
+OpMemberName %15 0 "a"
+OpMemberName %15 1 "b"
+OpMemberName %15 2 "c"
+OpName %16 "C"
+OpMemberName %16 0 "0"
 OpName %2 "a"
 OpName %3 "a_trans"
 OpName %4 "b"
 OpName %5 "b_trans"
-OpName %16 "SomeStruct"
-OpMemberName %16 0 "a"
-OpMemberName %16 1 "b"
-OpMemberName %16 2 "c"
+OpName %17 "SomeStruct"
+OpMemberName %17 0 "a"
+OpMemberName %17 1 "b"
+OpMemberName %17 2 "c"
 OpName %6 "c"
 OpName %7 "c_trans"
 OpName %8 "d"
 OpName %9 "d_trans"
 OpName %10 "e"
 OpName %11 "e_trans"
-OpName %17 "<core::marker::PhantomData<&()> as core::default::Default>::default"
+OpName %18 "<core::marker::PhantomData<&()> as core::default::Default>::default"
 OpDecorate %2 Location 0
 OpDecorate %3 Location 1
 OpDecorate %4 Location 2
 OpDecorate %5 Location 3
-OpMemberDecorate %16 0 Offset 0
-OpMemberDecorate %16 1 Offset 4
-OpMemberDecorate %16 2 Offset 8
+OpMemberDecorate %17 0 Offset 0
+OpMemberDecorate %17 1 Offset 4
+OpMemberDecorate %17 2 Offset 8
 OpDecorate %6 Location 4
 OpDecorate %7 Location 7
 OpDecorate %8 Location 10
 OpDecorate %9 Location 11
 OpDecorate %10 Location 12
 OpDecorate %11 Location 13
-%18 = OpTypeInt 32 0
-%19 = OpTypePointer Output %18
-%20 = OpTypeFloat 32
-%21 = OpTypeVector %20 3
-%13 = OpTypeStruct %21
-%22 = OpTypePointer Output %13
-%14 = OpTypeStruct %18 %20 %21
-%15 = OpTypeStruct %14
-%23 = OpTypePointer Output %15
-%24 = OpTypeVoid
-%25 = OpTypeFunction %24
-%2 = OpVariable  %19  Output
-%26 = OpConstant  %18  0
-%3 = OpVariable  %19  Output
-%27 = OpTypePointer Output %21
+%19 = OpTypeInt 32 0
+%20 = OpTypePointer Output %19
+%21 = OpTypeFloat 32
+%13 = OpTypeVector %21 3
+%14 = OpTypeStruct %13
+%22 = OpTypePointer Output %14
+%23 = OpTypePointer Output %13
+%15 = OpTypeStruct %19 %21 %13
+%16 = OpTypeStruct %15
+%24 = OpTypePointer Output %16
+%25 = OpTypePointer Output %15
+%26 = OpTypeVoid
+%27 = OpTypeFunction %26
+%2 = OpVariable  %20  Output
+%28 = OpConstant  %19  0
+%3 = OpVariable  %20  Output
 %4 = OpVariable  %22  Output
-%28 = OpConstant  %20  0
-%29 = OpConstantComposite  %21  %28 %28 %28
-%5 = OpVariable  %22  Output
-%16 = OpTypeStruct %18 %20 %21
-%30 = OpTypePointer Output %14
-%6 = OpVariable  %23  Output
-%7 = OpVariable  %23  Output
-%8 = OpVariable  %19  Output
-%9 = OpVariable  %19  Output
-%10 = OpVariable  %19  Output
-%11 = OpVariable  %19  Output
-%1 = OpFunction  %24  None %25
+%29 = OpConstant  %21  0
+%30 = OpConstantComposite  %13  %29 %29 %29
+%5 = OpVariable  %23  Output
+%17 = OpTypeStruct %19 %21 %13
+%6 = OpVariable  %24  Output
+%7 = OpVariable  %25  Output
+%8 = OpVariable  %20  Output
+%9 = OpVariable  %20  Output
+%10 = OpVariable  %20  Output
+%11 = OpVariable  %20  Output
+%1 = OpFunction  %26  None %27
 %31 = OpLabel
-OpStore %2 %26
-OpStore %3 %26
-%32 = OpInBoundsAccessChain  %27  %4 %26
-OpStore %32 %29
-%33 = OpInBoundsAccessChain  %27  %5 %26
-OpStore %33 %29
-%34 = OpCompositeConstruct  %16  %26 %28 %29
-%35 = OpInBoundsAccessChain  %30  %6 %26
-%36 = OpCompositeExtract  %18  %34 0
-%37 = OpCompositeExtract  %20  %34 1
-%38 = OpCompositeExtract  %21  %34 2
-%39 = OpCompositeConstruct  %14  %36 %37 %38
-OpStore %35 %39
-%40 = OpCompositeConstruct  %16  %26 %28 %29
-%41 = OpInBoundsAccessChain  %30  %7 %26
-%42 = OpCompositeExtract  %18  %40 0
-%43 = OpCompositeExtract  %20  %40 1
-%44 = OpCompositeExtract  %21  %40 2
-%45 = OpCompositeConstruct  %14  %42 %43 %44
-OpStore %41 %45
-%46 = OpFunctionCall  %24  %17
-OpStore %8 %26
-%47 = OpFunctionCall  %24  %17
-OpStore %9 %26
-OpStore %10 %26
-OpStore %11 %26
+OpStore %2 %28
+OpStore %3 %28
+%32 = OpInBoundsAccessChain  %23  %4 %28
+OpStore %32 %30
+OpStore %5 %30
+%33 = OpCompositeConstruct  %17  %28 %29 %30
+%34 = OpInBoundsAccessChain  %25  %6 %28
+%35 = OpCompositeExtract  %19  %33 0
+%36 = OpCompositeExtract  %21  %33 1
+%37 = OpCompositeExtract  %13  %33 2
+%38 = OpCompositeConstruct  %15  %35 %36 %37
+OpStore %34 %38
+%39 = OpCompositeConstruct  %17  %28 %29 %30
+%40 = OpCompositeExtract  %19  %39 0
+%41 = OpCompositeExtract  %21  %39 1
+%42 = OpCompositeExtract  %13  %39 2
+%43 = OpCompositeConstruct  %15  %40 %41 %42
+OpStore %7 %43
+%44 = OpFunctionCall  %26  %18
+OpStore %8 %28
+%45 = OpFunctionCall  %26  %18
+OpStore %9 %28
+OpStore %10 %28
+OpStore %11 %28
 OpNoLine
 OpReturn
 OpFunctionEnd
-%17 = OpFunction  %24  None %25
-%48 = OpLabel
+%18 = OpFunction  %26  None %27
+%46 = OpLabel
 OpReturn
 OpFunctionEnd