black_box: Fix pair and add disasembly compiletest

Author: LegNeato

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -250,20 +250,13 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
                 let llty = layout.spirv_type(self.span(), self);
 
                 match args[0].val {
-                    // Pass through scalars
+                    // Scalars pass through unchanged
                     OperandValue::Immediate(v) => v,
-
-                    // Preserve both elements by spilling + reloading
-                    OperandValue::Pair(..) => {
-                        let tmp = self.alloca(layout.size, layout.align.abi);
-                        self.store(args[0].immediate(), tmp, layout.align.abi);
-                        self.load(llty, tmp, layout.align.abi)
-                    }
-
-                    // For lvalues, load
+                    // Pack scalar pairs to a single SSA aggregate
+                    OperandValue::Pair(..) => args[0].immediate_or_packed_pair(self),
+                    // Lvalues get loaded
                     OperandValue::Ref(place) => self.load(llty, place.llval, place.align),
-
-                    // For ZSTs, return undef of the right type
+                    // ZSTs become undef of the right type
                     OperandValue::ZeroSized => self.undef(llty),
                 }
             }

tests/compiletests/ui/lang/core/intrinsics/black_box.rs

@@ -1,41 +1,47 @@
-// Test black_box intrinsic
 // build-pass
 // compile-flags: -C llvm-args=--disassemble-fn=black_box::disassemble
-
-#![allow(internal_features)]
-#![feature(core_intrinsics)]
 #![no_std]
 
 use core::hint::black_box;
 use spirv_std::spirv;
 
+// Minimal kernel that writes the disassembly function result to a buffer
 #[spirv(compute(threads(1)))]
 pub fn main(#[spirv(descriptor_set = 0, binding = 0, storage_buffer)] out: &mut [u32]) {
-    let result = disassemble();
-    for i in 0..result.len() {
-        out[i] = result[i];
+    let r = disassemble();
+    for i in 0..r.len() {
+        out[i] = r[i];
     }
 }
 
+#[inline(never)]
 pub fn disassemble() -> [u32; 12] {
-    // Test with various types
     let x = 42i32;
+    // Immediate: integer scalar passes through unchanged
     let y = black_box(x);
 
     let a = 3.14f32;
+    // Immediate: float scalar passes through unchanged
     let b = black_box(a);
 
-    let v = [1, 2, 3, 4];
+    let v = [1u32, 2, 3, 4];
+    // Ref: non-immediate aggregate is loaded from memory
     let w = black_box(v);
 
-    // Test in expressions
+    // Immediate: constants are immediates
     let result = black_box(10) + black_box(20);
 
-    // Test with references
     let data = 100u32;
+    // Immediate (pointer): reference value is an immediate scalar pointer
     let ref_data = black_box(&data);
 
-    let ref_slice = black_box(v.as_slice());
+    // Pair: two-element tuple packs into a single SSA aggregate
+    let pair = (5u32, 6u32);
+    let pair_bb = black_box(pair);
+    let pair_sum = pair_bb.0 + pair_bb.1;
+
+    // ZeroSized: unit type becomes `undef` of the right type
+    let _z = black_box(());
 
     [
         y as u32,
@@ -46,9 +52,9 @@ pub fn disassemble() -> [u32; 12] {
         w[3],
         result,
         *ref_data,
-        ref_slice[0],
-        ref_slice[1],
-        ref_slice[2],
-        ref_slice[3],
+        pair_sum,
+        0,
+        0,
+        0,
     ]
 }

tests/compiletests/ui/lang/core/intrinsics/black_box.stderr

@@ -1,17 +1,19 @@
 warning: black_box intrinsic does not prevent optimization in Rust GPU
 
-%1 = OpFunction  %2  None %3
+%1 = OpFunction  %2  DontInline %3
 %4 = OpLabel
-OpLine %5 34 17
+OpLine %5 32 17
 %6 = OpIAdd  %7  %8 %9
-OpLine %5 40 5
-%10 = OpBitcast  %7  %11
-OpLine %12 1092 17
+OpLine %5 41 19
+%10 = OpIAdd  %7  %11 %12
+OpLine %5 47 8
 %13 = OpBitcast  %7  %14
-OpLine %5 40 4
-%15 = OpCompositeConstruct  %2  %10 %13 %16 %17 %18 %19 %6 %20
+OpLine %15 1092 17
+%16 = OpBitcast  %7  %17
+OpLine %5 46 4
+%18 = OpCompositeConstruct  %2  %13 %16 %19 %20 %21 %22 %6 %23 %10 %24 %24 %24
 OpNoLine
-OpReturnValue %15
+OpReturnValue %18
 OpFunctionEnd
 warning: 1 warning emitted