Adding upstream version 127.0.upstream/127.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 20 insertions, 7 deletions

diff --git a/third_party/rust/naga/src/compact/expressions.rs b/third_party/rust/naga/src/compact/expressions.rs
index 301bbe3240..a418bde301 100644
--- a/third_party/rust/naga/src/compact/expressions.rs
+++ b/third_party/rust/naga/src/compact/expressions.rs
@@ -3,6 +3,7 @@ use crate::arena::{Arena, Handle};
 
 pub struct ExpressionTracer<'tracer> {
     pub constants: &'tracer Arena<crate::Constant>,
+    pub overrides: &'tracer Arena<crate::Override>,
 
     /// The arena in which we are currently tracing expressions.
     pub expressions: &'tracer Arena<crate::Expression>,
@@ -20,11 +21,11 @@ pub struct ExpressionTracer<'tracer> {
     /// the module's constant expression arena.
     pub expressions_used: &'tracer mut HandleSet<crate::Expression>,
 
-    /// The used set for the module's `const_expressions` arena.
+    /// The used set for the module's `global_expressions` arena.
     ///
     /// If `None`, we are already tracing the constant expressions,
     /// and `expressions_used` already refers to their handle set.
-    pub const_expressions_used: Option<&'tracer mut HandleSet<crate::Expression>>,
+    pub global_expressions_used: Option<&'tracer mut HandleSet<crate::Expression>>,
 }
 
 impl<'tracer> ExpressionTracer<'tracer> {
@@ -39,11 +40,11 @@ impl<'tracer> ExpressionTracer<'tracer> {
     /// marked.
     ///
     /// [fe]: crate::Function::expressions
-    /// [ce]: crate::Module::const_expressions
+    /// [ce]: crate::Module::global_expressions
     pub fn trace_expressions(&mut self) {
         log::trace!(
             "entering trace_expression of {}",
-            if self.const_expressions_used.is_some() {
+            if self.global_expressions_used.is_some() {
                 "function expressions"
             } else {
                 "const expressions"
@@ -71,6 +72,7 @@ impl<'tracer> ExpressionTracer<'tracer> {
                 | Ex::GlobalVariable(_)
                 | Ex::LocalVariable(_)
                 | Ex::CallResult(_)
+                | Ex::SubgroupBallotResult
                 | Ex::RayQueryProceedResult => {}
 
                 Ex::Constant(handle) => {
@@ -83,11 +85,16 @@ impl<'tracer> ExpressionTracer<'tracer> {
                     // and the constant refers to the initializer, it must
                     // precede `expr` in the arena.
                     let init = self.constants[handle].init;
-                    match self.const_expressions_used {
+                    match self.global_expressions_used {
                         Some(ref mut used) => used.insert(init),
                         None => self.expressions_used.insert(init),
                     }
                 }
+                Ex::Override(_) => {
+                    // All overrides are considered used by definition. We mark
+                    // their types and initialization expressions as used in
+                    // `compact::compact`, so we have no more work to do here.
+                }
                 Ex::ZeroValue(ty) => self.types_used.insert(ty),
                 Ex::Compose { ty, ref components } => {
                     self.types_used.insert(ty);
@@ -116,7 +123,7 @@ impl<'tracer> ExpressionTracer<'tracer> {
                     self.expressions_used
                         .insert_iter([image, sampler, coordinate]);
                     self.expressions_used.insert_iter(array_index);
-                    match self.const_expressions_used {
+                    match self.global_expressions_used {
                         Some(ref mut used) => used.insert_iter(offset),
                         None => self.expressions_used.insert_iter(offset),
                     }
@@ -186,6 +193,7 @@ impl<'tracer> ExpressionTracer<'tracer> {
                 Ex::AtomicResult { ty, comparison: _ } => self.types_used.insert(ty),
                 Ex::WorkGroupUniformLoadResult { ty } => self.types_used.insert(ty),
                 Ex::ArrayLength(expr) => self.expressions_used.insert(expr),
+                Ex::SubgroupOperationResult { ty } => self.types_used.insert(ty),
                 Ex::RayQueryGetIntersection {
                     query,
                     committed: _,
@@ -217,8 +225,12 @@ impl ModuleMap {
             | Ex::GlobalVariable(_)
             | Ex::LocalVariable(_)
             | Ex::CallResult(_)
+            | Ex::SubgroupBallotResult
             | Ex::RayQueryProceedResult => {}
 
+            // All overrides are retained, so their handles never change.
+            Ex::Override(_) => {}
+
             // Expressions that contain handles that need to be adjusted.
             Ex::Constant(ref mut constant) => self.constants.adjust(constant),
             Ex::ZeroValue(ref mut ty) => self.types.adjust(ty),
@@ -267,7 +279,7 @@ impl ModuleMap {
                 adjust(coordinate);
                 operand_map.adjust_option(array_index);
                 if let Some(ref mut offset) = *offset {
-                    self.const_expressions.adjust(offset);
+                    self.global_expressions.adjust(offset);
                 }
                 self.adjust_sample_level(level, operand_map);
                 operand_map.adjust_option(depth_ref);
@@ -344,6 +356,7 @@ impl ModuleMap {
                 comparison: _,
             } => self.types.adjust(ty),
             Ex::WorkGroupUniformLoadResult { ref mut ty } => self.types.adjust(ty),
+            Ex::SubgroupOperationResult { ref mut ty } => self.types.adjust(ty),
             Ex::ArrayLength(ref mut expr) => adjust(expr),
             Ex::RayQueryGetIntersection {
                 ref mut query,