Enum wgpu::naga::Statement

pub enum Statement {
    Emit(Range<Expression>),
    Block(Block),
    If {
        condition: Handle<Expression>,
        accept: Block,
        reject: Block,
    },
    Switch {
        selector: Handle<Expression>,
        cases: Vec<SwitchCase>,
    },
    Loop {
        body: Block,
        continuing: Block,
        break_if: Option<Handle<Expression>>,
    },
    Break,
    Continue,
    Return {
        value: Option<Handle<Expression>>,
    },
    Kill,
    Barrier(Barrier),
    Store {
        pointer: Handle<Expression>,
        value: Handle<Expression>,
    },
    ImageStore {
        image: Handle<Expression>,
        coordinate: Handle<Expression>,
        array_index: Option<Handle<Expression>>,
        value: Handle<Expression>,
    },
    Atomic {
        pointer: Handle<Expression>,
        fun: AtomicFunction,
        value: Handle<Expression>,
        result: Handle<Expression>,
    },
    WorkGroupUniformLoad {
        pointer: Handle<Expression>,
        result: Handle<Expression>,
    },
    Call {
        function: Handle<Function>,
        arguments: Vec<Handle<Expression>>,
        result: Option<Handle<Expression>>,
    },
    RayQuery {
        query: Handle<Expression>,
        fun: RayQueryFunction,
    },
}

Instructions which make up an executable block.

Variants

Emit(Range<Expression>)

Emit a range of expressions, visible to all statements that follow in this block.

See the module-level documentation for details.

Block(Block)

A block containing more statements, to be executed sequentially.

If

Fields

condition: Handle<Expression>

accept: Block

reject: Block

Conditionally executes one of two blocks, based on the value of the condition.

Switch

Fields

selector: Handle<Expression>

cases: Vec<SwitchCase>

Conditionally executes one of multiple blocks, based on the value of the selector.

Each case must have a distinct value, exactly one of which must be Default. The Default may appear at any position, and covers all values not explicitly appearing in other cases. A Default appearing in the midst of the list of cases does not shadow the cases that follow.

Some backend languages don’t support fallthrough (HLSL due to FXC, WGSL), and may translate fallthrough cases in the IR by duplicating code. However, all backend languages do support cases selected by multiple values, like case 1: case 2: case 3: { ... }. This is represented in the IR as a series of fallthrough cases with empty bodies, except for the last.

Loop

Fields

body: Block

continuing: Block

break_if: Option<Handle<Expression>>

Executes a block repeatedly.

Each iteration of the loop executes the body block, followed by the continuing block.

Executing a Break, Return or Kill statement exits the loop.

A Continue statement in body jumps to the continuing block. The continuing block is meant to be used to represent structures like the third expression of a C-style for loop head, to which continue statements in the loop’s body jump.

The continuing block and its substatements must not contain Return or Kill statements, or any Break or Continue statements targeting this loop. (It may have Break and Continue statements targeting loops or switches nested within the continuing block.) Expressions emitted in body are in scope in continuing.

If present, break_if is an expression which is evaluated after the continuing block. Expressions emitted in body or continuing are considered to be in scope. If the expression’s value is true, control continues after the Loop statement, rather than branching back to the top of body as usual. The break_if expression corresponds to a “break if” statement in WGSL, or a loop whose back edge is an OpBranchConditional instruction in SPIR-V.

Break

Exits the innermost enclosing Loop or Switch.

A Break statement may only appear within a Loop or Switch statement. It may not break out of a Loop from within the loop’s continuing block.

Continue

Skips to the continuing block of the innermost enclosing Loop.

A Continue statement may only appear within the body block of the innermost enclosing Loop statement. It must not appear within that loop’s continuing block.

Return

Fields

value: Option<Handle<Expression>>

Returns from the function (possibly with a value).

Return statements are forbidden within the continuing block of a Loop statement.

Kill

Aborts the current shader execution.

Kill statements are forbidden within the continuing block of a Loop statement.

Barrier(Barrier)

Synchronize invocations within the work group. The Barrier flags control which memory accesses should be synchronized. If empty, this becomes purely an execution barrier.

Store

Fields

pointer: Handle<Expression>

value: Handle<Expression>

Stores a value at an address.

For TypeInner::Atomic type behind the pointer, the value has to be a corresponding scalar. For other types behind the pointer<T>, the value is T.

This statement is a barrier for any operations on the Expression::LocalVariable or Expression::GlobalVariable that is the destination of an access chain, started from the pointer.

ImageStore

Fields

image: Handle<Expression>

coordinate: Handle<Expression>

array_index: Option<Handle<Expression>>

value: Handle<Expression>

Stores a texel value to an image.

The image, coordinate, and array_index fields have the same meanings as the corresponding operands of an ImageLoad expression; see that documentation for details. Storing into multisampled images or images with mipmaps is not supported, so there are no level or sample operands.

This statement is a barrier for any operations on the corresponding Expression::GlobalVariable for this image.

Atomic

Fields

pointer: Handle<Expression>

Pointer to an atomic value.

fun: AtomicFunction

Function to run on the atomic.

value: Handle<Expression>

Value to use in the function.

result: Handle<Expression>

AtomicResult expression representing this function’s result.

Atomic function.

WorkGroupUniformLoad

Fields

pointer: Handle<Expression>

This must be of type Pointer in the WorkGroup address space

result: Handle<Expression>

The WorkGroupUniformLoadResult expression representing this load’s result.

Load uniformly from a uniform pointer in the workgroup address space.

Corresponds to the workgroupUniformLoad built-in function of wgsl, and has the same barrier semantics

Call

Fields

function: Handle<Function>

arguments: Vec<Handle<Expression>>

result: Option<Handle<Expression>>

Calls a function.

If the result is Some, the corresponding expression has to be Expression::CallResult, and this statement serves as a barrier for any operations on that expression.

RayQuery

Fields

query: Handle<Expression>

The RayQuery object this statement operates on.

fun: RayQueryFunction

The specific operation we’re performing on query.

Implementations

impl Statement

pub const fn is_terminator(&self) -> bool

Returns true if the statement directly terminates the current block.

Used to decide whether case blocks require a explicit break.

Trait Implementations

impl Clone for Statement

fn clone(&self) -> Statement

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Statement

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.