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 const_expressions to global_expressions

Browse Source
This commit is contained in:
teoxoy
2024-02-14 15:25:23 +01:00
committed by Teodor Tanasoaia
parent fa5406fbb9
commit e9eb703941
34 changed files with 170 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
naga/src/back/glsl/mod.rs
View File

@@ -2410,7 +2410,7 @@ impl<'a, W: Write> Writer<'a, W> {
fn write_const_expr(&mut self, expr: Handle<crate::Expression>) -> BackendResult {
self.write_possibly_const_expr(
expr,
&self.module.const_expressions,
&self.module.global_expressions,
|expr| &self.info[expr],
|writer, expr| writer.write_const_expr(expr),
)

4
naga/src/back/hlsl/writer.rs
View File

@@ -243,7 +243,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
self.write_special_functions(module)?;
self.write_wrapped_compose_functions(module, &module.const_expressions)?;
self.write_wrapped_compose_functions(module, &module.global_expressions)?;
// Write all named constants
let mut constants = module
@@ -2007,7 +2007,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
self.write_possibly_const_expression(
module,
expr,
&module.const_expressions,
&module.global_expressions,
|writer, expr| writer.write_const_expression(module, expr),
)
}

2
naga/src/back/msl/writer.rs
View File

@@ -1248,7 +1248,7 @@ impl<W: Write> Writer<W> {
) -> BackendResult {
self.put_possibly_const_expression(
expr_handle,
&module.const_expressions,
&module.global_expressions,
module,
mod_info,
&(module, mod_info),

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

@@ -33,14 +33,14 @@ pub(super) fn process_overrides<'a>(
let mut module = module.clone();
let mut override_map = Vec::with_capacity(module.overrides.len());
let mut adjusted_const_expressions = Vec::with_capacity(module.const_expressions.len());
let mut adjusted_global_expressions = Vec::with_capacity(module.global_expressions.len());
let mut adjusted_constant_initializers = HashSet::with_capacity(module.constants.len());
let mut global_expression_kind_tracker = crate::proc::ExpressionKindTracker::new();
let mut override_iter = module.overrides.drain();
for (old_h, expr, span) in module.const_expressions.drain() {
for (old_h, expr, span) in module.global_expressions.drain() {
let mut expr = match expr {
Expression::Override(h) => {
let c_h = if let Some(new_h) = override_map.get(h.index()) {
@@ -54,7 +54,7 @@ pub(super) fn process_overrides<'a>(
pipeline_constants,
&mut module,
&mut override_map,
&adjusted_const_expressions,
&adjusted_global_expressions,
&mut adjusted_constant_initializers,
&mut global_expression_kind_tracker,
)?);
@@ -68,7 +68,7 @@ pub(super) fn process_overrides<'a>(
}
Expression::Constant(c_h) => {
adjusted_constant_initializers.insert(c_h);
module.constants[c_h].init = adjusted_const_expressions[c_h.index()];
module.constants[c_h].init = adjusted_global_expressions[c_h.index()];
expr
}
expr => expr,
@@ -78,10 +78,10 @@ pub(super) fn process_overrides<'a>(
&mut global_expression_kind_tracker,
false,
);
adjust_expr(&adjusted_const_expressions, &mut expr);
adjust_expr(&adjusted_global_expressions, &mut expr);
let h = evaluator.try_eval_and_append(expr, span)?;
debug_assert_eq!(old_h.index(), adjusted_const_expressions.len());
adjusted_const_expressions.push(h);
debug_assert_eq!(old_h.index(), adjusted_global_expressions.len());
adjusted_global_expressions.push(h);
}
for entry in override_iter {
@@ -90,7 +90,7 @@ pub(super) fn process_overrides<'a>(
pipeline_constants,
&mut module,
&mut override_map,
&adjusted_const_expressions,
&adjusted_global_expressions,
&mut adjusted_constant_initializers,
&mut global_expression_kind_tracker,
)?;
@@ -101,12 +101,12 @@ pub(super) fn process_overrides<'a>(
.iter_mut()
.filter(|&(c_h, _)| !adjusted_constant_initializers.contains(&c_h))
{
c.init = adjusted_const_expressions[c.init.index()];
c.init = adjusted_global_expressions[c.init.index()];
}
for (_, v) in module.global_variables.iter_mut() {
if let Some(ref mut init) = v.init {
*init = adjusted_const_expressions[init.index()];
*init = adjusted_global_expressions[init.index()];
}
}
@@ -121,7 +121,7 @@ fn process_override(
pipeline_constants: &PipelineConstants,
module: &mut Module,
override_map: &mut Vec<Handle<Constant>>,
adjusted_const_expressions: &[Handle<Expression>],
adjusted_global_expressions: &[Handle<Expression>],
adjusted_constant_initializers: &mut HashSet<Handle<Constant>>,
global_expression_kind_tracker: &mut crate::proc::ExpressionKindTracker,
) -> Result<Handle<Constant>, PipelineConstantError> {
@@ -138,12 +138,12 @@ fn process_override(
_ => unreachable!(),
};
let expr = module
.const_expressions
.global_expressions
.append(Expression::Literal(literal), Span::UNDEFINED);
global_expression_kind_tracker.insert(expr, crate::proc::ExpressionKind::Const);
expr
} else if let Some(init) = override_.init {
adjusted_const_expressions[init.index()]
adjusted_global_expressions[init.index()]
} else {
return Err(PipelineConstantError::MissingValue(key.to_string()));
};

8
naga/src/back/spv/writer.rs
View File

@@ -1258,7 +1258,7 @@ impl Writer {
ir_module: &crate::Module,
mod_info: &ModuleInfo,
) -> Result<Word, Error> {
let id = match ir_module.const_expressions[handle] {
let id = match ir_module.global_expressions[handle] {
crate::Expression::Literal(literal) => self.get_constant_scalar(literal),
crate::Expression::Constant(constant) => {
let constant = &ir_module.constants[constant];
@@ -1272,7 +1272,7 @@ impl Writer {
let component_ids: Vec<_> = crate::proc::flatten_compose(
ty,
components,
&ir_module.const_expressions,
&ir_module.global_expressions,
&ir_module.types,
)
.map(|component| self.constant_ids[component.index()])
@@ -1914,8 +1914,8 @@ impl Writer {
// write all const-expressions as constants
self.constant_ids
.resize(ir_module.const_expressions.len(), 0);
for (handle, _) in ir_module.const_expressions.iter() {
.resize(ir_module.global_expressions.len(), 0);
for (handle, _) in ir_module.global_expressions.iter() {
self.write_constant_expr(handle, ir_module, mod_info)?;
}
debug_assert!(self.constant_ids.iter().all(|&id| id != 0));

2
naga/src/back/wgsl/writer.rs
View File

@@ -1076,7 +1076,7 @@ impl<W: Write> Writer<W> {
self.write_possibly_const_expression(
module,
expr,
&module.const_expressions,
&module.global_expressions,
|writer, expr| writer.write_const_expression(module, expr),
)
}

14
naga/src/compact/expressions.rs
View File

@@ -21,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> {
@@ -40,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"
@@ -84,7 +84,7 @@ 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),
}
@@ -122,7 +122,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),
}
@@ -276,7 +276,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);

4
naga/src/compact/functions.rs
View File

@@ -8,7 +8,7 @@ pub struct FunctionTracer<'a> {
pub types_used: &'a mut HandleSet<crate::Type>,
pub constants_used: &'a mut HandleSet<crate::Constant>,
pub const_expressions_used: &'a mut HandleSet<crate::Expression>,
pub global_expressions_used: &'a mut HandleSet<crate::Expression>,
/// Function-local expressions used.
pub expressions_used: HandleSet<crate::Expression>,
@@ -54,7 +54,7 @@ impl<'a> FunctionTracer<'a> {
types_used: self.types_used,
constants_used: self.constants_used,
expressions_used: &mut self.expressions_used,
const_expressions_used: Some(&mut self.const_expressions_used),
global_expressions_used: Some(&mut self.global_expressions_used),
}
}
}

34
naga/src/compact/mod.rs
View File

@@ -38,7 +38,7 @@ pub fn compact(module: &mut crate::Module) {
log::trace!("tracing global {:?}", global.name);
module_tracer.types_used.insert(global.ty);
if let Some(init) = global.init {
module_tracer.const_expressions_used.insert(init);
module_tracer.global_expressions_used.insert(init);
}
}
}
@@ -50,7 +50,7 @@ pub fn compact(module: &mut crate::Module) {
for (handle, constant) in module.constants.iter() {
if constant.name.is_some() {
module_tracer.constants_used.insert(handle);
module_tracer.const_expressions_used.insert(constant.init);
module_tracer.global_expressions_used.insert(constant.init);
}
}
@@ -58,7 +58,7 @@ pub fn compact(module: &mut crate::Module) {
for (_, override_) in module.overrides.iter() {
module_tracer.types_used.insert(override_.ty);
if let Some(init) = override_.init {
module_tracer.const_expressions_used.insert(init);
module_tracer.global_expressions_used.insert(init);
}
}
@@ -145,9 +145,9 @@ pub fn compact(module: &mut crate::Module) {
// Drop unused constant expressions, reusing existing storage.
log::trace!("adjusting constant expressions");
module.const_expressions.retain_mut(|handle, expr| {
if module_map.const_expressions.used(handle) {
module_map.adjust_expression(expr, &module_map.const_expressions);
module.global_expressions.retain_mut(|handle, expr| {
if module_map.global_expressions.used(handle) {
module_map.adjust_expression(expr, &module_map.global_expressions);
true
} else {
false
@@ -159,7 +159,7 @@ pub fn compact(module: &mut crate::Module) {
module.constants.retain_mut(|handle, constant| {
if module_map.constants.used(handle) {
module_map.types.adjust(&mut constant.ty);
module_map.const_expressions.adjust(&mut constant.init);
module_map.global_expressions.adjust(&mut constant.init);
true
} else {
false
@@ -171,7 +171,7 @@ pub fn compact(module: &mut crate::Module) {
for (_, override_) in module.overrides.iter_mut() {
module_map.types.adjust(&mut override_.ty);
if let Some(init) = override_.init.as_mut() {
module_map.const_expressions.adjust(init);
module_map.global_expressions.adjust(init);
}
}
@@ -181,7 +181,7 @@ pub fn compact(module: &mut crate::Module) {
log::trace!("adjusting global {:?}", global.name);
module_map.types.adjust(&mut global.ty);
if let Some(ref mut init) = global.init {
module_map.const_expressions.adjust(init);
module_map.global_expressions.adjust(init);
}
}
@@ -210,7 +210,7 @@ struct ModuleTracer<'module> {
module: &'module crate::Module,
types_used: HandleSet<crate::Type>,
constants_used: HandleSet<crate::Constant>,
const_expressions_used: HandleSet<crate::Expression>,
global_expressions_used: HandleSet<crate::Expression>,
}
impl<'module> ModuleTracer<'module> {
@@ -219,7 +219,7 @@ impl<'module> ModuleTracer<'module> {
module,
types_used: HandleSet::for_arena(&module.types),
constants_used: HandleSet::for_arena(&module.constants),
const_expressions_used: HandleSet::for_arena(&module.const_expressions),
global_expressions_used: HandleSet::for_arena(&module.global_expressions),
}
}
@@ -250,13 +250,13 @@ impl<'module> ModuleTracer<'module> {
fn as_const_expression(&mut self) -> expressions::ExpressionTracer {
expressions::ExpressionTracer {
expressions: &self.module.const_expressions,
expressions: &self.module.global_expressions,
constants: &self.module.constants,
overrides: &self.module.overrides,
types_used: &mut self.types_used,
constants_used: &mut self.constants_used,
expressions_used: &mut self.const_expressions_used,
const_expressions_used: None,
expressions_used: &mut self.global_expressions_used,
global_expressions_used: None,
}
}
@@ -270,7 +270,7 @@ impl<'module> ModuleTracer<'module> {
overrides: &self.module.overrides,
types_used: &mut self.types_used,
constants_used: &mut self.constants_used,
const_expressions_used: &mut self.const_expressions_used,
global_expressions_used: &mut self.global_expressions_used,
expressions_used: HandleSet::for_arena(&function.expressions),
}
}
@@ -279,7 +279,7 @@ impl<'module> ModuleTracer<'module> {
struct ModuleMap {
types: HandleMap<crate::Type>,
constants: HandleMap<crate::Constant>,
const_expressions: HandleMap<crate::Expression>,
global_expressions: HandleMap<crate::Expression>,
}
impl From<ModuleTracer<'_>> for ModuleMap {
@@ -287,7 +287,7 @@ impl From<ModuleTracer<'_>> for ModuleMap {
ModuleMap {
types: HandleMap::from_set(used.types_used),
constants: HandleMap::from_set(used.constants_used),
const_expressions: HandleMap::from_set(used.const_expressions_used),
global_expressions: HandleMap::from_set(used.global_expressions_used),
}
}
}

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

@@ -79,7 +79,7 @@ pub struct Context<'a> {
pub is_const: bool,
/// Tracks the expression kind of `Expression`s residing in `self.expressions`
pub local_expression_kind_tracker: crate::proc::ExpressionKindTracker,
/// Tracks the expression kind of `Expression`s residing in `self.module.const_expressions`
/// Tracks the expression kind of `Expression`s residing in `self.module.global_expressions`
pub global_expression_kind_tracker: &'a mut crate::proc::ExpressionKindTracker,
}
@@ -1471,7 +1471,7 @@ impl Index<Handle<Expression>> for Context<'_> {
fn index(&self, index: Handle<Expression>) -> &Self::Output {
if self.is_const {
&self.module.const_expressions[index]
&self.module.global_expressions[index]
} else {
&self.expressions[index]
}

2
naga/src/front/glsl/parser/functions.rs
View File

@@ -198,7 +198,7 @@ impl<'source> ParsingContext<'source> {
ctx.global_expression_kind_tracker,
)?;
match ctx.module.const_expressions[const_expr] {
match ctx.module.global_expressions[const_expr] {
Expression::Literal(Literal::I32(value)) => match uint {
// This unchecked cast isn't good, but since
// we only reach this code when the selector

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

@@ -539,7 +539,7 @@ fn constants() {
let mut types = module.types.iter();
let mut constants = module.constants.iter();
let mut const_expressions = module.const_expressions.iter();
let mut global_expressions = module.global_expressions.iter();
let (ty_handle, ty) = types.next().unwrap();
assert_eq!(
@@ -550,7 +550,7 @@ fn constants() {
}
);
let (init_handle, init) = const_expressions.next().unwrap();
let (init_handle, init) = global_expressions.next().unwrap();
assert_eq!(init, &Expression::Literal(crate::Literal::F32(1.0)));
assert_eq!(

10
naga/src/front/glsl/types.rs
View File

@@ -233,7 +233,7 @@ impl Context<'_> {
};
let expressions = if self.is_const {
&self.module.const_expressions
&self.module.global_expressions
} else {
&self.expressions
};
@@ -333,20 +333,22 @@ impl Context<'_> {
let h = match self.expressions[expr] {
ref expr @ (Expression::Literal(_)
| Expression::Constant(_)
| Expression::ZeroValue(_)) => self.module.const_expressions.append(expr.clone(), meta),
| Expression::ZeroValue(_)) => {
self.module.global_expressions.append(expr.clone(), meta)
}
Expression::Compose { ty, ref components } => {
let mut components = components.clone();
for component in &mut components {
*component = self.lift_up_const_expression(*component)?;
}
self.module
.const_expressions
.global_expressions
.append(Expression::Compose { ty, components }, meta)
}
Expression::Splat { size, value } => {
let value = self.lift_up_const_expression(value)?;
self.module
.const_expressions
.global_expressions
.append(Expression::Splat { size, value }, meta)
}
_ => {

4
naga/src/front/spv/function.rs
View File

@@ -129,7 +129,7 @@ impl<I: Iterator<Item = u32>> super::Frontend<I> {
local_arena: &mut fun.local_variables,
const_arena: &mut module.constants,
overrides: &mut module.overrides,
const_expressions: &mut module.const_expressions,
global_expressions: &mut module.global_expressions,
type_arena: &module.types,
global_arena: &module.global_variables,
arguments: &fun.arguments,
@@ -583,7 +583,7 @@ impl<'function> BlockContext<'function> {
types: self.type_arena,
constants: self.const_arena,
overrides: self.overrides,
const_expressions: self.const_expressions,
global_expressions: self.global_expressions,
}
}

2
naga/src/front/spv/image.rs
View File

@@ -508,7 +508,7 @@ impl<I: Iterator<Item = u32>> super::Frontend<I> {
spirv::ImageOperands::CONST_OFFSET => {
let offset_constant = self.next()?;
let offset_handle = self.lookup_constant.lookup(offset_constant)?.handle;
let offset_handle = ctx.const_expressions.append(
let offset_handle = ctx.global_expressions.append(
crate::Expression::Constant(offset_handle),
Default::default(),
);

22
naga/src/front/spv/mod.rs
View File

@@ -532,7 +532,7 @@ struct BlockContext<'function> {
/// Constants arena of the module being processed
const_arena: &'function mut Arena<crate::Constant>,
overrides: &'function mut Arena<crate::Override>,
const_expressions: &'function mut Arena<crate::Expression>,
global_expressions: &'function mut Arena<crate::Expression>,
/// Type arena of the module being processed
type_arena: &'function UniqueArena<crate::Type>,
/// Global arena of the module being processed
@@ -4916,7 +4916,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
let span = self.span_from_with_op(start);
let init = module
.const_expressions
.global_expressions
.append(crate::Expression::Literal(literal), span);
self.lookup_constant.insert(
id,
@@ -4956,7 +4956,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
let span = self.span_from_with_op(start);
let constant = self.lookup_constant.lookup(component_id)?;
let expr = module
.const_expressions
.global_expressions
.append(crate::Expression::Constant(constant.handle), span);
components.push(expr);
}
@@ -4966,7 +4966,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
let span = self.span_from_with_op(start);
let init = module
.const_expressions
.global_expressions
.append(crate::Expression::Compose { ty, components }, span);
self.lookup_constant.insert(
id,
@@ -5003,7 +5003,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
let decor = self.future_decor.remove(&id).unwrap_or_default();
let init = module
.const_expressions
.global_expressions
.append(crate::Expression::ZeroValue(ty), span);
let handle = module.constants.append(
crate::Constant {
@@ -5036,7 +5036,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
let decor = self.future_decor.remove(&id).unwrap_or_default();
let init = module.const_expressions.append(
let init = module.global_expressions.append(
crate::Expression::Literal(crate::Literal::Bool(value)),
span,
);
@@ -5075,7 +5075,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
let span = self.span_from_with_op(start);
let lconst = self.lookup_constant.lookup(init_id)?;
let expr = module
.const_expressions
.global_expressions
.append(crate::Expression::Constant(lconst.handle), span);
Some(expr)
} else {
@@ -5197,7 +5197,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
match null::generate_default_built_in(
Some(built_in),
ty,
&mut module.const_expressions,
&mut module.global_expressions,
span,
) {
Ok(handle) => Some(handle),
@@ -5219,14 +5219,14 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
let handle = null::generate_default_built_in(
built_in,
member.ty,
&mut module.const_expressions,
&mut module.global_expressions,
span,
)?;
components.push(handle);
}
Some(
module
.const_expressions
.global_expressions
.append(crate::Expression::Compose { ty, components }, span),
)
}
@@ -5295,7 +5295,7 @@ fn resolve_constant(
gctx: crate::proc::GlobalCtx,
constant: Handle<crate::Constant>,
) -> Option<u32> {
match gctx.const_expressions[gctx.constants[constant].init] {
match gctx.global_expressions[gctx.constants[constant].init] {
crate::Expression::Literal(crate::Literal::U32(id)) => Some(id),
crate::Expression::Literal(crate::Literal::I32(id)) => Some(id as u32),
_ => None,

8
naga/src/front/spv/null.rs
View File

@@ -5,14 +5,14 @@ use crate::arena::{Arena, Handle};
pub fn generate_default_built_in(
built_in: Option<crate::BuiltIn>,
ty: Handle<crate::Type>,
const_expressions: &mut Arena<crate::Expression>,
global_expressions: &mut Arena<crate::Expression>,
span: crate::Span,
) -> Result<Handle<crate::Expression>, Error> {
let expr = match built_in {
Some(crate::BuiltIn::Position { .. }) => {
let zero = const_expressions
let zero = global_expressions
.append(crate::Expression::Literal(crate::Literal::F32(0.0)), span);
let one = const_expressions
let one = global_expressions
.append(crate::Expression::Literal(crate::Literal::F32(1.0)), span);
crate::Expression::Compose {
ty,
@@ -27,5 +27,5 @@ pub fn generate_default_built_in(
// Note: `crate::BuiltIn::ClipDistance` is intentionally left for the default path
_ => crate::Expression::ZeroValue(ty),
};
Ok(const_expressions.append(expr, span))
Ok(global_expressions.append(expr, span))
}

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

@@ -333,9 +333,9 @@ pub struct ExpressionContext<'source, 'temp, 'out> {
/// [`Module`]: crate::Module
module: &'out mut crate::Module,
/// Type judgments for [`module::const_expressions`].
/// Type judgments for [`module::global_expressions`].
///
/// [`module::const_expressions`]: crate::Module::const_expressions
/// [`module::global_expressions`]: crate::Module::global_expressions
const_typifier: &'temp mut Typifier,
global_expression_kind_tracker: &'temp mut crate::proc::ExpressionKindTracker,
@@ -421,7 +421,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
match self.expr_type {
ExpressionContextType::Runtime(ref ctx) => ctx.function.expressions.get_span(handle),
ExpressionContextType::Constant | ExpressionContextType::Override => {
self.module.const_expressions.get_span(handle)
self.module.global_expressions.get_span(handle)
}
}
}
@@ -554,7 +554,7 @@ impl<'source, 'temp, 'out> ExpressionContext<'source, 'temp, 'out> {
ExpressionContextType::Constant | ExpressionContextType::Override => {
resolve_ctx = ResolveContext::with_locals(self.module, &empty_arena, &[]);
typifier = self.const_typifier;
expressions = &self.module.const_expressions;
expressions = &self.module.global_expressions;
}
};
typifier

2
naga/src/front/wgsl/to_wgsl.rs
View File

@@ -227,7 +227,7 @@ mod tests {
types: &types,
constants: &crate::Arena::new(),
overrides: &crate::Arena::new(),
const_expressions: &crate::Arena::new(),
global_expressions: &crate::Arena::new(),
};
let array = crate::TypeInner::Array {
base: mytype1,

10
naga/src/lib.rs
View File

@@ -897,7 +897,7 @@ pub struct Override {
/// The default value of the pipeline-overridable constant.
///
/// This [`Handle`] refers to [`Module::const_expressions`], not
/// This [`Handle`] refers to [`Module::global_expressions`], not
/// any [`Function::expressions`] arena.
pub init: Option<Handle<Expression>>,
}
@@ -913,7 +913,7 @@ pub struct Constant {
/// The value of the constant.
///
/// This [`Handle`] refers to [`Module::const_expressions`], not
/// This [`Handle`] refers to [`Module::global_expressions`], not
/// any [`Function::expressions`] arena.
pub init: Handle<Expression>,
}
@@ -980,7 +980,7 @@ pub struct GlobalVariable {
pub ty: Handle<Type>,
/// Initial value for this variable.
///
/// Expression handle lives in const_expressions
/// Expression handle lives in global_expressions
pub init: Option<Handle<Expression>>,
}
@@ -1430,7 +1430,7 @@ pub enum Expression {
gather: Option<SwizzleComponent>,
coordinate: Handle<Expression>,
array_index: Option<Handle<Expression>>,
/// Expression handle lives in const_expressions
/// Expression handle lives in global_expressions
offset: Option<Handle<Expression>>,
level: SampleLevel,
depth_ref: Option<Handle<Expression>>,
@@ -2065,7 +2065,7 @@ pub struct Module {
///
/// [Constant expressions]: index.html#constant-expressions
/// [override expressions]: index.html#override-expressions
pub const_expressions: Arena<Expression>,
pub global_expressions: Arena<Expression>,
/// Arena for the functions defined in this module.
///
/// Each function must appear in this arena strictly before all its callers.

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

@@ -327,7 +327,7 @@ enum GlslRestrictions<'a> {
#[derive(Debug)]
struct FunctionLocalData<'a> {
/// Global constant expressions
const_expressions: &'a Arena<Expression>,
global_expressions: &'a Arena<Expression>,
emitter: &'a mut super::Emitter,
block: &'a mut crate::Block,
}
@@ -570,7 +570,7 @@ impl<'a> ConstantEvaluator<'a> {
types: &mut module.types,
constants: &module.constants,
overrides: &module.overrides,
expressions: &mut module.const_expressions,
expressions: &mut module.global_expressions,
expression_kind_tracker: global_expression_kind_tracker,
}
}
@@ -588,7 +588,7 @@ impl<'a> ConstantEvaluator<'a> {
) -> Self {
Self {
behavior: Behavior::Wgsl(WgslRestrictions::Runtime(FunctionLocalData {
const_expressions: &module.const_expressions,
global_expressions: &module.global_expressions,
emitter,
block,
})),
@@ -613,7 +613,7 @@ impl<'a> ConstantEvaluator<'a> {
) -> Self {
Self {
behavior: Behavior::Glsl(GlslRestrictions::Runtime(FunctionLocalData {
const_expressions: &module.const_expressions,
global_expressions: &module.global_expressions,
emitter,
block,
})),
@@ -630,8 +630,8 @@ impl<'a> ConstantEvaluator<'a> {
types: self.types,
constants: self.constants,
overrides: self.overrides,
const_expressions: match self.function_local_data() {
Some(data) => data.const_expressions,
global_expressions: match self.function_local_data() {
Some(data) => data.global_expressions,
None => self.expressions,
},
}
@@ -657,7 +657,7 @@ impl<'a> ConstantEvaluator<'a> {
// Deep-copy the constant's value into our arena.
self.copy_from(
self.constants[c].init,
function_local_data.const_expressions,
function_local_data.global_expressions,
)
} else {
// "See through" the constant and use its initializer.
@@ -2202,7 +2202,7 @@ mod tests {
let mut types = UniqueArena::new();
let mut constants = Arena::new();
let overrides = Arena::new();
let mut const_expressions = Arena::new();
let mut global_expressions = Arena::new();
let scalar_ty = types.insert(
Type {
@@ -2227,7 +2227,7 @@ mod tests {
Constant {
name: None,
ty: scalar_ty,
init: const_expressions
init: global_expressions
.append(Expression::Literal(Literal::I32(4)), Default::default()),
},
Default::default(),
@@ -2237,7 +2237,7 @@ mod tests {
Constant {
name: None,
ty: scalar_ty,
init: const_expressions
init: global_expressions
.append(Expression::Literal(Literal::I32(8)), Default::default()),
},
Default::default(),
@@ -2247,7 +2247,7 @@ mod tests {
Constant {
name: None,
ty: vec_ty,
init: const_expressions.append(
init: global_expressions.append(
Expression::Compose {
ty: vec_ty,
components: vec![constants[h].init, constants[h1].init],
@@ -2258,8 +2258,8 @@ mod tests {
Default::default(),
);
let expr = const_expressions.append(Expression::Constant(h), Default::default());
let expr1 = const_expressions.append(Expression::Constant(vec_h), Default::default());
let expr = global_expressions.append(Expression::Constant(h), Default::default());
let expr1 = global_expressions.append(Expression::Constant(vec_h), Default::default());
let expr2 = Expression::Unary {
op: UnaryOperator::Negate,
@@ -2276,13 +2276,13 @@ mod tests {
expr: expr1,
};
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,
constants: &constants,
overrides: &overrides,
expressions: &mut const_expressions,
expressions: &mut global_expressions,
expression_kind_tracker,
};
@@ -2297,16 +2297,16 @@ mod tests {
.unwrap();
assert_eq!(
const_expressions[res1],
global_expressions[res1],
Expression::Literal(Literal::I32(-4))
);
assert_eq!(
const_expressions[res2],
global_expressions[res2],
Expression::Literal(Literal::I32(!4))
);
let res3_inner = &const_expressions[res3];
let res3_inner = &global_expressions[res3];
match *res3_inner {
Expression::Compose {
@@ -2316,11 +2316,11 @@ mod tests {
assert_eq!(*ty, vec_ty);
let mut components_iter = components.iter().copied();
assert_eq!(
const_expressions[components_iter.next().unwrap()],
global_expressions[components_iter.next().unwrap()],
Expression::Literal(Literal::I32(!4))
);
assert_eq!(
const_expressions[components_iter.next().unwrap()],
global_expressions[components_iter.next().unwrap()],
Expression::Literal(Literal::I32(!8))
);
assert!(components_iter.next().is_none());
@@ -2334,7 +2334,7 @@ mod tests {
let mut types = UniqueArena::new();
let mut constants = Arena::new();
let overrides = Arena::new();
let mut const_expressions = Arena::new();
let mut global_expressions = Arena::new();
let scalar_ty = types.insert(
Type {
@@ -2348,13 +2348,13 @@ mod tests {
Constant {
name: None,
ty: scalar_ty,
init: const_expressions
init: global_expressions
.append(Expression::Literal(Literal::I32(4)), Default::default()),
},
Default::default(),
);
let expr = const_expressions.append(Expression::Constant(h), Default::default());
let expr = global_expressions.append(Expression::Constant(h), Default::default());
let root = Expression::As {
expr,
@@ -2362,13 +2362,13 @@ mod tests {
convert: Some(crate::BOOL_WIDTH),
};
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,
constants: &constants,
overrides: &overrides,
expressions: &mut const_expressions,
expressions: &mut global_expressions,
expression_kind_tracker,
};
@@ -2377,7 +2377,7 @@ mod tests {
.unwrap();
assert_eq!(
const_expressions[res],
global_expressions[res],
Expression::Literal(Literal::Bool(true))
);
}
@@ -2387,7 +2387,7 @@ mod tests {
let mut types = UniqueArena::new();
let mut constants = Arena::new();
let overrides = Arena::new();
let mut const_expressions = Arena::new();
let mut global_expressions = Arena::new();
let matrix_ty = types.insert(
Type {
@@ -2416,7 +2416,7 @@ mod tests {
let mut vec2_components = Vec::with_capacity(3);
for i in 0..3 {
let h = const_expressions.append(
let h = global_expressions.append(
Expression::Literal(Literal::F32(i as f32)),
Default::default(),
);
@@ -2425,7 +2425,7 @@ mod tests {
}
for i in 3..6 {
let h = const_expressions.append(
let h = global_expressions.append(
Expression::Literal(Literal::F32(i as f32)),
Default::default(),
);
@@ -2437,7 +2437,7 @@ mod tests {
Constant {
name: None,
ty: vec_ty,
init: const_expressions.append(
init: global_expressions.append(
Expression::Compose {
ty: vec_ty,
components: vec1_components,
@@ -2452,7 +2452,7 @@ mod tests {
Constant {
name: None,
ty: vec_ty,
init: const_expressions.append(
init: global_expressions.append(
Expression::Compose {
ty: vec_ty,
components: vec2_components,
@@ -2467,7 +2467,7 @@ mod tests {
Constant {
name: None,
ty: matrix_ty,
init: const_expressions.append(
init: global_expressions.append(
Expression::Compose {
ty: matrix_ty,
components: vec![constants[vec1].init, constants[vec2].init],
@@ -2478,15 +2478,15 @@ mod tests {
Default::default(),
);
let base = const_expressions.append(Expression::Constant(h), Default::default());
let base = global_expressions.append(Expression::Constant(h), Default::default());
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,
constants: &constants,
overrides: &overrides,
expressions: &mut const_expressions,
expressions: &mut global_expressions,
expression_kind_tracker,
};
@@ -2505,7 +2505,7 @@ mod tests {
.try_eval_and_append(root2, Default::default())
.unwrap();
match const_expressions[res1] {
match global_expressions[res1] {
Expression::Compose {
ref ty,
ref components,
@@ -2513,15 +2513,15 @@ mod tests {
assert_eq!(*ty, vec_ty);
let mut components_iter = components.iter().copied();
assert_eq!(
const_expressions[components_iter.next().unwrap()],
global_expressions[components_iter.next().unwrap()],
Expression::Literal(Literal::F32(3.))
);
assert_eq!(
const_expressions[components_iter.next().unwrap()],
global_expressions[components_iter.next().unwrap()],
Expression::Literal(Literal::F32(4.))
);
assert_eq!(
const_expressions[components_iter.next().unwrap()],
global_expressions[components_iter.next().unwrap()],
Expression::Literal(Literal::F32(5.))
);
assert!(components_iter.next().is_none());
@@ -2530,7 +2530,7 @@ mod tests {
}
assert_eq!(
const_expressions[res2],
global_expressions[res2],
Expression::Literal(Literal::F32(5.))
);
}
@@ -2540,7 +2540,7 @@ mod tests {
let mut types = UniqueArena::new();
let mut constants = Arena::new();
let overrides = Arena::new();
let mut const_expressions = Arena::new();
let mut global_expressions = Arena::new();
let i32_ty = types.insert(
Type {
@@ -2565,21 +2565,21 @@ mod tests {
Constant {
name: None,
ty: i32_ty,
init: const_expressions
init: global_expressions
.append(Expression::Literal(Literal::I32(4)), Default::default()),
},
Default::default(),
);
let h_expr = const_expressions.append(Expression::Constant(h), Default::default());
let h_expr = global_expressions.append(Expression::Constant(h), Default::default());
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,
constants: &constants,
overrides: &overrides,
expressions: &mut const_expressions,
expressions: &mut global_expressions,
expression_kind_tracker,
};
@@ -2602,11 +2602,11 @@ mod tests {
)
.unwrap();
let pass = match const_expressions[solved_negate] {
let pass = match global_expressions[solved_negate] {
Expression::Compose { ty, ref components } => {
ty == vec2_i32_ty
&& components.iter().all(|&component| {
let component = &const_expressions[component];
let component = &global_expressions[component];
matches!(*component, Expression::Literal(Literal::I32(-4)))
})
}
@@ -2622,7 +2622,7 @@ mod tests {
let mut types = UniqueArena::new();
let mut constants = Arena::new();
let overrides = Arena::new();
let mut const_expressions = Arena::new();
let mut global_expressions = Arena::new();
let i32_ty = types.insert(
Type {
@@ -2647,21 +2647,21 @@ mod tests {
Constant {
name: None,
ty: i32_ty,
init: const_expressions
init: global_expressions
.append(Expression::Literal(Literal::I32(4)), Default::default()),
},
Default::default(),
);
let h_expr = const_expressions.append(Expression::Constant(h), Default::default());
let h_expr = global_expressions.append(Expression::Constant(h), Default::default());
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&const_expressions);
let expression_kind_tracker = &mut ExpressionKindTracker::from_arena(&global_expressions);
let mut solver = ConstantEvaluator {
behavior: Behavior::Wgsl(WgslRestrictions::Const),
types: &mut types,
constants: &constants,
overrides: &overrides,
expressions: &mut const_expressions,
expressions: &mut global_expressions,
expression_kind_tracker,
};
@@ -2684,11 +2684,11 @@ mod tests {
)
.unwrap();
let pass = match const_expressions[solved_negate] {
let pass = match global_expressions[solved_negate] {
Expression::Compose { ty, ref components } => {
ty == vec2_i32_ty
&& components.iter().all(|&component| {
let component = &const_expressions[component];
let component = &global_expressions[component];
matches!(*component, Expression::Literal(Literal::I32(-4)))
})
}

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

@@ -649,7 +649,7 @@ impl crate::Module {
types: &self.types,
constants: &self.constants,
overrides: &self.overrides,
const_expressions: &self.const_expressions,
global_expressions: &self.global_expressions,
}
}
}
@@ -665,17 +665,17 @@ pub struct GlobalCtx<'a> {
pub types: &'a crate::UniqueArena<crate::Type>,
pub constants: &'a crate::Arena<crate::Constant>,
pub overrides: &'a crate::Arena<crate::Override>,
pub const_expressions: &'a crate::Arena<crate::Expression>,
pub global_expressions: &'a crate::Arena<crate::Expression>,
}
impl GlobalCtx<'_> {
/// Try to evaluate the expression in `self.const_expressions` using its `handle` and return it as a `u32`.
/// Try to evaluate the expression in `self.global_expressions` using its `handle` and return it as a `u32`.
#[allow(dead_code)]
pub(super) fn eval_expr_to_u32(
&self,
handle: crate::Handle<crate::Expression>,
) -> Result<u32, U32EvalError> {
self.eval_expr_to_u32_from(handle, self.const_expressions)
self.eval_expr_to_u32_from(handle, self.global_expressions)
}
/// Try to evaluate the expression in the `arena` using its `handle` and return it as a `u32`.
@@ -698,7 +698,7 @@ impl GlobalCtx<'_> {
&self,
handle: crate::Handle<crate::Expression>,
) -> Option<crate::Literal> {
self.eval_expr_to_literal_from(handle, self.const_expressions)
self.eval_expr_to_literal_from(handle, self.global_expressions)
}
fn eval_expr_to_literal_from(
@@ -722,7 +722,7 @@ impl GlobalCtx<'_> {
}
match arena[handle] {
crate::Expression::Constant(c) => {
get(*self, self.constants[c].init, self.const_expressions)
get(*self, self.constants[c].init, self.global_expressions)
}
_ => get(*self, handle, arena),
}

2
naga/src/valid/analyzer.rs
View File

@@ -1047,7 +1047,7 @@ impl ModuleInfo {
gctx: crate::proc::GlobalCtx,
) -> Result<(), super::ConstExpressionError> {
self.const_expression_types[handle.index()] =
resolve_context.resolve(&gctx.const_expressions[handle], |h| Ok(&self[h]))?;
resolve_context.resolve(&gctx.global_expressions[handle], |h| Ok(&self[h]))?;
Ok(())
}

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

@@ -195,7 +195,7 @@ impl super::Validator {
return Err(super::ConstExpressionError::NonConstOrOverride);
}
match gctx.const_expressions[handle] {
match gctx.global_expressions[handle] {
E::Literal(literal) => {
self.validate_literal(literal)?;
}
@@ -1729,7 +1729,7 @@ fn validate_with_const_expression(
use crate::span::Span;
let mut module = crate::Module::default();
module.const_expressions.append(expr, Span::default());
module.global_expressions.append(expr, Span::default());
let mut validator = super::Validator::new(super::ValidationFlags::CONSTANTS, caps);

12
naga/src/valid/handles.rs
View File

@@ -37,7 +37,7 @@ impl super::Validator {
ref global_variables,
ref types,
ref special_types,
ref const_expressions,
ref global_expressions,
} = module;
// NOTE: Types being first is important. All other forms of validation depend on this.
@@ -68,13 +68,13 @@ impl super::Validator {
}
}
for handle_and_expr in const_expressions.iter() {
for handle_and_expr in global_expressions.iter() {
Self::validate_const_expression_handles(handle_and_expr, constants, overrides, types)?;
}
let validate_type = |handle| Self::validate_type_handle(handle, types);
let validate_const_expr =
|handle| Self::validate_expression_handle(handle, const_expressions);
|handle| Self::validate_expression_handle(handle, global_expressions);
for (_handle, constant) in constants.iter() {
let &crate::Constant { name: _, ty, init } = constant;
@@ -150,7 +150,7 @@ impl super::Validator {
handle_and_expr,
constants,
overrides,
const_expressions,
global_expressions,
types,
local_variables,
global_variables,
@@ -256,7 +256,7 @@ impl super::Validator {
(handle, expression): (Handle<crate::Expression>, &crate::Expression),
constants: &Arena<crate::Constant>,
overrides: &Arena<crate::Override>,
const_expressions: &Arena<crate::Expression>,
global_expressions: &Arena<crate::Expression>,
types: &UniqueArena<crate::Type>,
local_variables: &Arena<crate::LocalVariable>,
global_variables: &Arena<crate::GlobalVariable>,
@@ -267,7 +267,7 @@ impl super::Validator {
let validate_constant = |handle| Self::validate_constant_handle(handle, constants);
let validate_override = |handle| Self::validate_override_handle(handle, overrides);
let validate_const_expr =
|handle| Self::validate_expression_handle(handle, const_expressions);
|handle| Self::validate_expression_handle(handle, global_expressions);
let validate_type = |handle| Self::validate_type_handle(handle, types);
match *expression {

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

@@ -435,7 +435,7 @@ impl Validator {
type_flags: Vec::with_capacity(module.types.len()),
functions: Vec::with_capacity(module.functions.len()),
entry_points: Vec::with_capacity(module.entry_points.len()),
const_expression_types: vec![placeholder; module.const_expressions.len()]
const_expression_types: vec![placeholder; module.global_expressions.len()]
.into_boxed_slice(),
};
@@ -457,20 +457,20 @@ impl Validator {
{
let t = crate::Arena::new();
let resolve_context = crate::proc::ResolveContext::with_locals(module, &t, &[]);
for (handle, _) in module.const_expressions.iter() {
for (handle, _) in module.global_expressions.iter() {
mod_info
.process_const_expression(handle, &resolve_context, module.to_ctx())
.map_err(|source| {
ValidationError::ConstExpression { handle, source }
.with_span_handle(handle, &module.const_expressions)
.with_span_handle(handle, &module.global_expressions)
})?
}
}
let global_expr_kind = ExpressionKindTracker::from_arena(&module.const_expressions);
let global_expr_kind = ExpressionKindTracker::from_arena(&module.global_expressions);
if self.flags.contains(ValidationFlags::CONSTANTS) {
for (handle, _) in module.const_expressions.iter() {
for (handle, _) in module.global_expressions.iter() {
self.validate_const_expression(
handle,
module.to_ctx(),
@@ -479,7 +479,7 @@ impl Validator {
)
.map_err(|source| {
ValidationError::ConstExpression { handle, source }
.with_span_handle(handle, &module.const_expressions)
.with_span_handle(handle, &module.global_expressions)
})?
}

2
naga/tests/out/ir/access.compact.ron
View File

@@ -378,7 +378,7 @@
init: None,
),
],
const_expressions: [
global_expressions: [
Literal(U32(0)),
Literal(U32(0)),
Literal(U32(0)),

2
naga/tests/out/ir/access.ron
View File

@@ -378,7 +378,7 @@
init: None,
),
],
const_expressions: [
global_expressions: [
Literal(U32(0)),
Literal(U32(0)),
Literal(U32(0)),

2
naga/tests/out/ir/collatz.compact.ron
View File

@@ -61,7 +61,7 @@
init: None,
),
],
const_expressions: [],
global_expressions: [],
functions: [
(
name: Some("collatz_iterations"),

2
naga/tests/out/ir/collatz.ron
View File

@@ -61,7 +61,7 @@
init: None,
),
],
const_expressions: [],
global_expressions: [],
functions: [
(
name: Some("collatz_iterations"),

2
naga/tests/out/ir/overrides.compact.ron
View File

@@ -66,7 +66,7 @@
),
],
global_variables: [],
const_expressions: [
global_expressions: [
Literal(Bool(true)),
Literal(F32(2.3)),
Literal(F32(0.0)),

2
naga/tests/out/ir/overrides.ron
View File

@@ -66,7 +66,7 @@
),
],
global_variables: [],
const_expressions: [
global_expressions: [
Literal(Bool(true)),
Literal(F32(2.3)),
Literal(F32(0.0)),

2
naga/tests/out/ir/shadow.compact.ron
View File

@@ -319,7 +319,7 @@
init: None,
),
],
const_expressions: [
global_expressions: [
Literal(F32(0.0)),
Literal(F32(1.0)),
Literal(F32(0.5)),

2
naga/tests/out/ir/shadow.ron
View File

@@ -522,7 +522,7 @@
init: None,
),
],
const_expressions: [
global_expressions: [
Literal(F32(0.0)),
Literal(F32(1.0)),
Literal(F32(0.5)),