CI fixes

Author: andyleiserson

naga/src/back/msl/writer.rs

@@ -6990,9 +6990,20 @@ mod workgroup_mem_init {
 
             let mut access_stack = AccessStack::new();
 
-            let vars = module.global_variables.iter().filter(|&(handle, var)| {
-                !fun_info[handle].is_empty() && var.space == crate::AddressSpace::WorkGroup
-            });
+            let vars = module
+                .global_variables
+                .iter()
+                .filter(|&(handle, var)| {
+                    !fun_info[handle].is_empty()
+                        && var.space == crate::AddressSpace::WorkGroup
+                        && !self
+                            .unresolved_overrides
+                            .as_ref()
+                            .unwrap()
+                            .global_variables
+                            .contains_key(&handle)
+                })
+                .collect::<Vec<_>>();
 
             for (handle, var) in vars {
                 access_stack.enter(Access::GlobalVariable(handle), |access_stack| {

naga/src/back/pipeline_constants.rs

@@ -13,7 +13,8 @@ use crate::{
     ir,
     proc::{ConstantEvaluator, ConstantEvaluatorError, Emitter, U32EvalError},
     valid::{
-        Capabilities, ModuleInfo, UnresolvedOverrides, ValidationError, ValidationFlags, Validator,
+        Capabilities, FunctionInfo, ModuleInfo, UnresolvedOverrides, ValidationError,
+        ValidationFlags, Validator,
     },
     Arena, Block, Constant, Expression, FastHashMap, Function, Handle, Literal, Module, Override,
     Range, Scalar, Span, Statement, TypeInner, WithSpan,
@@ -59,6 +60,26 @@ pub struct ProcessOverridesOutput<'a> {
     pub unresolved: UnresolvedOverrides,
 }
 
+/// Check the global usage in `fun_info` for any globals affected by unresolved
+/// overrides.
+///
+/// If any is found, returns `Some`, otherwise returns `None`.
+fn check_for_unresolved_global_use<'a>(
+    globals: impl Iterator<Item = (Handle<ir::GlobalVariable>, &'a ir::GlobalVariable)>,
+    unresolved: &UnresolvedOverrides,
+    fun_info: &FunctionInfo,
+) -> Option<Handle<Override>> {
+    for (var_handle, _) in globals {
+        match unresolved.global_variables.get(&var_handle) {
+            Some(&o_handle) if !fun_info[var_handle].is_empty() => {
+                return Some(o_handle);
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
 /// Replace overrides in `module` with constants.
 ///
 /// If no changes are needed, this just returns `Cow::Borrowed`
@@ -325,11 +346,11 @@ pub fn process_overrides<'a>(
     }
 
     // Process functions, taking note of which ones require overrides that were
-    // not specified. Like expressions, callees are guarenteed to appear before
+    // not specified. Like expressions, callees are guaranteed to appear before
     // their callers.
     let mut functions = mem::take(&mut module.functions);
     for (f_handle, function) in functions.iter_mut() {
-        if let Some(o_handle) = process_function(
+        let result = if let Some(o_handle) = process_function(
             &mut module,
             &override_map,
             &unresolved.functions,
@@ -341,6 +362,15 @@ pub fn process_overrides<'a>(
                 function.name,
                 overrides[o_handle].name
             );
+            Some(o_handle)
+        } else {
+            check_for_unresolved_global_use(
+                module.global_variables.iter(),
+                &unresolved,
+                &module_info[f_handle],
+            )
+        };
+        if let Some(o_handle) = result {
             unresolved.functions.insert(f_handle, o_handle);
         }
     }
@@ -367,19 +397,11 @@ pub fn process_overrides<'a>(
         {
             Some(o_handle)
         } else {
-            // See if we use any global variables that are missing overrides.
-            let mut missing = None;
-            for (var_handle, _) in module.global_variables.iter() {
-                let global_use = module_info.get_entry_point(ep_index)[var_handle];
-                match unresolved.global_variables.get(&var_handle) {
-                    Some(&o_handle) if !global_use.is_empty() => {
-                        missing = Some(o_handle);
-                        break;
-                    }
-                    _ => {}
-                }
-            }
-            missing
+            check_for_unresolved_global_use(
+                module.global_variables.iter(),
+                &unresolved,
+                module_info.get_entry_point(ep_index),
+            )
         };
         if let Some(o_handle) = result {
             // We found a missing override that is required by this entry point.

naga/src/valid/mod.rs

@@ -273,7 +273,6 @@ impl ops::Index<Handle<crate::Expression>> for ModuleInfo {
 /// This struct may be passed to the various backend writers.
 ///
 /// [`process_overrides`]: crate::back::pipeline_constants::process_overrides
-#[cfg(any(hlsl_out, msl_out, spv_out, glsl_out))]
 #[derive(Clone, Debug, Default)]
 pub struct UnresolvedOverrides {
     pub(crate) global_variables:

naga/tests/naga/snapshots.rs

@@ -235,6 +235,12 @@ impl Input {
                 return None;
             }
 
+            if let Ok(pat) = std::env::var("NAGA_SNAPSHOT") {
+                if !file_name.to_string_lossy().contains(&pat) {
+                    return None;
+                }
+            }
+
             let input = Input::new(
                 subdirectory,
                 file_name.file_stem().unwrap().to_str().unwrap(),

naga/tests/out/msl/wgsl-missing-unused-overrides.msl

@@ -9,15 +9,6 @@ struct FragmentIn {
 };
 constant float ov_for_vertex = 1.5;
 
-void compute_helper(
-    thread uint& foo,
-    threadgroup type_4& arr
-) {
-    uint phony = foo;
-    uint phony_1 = arr.inner[0];
-    return;
-}
-
 struct vert_mainInput {
     metal::float2 pos [[attribute(0)]];
 };

wgpu-hal/src/dx12/device.rs

@@ -276,7 +276,11 @@ impl super::Device {
 
         let stage_bit = auxil::map_naga_stage(naga_stage);
 
-        let (module, info) = naga::back::pipeline_constants::process_overrides(
+        let naga::back::pipeline_constants::ProcessOverridesOutput {
+            module,
+            info,
+            unresolved: _,
+        } = naga::back::pipeline_constants::process_overrides(
             &stage.module.naga.module,
             &stage.module.naga.info,
             None,