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_array.stderr

@@ -1,73 +1,74 @@
 OpCapability Shader
 OpMemoryModel Logical Simple
 OpEntryPoint Vertex %1 "main" %2 %3 %4
-OpName %6 "A"
-OpMemberName %6 0 "0"
+OpName %6 "AT"
+OpName %7 "A"
+OpMemberName %7 0 "0"
 OpName %2 "tid"
+OpName %8 "AT"
 OpName %3 "a"
 OpName %4 "at"
 OpDecorate %2 BuiltIn LocalInvocationIndex
-OpDecorate %7 ArrayStride 4
+OpDecorate %8 ArrayStride 4
 OpDecorate %3 Location 0
 OpDecorate %4 Location 3
-%8 = OpTypeInt 32 0
-%9 = OpConstant  %8  3
-%10 = OpTypeArray %8 %9
-%6 = OpTypeStruct %10
-%11 = OpTypePointer Output %6
-%12 = OpTypePointer Input %8
-%13 = OpTypeVoid
-%14 = OpTypeFunction %13
-%2 = OpVariable  %12  Input
-%7 = OpTypeArray %8 %9
-%15 = OpConstant  %8  1
-%16 = OpConstant  %8  2
-%17 = OpTypePointer Output %10
+%9 = OpTypeInt 32 0
+%10 = OpConstant  %9  3
+%6 = OpTypeArray %9 %10
+%7 = OpTypeStruct %6
+%11 = OpTypePointer Output %7
+%12 = OpTypePointer Output %6
+%13 = OpTypePointer Input %9
+%14 = OpTypeVoid
+%15 = OpTypeFunction %14
+%2 = OpVariable  %13  Input
+%8 = OpTypeArray %9 %10
+%16 = OpConstant  %9  1
+%17 = OpConstant  %9  2
 %3 = OpVariable  %11  Output
-%18 = OpConstant  %8  0
-%19 = OpTypePointer Output %8
-%20 = OpConstant  %8  4
-%4 = OpVariable  %11  Output
-%21 = OpConstant  %8  5
-%1 = OpFunction  %13  None %14
+%18 = OpConstant  %9  0
+%19 = OpTypePointer Output %9
+%20 = OpConstant  %9  4
+%4 = OpVariable  %12  Output
+%21 = OpConstant  %9  5
+%1 = OpFunction  %14  None %15
 %22 = OpLabel
-%23 = OpLoad  %8  %2
-%24 = OpCompositeConstruct  %7  %23 %15 %16
-%25 = OpInBoundsAccessChain  %17  %3 %18
-%26 = OpCompositeExtract  %8  %24 0
-%27 = OpCompositeExtract  %8  %24 1
-%28 = OpCompositeExtract  %8  %24 2
-%29 = OpCompositeConstruct  %10  %26 %27 %28
+%23 = OpLoad  %9  %2
+%24 = OpCompositeConstruct  %8  %23 %16 %17
+%25 = OpInBoundsAccessChain  %12  %3 %18
+%26 = OpCompositeExtract  %9  %24 0
+%27 = OpCompositeExtract  %9  %24 1
+%28 = OpCompositeExtract  %9  %24 2
+%29 = OpCompositeConstruct  %6  %26 %27 %28
 OpStore %25 %29
 %30 = OpInBoundsAccessChain  %19  %3 %18 %18
 OpStore %30 %23
-%31 = OpInBoundsAccessChain  %19  %3 %18 %15
-OpStore %31 %15
-%32 = OpInBoundsAccessChain  %19  %3 %18 %16
-OpStore %32 %16
-%33 = OpInBoundsAccessChain  %19  %3 %18 %16
-%34 = OpInBoundsAccessChain  %19  %3 %18 %16
-%35 = OpLoad  %8  %34
-%36 = OpIAdd  %8  %35 %20
+%31 = OpInBoundsAccessChain  %19  %3 %18 %16
+OpStore %31 %16
+%32 = OpInBoundsAccessChain  %19  %3 %18 %17
+OpStore %32 %17
+%33 = OpInBoundsAccessChain  %19  %3 %18 %17
+%34 = OpInBoundsAccessChain  %19  %3 %18 %17
+%35 = OpLoad  %9  %34
+%36 = OpIAdd  %9  %35 %20
 OpStore %33 %36
