Merge branch 'Rust-GPU:main' into main

Author: voxelbee

.github/workflows/ci.yaml

@@ -13,13 +13,15 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
   cancel-in-progress: true
 
+permissions: {}
+
 jobs:
   test:
     name: Test
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-24.04, windows-2022, macOS-latest ]
+        os: [ ubuntu-latest, windows-latest, macOS-latest ]
     runs-on: ${{ matrix.os }}
     env:
       RUSTUP_UNPACK_RAM: "26214400"
@@ -79,7 +81,7 @@ jobs:
     name: Android
     strategy:
       matrix:
-        os: [ ubuntu-24.04 ]
+        os: [ ubuntu-latest ]
         target: [ aarch64-linux-android ]
     runs-on: ${{ matrix.os }}
     env:
@@ -127,7 +129,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-24.04, windows-2022, macOS-latest ]
+        os: [ ubuntu-latest, windows-latest, macOS-latest ]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
@@ -150,7 +152,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-24.04, windows-2022, macOS-latest ]
+        os: [ ubuntu-latest, windows-latest, macOS-latest ]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
@@ -161,16 +163,8 @@ jobs:
           install_runtime: true
           cache: true
           stripdown: true
-
-          # FIXME(eddyb) consider using lavapipe instead, or even trying both.
-          install_swiftshader: true
-          # install_lavapipe: true
-      - if: ${{ runner.os == 'Windows' }}
-        name: Windows - Use SwiftShader as Vulkan driver
-        # FIXME(eddyb) ideally `jakoch/install-vulkan-sdk-action` should do this.
-        run: |
-          echo "C:/Swiftshader/" >> "$GITHUB_PATH"
-          echo "VK_DRIVER_FILES=C:/Swiftshader/vk_swiftshader_icd.json" >> "$GITHUB_ENV"
+          install_lavapipe: true
+          github_token: ${{ secrets.GITHUB_TOKEN }}
       - if: ${{ runner.os == 'Linux' }}
         name: Linux - Install native dependencies
         run: sudo apt install libwayland-cursor0 libxkbcommon-dev libwayland-dev
@@ -195,7 +189,7 @@ jobs:
   # This allows us to have a single job we can branch protect on, rather than needing
   # to update the branch protection rules when the test matrix changes
   test_success:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
     needs: [test, compiletest, difftest, android, lint, cargo-deny]
     # Hack for buggy GitHub Actions behavior with skipped checks: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/collaborating-on-repositories-with-code-quality-features/troubleshooting-required-status-checks#handling-skipped-but-required-checks
     if: ${{ always() }}
@@ -212,7 +206,7 @@ jobs:
 
   lint:
     name: Lint
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
     steps:
       # Note that we are explicitly NOT checking out submodules, to validate
       # that we haven't accidentally enabled spirv-tools native compilation
@@ -254,7 +248,7 @@ jobs:
         run: .github/workflows/lint.sh
 
   cargo-deny:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - uses: EmbarkStudios/cargo-deny-action@v2

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -9,7 +9,7 @@ use crate::builder_spirv::{SpirvFunctionCursor, SpirvValue, SpirvValueExt};
 use crate::spirv_type::SpirvType;
 use rspirv::dr::Operand;
 use rspirv::spirv::{
-    Capability, Decoration, Dim, ExecutionModel, FunctionControl, StorageClass, Word,
+    BuiltIn, Capability, Decoration, Dim, ExecutionModel, FunctionControl, StorageClass, Word,
 };
 use rustc_abi::FieldsShape;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods, MiscCodegenMethods as _};
