naga/back/
mod.rs

1/*!
2Backend functions that export shader [`Module`](super::Module)s into binary and text formats.
3*/
4#![cfg_attr(
5    not(any(dot_out, glsl_out, hlsl_out, msl_out, spv_out, wgsl_out)),
6    allow(
7        dead_code,
8        reason = "shared helpers can be dead if none of the enabled backends need it"
9    )
10)]
11
12use alloc::string::String;
13
14#[cfg(dot_out)]
15pub mod dot;
16#[cfg(glsl_out)]
17pub mod glsl;
18#[cfg(hlsl_out)]
19pub mod hlsl;
20#[cfg(msl_out)]
21pub mod msl;
22#[cfg(spv_out)]
23pub mod spv;
24#[cfg(wgsl_out)]
25pub mod wgsl;
26
27#[cfg(any(hlsl_out, msl_out, spv_out, glsl_out))]
28pub mod pipeline_constants;
29
30#[cfg(any(hlsl_out, glsl_out))]
31mod continue_forward;
32
33/// Names of vector components.
34pub const COMPONENTS: &[char] = &['x', 'y', 'z', 'w'];
35/// Indent for backends.
36pub const INDENT: &str = "    ";
37
38/// Expressions that need baking.
39pub type NeedBakeExpressions = crate::FastHashSet<crate::Handle<crate::Expression>>;
40
41/// A type for displaying expression handles as baking identifiers.
42///
43/// Given an [`Expression`] [`Handle`] `h`, `Baked(h)` implements
44/// [`core::fmt::Display`], showing the handle's index prefixed by
45/// `_e`.
46///
47/// [`Expression`]: crate::Expression
48/// [`Handle`]: crate::Handle
49#[cfg_attr(
50    not(any(glsl_out, hlsl_out, msl_out, wgsl_out)),
51    allow(
52        dead_code,
53        reason = "shared helpers can be dead if none of the enabled backends need it"
54    )
55)]
56struct Baked(crate::Handle<crate::Expression>);
57
58impl core::fmt::Display for Baked {
59    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
60        self.0.write_prefixed(f, "_e")
61    }
62}
63
64/// Specifies the values of pipeline-overridable constants in the shader module.
65///
66/// If an `@id` attribute was specified on the declaration,
67/// the key must be the pipeline constant ID as a decimal ASCII number; if not,
68/// the key must be the constant's identifier name.
69///
70/// The value may represent any of WGSL's concrete scalar types.
71pub type PipelineConstants = hashbrown::HashMap<String, f64>;
72
73/// Indentation level.
74#[derive(Clone, Copy)]
75pub struct Level(pub usize);
76
77impl Level {
78    pub const fn next(&self) -> Self {
79        Level(self.0 + 1)
80    }
81}
82
83impl core::fmt::Display for Level {
84    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
85        (0..self.0).try_for_each(|_| formatter.write_str(INDENT))
86    }
87}
88
89/// Locate the entry point(s) to write.
90///
91/// If `entry_point` is given, and the specified entry point exists, returns a
92/// length-1 `Range` containing the index of that entry point.  If no
93/// `entry_point` is given, returns the complete range of entry point indices.
94/// If `entry_point` is given but does not exist, returns an error.
95#[cfg(any(hlsl_out, msl_out))]
96fn get_entry_points(
97    module: &crate::ir::Module,
98    entry_point: Option<&(crate::ir::ShaderStage, String)>,
99) -> Result<core::ops::Range<usize>, (crate::ir::ShaderStage, String)> {
100    use alloc::borrow::ToOwned;
101
102    if let Some(&(stage, ref name)) = entry_point {
103        let Some(ep_index) = module
104            .entry_points
105            .iter()
106            .position(|ep| ep.stage == stage && ep.name == *name)
107        else {
108            return Err((stage, name.to_owned()));
109        };
110        Ok(ep_index..ep_index + 1)
111    } else {
112        Ok(0..module.entry_points.len())
113    }
114}
115
116/// Whether we're generating an entry point or a regular function.
117///
118/// Backend languages often require different code for a [`Function`]
119/// depending on whether it represents an [`EntryPoint`] or not.
120/// Backends can pass common code one of these values to select the
121/// right behavior.
122///
123/// These values also carry enough information to find the `Function`
124/// in the [`Module`]: the `Handle` for a regular function, or the
125/// index into [`Module::entry_points`] for an entry point.
126///
127/// [`Function`]: crate::Function
128/// [`EntryPoint`]: crate::EntryPoint
129/// [`Module`]: crate::Module
130/// [`Module::entry_points`]: crate::Module::entry_points
131pub enum FunctionType {
132    /// A regular function.
133    Function(crate::Handle<crate::Function>),
134    /// An [`EntryPoint`], and its index in [`Module::entry_points`].
135    ///
136    /// [`EntryPoint`]: crate::EntryPoint
137    /// [`Module::entry_points`]: crate::Module::entry_points
138    EntryPoint(crate::proc::EntryPointIndex),
139}
140
141impl FunctionType {
142    /// Returns true if the function is an entry point for a compute-like shader.
143    pub fn is_compute_like_entry_point(&self, module: &crate::Module) -> bool {
144        match *self {
145            FunctionType::EntryPoint(index) => {
146                module.entry_points[index as usize].stage.compute_like()
147            }
148            FunctionType::Function(_) => false,
149        }
150    }
151}
152
153/// Helper structure that stores data needed when writing the function
154pub struct FunctionCtx<'a> {
155    /// The current function being written
156    pub ty: FunctionType,
157    /// Analysis about the function
158    pub info: &'a crate::valid::FunctionInfo,
159    /// The expression arena of the current function being written
160    pub expressions: &'a crate::Arena<crate::Expression>,
161    /// Map of expressions that have associated variable names
162    pub named_expressions: &'a crate::NamedExpressions,
163}
164
165impl FunctionCtx<'_> {
166    /// Helper method that resolves a type of a given expression.
167    pub fn resolve_type<'a>(
168        &'a self,
169        handle: crate::Handle<crate::Expression>,
170        types: &'a crate::UniqueArena<crate::Type>,
171    ) -> &'a crate::TypeInner {
172        self.info[handle].ty.inner_with(types)
173    }
174
175    /// Helper method that generates a [`NameKey`](crate::proc::NameKey) for a local in the current function
176    pub const fn name_key(
177        &self,
178        local: crate::Handle<crate::LocalVariable>,
179    ) -> crate::proc::NameKey {
180        match self.ty {
181            FunctionType::Function(handle) => crate::proc::NameKey::FunctionLocal(handle, local),
182            FunctionType::EntryPoint(idx) => crate::proc::NameKey::EntryPointLocal(idx, local),
183        }
184    }
185
186    /// Helper method that generates a [`NameKey`](crate::proc::NameKey) for a function argument.
187    ///
188    /// # Panics
189    /// - If the function arguments are less or equal to `arg`
190    pub const fn argument_key(&self, arg: u32) -> crate::proc::NameKey {
191        match self.ty {
192            FunctionType::Function(handle) => crate::proc::NameKey::FunctionArgument(handle, arg),
193            FunctionType::EntryPoint(ep_index) => {
194                crate::proc::NameKey::EntryPointArgument(ep_index, arg)
195            }
196        }
197    }
198
199    /// Helper method that generates a [`NameKey`](crate::proc::NameKey) for an external texture
200    /// function argument.
201    ///
202    /// # Panics
203    /// - If the function arguments are less or equal to `arg`
204    /// - If `self.ty` is not `FunctionType::Function`.
205    pub const fn external_texture_argument_key(
206        &self,
207        arg: u32,
208        external_texture_key: crate::proc::ExternalTextureNameKey,
209    ) -> crate::proc::NameKey {
210        match self.ty {
211            FunctionType::Function(handle) => {
212                crate::proc::NameKey::ExternalTextureFunctionArgument(
213                    handle,
214                    arg,
215                    external_texture_key,
216                )
217            }
218            // This is a const function, which _sometimes_ gets called,
219            // so this lint is _sometimes_ triggered, depending on feature set.
220            #[expect(clippy::allow_attributes)]
221            #[allow(clippy::panic)]
222            FunctionType::EntryPoint(_) => {
223                panic!("External textures cannot be used as arguments to entry points")
224            }
225        }
226    }
227
228    /// Returns true if the given expression points to a fixed-function pipeline input.
229    pub fn is_fixed_function_input(
230        &self,
231        mut expression: crate::Handle<crate::Expression>,
232        module: &crate::Module,
233    ) -> Option<crate::BuiltIn> {
234        let ep_function = match self.ty {
235            FunctionType::Function(_) => return None,
236            FunctionType::EntryPoint(ep_index) => &module.entry_points[ep_index as usize].function,
237        };
238        let mut built_in = None;
239        loop {
240            match self.expressions[expression] {
241                crate::Expression::FunctionArgument(arg_index) => {
242                    return match ep_function.arguments[arg_index as usize].binding {
243                        Some(crate::Binding::BuiltIn(bi)) => Some(bi),
244                        _ => built_in,
245                    };
246                }
247                crate::Expression::AccessIndex { base, index } => {
248                    match *self.resolve_type(base, &module.types) {
249                        crate::TypeInner::Struct { ref members, .. } => {
250                            if let Some(crate::Binding::BuiltIn(bi)) =
251                                members[index as usize].binding
252                            {
253                                built_in = Some(bi);
254                            }
255                        }
256                        _ => return None,
257                    }
258                    expression = base;
259                }
260                _ => return None,
261            }
262        }
263    }
264}
265
266impl crate::Expression {
267    /// Returns the ref count, upon reaching which this expression
268    /// should be considered for baking.
269    ///
270    /// Note: we have to cache any expressions that depend on the control flow,
271    /// or otherwise they may be moved into a non-uniform control flow, accidentally.
272    /// See the [module-level documentation][emit] for details.
273    ///
274    /// [emit]: index.html#expression-evaluation-time
275    pub const fn bake_ref_count(&self) -> usize {
276        match *self {
277            // accesses are never cached, only loads are
278            crate::Expression::Access { .. } | crate::Expression::AccessIndex { .. } => usize::MAX,
279            // sampling may use the control flow, and image ops look better by themselves
280            crate::Expression::ImageSample { .. } | crate::Expression::ImageLoad { .. } => 1,
281            // derivatives use the control flow
282            crate::Expression::Derivative { .. } => 1,
283            // TODO: We need a better fix for named `Load` expressions
284            // More info - https://github.com/gfx-rs/naga/pull/914
285            // And https://github.com/gfx-rs/naga/issues/910
286            crate::Expression::Load { .. } => 1,
287            // cache expressions that are referenced multiple times
288            _ => 2,
289        }
290    }
291}
292
293/// Helper function that returns the string corresponding to the [`BinaryOperator`](crate::BinaryOperator)
294pub const fn binary_operation_str(op: crate::BinaryOperator) -> &'static str {
295    use crate::BinaryOperator as Bo;
296    match op {
297        Bo::Add => "+",
298        Bo::Subtract => "-",
299        Bo::Multiply => "*",
300        Bo::Divide => "/",
301        Bo::Modulo => "%",
302        Bo::Equal => "==",
303        Bo::NotEqual => "!=",
304        Bo::Less => "<",
305        Bo::LessEqual => "<=",
306        Bo::Greater => ">",
307        Bo::GreaterEqual => ">=",
308        Bo::And => "&",
309        Bo::ExclusiveOr => "^",
310        Bo::InclusiveOr => "|",
311        Bo::LogicalAnd => "&&",
312        Bo::LogicalOr => "||",
313        Bo::ShiftLeft => "<<",
314        Bo::ShiftRight => ">>",
315    }
316}
317
318impl crate::TypeInner {
319    /// Returns true if this is a handle to a type rather than the type directly.
320    pub const fn is_handle(&self) -> bool {
321        match *self {
322            crate::TypeInner::Image { .. }
323            | crate::TypeInner::Sampler { .. }
324            | crate::TypeInner::AccelerationStructure { .. } => true,
325            _ => false,
326        }
327    }
328}
329
330impl crate::Statement {
331    /// Returns true if the statement directly terminates the current block.
332    ///
333    /// Used to decide whether case blocks require a explicit `break`.
334    pub const fn is_terminator(&self) -> bool {
335        match *self {
336            crate::Statement::Break
337            | crate::Statement::Continue
338            | crate::Statement::Return { .. }
339            | crate::Statement::Kill => true,
340            _ => false,
341        }
342    }
343}
344
345bitflags::bitflags! {
346    /// Ray flags, for a [`RayDesc`]'s `flags` field.
347    ///
348    /// Note that these exactly correspond to the SPIR-V "Ray Flags" mask, and
349    /// the SPIR-V backend passes them directly through to the
350    /// [`OpRayQueryInitializeKHR`][op] instruction. (We have to choose something, so
351    /// we might as well make one back end's life easier.)
352    ///
353    /// [`RayDesc`]: crate::Module::generate_ray_desc_type
354    /// [op]: https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#OpRayQueryInitializeKHR
355    #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
356    pub struct RayFlag: u32 {
357        const OPAQUE = 0x01;
358        const NO_OPAQUE = 0x02;
359        const TERMINATE_ON_FIRST_HIT = 0x04;
360        const SKIP_CLOSEST_HIT_SHADER = 0x08;
361        const CULL_BACK_FACING = 0x10;
362        const CULL_FRONT_FACING = 0x20;
363        const CULL_OPAQUE = 0x40;
364        const CULL_NO_OPAQUE = 0x80;
365        const SKIP_TRIANGLES = 0x100;
366        const SKIP_AABBS = 0x200;
367    }
368}
369
370/// The intersection test to use for ray queries.
371#[repr(u32)]
372pub enum RayIntersectionType {
373    Triangle = 1,
374    BoundingBox = 4,
375}
naga/back/mod.rs

naga/back/
mod.rs
