github/wgpu
1
1
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2026-04-22 03:02:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

rename ExpressionConstnessTracker to ExpressionKindTracker

Browse Source
This commit is contained in:
teoxoy
2024-02-14 15:20:29 +01:00
committed by Teodor Tanasoaia
parent d6ebd88f42
commit fa5406fbb9
10 changed files with 53 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
naga/src/back/pipeline_constants.rs
View File

@@ -36,7 +36,7 @@ pub(super) fn process_overrides<'a>(
let mut adjusted_const_expressions = Vec::with_capacity(module.const_expressions.len());
let mut adjusted_constant_initializers = HashSet::with_capacity(module.constants.len());
let mut global_expression_kind_tracker = crate::proc::ExpressionConstnessTracker::new();
let mut global_expression_kind_tracker = crate::proc::ExpressionKindTracker::new();
let mut override_iter = module.overrides.drain();
@@ -123,7 +123,7 @@ fn process_override(
override_map: &mut Vec<Handle<Constant>>,
adjusted_const_expressions: &[Handle<Expression>],
adjusted_constant_initializers: &mut HashSet<Handle<Constant>>,
global_expression_kind_tracker: &mut crate::proc::ExpressionConstnessTracker,
global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker,
) -> Result<Handle<Constant>, PipelineConstantError> {
let key = if let Some(id) = override_.id {
Cow::Owned(id.to_string())

8
naga/src/front/glsl/context.rs
View File

@@ -78,9 +78,9 @@ pub struct Context<'a> {
pub module: &'a mut crate::Module,
pub is_const: bool,
/// Tracks the expression kind of `Expression`s residing in `self.expressions`
pub local_expression_kind_tracker: crate::proc::ExpressionConstnessTracker,
pub local_expression_kind_tracker: crate::proc::ExpressionKindTracker,
/// Tracks the expression kind of `Expression`s residing in `self.module.const_expressions`
pub global_expression_kind_tracker: &'a mut crate::proc::ExpressionConstnessTracker,
pub global_expression_kind_tracker: &'a mut crate::proc::ExpressionKindTracker,
}
impl<'a> Context<'a> {
@@ -88,7 +88,7 @@ impl<'a> Context<'a> {
frontend: &Frontend,
module: &'a mut crate::Module,
is_const: bool,
global_expression_kind_tracker: &'a mut crate::proc::ExpressionConstnessTracker,
global_expression_kind_tracker: &'a mut crate::proc::ExpressionKindTracker,
) -> Result<Self> {
let mut this = Context {
expressions: Arena::new(),
@@ -108,7 +108,7 @@ impl<'a> Context<'a> {
body: Block::new(),
module,
is_const: false,
local_expression_kind_tracker: crate::proc::ExpressionConstnessTracker::new(),
local_expression_kind_tracker: crate::proc::ExpressionKindTracker::new(),
global_expression_kind_tracker,
};

4
naga/src/front/glsl/parser.rs
View File

@@ -164,7 +164,7 @@ impl<'source> ParsingContext<'source> {
pub fn parse(&mut self, frontend: &mut Frontend) -> Result<Module> {
let mut module = Module::default();
let mut global_expression_kind_tracker = crate::proc::ExpressionConstnessTracker::new();
let mut global_expression_kind_tracker = crate::proc::ExpressionKindTracker::new();
// Body and expression arena for global initialization
let mut ctx = Context::new(
@@ -229,7 +229,7 @@ impl<'source> ParsingContext<'source> {
&mut self,
frontend: &mut Frontend,
module: &mut Module,
global_expression_kind_tracker: &mut crate::proc::ExpressionConstnessTracker,
global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker,
) -> Result<(Handle<Expression>, Span)> {
let mut ctx = Context::new(frontend, module, true, global_expression_kind_tracker)?;

38
naga/src/front/wgsl/lower/mod.rs
View File

@@ -87,7 +87,7 @@ pub struct GlobalContext<'source, 'temp, 'out> {
const_typifier: &'temp mut Typifier,
global_expression_kind_tracker: &'temp mut crate::proc::ExpressionConstnessTracker,
global_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
}
impl<'source> GlobalContext<'source, '_, '_> {
@@ -179,8 +179,8 @@ pub struct StatementContext<'source, 'temp, 'out> {
/// with the form of the expressions; it is also tracking whether WGSL says
/// we should consider them to be const. See the use of `force_non_const` in
/// the code for lowering `let` bindings.
expression_constness: &'temp mut crate::proc::ExpressionConstnessTracker,
global_expression_kind_tracker: &'temp mut crate::proc::ExpressionConstnessTracker,
local_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
global_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
}
impl<'a, 'temp> StatementContext<'a, 'temp, '_> {
@@ -205,7 +205,7 @@ impl<'a, 'temp> StatementContext<'a, 'temp, '_> {
block,
emitter,
typifier: self.typifier,
expression_constness: self.expression_constness,
local_expression_kind_tracker: self.local_expression_kind_tracker,
}),
}
}
@@ -250,8 +250,8 @@ pub struct RuntimeExpressionContext<'temp, 'out> {
/// Which `Expression`s in `self.naga_expressions` are const expressions, in
/// the WGSL sense.
///
/// See [`StatementContext::expression_constness`] for details.
expression_constness: &'temp mut crate::proc::ExpressionConstnessTracker,
/// See [`StatementContext::local_expression_kind_tracker`] for details.
local_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
}
/// The type of Naga IR expression we are lowering an [`ast::Expression`] to.
@@ -337,7 +337,7 @@ pub struct ExpressionContext<'source, 'temp, 'out> {
///
/// [`module::const_expressions`]: crate::Module::const_expressions
const_typifier: &'temp mut Typifier,
global_expression_kind_tracker: &'temp mut crate::proc::ExpressionConstnessTracker,
global_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
/// Whether we are lowering a constant expression or a general
/// runtime expression, and the data needed in each case.
@@ -373,7 +373,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
ExpressionContextType::Runtime(ref mut rctx) => ConstantEvaluator::for_wgsl_function(
self.module,
&mut rctx.function.expressions,
rctx.expression_constness,
rctx.local_expression_kind_tracker,
rctx.emitter,
rctx.block,
),
@@ -403,7 +403,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
fn const_access(&self, handle: Handle<crate::Expression>) -> Option<u32> {
match self.expr_type {
ExpressionContextType::Runtime(ref ctx) => {
if !ctx.expression_constness.is_const(handle) {
if !ctx.local_expression_kind_tracker.is_const(handle) {
return None;
}
@@ -455,7 +455,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
) -> Result<crate::SwizzleComponent, Error<'source>> {
match self.expr_type {
ExpressionContextType::Runtime(ref rctx) => {
if !rctx.expression_constness.is_const(expr) {
if !rctx.local_expression_kind_tracker.is_const(expr) {
return Err(Error::ExpectedConstExprConcreteIntegerScalar(
component_span,
));
@@ -899,7 +899,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
types: &tu.types,
module: &mut module,
const_typifier: &mut Typifier::new(),
global_expression_kind_tracker: &mut crate::proc::ExpressionConstnessTracker::new(),
global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker::new(),
};
for decl_handle in self.index.visit_ordered() {
@@ -1097,7 +1097,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
let mut local_table = FastHashMap::default();
let mut expressions = Arena::new();
let mut named_expressions = FastIndexMap::default();
let mut local_expression_kind_tracker = crate::proc::ExpressionConstnessTracker::new();
let mut local_expression_kind_tracker = crate::proc::ExpressionKindTracker::new();
let arguments = f
.arguments
@@ -1152,7 +1152,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
named_expressions: &mut named_expressions,
types: ctx.types,
module: ctx.module,
expression_constness: &mut local_expression_kind_tracker,
local_expression_kind_tracker: &mut local_expression_kind_tracker,
global_expression_kind_tracker: ctx.global_expression_kind_tracker,
};
let mut body = self.block(&f.body, false, &mut stmt_ctx)?;
@@ -1232,7 +1232,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
// affects when errors must be reported, so we can't even
// treat suitable `let` bindings as constant as an
// optimization.
ctx.expression_constness.force_non_const(value);
ctx.local_expression_kind_tracker.force_non_const(value);
let explicit_ty =
l.ty.map(|ty| self.resolve_ast_type(ty, &mut ctx.as_global()))
@@ -1316,7 +1316,9 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
// - the initialization is not a constant
// expression, so its value depends on the
// state at the point of initialization.
if is_inside_loop || !ctx.expression_constness.is_const(init) {
if is_inside_loop
|| !ctx.local_expression_kind_tracker.is_const(init)
{
(None, Some(init))
} else {
(Some(init), None)
@@ -1569,9 +1571,9 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
.function
.expressions
.append(crate::Expression::Binary { op, left, right }, stmt.span);
rctx.expression_constness
rctx.local_expression_kind_tracker
.insert(left, crate::proc::ExpressionKind::Runtime);
rctx.expression_constness
rctx.local_expression_kind_tracker
.insert(value, crate::proc::ExpressionKind::Runtime);
block.extend(emitter.finish(&ctx.function.expressions));
@@ -1950,7 +1952,7 @@ impl<'source, 'temp> Lowerer<'source, 'temp> {
.function
.expressions
.append(crate::Expression::CallResult(function), span);
rctx.expression_constness
rctx.local_expression_kind_tracker
.insert(result, crate::proc::ExpressionKind::Runtime);
result
});

33
naga/src/proc/constant_evaluator.rs
View File

@@ -298,7 +298,7 @@ pub struct ConstantEvaluator<'a> {
expressions: &'a mut Arena<Expression>,
/// Tracks the constness of expressions residing in [`Self::expressions`]
expression_kind_tracker: &'a mut ExpressionConstnessTracker,
expression_kind_tracker: &'a mut ExpressionKindTracker,
}
#[derive(Debug)]
@@ -340,11 +340,11 @@ pub enum ExpressionKind {
}
#[derive(Debug)]
pub struct ExpressionConstnessTracker {
pub struct ExpressionKindTracker {
inner: Vec<ExpressionKind>,
}
impl ExpressionConstnessTracker {
impl ExpressionKindTracker {
pub const fn new() -> Self {
Self { inner: Vec::new() }
}
@@ -531,7 +531,7 @@ impl<'a> ConstantEvaluator<'a> {
/// Report errors according to WGSL's rules for constant evaluation.
pub fn for_wgsl_module(
module: &'a mut crate::Module,
global_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
global_expression_kind_tracker: &'a mut ExpressionKindTracker,
in_override_ctx: bool,
) -> Self {
Self::for_module(
@@ -551,7 +551,7 @@ impl<'a> ConstantEvaluator<'a> {
/// Report errors according to GLSL's rules for constant evaluation.
pub fn for_glsl_module(
module: &'a mut crate::Module,
global_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
global_expression_kind_tracker: &'a mut ExpressionKindTracker,
) -> Self {
Self::for_module(
Behavior::Glsl(GlslRestrictions::Const),
@@ -563,7 +563,7 @@ impl<'a> ConstantEvaluator<'a> {
fn for_module(
behavior: Behavior<'a>,
module: &'a mut crate::Module,
global_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
global_expression_kind_tracker: &'a mut ExpressionKindTracker,
) -> Self {
Self {
behavior,
@@ -582,7 +582,7 @@ impl<'a> ConstantEvaluator<'a> {
pub fn for_wgsl_function(
module: &'a mut crate::Module,
expressions: &'a mut Arena<Expression>,
local_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
local_expression_kind_tracker: &'a mut ExpressionKindTracker,
emitter: &'a mut super::Emitter,
block: &'a mut crate::Block,
) -> Self {
@@ -607,7 +607,7 @@ impl<'a> ConstantEvaluator<'a> {
pub fn for_glsl_function(
module: &'a mut crate::Module,
expressions: &'a mut Arena<Expression>,
local_expression_kind_tracker: &'a mut ExpressionConstnessTracker,
local_expression_kind_tracker: &'a mut ExpressionKindTracker,
emitter: &'a mut super::Emitter,
block: &'a mut crate::Block,
) -> Self {
@@ -2195,7 +2195,7 @@ mod tests {
UniqueArena, VectorSize,
};
use super::{Behavior, ConstantEvaluator, ExpressionConstnessTracker, WgslRestrictions};
use super::{Behavior, ConstantEvaluator, ExpressionKindTracker, WgslRestrictions};
#[test]
fn unary_op() {
@@ -2276,8 +2276,7 @@ mod tests {
expr: expr1,
};
let expression_kind_tracker =
&mut ExpressionConstnessTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,
@@ -2363,8 +2362,7 @@ mod tests {
convert: Some(crate::BOOL_WIDTH),
};
let expression_kind_tracker =
&mut ExpressionConstnessTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,
@@ -2482,8 +2480,7 @@ mod tests {
let base = const_expressions.append(Expression::Constant(h), Default::default());
let expression_kind_tracker =
&mut ExpressionConstnessTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,
@@ -2576,8 +2573,7 @@ mod tests {
let h_expr = const_expressions.append(Expression::Constant(h), Default::default());
let expression_kind_tracker =
&mut ExpressionConstnessTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,
@@ -2659,8 +2655,7 @@ mod tests {
let h_expr = const_expressions.append(Expression::Constant(h), Default::default());
let expression_kind_tracker =
&mut ExpressionConstnessTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,

2
naga/src/proc/mod.rs
View File

@@ -11,7 +11,7 @@ mod terminator;
mod typifier;
pub use constant_evaluator::{
ConstantEvaluator, ConstantEvaluatorError, ExpressionConstnessTracker, ExpressionKind,
ConstantEvaluator, ConstantEvaluatorError, ExpressionKind, ExpressionKindTracker,
};
pub use emitter::Emitter;
pub use index::{BoundsCheckPolicies, BoundsCheckPolicy, IndexableLength, IndexableLengthError};

4
naga/src/valid/expression.rs
View File

@@ -187,7 +187,7 @@ impl super::Validator {
handle: Handle<crate::Expression>,
gctx: crate::proc::GlobalCtx,
mod_info: &ModuleInfo,
global_expr_kind: &crate::proc::ExpressionConstnessTracker,
global_expr_kind: &crate::proc::ExpressionKindTracker,
) -> Result<(), ConstExpressionError> {
use crate::Expression as E;
@@ -227,7 +227,7 @@ impl super::Validator {
module: &crate::Module,
info: &FunctionInfo,
mod_info: &ModuleInfo,
global_expr_kind: &crate::proc::ExpressionConstnessTracker,
global_expr_kind: &crate::proc::ExpressionKindTracker,
) -> Result<ShaderStages, ExpressionError> {
use crate::{Expression as E, Scalar as Sc, ScalarKind as Sk, TypeInner as Ti};

6
naga/src/valid/function.rs
View File

@@ -927,7 +927,7 @@ impl super::Validator {
var: &crate::LocalVariable,
gctx: crate::proc::GlobalCtx,
fun_info: &FunctionInfo,
local_expr_kind: &crate::proc::ExpressionConstnessTracker,
local_expr_kind: &crate::proc::ExpressionKindTracker,
) -> Result<(), LocalVariableError> {
log::debug!("var {:?}", var);
let type_info = self
@@ -959,11 +959,11 @@ impl super::Validator {
module: &crate::Module,
mod_info: &ModuleInfo,
entry_point: bool,
global_expr_kind: &crate::proc::ExpressionConstnessTracker,
global_expr_kind: &crate::proc::ExpressionKindTracker,
) -> Result<FunctionInfo, WithSpan<FunctionError>> {
let mut info = mod_info.process_function(fun, module, self.flags, self.capabilities)?;
let local_expr_kind = crate::proc::ExpressionConstnessTracker::from_arena(&fun.expressions);
let local_expr_kind = crate::proc::ExpressionKindTracker::from_arena(&fun.expressions);
for (var_handle, var) in fun.local_variables.iter() {
self.validate_local_var(var, module.to_ctx(), &info, &local_expr_kind)

4
naga/src/valid/interface.rs
View File

@@ -400,7 +400,7 @@ impl super::Validator {
var: &crate::GlobalVariable,
gctx: crate::proc::GlobalCtx,
mod_info: &ModuleInfo,
global_expr_kind: &crate::proc::ExpressionConstnessTracker,
global_expr_kind: &crate::proc::ExpressionKindTracker,
) -> Result<(), GlobalVariableError> {
use super::TypeFlags;
@@ -548,7 +548,7 @@ impl super::Validator {
ep: &crate::EntryPoint,
module: &crate::Module,
mod_info: &ModuleInfo,
global_expr_kind: &crate::proc::ExpressionConstnessTracker,
global_expr_kind: &crate::proc::ExpressionKindTracker,
) -> Result<FunctionInfo, WithSpan<EntryPointError>> {
if ep.early_depth_test.is_some() {
let required = Capabilities::EARLY_DEPTH_TEST;

6
naga/src/valid/mod.rs
View File

@@ -12,7 +12,7 @@ mod r#type;
use crate::{
arena::Handle,
proc::{ExpressionConstnessTracker, LayoutError, Layouter, TypeResolution},
proc::{ExpressionKindTracker, LayoutError, Layouter, TypeResolution},
FastHashSet,
};
use bit_set::BitSet;
@@ -342,7 +342,7 @@ impl Validator {
handle: Handle<crate::Constant>,
gctx: crate::proc::GlobalCtx,
mod_info: &ModuleInfo,
global_expr_kind: &ExpressionConstnessTracker,
global_expr_kind: &ExpressionKindTracker,
) -> Result<(), ConstantError> {
let con = &gctx.constants[handle];
@@ -467,7 +467,7 @@ impl Validator {
}
}
let global_expr_kind = ExpressionConstnessTracker::from_arena(&module.const_expressions);
let global_expr_kind = ExpressionKindTracker::from_arena(&module.const_expressions);
if self.flags.contains(ValidationFlags::CONSTANTS) {
for (handle, _) in module.const_expressions.iter() {