@@ -722,8 +722,9 @@ impl<'tcx> CodegenCx<'tcx> {
             Ok(StorageClass::Input | StorageClass::Output | StorageClass::UniformConstant)
         );
         let mut assign_location = |var_id: Result<Word, &str>, explicit: Option<u32>| {
+            let storage_class = storage_class.unwrap();
             let location = decoration_locations
-                .entry(storage_class.unwrap())
+                .entry(storage_class)
                 .or_insert_with(|| 0);
             if let Some(explicit) = explicit {
                 *location = explicit;
@@ -733,7 +734,46 @@ impl<'tcx> CodegenCx<'tcx> {
                 Decoration::Location,
                 std::iter::once(Operand::LiteralBit32(*location)),
             );
-            let spirv_type = self.lookup_type(value_spirv_type);
+            let mut spirv_type = self.lookup_type(value_spirv_type);
+
+            // These shader types and storage classes skip the outer array or pointer of the declaration when computing
+            // the location layout, see bug at https://github.com/Rust-GPU/rust-gpu/issues/500.
+            //
+            // The match statment follows the rules at:
+            // https://registry.khronos.org/vulkan/specs/latest/html/vkspec.html#interfaces-iointerfaces-matching
+            #[allow(clippy::match_same_arms)]
+            let can_skip_outer_array =
+                match (execution_model, storage_class, attrs.per_primitive_ext) {
+                    // > if the input is declared in a tessellation control or geometry shader...
+                    (
+                        ExecutionModel::TessellationControl | ExecutionModel::Geometry,
+                        StorageClass::Input,
+                        _,
+                    ) => true,
+                    // > if the maintenance4 feature is enabled, they are declared as OpTypeVector variables, and the
+                    // > output has a Component Count value higher than that of the input but the same Component Type
+                    // Irrelevant: This allows a vertex shader to output a Vec4 and a fragment shader to accept a vector
+                    // type with fewer components, like Vec3, Vec2 (or f32?). Which has no influence on locations.
+                    // > if the output is declared in a mesh shader...
+                    (ExecutionModel::MeshEXT | ExecutionModel::MeshNV, StorageClass::Output, _) => {
+                        true
+                    }
+                    // > if the input is decorated with PerVertexKHR, and is declared in a fragment shader...
+                    (ExecutionModel::Fragment, StorageClass::Input, Some(_)) => true,
+                    // > if in any other case...
+                    (_, _, _) => false,
+                };
+            if can_skip_outer_array {
+                spirv_type = match spirv_type {
+                    SpirvType::Array { element, .. }
+                    | SpirvType::RuntimeArray { element, .. }
+                    | SpirvType::Pointer {
+                        pointee: element, ..
+                    } => self.lookup_type(element),
+                    e => e,
+                };
+            }
+
             if let Some(location_size) = spirv_type.location_size(self) {
                 *location += location_size;
             } else {
@@ -916,6 +956,11 @@ impl<'tcx> CodegenCx<'tcx> {
             );
         }
 
+        // Check builtin-specific type requirements.
+        if let Some(builtin) = attrs.builtin {
+            self.check_builtin_type(hir_param.ty_span, value_layout.ty, builtin);
+        }
+
         if let Ok(storage_class) = storage_class {
             self.check_for_bad_types(
                 execution_model,
@@ -1083,4 +1128,15 @@ impl<'tcx> CodegenCx<'tcx> {
             }
         }
     }
+
+    /// Check that builtin variables have the correct type.
+    fn check_builtin_type(&self, span: Span, rust_ty: Ty<'tcx>, builtin: Spanned<BuiltIn>) {
+        // LocalInvocationIndex must be a u32.
+        if builtin.value == BuiltIn::LocalInvocationIndex && rust_ty != self.tcx.types.u32 {
+            self.tcx.dcx().span_err(
+                span,
+                format!("`#[spirv(local_invocation_index)]` must be a `u32`, not `{rust_ty}`"),
+            );
+        }
+    }
 }

crates/rustc_codegen_spirv/src/linker/dce.rs

@@ -282,7 +282,15 @@ fn instruction_is_pure(inst: &Instruction) -> bool {
         | PtrEqual
         | PtrNotEqual
         | PtrDiff => true,
-        Variable => inst.operands.first() == Some(&Operand::StorageClass(StorageClass::Function)),
+        // Variables with Function or Private storage class are pure and can be DCE'd if unused.
+        // Other storage classes (Input, Output, Uniform, etc.) are part of the shader interface
+        // and must be kept.
+        Variable => matches!(
+            inst.operands.first(),
+            Some(&Operand::StorageClass(
+                StorageClass::Function | StorageClass::Private
+            ))
+        ),
         _ => false,
     }
 }