-%37 = OpCompositeConstruct  %7  %23 %15 %16
-%38 = OpInBoundsAccessChain  %17  %4 %18
-%39 = OpCompositeExtract  %8  %37 0
-%40 = OpCompositeExtract  %8  %37 1
-%41 = OpCompositeExtract  %8  %37 2
-%42 = OpCompositeConstruct  %10  %39 %40 %41
-OpStore %38 %42
-%43 = OpInBoundsAccessChain  %19  %4 %18 %18
-OpStore %43 %23
-%44 = OpInBoundsAccessChain  %19  %4 %18 %15
-OpStore %44 %15
-%45 = OpInBoundsAccessChain  %19  %4 %18 %16
-OpStore %45 %16
-%46 = OpInBoundsAccessChain  %19  %4 %18 %16
-%47 = OpInBoundsAccessChain  %19  %4 %18 %16
-%48 = OpLoad  %8  %47
-%49 = OpIAdd  %8  %48 %21
-OpStore %46 %49
+%37 = OpCompositeConstruct  %8  %23 %16 %17
+%38 = OpCompositeExtract  %9  %37 0
+%39 = OpCompositeExtract  %9  %37 1
+%40 = OpCompositeExtract  %9  %37 2
+%41 = OpCompositeConstruct  %6  %38 %39 %40
+OpStore %4 %41
+%42 = OpInBoundsAccessChain  %19  %4 %18
+OpStore %42 %23
+%43 = OpInBoundsAccessChain  %19  %4 %16
+OpStore %43 %16
+%44 = OpInBoundsAccessChain  %19  %4 %17
+OpStore %44 %17
+%45 = OpInBoundsAccessChain  %19  %4 %17
+%46 = OpInBoundsAccessChain  %19  %4 %17
+%47 = OpLoad  %9  %46
+%48 = OpIAdd  %9  %47 %21
+OpStore %45 %48
 OpNoLine
 OpReturn
 OpFunctionEnd

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

@@ -1,72 +1,70 @@
 OpCapability Shader
 OpMemoryModel Logical Simple
 OpEntryPoint Vertex %1 "main" %2 %3 %4
-OpName %7 "A"
-OpMemberName %7 0 "0"
-OpName %8 "B"
+OpName %7 "AT"
+OpName %8 "A"
 OpMemberName %8 0 "0"
-OpName %2 "tid"
-OpName %9 "A"
+OpName %9 "B"
 OpMemberName %9 0 "0"
-OpName %10 "B"
+OpName %2 "tid"
+OpName %10 "A"
 OpMemberName %10 0 "0"
+OpName %11 "B"
+OpMemberName %11 0 "0"
 OpName %3 "a"
 OpName %4 "at"
 OpDecorate %2 BuiltIn LocalInvocationIndex
-OpMemberDecorate %9 0 Offset 0
 OpMemberDecorate %10 0 Offset 0
+OpMemberDecorate %11 0 Offset 0
 OpDecorate %3 Location 0
 OpDecorate %4 Location 1
-%11 = OpTypeInt 32 0
-%12 = OpTypeVector %11 3
-%7 = OpTypeStruct %12
+%12 = OpTypeInt 32 0
+%7 = OpTypeVector %12 3
 %8 = OpTypeStruct %7
