pub enum Statement {
Show 16 variants
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,
},
}Expand description
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
Conditionally executes one of two blocks, based on the value of the condition.
Switch
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
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
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: AtomicFunctionFunction 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>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
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: RayQueryFunctionThe specific operation we’re performing on query.