crates/rustc_codegen_spirv/src/linker/mod.rs

@@ -415,6 +415,16 @@ pub fn link(
         inline::inline(sess, &mut output)?;
     }
 
+    // Fold OpLoad from Private/Function variables with constant initializers.
+    // This must run after inlining (which may expose such patterns) and before DCE
+    // (so that the now-unused variables can be removed).
+    // This is critical for pointer-to-pointer patterns like `&&123` which would
+    // otherwise generate invalid SPIR-V in Logical addressing mode.
+    {
+        let _timer = sess.timer("link_fold_load_from_constant_variable");
+        peephole_opts::fold_load_from_constant_variable(&mut output);
+    }
+
     {
         let _timer = sess.timer("link_dce-after-inlining");
         dce::dce(&mut output);

crates/rustc_codegen_spirv/src/linker/peephole_opts.rs

@@ -606,3 +606,77 @@ pub fn bool_fusion(
     }
     super::apply_rewrite_rules(&rewrite_rules, &mut function.blocks);
 }
+
+/// Fold `OpLoad` from Private/Function storage class variables that have constant initializers.
+///
+/// This optimization handles patterns like:
+/// ```text
+/// %ptr = OpVariable %_ptr_Private_T Private %initializer
+/// %val = OpLoad %T %ptr
+/// ```
+/// After this optimization, uses of `%val` are replaced with `%initializer`.
+///
+/// This is particularly important for pointer-to-pointer constants (e.g., `&&123`)
+/// where the outer pointer variable has a known initializer (the inner pointer).
+/// Without this optimization, such patterns generate invalid SPIR-V in Logical
+/// addressing mode (pointer-to-pointer with Private storage class is not allowed).
+pub fn fold_load_from_constant_variable(module: &mut Module) {
+    use rspirv::spirv::StorageClass;
+
+    // Build a map of variable ID -> initializer ID for Private/Function variables
+    // that have constant initializers.
+    let var_initializers: FxHashMap<Word, Word> = module
+        .types_global_values
+        .iter()
+        .filter_map(|inst| {
+            if inst.class.opcode != Op::Variable {
+                return None;
+            }
+            // Check storage class - only Private and Function can be folded
+            let storage_class = inst.operands.first()?.unwrap_storage_class();
+            if !matches!(
+                storage_class,
+                StorageClass::Private | StorageClass::Function
+            ) {
+                return None;
+            }
+            // Check for initializer (second operand after storage class)
+            let initializer = inst.operands.get(1)?.id_ref_any()?;
+            Some((inst.result_id?, initializer))
+        })
+        .collect();
+
+    if var_initializers.is_empty() {
+        return;
+    }
+
+    // Rewrite OpLoad instructions that load from variables with known initializers
+    let mut rewrite_rules: FxHashMap<Word, Word> = FxHashMap::default();
+
+    for func in &mut module.functions {
+        for block in &mut func.blocks {
+            for inst in &mut block.instructions {
+                if inst.class.opcode != Op::Load {
+                    continue;
+                }
+                // OpLoad has pointer as first operand
+                let ptr_id = inst.operands[0].unwrap_id_ref();
+                if let Some(&initializer) = var_initializers.get(&ptr_id) {
+                    // This load can be replaced with the initializer value
+                    if let Some(result_id) = inst.result_id {
+                        rewrite_rules.insert(result_id, initializer);
+                        // Turn this instruction into a Nop
+                        *inst = Instruction::new(Op::Nop, None, None, Vec::new());
+                    }
+                }
+            }
+        }
+    }
+
+    if !rewrite_rules.is_empty() {
+        // Apply rewrite rules to all functions
+        for func in &mut module.functions {
+            super::apply_rewrite_rules(&rewrite_rules, &mut func.blocks);
+        }
+    }
+}

tests/compiletests/ui/arch/shared/dce_shared.rs