-%13 = OpTypePointer Output %8
-%14 = OpTypePointer Input %11
-%15 = OpTypeVoid
-%16 = OpTypeFunction %15
-%2 = OpVariable  %14  Input
-%17 = OpConstant  %11  1
-%18 = OpConstant  %11  2
-%9 = OpTypeStruct %12
-%10 = OpTypeStruct %9
-%19 = OpUndef  %10
-%20 = OpTypePointer Output %12
+%9 = OpTypeStruct %8
+%13 = OpTypePointer Output %9
+%14 = OpTypePointer Output %7
+%15 = OpTypePointer Input %12
+%16 = OpTypeVoid
+%17 = OpTypeFunction %16
+%2 = OpVariable  %15  Input
+%18 = OpConstant  %12  1
+%19 = OpConstant  %12  2
+%10 = OpTypeStruct %7
+%11 = OpTypeStruct %10
+%20 = OpUndef  %11
 %3 = OpVariable  %13  Output
-%21 = OpConstant  %11  0
-%22 = OpTypePointer Output %11
-%23 = OpConstant  %11  4
-%4 = OpVariable  %13  Output
-%24 = OpConstant  %11  5
-%1 = OpFunction  %15  None %16
+%21 = OpConstant  %12  0
+%22 = OpTypePointer Output %12
+%23 = OpConstant  %12  4
+%4 = OpVariable  %14  Output
+%24 = OpConstant  %12  5
+%1 = OpFunction  %16  None %17
 %25 = OpLabel
-%26 = OpLoad  %11  %2
-%27 = OpCompositeConstruct  %12  %26 %17 %18
-%28 = OpCompositeInsert  %10  %27 %19 0 0
-%29 = OpInBoundsAccessChain  %20  %3 %21 %21
-%30 = OpCompositeExtract  %12  %28 0 0
+%26 = OpLoad  %12  %2
+%27 = OpCompositeConstruct  %7  %26 %18 %19
+%28 = OpCompositeInsert  %11  %27 %20 0 0
+%29 = OpInBoundsAccessChain  %14  %3 %21 %21
+%30 = OpCompositeExtract  %7  %28 0 0
 OpStore %29 %30
-%31 = OpInBoundsAccessChain  %22  %3 %21 %21 %17
-%32 = OpIAdd  %11  %26 %17
+%31 = OpInBoundsAccessChain  %22  %3 %21 %21 %18
+%32 = OpIAdd  %12  %26 %18
 OpStore %31 %32
 %33 = OpInBoundsAccessChain  %22  %3 %21 %21 %21
-%34 = OpLoad  %11  %33
-%35 = OpIAdd  %11  %34 %23
+%34 = OpLoad  %12  %33
+%35 = OpIAdd  %12  %34 %23
 %36 = OpInBoundsAccessChain  %22  %3 %21 %21 %21
 OpStore %36 %35
-%37 = OpCompositeConstruct  %12  %26 %17 %18
-%38 = OpCompositeInsert  %10  %37 %19 0 0
-%39 = OpInBoundsAccessChain  %20  %4 %21 %21
-%40 = OpCompositeExtract  %12  %38 0 0
-OpStore %39 %40
-%41 = OpInBoundsAccessChain  %22  %4 %21 %21 %17
-%42 = OpIAdd  %11  %26 %18
-OpStore %41 %42
-%43 = OpInBoundsAccessChain  %22  %4 %21 %21 %21
-%44 = OpLoad  %11  %43
-%45 = OpIAdd  %11  %44 %24
-%46 = OpInBoundsAccessChain  %22  %4 %21 %21 %21
-OpStore %46 %45
+%37 = OpCompositeConstruct  %7  %26 %18 %19
+OpStore %4 %37
+%38 = OpInBoundsAccessChain  %22  %4 %18
+%39 = OpIAdd  %12  %26 %19
+OpStore %38 %39
+%40 = OpInBoundsAccessChain  %22  %4 %21
+%41 = OpLoad  %12  %40
+%42 = OpIAdd  %12  %41 %24
+%43 = OpInBoundsAccessChain  %22  %4 %21
+OpStore %43 %42
 OpNoLine
 OpReturn
 OpFunctionEnd