@@ -21,10 +21,10 @@ pub fn main(
     #[spirv(descriptor_set = 0, binding = 1, storage_buffer)] output: &mut f32,
     #[spirv(workgroup)] used_shared: &mut f32,
     #[spirv(workgroup)] dce_shared: &mut [i32; 2],
-    #[spirv(local_invocation_index)] inv_id: UVec3,
+    #[spirv(local_invocation_index)] inv_id: u32,
 ) {
     unsafe {
-        let inv_id = inv_id.x as usize;
+        let inv_id = inv_id as usize;
         if inv_id == 0 {
             *used_shared = *input;
         }

tests/compiletests/ui/arch/shared/dce_shared.stderr

@@ -20,16 +20,15 @@ OpDecorate %4 BuiltIn LocalInvocationIndex
 %11 = OpTypePointer Workgroup %9
 %12 = OpTypeInt 32 0
 %13 = OpConstant  %12  2
-%14 = OpTypeVector %12 3
-%15 = OpTypePointer Input %14
-%16 = OpTypeVoid
-%17 = OpTypeFunction %16
-%18 = OpTypePointer StorageBuffer %9
+%14 = OpTypePointer Input %12
+%15 = OpTypeVoid
+%16 = OpTypeFunction %15
+%17 = OpTypePointer StorageBuffer %9
 %2 = OpVariable  %10  StorageBuffer
-%19 = OpConstant  %12  0
+%18 = OpConstant  %12  0
 %3 = OpVariable  %10  StorageBuffer
-%4 = OpVariable  %15  Input
-%20 = OpTypeBool
+%4 = OpVariable  %14  Input
+%19 = OpTypeBool
 %5 = OpVariable  %11  Workgroup
-%21 = OpConstant  %12  264
-%22 = OpConstant  %12  1
+%20 = OpConstant  %12  264
+%21 = OpConstant  %12  1

tests/compiletests/ui/arch/shared/reduction_array.rs

@@ -57,10 +57,10 @@ pub fn main(
     #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] input: &[Value],
     #[spirv(descriptor_set = 0, binding = 1, storage_buffer)] output: &mut Value,
     #[spirv(workgroup)] shared: &mut [Value; WG_SIZE],
-    #[spirv(local_invocation_index)] inv_id: UVec3,
+    #[spirv(local_invocation_index)] inv_id: u32,
 ) {
     unsafe {
-        let inv_id = inv_id.x as usize;
+        let inv_id = inv_id as usize;
         shared[inv_id] = input[inv_id];
         workgroup_memory_barrier_with_group_sync();
 

tests/compiletests/ui/arch/shared/reduction_big_struct.rs

@@ -65,10 +65,10 @@ pub fn main(
     #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] input: &[Value],
     #[spirv(descriptor_set = 0, binding = 1, storage_buffer)] output: &mut Value,
     #[spirv(workgroup)] shared: &mut [Value; WG_SIZE],
-    #[spirv(local_invocation_index)] inv_id: UVec3,
+    #[spirv(local_invocation_index)] inv_id: u32,
 ) {
     unsafe {
-        let inv_id = inv_id.x as usize;
+        let inv_id = inv_id as usize;
         shared[inv_id] = input[inv_id];
         workgroup_memory_barrier_with_group_sync();
 

tests/compiletests/ui/arch/shared/reduction_u32.rs

@@ -22,10 +22,10 @@ pub fn main(
     #[spirv(descriptor_set = 0, binding = 0, storage_buffer)] input: &[Value],
     #[spirv(descriptor_set = 0, binding = 1, storage_buffer)] output: &mut Value,
     #[spirv(workgroup)] shared: &mut [Value; WG_SIZE],
-    #[spirv(local_invocation_index)] inv_id: UVec3,
+    #[spirv(local_invocation_index)] inv_id: u32,
 ) {
     unsafe {
-        let inv_id = inv_id.x as usize;
+        let inv_id = inv_id as usize;
         shared[inv_id] = input[inv_id];
         workgroup_memory_barrier_with_group_sync();