Struct rspirv::dr::Builder

pub struct Builder { /* fields omitted */ }

The data representation builder.

Constructs a Module by aggregating results from method calls for various instructions.

This builder is designed to be low level; its build methods’ signatures basically reflects the layout of the corresponding SPIR-V instructions faithfully.

If a SPIR-V instruction generates a result id and the result id can be forward referenced, the build method will take an optional result_id parameter. Filling it with Some(val) will instruct the builder to use the given val as the result id. For other cases, an unused result id will be automatically assigned from the builder.

So for instructions forward referencing an id, to avoid id collision, you can either

• first append the target instruction generating that id and then append the forward referencing instruction; or
• use the id() method to get an unused id from the builder, use it in the forward referencing instruction, and then later fill the optional result_id parameter of the target instruction with the same id.

Instructions belonging to the module (e.g., OpDecorate) can be appended at any time, no matter that a block is currently under construction or not. Intructions that can appear both in the module and block (e.g., OpVariable) will be inserted to the current block under construction first, if any.

Errors

Methods in the builder implement little sanity check; only appending instructions that violates the module structure is guarded. So methods possibly returning errors are basically those related to function and block construction (e.g., OpFunction and OpLabel).

Errors returned are enumerants related to function structure from the Error enum.

Examples

use rspirv::binary::Disassemble;

fn main() {
    let mut b = rspirv::dr::Builder::new();
    b.set_version(1, 0);
    b.memory_model(spirv::AddressingModel::Logical, spirv::MemoryModel::Simple);
    let void = b.type_void();
    let voidf = b.type_function(void, vec![void]);
    b.begin_function(void,
                     None,
                     (spirv::FunctionControl::DONT_INLINE |
                      spirv::FunctionControl::CONST),
                     voidf)
     .unwrap();
    b.begin_block(None).unwrap();
    b.ret().unwrap();
    b.end_function().unwrap();

    assert_eq!(b.module().disassemble(),
               "; SPIR-V\n\
                ; Version: 1.0\n\
                ; Generator: rspirv\n\
                ; Bound: 5\n\
                OpMemoryModel Logical Simple\n\
                %1 = OpTypeVoid\n\
                %2 = OpTypeFunction %1 %1\n\
                %3 = OpFunction  %1  DontInline|Const %2\n\
                %4 = OpLabel\n\
                OpReturn\n\
                OpFunctionEnd");
}

Implementations

impl Builder

pub fn new() -> Builder

Creates a new empty builder.

pub fn new_from_module(module: Module) -> Builder

Create a new builder from an existing module

pub fn insert_into_block(
    &mut self,
    insert_point: InsertPoint,
    inst: Instruction
) -> Result<(), Error>

pub fn insert_types_global_values(
    &mut self,
    insert_point: InsertPoint,
    inst: Instruction
)

pub fn pop_instruction(&mut self) -> Result<Instruction, Error>

pub fn set_version(&mut self, major: u8, minor: u8)

Sets the SPIR-V version to the given major.minor version.

If this method is not called, the generated SPIR-V will be set as the newest version supported.

pub fn version(&self) -> Option<(u8, u8)>

Get the SPIR-V version as a (major, minor) tuple

pub fn module(self) -> Module

Returns the Module under construction.

pub fn module_ref(&self) -> &Module

Returns the Module under construction as a reference. Note that header.bound will be inaccurate.

pub fn module_mut(&mut self) -> &mut Module

Returns the Module under construction as a mutable reference. Note that header.bound will be inaccurate.

pub fn selected_function(&self) -> Option<usize>

pub fn selected_block(&self) -> Option<usize>

pub fn id(&mut self) -> Word

Returns the next unused id.

pub fn dedup_insert_type(&mut self, inst: &Instruction) -> Option<Word>

Insert a OpType instruction, deduplicate it if needed and either return the existing ID or a new unused ID if we can’t find find the instruction already. Useful to uphold the SPIR-V rule that non-aggregate types can’t be duplicates.

pub fn find_return_block_indices(&self) -> Vec<usize>

Find all blocks that end in OpReturn

pub fn select_function_by_name(&mut self, name: &str) -> Result<(), Error>

Select a function to insert instructions into by name

pub fn select_function(&mut self, idx: Option<usize>) -> Result<(), Error>

Select a function to insert instructions into by index (indexed into self.module.functions), or unselect if None

pub fn select_block(&mut self, idx: Option<usize>) -> Result<(), Error>

Select a basic block (by index) to insert instructions into, indexed off of self.modules.functions[self.selected_function].blocks[idx], or unselect if None

pub fn begin_function(
    &mut self,
    return_type: Word,
    function_id: Option<Word>,
    control: FunctionControl,
    function_type: Word
) -> Result<Word, Error>

Begins building of a new function.

If function_id is Some(val), then val will be used as the result id of the function under construction; otherwise, an unused result id will be automatically assigned.

pub fn end_function(&mut self) -> Result<(), Error>

Ends building of the current function.

pub fn function_parameter(&mut self, result_type: Word) -> Result<Word, Error>

Declares a formal parameter for the current function.

pub fn begin_block(&mut self, label_id: Option<Word>) -> Result<Word, Error>

Begins building of a new block.

If label_id is Some(val), then val will be used as the result id for the OpLabel instruction begining this block; otherwise, a unused result id will be automatically assigned.

pub fn begin_block_no_label(
    &mut self,
    label_id: Option<Word>
) -> Result<Word, Error>

Begins building of a new block.

Counter to begin_block that always generates a new OpLabel at the beginning of a block - in some cases this is undesirable (such as when constructing a branch).

pub fn capability(&mut self, capability: Capability)

Appends an OpCapability instruction.

pub fn extension(&mut self, extension: impl Into<String>)

Appends an OpExtension instruction.

pub fn ext_inst_import(&mut self, extended_inst_set: impl Into<String>) -> Word

Appends an OpExtInstImport instruction and returns the result id.

pub fn memory_model(
    &mut self,
    addressing_model: AddressingModel,
    memory_model: MemoryModel
)

Appends an OpMemoryModel instruction.

pub fn entry_point(
    &mut self,
    execution_model: ExecutionModel,
    entry_point: Word,
    name: impl Into<String>,
    interface: impl AsRef<[Word]>
)

Appends an OpEntryPoint instruction.

pub fn execution_mode(
    &mut self,
    entry_point: Word,
    execution_mode: ExecutionMode,
    params: impl AsRef<[u32]>
)

Appends an OpExecutionMode instruction.

pub fn execution_mode_id(
    &mut self,
    entry_point: Word,
    execution_mode: ExecutionMode,
    params: impl AsRef<[u32]>
)

Appends an OpExecutionModeId instruction.

pub fn ext_inst(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    extension_set: Word,
    instruction: Word,
    operands: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

pub fn line(&mut self, file: Word, line: u32, column: u32)

Appends an OpLine instruction.

If a block is currently selected, the OpLine is inserted into that block. If no block is currently selected, the OpLine is inserted into types_global_values.

pub fn no_line(&mut self)

Appends an OpNoLine instruction.

If a block is currently selected, the OpNoLine is inserted into that block. If no block is currently selected, the OpNoLine is inserted into types_global_values.

impl Builder

pub fn type_void(&mut self) -> Word

Appends an OpTypeVoid instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_void_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypeVoid instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_bool(&mut self) -> Word

Appends an OpTypeBool instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_bool_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypeBool instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_int(&mut self, width: u32, signedness: u32) -> Word

Appends an OpTypeInt instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_int_id(
    &mut self,
    result_id: Option<Word>,
    width: u32,
    signedness: u32
) -> Word

Appends an OpTypeInt instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_float(&mut self, width: u32) -> Word

Appends an OpTypeFloat instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_float_id(&mut self, result_id: Option<Word>, width: u32) -> Word

Appends an OpTypeFloat instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_vector(
    &mut self,
    component_type: Word,
    component_count: u32
) -> Word

Appends an OpTypeVector instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_vector_id(
    &mut self,
    result_id: Option<Word>,
    component_type: Word,
    component_count: u32
) -> Word

Appends an OpTypeVector instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_matrix(&mut self, column_type: Word, column_count: u32) -> Word

Appends an OpTypeMatrix instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_matrix_id(
    &mut self,
    result_id: Option<Word>,
    column_type: Word,
    column_count: u32
) -> Word

Appends an OpTypeMatrix instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_image(
    &mut self,
    sampled_type: Word,
    dim: Dim,
    depth: u32,
    arrayed: u32,
    ms: u32,
    sampled: u32,
    image_format: ImageFormat,
    access_qualifier: Option<AccessQualifier>
) -> Word

Appends an OpTypeImage instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_image_id(
    &mut self,
    result_id: Option<Word>,
    sampled_type: Word,
    dim: Dim,
    depth: u32,
    arrayed: u32,
    ms: u32,
    sampled: u32,
    image_format: ImageFormat,
    access_qualifier: Option<AccessQualifier>
) -> Word

Appends an OpTypeImage instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_sampler(&mut self) -> Word

Appends an OpTypeSampler instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_sampler_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypeSampler instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_sampled_image(&mut self, image_type: Word) -> Word

Appends an OpTypeSampledImage instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_sampled_image_id(
    &mut self,
    result_id: Option<Word>,
    image_type: Word
) -> Word

Appends an OpTypeSampledImage instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_array(&mut self, element_type: Word, length: Word) -> Word

Appends an OpTypeArray instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_array_id(
    &mut self,
    result_id: Option<Word>,
    element_type: Word,
    length: Word
) -> Word

Appends an OpTypeArray instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_runtime_array(&mut self, element_type: Word) -> Word

Appends an OpTypeRuntimeArray instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_runtime_array_id(
    &mut self,
    result_id: Option<Word>,
    element_type: Word
) -> Word

Appends an OpTypeRuntimeArray instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_struct(
    &mut self,
    member_0_type_member_1_type: impl IntoIterator<Item = Word>
) -> Word

Appends an OpTypeStruct instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_struct_id(
    &mut self,
    result_id: Option<Word>,
    member_0_type_member_1_type: impl IntoIterator<Item = Word>
) -> Word

Appends an OpTypeStruct instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_function(
    &mut self,
    return_type: Word,
    parameter_0_type_parameter_1_type: impl IntoIterator<Item = Word>
) -> Word

Appends an OpTypeFunction instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_function_id(
    &mut self,
    result_id: Option<Word>,
    return_type: Word,
    parameter_0_type_parameter_1_type: impl IntoIterator<Item = Word>
) -> Word

Appends an OpTypeFunction instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_event(&mut self) -> Word

Appends an OpTypeEvent instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_event_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypeEvent instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_device_event(&mut self) -> Word

Appends an OpTypeDeviceEvent instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_device_event_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypeDeviceEvent instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_reserve_id(&mut self) -> Word

Appends an OpTypeReserveId instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_reserve_id_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypeReserveId instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_queue(&mut self) -> Word

Appends an OpTypeQueue instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_queue_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypeQueue instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_pipe(&mut self, qualifier: AccessQualifier) -> Word

Appends an OpTypePipe instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_pipe_id(
    &mut self,
    result_id: Option<Word>,
    qualifier: AccessQualifier
) -> Word

Appends an OpTypePipe instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_pipe_storage(&mut self) -> Word

Appends an OpTypePipeStorage instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_pipe_storage_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypePipeStorage instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_named_barrier(&mut self) -> Word

Appends an OpTypeNamedBarrier instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_named_barrier_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypeNamedBarrier instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_ray_query_khr(&mut self) -> Word

Appends an OpTypeRayQueryKHR instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_ray_query_khr_id(&mut self, result_id: Option<Word>) -> Word

Appends an OpTypeRayQueryKHR instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_acceleration_structure_khr(&mut self) -> Word

Appends an OpTypeAccelerationStructureKHR instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_acceleration_structure_khr_id(
    &mut self,
    result_id: Option<Word>
) -> Word

Appends an OpTypeAccelerationStructureKHR instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_cooperative_matrix_nv(
    &mut self,
    component_type: Word,
    execution: Word,
    rows: Word,
    columns: Word
) -> Word

Appends an OpTypeCooperativeMatrixNV instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_cooperative_matrix_nv_id(
    &mut self,
    result_id: Option<Word>,
    component_type: Word,
    execution: Word,
    rows: Word,
    columns: Word
) -> Word

Appends an OpTypeCooperativeMatrixNV instruction and returns the result id, or return the existing id if the instruction was already present.

impl Builder

pub fn constant_true(&mut self, result_type: Word) -> Word

Appends an OpConstantTrue instruction.

pub fn constant_false(&mut self, result_type: Word) -> Word

Appends an OpConstantFalse instruction.

pub fn constant_composite(
    &mut self,
    result_type: Word,
    constituents: impl IntoIterator<Item = Word>
) -> Word

Appends an OpConstantComposite instruction.

pub fn constant_sampler(
    &mut self,
    result_type: Word,
    sampler_addressing_mode: SamplerAddressingMode,
    param: u32,
    sampler_filter_mode: SamplerFilterMode
) -> Word

Appends an OpConstantSampler instruction.

pub fn constant_null(&mut self, result_type: Word) -> Word

Appends an OpConstantNull instruction.

pub fn spec_constant_true(&mut self, result_type: Word) -> Word

Appends an OpSpecConstantTrue instruction.

pub fn spec_constant_false(&mut self, result_type: Word) -> Word

Appends an OpSpecConstantFalse instruction.

pub fn spec_constant_composite(
    &mut self,
    result_type: Word,
    constituents: impl IntoIterator<Item = Word>
) -> Word

Appends an OpSpecConstantComposite instruction.

pub fn spec_constant_op(&mut self, result_type: Word, opcode: Op) -> Word

Appends an OpSpecConstantOp instruction.

impl Builder

pub fn decorate(
    &mut self,
    target: Word,
    decoration: Decoration,
    additional_params: impl IntoIterator<Item = Operand>
)

Appends an OpDecorate instruction.

pub fn member_decorate(
    &mut self,
    structure_type: Word,
    member: u32,
    decoration: Decoration,
    additional_params: impl IntoIterator<Item = Operand>
)

Appends an OpMemberDecorate instruction.

pub fn group_decorate(
    &mut self,
    decoration_group: Word,
    targets: impl IntoIterator<Item = Word>
)

Appends an OpGroupDecorate instruction.

pub fn group_member_decorate(
    &mut self,
    decoration_group: Word,
    targets: impl IntoIterator<Item = (Word, u32)>
)

Appends an OpGroupMemberDecorate instruction.

pub fn decorate_id(
    &mut self,
    target: Word,
    decoration: Decoration,
    additional_params: impl IntoIterator<Item = Operand>
)

Appends an OpDecorateId instruction.

pub fn decorate_string(
    &mut self,
    target: Word,
    decoration: Decoration,
    additional_params: impl IntoIterator<Item = Operand>
)

Appends an OpDecorateString instruction.

pub fn decorate_string_google(
    &mut self,
    target: Word,
    decoration: Decoration,
    additional_params: impl IntoIterator<Item = Operand>
)

Appends an OpDecorateStringGOOGLE instruction.

pub fn member_decorate_string(
    &mut self,
    struct_type: Word,
    member: u32,
    decoration: Decoration,
    additional_params: impl IntoIterator<Item = Operand>
)

Appends an OpMemberDecorateString instruction.

pub fn member_decorate_string_google(
    &mut self,
    struct_type: Word,
    member: u32,
    decoration: Decoration,
    additional_params: impl IntoIterator<Item = Operand>
)

Appends an OpMemberDecorateStringGOOGLE instruction.

impl Builder

pub fn loop_merge(
    &mut self,
    merge_block: Word,
    continue_target: Word,
    loop_control: LoopControl,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpLoopMerge instruction and ends the current block.

pub fn insert_loop_merge(
    &mut self,
    insert_point: InsertPoint,
    merge_block: Word,
    continue_target: Word,
    loop_control: LoopControl,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Insert an OpLoopMerge instruction and ends the current block.

pub fn selection_merge(
    &mut self,
    merge_block: Word,
    selection_control: SelectionControl
) -> Result<(), Error>

Appends an OpSelectionMerge instruction and ends the current block.

pub fn insert_selection_merge(
    &mut self,
    insert_point: InsertPoint,
    merge_block: Word,
    selection_control: SelectionControl
) -> Result<(), Error>

Insert an OpSelectionMerge instruction and ends the current block.

pub fn branch(&mut self, target_label: Word) -> Result<(), Error>

Appends an OpBranch instruction and ends the current block.

pub fn insert_branch(
    &mut self,
    insert_point: InsertPoint,
    target_label: Word
) -> Result<(), Error>

Insert an OpBranch instruction and ends the current block.

pub fn branch_conditional(
    &mut self,
    condition: Word,
    true_label: Word,
    false_label: Word,
    branch_weights: impl IntoIterator<Item = u32>
) -> Result<(), Error>

Appends an OpBranchConditional instruction and ends the current block.

pub fn insert_branch_conditional(
    &mut self,
    insert_point: InsertPoint,
    condition: Word,
    true_label: Word,
    false_label: Word,
    branch_weights: impl IntoIterator<Item = u32>
) -> Result<(), Error>

Insert an OpBranchConditional instruction and ends the current block.

pub fn switch(
    &mut self,
    selector: Word,
    default: Word,
    target: impl IntoIterator<Item = (Operand, Word)>
) -> Result<(), Error>

Appends an OpSwitch instruction and ends the current block.

pub fn insert_switch(
    &mut self,
    insert_point: InsertPoint,
    selector: Word,
    default: Word,
    target: impl IntoIterator<Item = (Operand, Word)>
) -> Result<(), Error>

Insert an OpSwitch instruction and ends the current block.

pub fn kill(&mut self) -> Result<(), Error>

Appends an OpKill instruction and ends the current block.

pub fn insert_kill(&mut self, insert_point: InsertPoint) -> Result<(), Error>

Insert an OpKill instruction and ends the current block.

pub fn ret(&mut self) -> Result<(), Error>

Appends an OpReturn instruction and ends the current block.

pub fn insert_ret(&mut self, insert_point: InsertPoint) -> Result<(), Error>

Insert an OpReturn instruction and ends the current block.

pub fn ret_value(&mut self, value: Word) -> Result<(), Error>

Appends an OpReturnValue instruction and ends the current block.

pub fn insert_ret_value(
    &mut self,
    insert_point: InsertPoint,
    value: Word
) -> Result<(), Error>

Insert an OpReturnValue instruction and ends the current block.

pub fn unreachable(&mut self) -> Result<(), Error>

Appends an OpUnreachable instruction and ends the current block.

pub fn insert_unreachable(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Insert an OpUnreachable instruction and ends the current block.

pub fn lifetime_start(&mut self, pointer: Word, size: u32) -> Result<(), Error>

Appends an OpLifetimeStart instruction and ends the current block.

pub fn insert_lifetime_start(
    &mut self,
    insert_point: InsertPoint,
    pointer: Word,
    size: u32
) -> Result<(), Error>

Insert an OpLifetimeStart instruction and ends the current block.

pub fn lifetime_stop(&mut self, pointer: Word, size: u32) -> Result<(), Error>

Appends an OpLifetimeStop instruction and ends the current block.

pub fn insert_lifetime_stop(
    &mut self,
    insert_point: InsertPoint,
    pointer: Word,
    size: u32
) -> Result<(), Error>

Insert an OpLifetimeStop instruction and ends the current block.

pub fn terminate_invocation(&mut self) -> Result<(), Error>

Appends an OpTerminateInvocation instruction and ends the current block.

pub fn insert_terminate_invocation(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Insert an OpTerminateInvocation instruction and ends the current block.

pub fn ignore_intersection_khr(&mut self) -> Result<(), Error>

Appends an OpIgnoreIntersectionKHR instruction and ends the current block.

pub fn insert_ignore_intersection_khr(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Insert an OpIgnoreIntersectionKHR instruction and ends the current block.

pub fn terminate_ray_khr(&mut self) -> Result<(), Error>

Appends an OpTerminateRayKHR instruction and ends the current block.

pub fn insert_terminate_ray_khr(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Insert an OpTerminateRayKHR instruction and ends the current block.

impl Builder

pub fn source_continued(&mut self, continued_source: impl Into<String>)

Appends an OpSourceContinued instruction.

pub fn source(
    &mut self,
    source_language: SourceLanguage,
    version: u32,
    file: Option<Word>,
    source: Option<impl Into<String>>
)

Appends an OpSource instruction.

pub fn source_extension(&mut self, extension: impl Into<String>)

Appends an OpSourceExtension instruction.

pub fn name(&mut self, target: Word, name: impl Into<String>)

Appends an OpName instruction.

pub fn member_name(&mut self, ty: Word, member: u32, name: impl Into<String>)

Appends an OpMemberName instruction.

pub fn module_processed(&mut self, process: impl Into<String>)

Appends an OpModuleProcessed instruction.

impl Builder

pub fn decoration_group(&mut self) -> Word

Appends an OpDecorationGroup instruction and returns the result id.

pub fn string(&mut self, s: impl Into<String>) -> Word

impl Builder

pub fn type_forward_pointer(
    &mut self,
    pointer_type: Word,
    storage_class: StorageClass
)

Appends an OpTypeForwardPointer instruction.

pub fn type_pointer(
    &mut self,
    result_id: Option<Word>,
    storage_class: StorageClass,
    pointee_type: Word
) -> Word

Appends an OpTypePointer instruction and returns the result id, or return the existing id if the instruction was already present.

pub fn type_opaque(&mut self, type_name: impl Into<String>) -> Word

Appends an OpTypeOpaque instruction and returns the result id.

pub fn constant_f32(&mut self, result_type: Word, value: f32) -> Word

Appends an OpConstant instruction with the given 32-bit float value. or the module if no block is under construction.

pub fn constant_f64(&mut self, result_type: Word, value: f64) -> Word

Appends an OpConstant instruction with the given 64-bit float value.

pub fn constant_u32(&mut self, result_type: Word, value: u32) -> Word

Appends an OpConstant instruction with the given 32-bit integer value. or the module if no block is under construction.

pub fn constant_u64(&mut self, result_type: Word, value: u64) -> Word

Appends an OpConstant instruction with the given 64-bit integer value.

pub fn spec_constant_f32(&mut self, result_type: Word, value: f32) -> Word

Appends an OpSpecConstant instruction with the given 32-bit float value. or the module if no block is under construction.

pub fn spec_constant_f64(&mut self, result_type: Word, value: f64) -> Word

Appends an OpSpecConstant instruction with the given 64-bit float value.

pub fn spec_constant_u32(&mut self, result_type: Word, value: u32) -> Word

Appends an OpSpecConstant instruction with the given 32-bit integer value. or the module if no block is under construction.

pub fn spec_constant_u64(&mut self, result_type: Word, value: u64) -> Word

Appends an OpSpecConstant instruction with the given 32-bit integer value.

pub fn variable(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    storage_class: StorageClass,
    initializer: Option<Word>
) -> Word

Appends an OpVariable instruction to either the current block or the module if no block is under construction.

pub fn undef(&mut self, result_type: Word, result_id: Option<Word>) -> Word

Appends an OpUndef instruction to either the current block or the module if no block is under construction.

impl Builder

pub fn nop(&mut self) -> Result<(), Error>

Appends an OpNop instruction to the current block.

pub fn insert_nop(&mut self, insert_point: InsertPoint) -> Result<(), Error>

Appends an OpNop instruction to the current block.

pub fn function_call(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    function: Word,
    argument_0_argument_1: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpFunctionCall instruction to the current block.

pub fn insert_function_call(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    function: Word,
    argument_0_argument_1: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpFunctionCall instruction to the current block.

pub fn image_texel_pointer(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    sample: Word
) -> Result<Word, Error>

Appends an OpImageTexelPointer instruction to the current block.

pub fn insert_image_texel_pointer(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    sample: Word
) -> Result<Word, Error>

Appends an OpImageTexelPointer instruction to the current block.

pub fn load(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory_access: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpLoad instruction to the current block.

pub fn insert_load(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory_access: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpLoad instruction to the current block.

pub fn store(
    &mut self,
    pointer: Word,
    object: Word,
    memory_access: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpStore instruction to the current block.

pub fn insert_store(
    &mut self,
    insert_point: InsertPoint,
    pointer: Word,
    object: Word,
    memory_access: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpStore instruction to the current block.

pub fn copy_memory(
    &mut self,
    target: Word,
    source: Word,
    memory_access: Option<MemoryAccess>,
    memory_access_2: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpCopyMemory instruction to the current block.

pub fn insert_copy_memory(
    &mut self,
    insert_point: InsertPoint,
    target: Word,
    source: Word,
    memory_access: Option<MemoryAccess>,
    memory_access_2: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpCopyMemory instruction to the current block.

pub fn copy_memory_sized(
    &mut self,
    target: Word,
    source: Word,
    size: Word,
    memory_access: Option<MemoryAccess>,
    memory_access_2: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpCopyMemorySized instruction to the current block.

pub fn insert_copy_memory_sized(
    &mut self,
    insert_point: InsertPoint,
    target: Word,
    source: Word,
    size: Word,
    memory_access: Option<MemoryAccess>,
    memory_access_2: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpCopyMemorySized instruction to the current block.

pub fn access_chain(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    indexes: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpAccessChain instruction to the current block.

pub fn insert_access_chain(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    indexes: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpAccessChain instruction to the current block.

pub fn in_bounds_access_chain(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    indexes: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpInBoundsAccessChain instruction to the current block.

pub fn insert_in_bounds_access_chain(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    indexes: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpInBoundsAccessChain instruction to the current block.

pub fn ptr_access_chain(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    element: Word,
    indexes: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpPtrAccessChain instruction to the current block.

pub fn insert_ptr_access_chain(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    element: Word,
    indexes: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpPtrAccessChain instruction to the current block.

pub fn array_length(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    structure: Word,
    array_member: u32
) -> Result<Word, Error>

Appends an OpArrayLength instruction to the current block.

pub fn insert_array_length(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    structure: Word,
    array_member: u32
) -> Result<Word, Error>

Appends an OpArrayLength instruction to the current block.

pub fn generic_ptr_mem_semantics(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpGenericPtrMemSemantics instruction to the current block.

pub fn insert_generic_ptr_mem_semantics(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpGenericPtrMemSemantics instruction to the current block.

pub fn in_bounds_ptr_access_chain(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    element: Word,
    indexes: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpInBoundsPtrAccessChain instruction to the current block.

pub fn insert_in_bounds_ptr_access_chain(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    element: Word,
    indexes: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpInBoundsPtrAccessChain instruction to the current block.

pub fn vector_extract_dynamic(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpVectorExtractDynamic instruction to the current block.

pub fn insert_vector_extract_dynamic(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpVectorExtractDynamic instruction to the current block.

pub fn vector_insert_dynamic(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word,
    component: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpVectorInsertDynamic instruction to the current block.

pub fn insert_vector_insert_dynamic(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word,
    component: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpVectorInsertDynamic instruction to the current block.

pub fn vector_shuffle(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    vector_1: Word,
    vector_2: Word,
    components: impl IntoIterator<Item = u32>
) -> Result<Word, Error>

Appends an OpVectorShuffle instruction to the current block.

pub fn insert_vector_shuffle(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    vector_1: Word,
    vector_2: Word,
    components: impl IntoIterator<Item = u32>
) -> Result<Word, Error>

Appends an OpVectorShuffle instruction to the current block.

pub fn composite_construct(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    constituents: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpCompositeConstruct instruction to the current block.

pub fn insert_composite_construct(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    constituents: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpCompositeConstruct instruction to the current block.

pub fn composite_extract(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    composite: Word,
    indexes: impl IntoIterator<Item = u32>
) -> Result<Word, Error>

Appends an OpCompositeExtract instruction to the current block.

pub fn insert_composite_extract(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    composite: Word,
    indexes: impl IntoIterator<Item = u32>
) -> Result<Word, Error>

Appends an OpCompositeExtract instruction to the current block.

pub fn composite_insert(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    object: Word,
    composite: Word,
    indexes: impl IntoIterator<Item = u32>
) -> Result<Word, Error>

Appends an OpCompositeInsert instruction to the current block.

pub fn insert_composite_insert(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    object: Word,
    composite: Word,
    indexes: impl IntoIterator<Item = u32>
) -> Result<Word, Error>

Appends an OpCompositeInsert instruction to the current block.

pub fn copy_object(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpCopyObject instruction to the current block.

pub fn insert_copy_object(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpCopyObject instruction to the current block.

pub fn transpose(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    matrix: Word
) -> Result<Word, Error>

Appends an OpTranspose instruction to the current block.

pub fn insert_transpose(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    matrix: Word
) -> Result<Word, Error>

Appends an OpTranspose instruction to the current block.

pub fn sampled_image(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    sampler: Word
) -> Result<Word, Error>

Appends an OpSampledImage instruction to the current block.

pub fn insert_sampled_image(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    sampler: Word
) -> Result<Word, Error>

Appends an OpSampledImage instruction to the current block.

pub fn image_sample_implicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleImplicitLod instruction to the current block.

pub fn insert_image_sample_implicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleImplicitLod instruction to the current block.

pub fn image_sample_explicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleExplicitLod instruction to the current block.

pub fn insert_image_sample_explicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleExplicitLod instruction to the current block.

pub fn image_sample_dref_implicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleDrefImplicitLod instruction to the current block.

pub fn insert_image_sample_dref_implicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleDrefImplicitLod instruction to the current block.

pub fn image_sample_dref_explicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleDrefExplicitLod instruction to the current block.

pub fn insert_image_sample_dref_explicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleDrefExplicitLod instruction to the current block.

pub fn image_sample_proj_implicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleProjImplicitLod instruction to the current block.

pub fn insert_image_sample_proj_implicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleProjImplicitLod instruction to the current block.

pub fn image_sample_proj_explicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleProjExplicitLod instruction to the current block.

pub fn insert_image_sample_proj_explicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleProjExplicitLod instruction to the current block.

pub fn image_sample_proj_dref_implicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleProjDrefImplicitLod instruction to the current block.

pub fn insert_image_sample_proj_dref_implicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleProjDrefImplicitLod instruction to the current block.

pub fn image_sample_proj_dref_explicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleProjDrefExplicitLod instruction to the current block.

pub fn insert_image_sample_proj_dref_explicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleProjDrefExplicitLod instruction to the current block.

pub fn image_fetch(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageFetch instruction to the current block.

pub fn insert_image_fetch(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageFetch instruction to the current block.

pub fn image_gather(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    component: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageGather instruction to the current block.

pub fn insert_image_gather(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    component: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageGather instruction to the current block.

pub fn image_dref_gather(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageDrefGather instruction to the current block.

pub fn insert_image_dref_gather(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageDrefGather instruction to the current block.

pub fn image_read(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageRead instruction to the current block.

pub fn insert_image_read(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageRead instruction to the current block.

pub fn image_write(
    &mut self,
    image: Word,
    coordinate: Word,
    texel: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpImageWrite instruction to the current block.

pub fn insert_image_write(
    &mut self,
    insert_point: InsertPoint,
    image: Word,
    coordinate: Word,
    texel: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpImageWrite instruction to the current block.

pub fn image(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word
) -> Result<Word, Error>

Appends an OpImage instruction to the current block.

pub fn insert_image(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word
) -> Result<Word, Error>

Appends an OpImage instruction to the current block.

pub fn image_query_format(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQueryFormat instruction to the current block.

pub fn insert_image_query_format(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQueryFormat instruction to the current block.

pub fn image_query_order(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQueryOrder instruction to the current block.

pub fn insert_image_query_order(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQueryOrder instruction to the current block.

pub fn image_query_size_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    level_of_detail: Word
) -> Result<Word, Error>

Appends an OpImageQuerySizeLod instruction to the current block.

pub fn insert_image_query_size_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    level_of_detail: Word
) -> Result<Word, Error>

Appends an OpImageQuerySizeLod instruction to the current block.

pub fn image_query_size(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQuerySize instruction to the current block.

pub fn insert_image_query_size(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQuerySize instruction to the current block.

pub fn image_query_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word
) -> Result<Word, Error>

Appends an OpImageQueryLod instruction to the current block.

pub fn insert_image_query_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word
) -> Result<Word, Error>

Appends an OpImageQueryLod instruction to the current block.

pub fn image_query_levels(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQueryLevels instruction to the current block.

pub fn insert_image_query_levels(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQueryLevels instruction to the current block.

pub fn image_query_samples(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQuerySamples instruction to the current block.

pub fn insert_image_query_samples(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word
) -> Result<Word, Error>

Appends an OpImageQuerySamples instruction to the current block.

pub fn convert_f_to_u(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    float_value: Word
) -> Result<Word, Error>

Appends an OpConvertFToU instruction to the current block.

pub fn insert_convert_f_to_u(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    float_value: Word
) -> Result<Word, Error>

Appends an OpConvertFToU instruction to the current block.

pub fn convert_f_to_s(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    float_value: Word
) -> Result<Word, Error>

Appends an OpConvertFToS instruction to the current block.

pub fn insert_convert_f_to_s(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    float_value: Word
) -> Result<Word, Error>

Appends an OpConvertFToS instruction to the current block.

pub fn convert_s_to_f(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    signed_value: Word
) -> Result<Word, Error>

Appends an OpConvertSToF instruction to the current block.

pub fn insert_convert_s_to_f(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    signed_value: Word
) -> Result<Word, Error>

Appends an OpConvertSToF instruction to the current block.

pub fn convert_u_to_f(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    unsigned_value: Word
) -> Result<Word, Error>

Appends an OpConvertUToF instruction to the current block.

pub fn insert_convert_u_to_f(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    unsigned_value: Word
) -> Result<Word, Error>

Appends an OpConvertUToF instruction to the current block.

pub fn u_convert(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    unsigned_value: Word
) -> Result<Word, Error>

Appends an OpUConvert instruction to the current block.

pub fn insert_u_convert(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    unsigned_value: Word
) -> Result<Word, Error>

Appends an OpUConvert instruction to the current block.

pub fn s_convert(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    signed_value: Word
) -> Result<Word, Error>

Appends an OpSConvert instruction to the current block.

pub fn insert_s_convert(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    signed_value: Word
) -> Result<Word, Error>

Appends an OpSConvert instruction to the current block.

pub fn f_convert(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    float_value: Word
) -> Result<Word, Error>

Appends an OpFConvert instruction to the current block.

pub fn insert_f_convert(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    float_value: Word
) -> Result<Word, Error>

Appends an OpFConvert instruction to the current block.

pub fn quantize_to_f16(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    value: Word
) -> Result<Word, Error>

Appends an OpQuantizeToF16 instruction to the current block.

pub fn insert_quantize_to_f16(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    value: Word
) -> Result<Word, Error>

Appends an OpQuantizeToF16 instruction to the current block.

pub fn convert_ptr_to_u(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpConvertPtrToU instruction to the current block.

pub fn insert_convert_ptr_to_u(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpConvertPtrToU instruction to the current block.

pub fn sat_convert_s_to_u(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    signed_value: Word
) -> Result<Word, Error>

Appends an OpSatConvertSToU instruction to the current block.

pub fn insert_sat_convert_s_to_u(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    signed_value: Word
) -> Result<Word, Error>

Appends an OpSatConvertSToU instruction to the current block.

pub fn sat_convert_u_to_s(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    unsigned_value: Word
) -> Result<Word, Error>

Appends an OpSatConvertUToS instruction to the current block.

pub fn insert_sat_convert_u_to_s(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    unsigned_value: Word
) -> Result<Word, Error>

Appends an OpSatConvertUToS instruction to the current block.

pub fn convert_u_to_ptr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    integer_value: Word
) -> Result<Word, Error>

Appends an OpConvertUToPtr instruction to the current block.

pub fn insert_convert_u_to_ptr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    integer_value: Word
) -> Result<Word, Error>

Appends an OpConvertUToPtr instruction to the current block.

pub fn ptr_cast_to_generic(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpPtrCastToGeneric instruction to the current block.

pub fn insert_ptr_cast_to_generic(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpPtrCastToGeneric instruction to the current block.

pub fn generic_cast_to_ptr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpGenericCastToPtr instruction to the current block.

pub fn insert_generic_cast_to_ptr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpGenericCastToPtr instruction to the current block.

pub fn generic_cast_to_ptr_explicit(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    storage: StorageClass
) -> Result<Word, Error>

Appends an OpGenericCastToPtrExplicit instruction to the current block.

pub fn insert_generic_cast_to_ptr_explicit(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    storage: StorageClass
) -> Result<Word, Error>

Appends an OpGenericCastToPtrExplicit instruction to the current block.

pub fn bitcast(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpBitcast instruction to the current block.

pub fn insert_bitcast(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpBitcast instruction to the current block.

pub fn s_negate(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpSNegate instruction to the current block.

pub fn insert_s_negate(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpSNegate instruction to the current block.

pub fn f_negate(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpFNegate instruction to the current block.

pub fn insert_f_negate(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpFNegate instruction to the current block.

pub fn i_add(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAdd instruction to the current block.

pub fn insert_i_add(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAdd instruction to the current block.

pub fn f_add(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFAdd instruction to the current block.

pub fn insert_f_add(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFAdd instruction to the current block.

pub fn i_sub(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpISub instruction to the current block.

pub fn insert_i_sub(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpISub instruction to the current block.

pub fn f_sub(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFSub instruction to the current block.

pub fn insert_f_sub(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFSub instruction to the current block.

pub fn i_mul(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIMul instruction to the current block.

pub fn insert_i_mul(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIMul instruction to the current block.

pub fn f_mul(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFMul instruction to the current block.

pub fn insert_f_mul(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFMul instruction to the current block.

pub fn u_div(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUDiv instruction to the current block.

pub fn insert_u_div(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUDiv instruction to the current block.

pub fn s_div(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSDiv instruction to the current block.

pub fn insert_s_div(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSDiv instruction to the current block.

pub fn f_div(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFDiv instruction to the current block.

pub fn insert_f_div(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFDiv instruction to the current block.

pub fn u_mod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUMod instruction to the current block.

pub fn insert_u_mod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUMod instruction to the current block.

pub fn s_rem(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSRem instruction to the current block.

pub fn insert_s_rem(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSRem instruction to the current block.

pub fn s_mod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSMod instruction to the current block.

pub fn insert_s_mod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSMod instruction to the current block.

pub fn f_rem(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFRem instruction to the current block.

pub fn insert_f_rem(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFRem instruction to the current block.

pub fn f_mod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFMod instruction to the current block.

pub fn insert_f_mod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFMod instruction to the current block.

pub fn vector_times_scalar(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word,
    scalar: Word
) -> Result<Word, Error>

Appends an OpVectorTimesScalar instruction to the current block.

pub fn insert_vector_times_scalar(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word,
    scalar: Word
) -> Result<Word, Error>

Appends an OpVectorTimesScalar instruction to the current block.

pub fn matrix_times_scalar(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    matrix: Word,
    scalar: Word
) -> Result<Word, Error>

Appends an OpMatrixTimesScalar instruction to the current block.

pub fn insert_matrix_times_scalar(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    matrix: Word,
    scalar: Word
) -> Result<Word, Error>

Appends an OpMatrixTimesScalar instruction to the current block.

pub fn vector_times_matrix(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word,
    matrix: Word
) -> Result<Word, Error>

Appends an OpVectorTimesMatrix instruction to the current block.

pub fn insert_vector_times_matrix(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word,
    matrix: Word
) -> Result<Word, Error>

Appends an OpVectorTimesMatrix instruction to the current block.

pub fn matrix_times_vector(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    matrix: Word,
    vector: Word
) -> Result<Word, Error>

Appends an OpMatrixTimesVector instruction to the current block.

pub fn insert_matrix_times_vector(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    matrix: Word,
    vector: Word
) -> Result<Word, Error>

Appends an OpMatrixTimesVector instruction to the current block.

pub fn matrix_times_matrix(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    left_matrix: Word,
    right_matrix: Word
) -> Result<Word, Error>

Appends an OpMatrixTimesMatrix instruction to the current block.

pub fn insert_matrix_times_matrix(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    left_matrix: Word,
    right_matrix: Word
) -> Result<Word, Error>

Appends an OpMatrixTimesMatrix instruction to the current block.

pub fn outer_product(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    vector_1: Word,
    vector_2: Word
) -> Result<Word, Error>

Appends an OpOuterProduct instruction to the current block.

pub fn insert_outer_product(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    vector_1: Word,
    vector_2: Word
) -> Result<Word, Error>

Appends an OpOuterProduct instruction to the current block.

pub fn dot(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    vector_1: Word,
    vector_2: Word
) -> Result<Word, Error>

Appends an OpDot instruction to the current block.

pub fn insert_dot(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    vector_1: Word,
    vector_2: Word
) -> Result<Word, Error>

Appends an OpDot instruction to the current block.

pub fn i_add_carry(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAddCarry instruction to the current block.

pub fn insert_i_add_carry(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAddCarry instruction to the current block.

pub fn i_sub_borrow(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpISubBorrow instruction to the current block.

pub fn insert_i_sub_borrow(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpISubBorrow instruction to the current block.

pub fn u_mul_extended(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUMulExtended instruction to the current block.

pub fn insert_u_mul_extended(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUMulExtended instruction to the current block.

pub fn s_mul_extended(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSMulExtended instruction to the current block.

pub fn insert_s_mul_extended(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSMulExtended instruction to the current block.

pub fn any(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word
) -> Result<Word, Error>

Appends an OpAny instruction to the current block.

pub fn insert_any(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word
) -> Result<Word, Error>

Appends an OpAny instruction to the current block.

pub fn all(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word
) -> Result<Word, Error>

Appends an OpAll instruction to the current block.

pub fn insert_all(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    vector: Word
) -> Result<Word, Error>

Appends an OpAll instruction to the current block.

pub fn is_nan(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpIsNan instruction to the current block.

pub fn insert_is_nan(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpIsNan instruction to the current block.

pub fn is_inf(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpIsInf instruction to the current block.

pub fn insert_is_inf(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpIsInf instruction to the current block.

pub fn is_finite(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpIsFinite instruction to the current block.

pub fn insert_is_finite(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpIsFinite instruction to the current block.

pub fn is_normal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpIsNormal instruction to the current block.

pub fn insert_is_normal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpIsNormal instruction to the current block.

pub fn sign_bit_set(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpSignBitSet instruction to the current block.

pub fn insert_sign_bit_set(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    x: Word
) -> Result<Word, Error>

Appends an OpSignBitSet instruction to the current block.

pub fn less_or_greater(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    x: Word,
    y: Word
) -> Result<Word, Error>

Appends an OpLessOrGreater instruction to the current block.

pub fn insert_less_or_greater(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    x: Word,
    y: Word
) -> Result<Word, Error>

Appends an OpLessOrGreater instruction to the current block.

pub fn ordered(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    x: Word,
    y: Word
) -> Result<Word, Error>

Appends an OpOrdered instruction to the current block.

pub fn insert_ordered(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    x: Word,
    y: Word
) -> Result<Word, Error>

Appends an OpOrdered instruction to the current block.

pub fn unordered(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    x: Word,
    y: Word
) -> Result<Word, Error>

Appends an OpUnordered instruction to the current block.

pub fn insert_unordered(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    x: Word,
    y: Word
) -> Result<Word, Error>

Appends an OpUnordered instruction to the current block.

pub fn logical_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpLogicalEqual instruction to the current block.

pub fn insert_logical_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpLogicalEqual instruction to the current block.

pub fn logical_not_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpLogicalNotEqual instruction to the current block.

pub fn insert_logical_not_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpLogicalNotEqual instruction to the current block.

pub fn logical_or(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpLogicalOr instruction to the current block.

pub fn insert_logical_or(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpLogicalOr instruction to the current block.

pub fn logical_and(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpLogicalAnd instruction to the current block.

pub fn insert_logical_and(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpLogicalAnd instruction to the current block.

pub fn logical_not(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpLogicalNot instruction to the current block.

pub fn insert_logical_not(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpLogicalNot instruction to the current block.

pub fn select(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    condition: Word,
    object_1: Word,
    object_2: Word
) -> Result<Word, Error>

Appends an OpSelect instruction to the current block.

pub fn insert_select(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    condition: Word,
    object_1: Word,
    object_2: Word
) -> Result<Word, Error>

Appends an OpSelect instruction to the current block.

pub fn i_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIEqual instruction to the current block.

pub fn insert_i_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIEqual instruction to the current block.

pub fn i_not_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpINotEqual instruction to the current block.

pub fn insert_i_not_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpINotEqual instruction to the current block.

pub fn u_greater_than(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUGreaterThan instruction to the current block.

pub fn insert_u_greater_than(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUGreaterThan instruction to the current block.

pub fn s_greater_than(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSGreaterThan instruction to the current block.

pub fn insert_s_greater_than(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSGreaterThan instruction to the current block.

pub fn u_greater_than_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUGreaterThanEqual instruction to the current block.

pub fn insert_u_greater_than_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUGreaterThanEqual instruction to the current block.

pub fn s_greater_than_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSGreaterThanEqual instruction to the current block.

pub fn insert_s_greater_than_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSGreaterThanEqual instruction to the current block.

pub fn u_less_than(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpULessThan instruction to the current block.

pub fn insert_u_less_than(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpULessThan instruction to the current block.

pub fn s_less_than(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSLessThan instruction to the current block.

pub fn insert_s_less_than(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSLessThan instruction to the current block.

pub fn u_less_than_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpULessThanEqual instruction to the current block.

pub fn insert_u_less_than_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpULessThanEqual instruction to the current block.

pub fn s_less_than_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSLessThanEqual instruction to the current block.

pub fn insert_s_less_than_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpSLessThanEqual instruction to the current block.

pub fn f_ord_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdEqual instruction to the current block.

pub fn insert_f_ord_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdEqual instruction to the current block.

pub fn f_unord_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordEqual instruction to the current block.

pub fn insert_f_unord_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordEqual instruction to the current block.

pub fn f_ord_not_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdNotEqual instruction to the current block.

pub fn insert_f_ord_not_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdNotEqual instruction to the current block.

pub fn f_unord_not_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordNotEqual instruction to the current block.

pub fn insert_f_unord_not_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordNotEqual instruction to the current block.

pub fn f_ord_less_than(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdLessThan instruction to the current block.

pub fn insert_f_ord_less_than(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdLessThan instruction to the current block.

pub fn f_unord_less_than(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordLessThan instruction to the current block.

pub fn insert_f_unord_less_than(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordLessThan instruction to the current block.

pub fn f_ord_greater_than(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdGreaterThan instruction to the current block.

pub fn insert_f_ord_greater_than(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdGreaterThan instruction to the current block.

pub fn f_unord_greater_than(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordGreaterThan instruction to the current block.

pub fn insert_f_unord_greater_than(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordGreaterThan instruction to the current block.

pub fn f_ord_less_than_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdLessThanEqual instruction to the current block.

pub fn insert_f_ord_less_than_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdLessThanEqual instruction to the current block.

pub fn f_unord_less_than_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordLessThanEqual instruction to the current block.

pub fn insert_f_unord_less_than_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordLessThanEqual instruction to the current block.

pub fn f_ord_greater_than_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdGreaterThanEqual instruction to the current block.

pub fn insert_f_ord_greater_than_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFOrdGreaterThanEqual instruction to the current block.

pub fn f_unord_greater_than_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordGreaterThanEqual instruction to the current block.

pub fn insert_f_unord_greater_than_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpFUnordGreaterThanEqual instruction to the current block.

pub fn shift_right_logical(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    shift: Word
) -> Result<Word, Error>

Appends an OpShiftRightLogical instruction to the current block.

pub fn insert_shift_right_logical(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    shift: Word
) -> Result<Word, Error>

Appends an OpShiftRightLogical instruction to the current block.

pub fn shift_right_arithmetic(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    shift: Word
) -> Result<Word, Error>

Appends an OpShiftRightArithmetic instruction to the current block.

pub fn insert_shift_right_arithmetic(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    shift: Word
) -> Result<Word, Error>

Appends an OpShiftRightArithmetic instruction to the current block.

pub fn shift_left_logical(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    shift: Word
) -> Result<Word, Error>

Appends an OpShiftLeftLogical instruction to the current block.

pub fn insert_shift_left_logical(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    shift: Word
) -> Result<Word, Error>

Appends an OpShiftLeftLogical instruction to the current block.

pub fn bitwise_or(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpBitwiseOr instruction to the current block.

pub fn insert_bitwise_or(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpBitwiseOr instruction to the current block.

pub fn bitwise_xor(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpBitwiseXor instruction to the current block.

pub fn insert_bitwise_xor(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpBitwiseXor instruction to the current block.

pub fn bitwise_and(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpBitwiseAnd instruction to the current block.

pub fn insert_bitwise_and(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpBitwiseAnd instruction to the current block.

pub fn not(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpNot instruction to the current block.

pub fn insert_not(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpNot instruction to the current block.

pub fn bit_field_insert(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    insert: Word,
    offset: Word,
    count: Word
) -> Result<Word, Error>

Appends an OpBitFieldInsert instruction to the current block.

pub fn insert_bit_field_insert(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    insert: Word,
    offset: Word,
    count: Word
) -> Result<Word, Error>

Appends an OpBitFieldInsert instruction to the current block.

pub fn bit_field_s_extract(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    offset: Word,
    count: Word
) -> Result<Word, Error>

Appends an OpBitFieldSExtract instruction to the current block.

pub fn insert_bit_field_s_extract(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    offset: Word,
    count: Word
) -> Result<Word, Error>

Appends an OpBitFieldSExtract instruction to the current block.

pub fn bit_field_u_extract(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    offset: Word,
    count: Word
) -> Result<Word, Error>

Appends an OpBitFieldUExtract instruction to the current block.

pub fn insert_bit_field_u_extract(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word,
    offset: Word,
    count: Word
) -> Result<Word, Error>

Appends an OpBitFieldUExtract instruction to the current block.

pub fn bit_reverse(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word
) -> Result<Word, Error>

Appends an OpBitReverse instruction to the current block.

pub fn insert_bit_reverse(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word
) -> Result<Word, Error>

Appends an OpBitReverse instruction to the current block.

pub fn bit_count(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    base: Word
) -> Result<Word, Error>

Appends an OpBitCount instruction to the current block.

pub fn insert_bit_count(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    base: Word
) -> Result<Word, Error>

Appends an OpBitCount instruction to the current block.

pub fn d_pdx(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdx instruction to the current block.

pub fn insert_d_pdx(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdx instruction to the current block.

pub fn d_pdy(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdy instruction to the current block.

pub fn insert_d_pdy(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdy instruction to the current block.

pub fn fwidth(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpFwidth instruction to the current block.

pub fn insert_fwidth(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpFwidth instruction to the current block.

pub fn d_pdx_fine(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdxFine instruction to the current block.

pub fn insert_d_pdx_fine(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdxFine instruction to the current block.

pub fn d_pdy_fine(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdyFine instruction to the current block.

pub fn insert_d_pdy_fine(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdyFine instruction to the current block.

pub fn fwidth_fine(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpFwidthFine instruction to the current block.

pub fn insert_fwidth_fine(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpFwidthFine instruction to the current block.

pub fn d_pdx_coarse(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdxCoarse instruction to the current block.

pub fn insert_d_pdx_coarse(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdxCoarse instruction to the current block.

pub fn d_pdy_coarse(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdyCoarse instruction to the current block.

pub fn insert_d_pdy_coarse(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpDPdyCoarse instruction to the current block.

pub fn fwidth_coarse(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpFwidthCoarse instruction to the current block.

pub fn insert_fwidth_coarse(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    p: Word
) -> Result<Word, Error>

Appends an OpFwidthCoarse instruction to the current block.

pub fn emit_vertex(&mut self) -> Result<(), Error>

Appends an OpEmitVertex instruction to the current block.

pub fn insert_emit_vertex(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Appends an OpEmitVertex instruction to the current block.

pub fn end_primitive(&mut self) -> Result<(), Error>

Appends an OpEndPrimitive instruction to the current block.

pub fn insert_end_primitive(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Appends an OpEndPrimitive instruction to the current block.

pub fn emit_stream_vertex(&mut self, stream: Word) -> Result<(), Error>

Appends an OpEmitStreamVertex instruction to the current block.

pub fn insert_emit_stream_vertex(
    &mut self,
    insert_point: InsertPoint,
    stream: Word
) -> Result<(), Error>

Appends an OpEmitStreamVertex instruction to the current block.

pub fn end_stream_primitive(&mut self, stream: Word) -> Result<(), Error>

Appends an OpEndStreamPrimitive instruction to the current block.

pub fn insert_end_stream_primitive(
    &mut self,
    insert_point: InsertPoint,
    stream: Word
) -> Result<(), Error>

Appends an OpEndStreamPrimitive instruction to the current block.

pub fn control_barrier(
    &mut self,
    execution: Word,
    memory: Word,
    semantics: Word
) -> Result<(), Error>

Appends an OpControlBarrier instruction to the current block.

pub fn insert_control_barrier(
    &mut self,
    insert_point: InsertPoint,
    execution: Word,
    memory: Word,
    semantics: Word
) -> Result<(), Error>

Appends an OpControlBarrier instruction to the current block.

pub fn memory_barrier(
    &mut self,
    memory: Word,
    semantics: Word
) -> Result<(), Error>

Appends an OpMemoryBarrier instruction to the current block.

pub fn insert_memory_barrier(
    &mut self,
    insert_point: InsertPoint,
    memory: Word,
    semantics: Word
) -> Result<(), Error>

Appends an OpMemoryBarrier instruction to the current block.

pub fn atomic_load(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<Word, Error>

Appends an OpAtomicLoad instruction to the current block.

pub fn insert_atomic_load(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<Word, Error>

Appends an OpAtomicLoad instruction to the current block.

pub fn atomic_store(
    &mut self,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<(), Error>

Appends an OpAtomicStore instruction to the current block.

pub fn insert_atomic_store(
    &mut self,
    insert_point: InsertPoint,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<(), Error>

Appends an OpAtomicStore instruction to the current block.

pub fn atomic_exchange(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicExchange instruction to the current block.

pub fn insert_atomic_exchange(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicExchange instruction to the current block.

pub fn atomic_compare_exchange(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    equal: Word,
    unequal: Word,
    value: Word,
    comparator: Word
) -> Result<Word, Error>

Appends an OpAtomicCompareExchange instruction to the current block.

pub fn insert_atomic_compare_exchange(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    equal: Word,
    unequal: Word,
    value: Word,
    comparator: Word
) -> Result<Word, Error>

Appends an OpAtomicCompareExchange instruction to the current block.

pub fn atomic_compare_exchange_weak(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    equal: Word,
    unequal: Word,
    value: Word,
    comparator: Word
) -> Result<Word, Error>

Appends an OpAtomicCompareExchangeWeak instruction to the current block.

pub fn insert_atomic_compare_exchange_weak(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    equal: Word,
    unequal: Word,
    value: Word,
    comparator: Word
) -> Result<Word, Error>

Appends an OpAtomicCompareExchangeWeak instruction to the current block.

pub fn atomic_i_increment(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<Word, Error>

Appends an OpAtomicIIncrement instruction to the current block.

pub fn insert_atomic_i_increment(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<Word, Error>

Appends an OpAtomicIIncrement instruction to the current block.

pub fn atomic_i_decrement(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<Word, Error>

Appends an OpAtomicIDecrement instruction to the current block.

pub fn insert_atomic_i_decrement(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<Word, Error>

Appends an OpAtomicIDecrement instruction to the current block.

pub fn atomic_i_add(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicIAdd instruction to the current block.

pub fn insert_atomic_i_add(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicIAdd instruction to the current block.

pub fn atomic_i_sub(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicISub instruction to the current block.

pub fn insert_atomic_i_sub(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicISub instruction to the current block.

pub fn atomic_s_min(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicSMin instruction to the current block.

pub fn insert_atomic_s_min(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicSMin instruction to the current block.

pub fn atomic_u_min(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicUMin instruction to the current block.

pub fn insert_atomic_u_min(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicUMin instruction to the current block.

pub fn atomic_s_max(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicSMax instruction to the current block.

pub fn insert_atomic_s_max(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicSMax instruction to the current block.

pub fn atomic_u_max(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicUMax instruction to the current block.

pub fn insert_atomic_u_max(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicUMax instruction to the current block.

pub fn atomic_and(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicAnd instruction to the current block.

pub fn insert_atomic_and(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicAnd instruction to the current block.

pub fn atomic_or(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicOr instruction to the current block.

pub fn insert_atomic_or(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicOr instruction to the current block.

pub fn atomic_xor(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicXor instruction to the current block.

pub fn insert_atomic_xor(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicXor instruction to the current block.

pub fn phi(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    variable_parent: impl IntoIterator<Item = (Word, Word)>
) -> Result<Word, Error>

Appends an OpPhi instruction to the current block.

pub fn insert_phi(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    variable_parent: impl IntoIterator<Item = (Word, Word)>
) -> Result<Word, Error>

Appends an OpPhi instruction to the current block.

pub fn group_async_copy(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    destination: Word,
    source: Word,
    num_elements: Word,
    stride: Word,
    event: Word
) -> Result<Word, Error>

Appends an OpGroupAsyncCopy instruction to the current block.

pub fn insert_group_async_copy(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    destination: Word,
    source: Word,
    num_elements: Word,
    stride: Word,
    event: Word
) -> Result<Word, Error>

Appends an OpGroupAsyncCopy instruction to the current block.

pub fn group_wait_events(
    &mut self,
    execution: Word,
    num_events: Word,
    events_list: Word
) -> Result<(), Error>

Appends an OpGroupWaitEvents instruction to the current block.

pub fn insert_group_wait_events(
    &mut self,
    insert_point: InsertPoint,
    execution: Word,
    num_events: Word,
    events_list: Word
) -> Result<(), Error>

Appends an OpGroupWaitEvents instruction to the current block.

pub fn group_all(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupAll instruction to the current block.

pub fn insert_group_all(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupAll instruction to the current block.

pub fn group_any(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupAny instruction to the current block.

pub fn insert_group_any(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupAny instruction to the current block.

pub fn group_broadcast(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    local_id: Word
) -> Result<Word, Error>

Appends an OpGroupBroadcast instruction to the current block.

pub fn insert_group_broadcast(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    local_id: Word
) -> Result<Word, Error>

Appends an OpGroupBroadcast instruction to the current block.

pub fn group_i_add(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupIAdd instruction to the current block.

pub fn insert_group_i_add(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupIAdd instruction to the current block.

pub fn group_f_add(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFAdd instruction to the current block.

pub fn insert_group_f_add(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFAdd instruction to the current block.

pub fn group_f_min(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFMin instruction to the current block.

pub fn insert_group_f_min(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFMin instruction to the current block.

pub fn group_u_min(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupUMin instruction to the current block.

pub fn insert_group_u_min(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupUMin instruction to the current block.

pub fn group_s_min(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupSMin instruction to the current block.

pub fn insert_group_s_min(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupSMin instruction to the current block.

pub fn group_f_max(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFMax instruction to the current block.

pub fn insert_group_f_max(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFMax instruction to the current block.

pub fn group_u_max(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupUMax instruction to the current block.

pub fn insert_group_u_max(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupUMax instruction to the current block.

pub fn group_s_max(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupSMax instruction to the current block.

pub fn insert_group_s_max(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupSMax instruction to the current block.

pub fn read_pipe(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    pointer: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReadPipe instruction to the current block.

pub fn insert_read_pipe(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    pointer: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReadPipe instruction to the current block.

pub fn write_pipe(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    pointer: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpWritePipe instruction to the current block.

pub fn insert_write_pipe(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    pointer: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpWritePipe instruction to the current block.

pub fn reserved_read_pipe(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    reserve_id: Word,
    index: Word,
    pointer: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReservedReadPipe instruction to the current block.

pub fn insert_reserved_read_pipe(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    reserve_id: Word,
    index: Word,
    pointer: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReservedReadPipe instruction to the current block.

pub fn reserved_write_pipe(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    reserve_id: Word,
    index: Word,
    pointer: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReservedWritePipe instruction to the current block.

pub fn insert_reserved_write_pipe(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    reserve_id: Word,
    index: Word,
    pointer: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReservedWritePipe instruction to the current block.

pub fn reserve_read_pipe_packets(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    num_packets: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReserveReadPipePackets instruction to the current block.

pub fn insert_reserve_read_pipe_packets(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    num_packets: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReserveReadPipePackets instruction to the current block.

pub fn reserve_write_pipe_packets(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    num_packets: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReserveWritePipePackets instruction to the current block.

pub fn insert_reserve_write_pipe_packets(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    num_packets: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReserveWritePipePackets instruction to the current block.

pub fn commit_read_pipe(
    &mut self,
    pipe: Word,
    reserve_id: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<(), Error>

Appends an OpCommitReadPipe instruction to the current block.

pub fn insert_commit_read_pipe(
    &mut self,
    insert_point: InsertPoint,
    pipe: Word,
    reserve_id: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<(), Error>

Appends an OpCommitReadPipe instruction to the current block.

pub fn commit_write_pipe(
    &mut self,
    pipe: Word,
    reserve_id: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<(), Error>

Appends an OpCommitWritePipe instruction to the current block.

pub fn insert_commit_write_pipe(
    &mut self,
    insert_point: InsertPoint,
    pipe: Word,
    reserve_id: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<(), Error>

Appends an OpCommitWritePipe instruction to the current block.

pub fn is_valid_reserve_id(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    reserve_id: Word
) -> Result<Word, Error>

Appends an OpIsValidReserveId instruction to the current block.

pub fn insert_is_valid_reserve_id(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    reserve_id: Word
) -> Result<Word, Error>

Appends an OpIsValidReserveId instruction to the current block.

pub fn get_num_pipe_packets(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpGetNumPipePackets instruction to the current block.

pub fn insert_get_num_pipe_packets(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpGetNumPipePackets instruction to the current block.

pub fn get_max_pipe_packets(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpGetMaxPipePackets instruction to the current block.

pub fn insert_get_max_pipe_packets(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pipe: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpGetMaxPipePackets instruction to the current block.

pub fn group_reserve_read_pipe_packets(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    pipe: Word,
    num_packets: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpGroupReserveReadPipePackets instruction to the current block.

pub fn insert_group_reserve_read_pipe_packets(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    pipe: Word,
    num_packets: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpGroupReserveReadPipePackets instruction to the current block.

pub fn group_reserve_write_pipe_packets(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    pipe: Word,
    num_packets: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpGroupReserveWritePipePackets instruction to the current block.

pub fn insert_group_reserve_write_pipe_packets(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    pipe: Word,
    num_packets: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpGroupReserveWritePipePackets instruction to the current block.

pub fn group_commit_read_pipe(
    &mut self,
    execution: Word,
    pipe: Word,
    reserve_id: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<(), Error>

Appends an OpGroupCommitReadPipe instruction to the current block.

pub fn insert_group_commit_read_pipe(
    &mut self,
    insert_point: InsertPoint,
    execution: Word,
    pipe: Word,
    reserve_id: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<(), Error>

Appends an OpGroupCommitReadPipe instruction to the current block.

pub fn group_commit_write_pipe(
    &mut self,
    execution: Word,
    pipe: Word,
    reserve_id: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<(), Error>

Appends an OpGroupCommitWritePipe instruction to the current block.

pub fn insert_group_commit_write_pipe(
    &mut self,
    insert_point: InsertPoint,
    execution: Word,
    pipe: Word,
    reserve_id: Word,
    packet_size: Word,
    packet_alignment: Word
) -> Result<(), Error>

Appends an OpGroupCommitWritePipe instruction to the current block.

pub fn enqueue_marker(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    queue: Word,
    num_events: Word,
    wait_events: Word,
    ret_event: Word
) -> Result<Word, Error>

Appends an OpEnqueueMarker instruction to the current block.

pub fn insert_enqueue_marker(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    queue: Word,
    num_events: Word,
    wait_events: Word,
    ret_event: Word
) -> Result<Word, Error>

Appends an OpEnqueueMarker instruction to the current block.

pub fn enqueue_kernel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    queue: Word,
    flags: Word,
    nd_range: Word,
    num_events: Word,
    wait_events: Word,
    ret_event: Word,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word,
    local_size: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpEnqueueKernel instruction to the current block.

pub fn insert_enqueue_kernel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    queue: Word,
    flags: Word,
    nd_range: Word,
    num_events: Word,
    wait_events: Word,
    ret_event: Word,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word,
    local_size: impl IntoIterator<Item = Word>
) -> Result<Word, Error>

Appends an OpEnqueueKernel instruction to the current block.

pub fn get_kernel_n_drange_sub_group_count(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    nd_range: Word,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelNDrangeSubGroupCount instruction to the current block.

pub fn insert_get_kernel_n_drange_sub_group_count(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    nd_range: Word,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelNDrangeSubGroupCount instruction to the current block.

pub fn get_kernel_n_drange_max_sub_group_size(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    nd_range: Word,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelNDrangeMaxSubGroupSize instruction to the current block.

pub fn insert_get_kernel_n_drange_max_sub_group_size(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    nd_range: Word,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelNDrangeMaxSubGroupSize instruction to the current block.

pub fn get_kernel_work_group_size(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelWorkGroupSize instruction to the current block.

pub fn insert_get_kernel_work_group_size(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelWorkGroupSize instruction to the current block.

pub fn get_kernel_preferred_work_group_size_multiple(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelPreferredWorkGroupSizeMultiple instruction to the current block.

pub fn insert_get_kernel_preferred_work_group_size_multiple(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelPreferredWorkGroupSizeMultiple instruction to the current block.

pub fn retain_event(&mut self, event: Word) -> Result<(), Error>

Appends an OpRetainEvent instruction to the current block.

pub fn insert_retain_event(
    &mut self,
    insert_point: InsertPoint,
    event: Word
) -> Result<(), Error>

Appends an OpRetainEvent instruction to the current block.

pub fn release_event(&mut self, event: Word) -> Result<(), Error>

Appends an OpReleaseEvent instruction to the current block.

pub fn insert_release_event(
    &mut self,
    insert_point: InsertPoint,
    event: Word
) -> Result<(), Error>

Appends an OpReleaseEvent instruction to the current block.

pub fn create_user_event(
    &mut self,
    result_type: Word,
    result_id: Option<Word>
) -> Result<Word, Error>

Appends an OpCreateUserEvent instruction to the current block.

pub fn insert_create_user_event(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>
) -> Result<Word, Error>

Appends an OpCreateUserEvent instruction to the current block.

pub fn is_valid_event(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    event: Word
) -> Result<Word, Error>

Appends an OpIsValidEvent instruction to the current block.

pub fn insert_is_valid_event(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    event: Word
) -> Result<Word, Error>

Appends an OpIsValidEvent instruction to the current block.

pub fn set_user_event_status(
    &mut self,
    event: Word,
    status: Word
) -> Result<(), Error>

Appends an OpSetUserEventStatus instruction to the current block.

pub fn insert_set_user_event_status(
    &mut self,
    insert_point: InsertPoint,
    event: Word,
    status: Word
) -> Result<(), Error>

Appends an OpSetUserEventStatus instruction to the current block.

pub fn capture_event_profiling_info(
    &mut self,
    event: Word,
    profiling_info: Word,
    value: Word
) -> Result<(), Error>

Appends an OpCaptureEventProfilingInfo instruction to the current block.

pub fn insert_capture_event_profiling_info(
    &mut self,
    insert_point: InsertPoint,
    event: Word,
    profiling_info: Word,
    value: Word
) -> Result<(), Error>

Appends an OpCaptureEventProfilingInfo instruction to the current block.

pub fn get_default_queue(
    &mut self,
    result_type: Word,
    result_id: Option<Word>
) -> Result<Word, Error>

Appends an OpGetDefaultQueue instruction to the current block.

pub fn insert_get_default_queue(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>
) -> Result<Word, Error>

Appends an OpGetDefaultQueue instruction to the current block.

pub fn build_nd_range(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    global_work_size: Word,
    local_work_size: Word,
    global_work_offset: Word
) -> Result<Word, Error>

Appends an OpBuildNDRange instruction to the current block.

pub fn insert_build_nd_range(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    global_work_size: Word,
    local_work_size: Word,
    global_work_offset: Word
) -> Result<Word, Error>

Appends an OpBuildNDRange instruction to the current block.

pub fn image_sparse_sample_implicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleImplicitLod instruction to the current block.

pub fn insert_image_sparse_sample_implicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleImplicitLod instruction to the current block.

pub fn image_sparse_sample_explicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleExplicitLod instruction to the current block.

pub fn insert_image_sparse_sample_explicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleExplicitLod instruction to the current block.

pub fn image_sparse_sample_dref_implicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleDrefImplicitLod instruction to the current block.

pub fn insert_image_sparse_sample_dref_implicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleDrefImplicitLod instruction to the current block.

pub fn image_sparse_sample_dref_explicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleDrefExplicitLod instruction to the current block.

pub fn insert_image_sparse_sample_dref_explicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleDrefExplicitLod instruction to the current block.

pub fn image_sparse_sample_proj_implicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleProjImplicitLod instruction to the current block.

pub fn insert_image_sparse_sample_proj_implicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleProjImplicitLod instruction to the current block.

pub fn image_sparse_sample_proj_explicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleProjExplicitLod instruction to the current block.

pub fn insert_image_sparse_sample_proj_explicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleProjExplicitLod instruction to the current block.

pub fn image_sparse_sample_proj_dref_implicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleProjDrefImplicitLod instruction to the current block.

pub fn insert_image_sparse_sample_proj_dref_implicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleProjDrefImplicitLod instruction to the current block.

pub fn image_sparse_sample_proj_dref_explicit_lod(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleProjDrefExplicitLod instruction to the current block.

pub fn insert_image_sparse_sample_proj_dref_explicit_lod(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: ImageOperands,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseSampleProjDrefExplicitLod instruction to the current block.

pub fn image_sparse_fetch(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseFetch instruction to the current block.

pub fn insert_image_sparse_fetch(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseFetch instruction to the current block.

pub fn image_sparse_gather(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    component: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseGather instruction to the current block.

pub fn insert_image_sparse_gather(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    component: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseGather instruction to the current block.

pub fn image_sparse_dref_gather(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseDrefGather instruction to the current block.

pub fn insert_image_sparse_dref_gather(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    d_ref: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseDrefGather instruction to the current block.

pub fn image_sparse_texels_resident(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    resident_code: Word
) -> Result<Word, Error>

Appends an OpImageSparseTexelsResident instruction to the current block.

pub fn insert_image_sparse_texels_resident(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    resident_code: Word
) -> Result<Word, Error>

Appends an OpImageSparseTexelsResident instruction to the current block.

pub fn atomic_flag_test_and_set(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<Word, Error>

Appends an OpAtomicFlagTestAndSet instruction to the current block.

pub fn insert_atomic_flag_test_and_set(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<Word, Error>

Appends an OpAtomicFlagTestAndSet instruction to the current block.

pub fn atomic_flag_clear(
    &mut self,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<(), Error>

Appends an OpAtomicFlagClear instruction to the current block.

pub fn insert_atomic_flag_clear(
    &mut self,
    insert_point: InsertPoint,
    pointer: Word,
    memory: Word,
    semantics: Word
) -> Result<(), Error>

Appends an OpAtomicFlagClear instruction to the current block.

pub fn image_sparse_read(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseRead instruction to the current block.

pub fn insert_image_sparse_read(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSparseRead instruction to the current block.

pub fn size_of(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpSizeOf instruction to the current block.

pub fn insert_size_of(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word
) -> Result<Word, Error>

Appends an OpSizeOf instruction to the current block.

pub fn constant_pipe_storage(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    packet_size: u32,
    packet_alignment: u32,
    capacity: u32
) -> Result<Word, Error>

Appends an OpConstantPipeStorage instruction to the current block.

pub fn insert_constant_pipe_storage(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    packet_size: u32,
    packet_alignment: u32,
    capacity: u32
) -> Result<Word, Error>

Appends an OpConstantPipeStorage instruction to the current block.

pub fn create_pipe_from_pipe_storage(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pipe_storage: Word
) -> Result<Word, Error>

Appends an OpCreatePipeFromPipeStorage instruction to the current block.

pub fn insert_create_pipe_from_pipe_storage(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pipe_storage: Word
) -> Result<Word, Error>

Appends an OpCreatePipeFromPipeStorage instruction to the current block.

pub fn get_kernel_local_size_for_subgroup_count(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    subgroup_count: Word,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelLocalSizeForSubgroupCount instruction to the current block.

pub fn insert_get_kernel_local_size_for_subgroup_count(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    subgroup_count: Word,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelLocalSizeForSubgroupCount instruction to the current block.

pub fn get_kernel_max_num_subgroups(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelMaxNumSubgroups instruction to the current block.

pub fn insert_get_kernel_max_num_subgroups(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    invoke: Word,
    param: Word,
    param_size: Word,
    param_align: Word
) -> Result<Word, Error>

Appends an OpGetKernelMaxNumSubgroups instruction to the current block.

pub fn named_barrier_initialize(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    subgroup_count: Word
) -> Result<Word, Error>

Appends an OpNamedBarrierInitialize instruction to the current block.

pub fn insert_named_barrier_initialize(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    subgroup_count: Word
) -> Result<Word, Error>

Appends an OpNamedBarrierInitialize instruction to the current block.

pub fn memory_named_barrier(
    &mut self,
    named_barrier: Word,
    memory: Word,
    semantics: Word
) -> Result<(), Error>

Appends an OpMemoryNamedBarrier instruction to the current block.

pub fn insert_memory_named_barrier(
    &mut self,
    insert_point: InsertPoint,
    named_barrier: Word,
    memory: Word,
    semantics: Word
) -> Result<(), Error>

Appends an OpMemoryNamedBarrier instruction to the current block.

pub fn group_non_uniform_elect(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformElect instruction to the current block.

pub fn insert_group_non_uniform_elect(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformElect instruction to the current block.

pub fn group_non_uniform_all(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformAll instruction to the current block.

pub fn insert_group_non_uniform_all(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformAll instruction to the current block.

pub fn group_non_uniform_any(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformAny instruction to the current block.

pub fn insert_group_non_uniform_any(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformAny instruction to the current block.

pub fn group_non_uniform_all_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformAllEqual instruction to the current block.

pub fn insert_group_non_uniform_all_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformAllEqual instruction to the current block.

pub fn group_non_uniform_broadcast(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    id: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBroadcast instruction to the current block.

pub fn insert_group_non_uniform_broadcast(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    id: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBroadcast instruction to the current block.

pub fn group_non_uniform_broadcast_first(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBroadcastFirst instruction to the current block.

pub fn insert_group_non_uniform_broadcast_first(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBroadcastFirst instruction to the current block.

pub fn group_non_uniform_ballot(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallot instruction to the current block.

pub fn insert_group_non_uniform_ballot(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    predicate: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallot instruction to the current block.

pub fn group_non_uniform_inverse_ballot(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformInverseBallot instruction to the current block.

pub fn insert_group_non_uniform_inverse_ballot(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformInverseBallot instruction to the current block.

pub fn group_non_uniform_ballot_bit_extract(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallotBitExtract instruction to the current block.

pub fn insert_group_non_uniform_ballot_bit_extract(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallotBitExtract instruction to the current block.

pub fn group_non_uniform_ballot_bit_count(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallotBitCount instruction to the current block.

pub fn insert_group_non_uniform_ballot_bit_count(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallotBitCount instruction to the current block.

pub fn group_non_uniform_ballot_find_lsb(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallotFindLSB instruction to the current block.

pub fn insert_group_non_uniform_ballot_find_lsb(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallotFindLSB instruction to the current block.

pub fn group_non_uniform_ballot_find_msb(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallotFindMSB instruction to the current block.

pub fn insert_group_non_uniform_ballot_find_msb(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformBallotFindMSB instruction to the current block.

pub fn group_non_uniform_shuffle(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    id: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformShuffle instruction to the current block.

pub fn insert_group_non_uniform_shuffle(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    id: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformShuffle instruction to the current block.

pub fn group_non_uniform_shuffle_xor(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    mask: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformShuffleXor instruction to the current block.

pub fn insert_group_non_uniform_shuffle_xor(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    mask: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformShuffleXor instruction to the current block.

pub fn group_non_uniform_shuffle_up(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    delta: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformShuffleUp instruction to the current block.

pub fn insert_group_non_uniform_shuffle_up(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    delta: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformShuffleUp instruction to the current block.

pub fn group_non_uniform_shuffle_down(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    delta: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformShuffleDown instruction to the current block.

pub fn insert_group_non_uniform_shuffle_down(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    delta: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformShuffleDown instruction to the current block.

pub fn group_non_uniform_i_add(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformIAdd instruction to the current block.

pub fn insert_group_non_uniform_i_add(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformIAdd instruction to the current block.

pub fn group_non_uniform_f_add(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformFAdd instruction to the current block.

pub fn insert_group_non_uniform_f_add(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformFAdd instruction to the current block.

pub fn group_non_uniform_i_mul(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformIMul instruction to the current block.

pub fn insert_group_non_uniform_i_mul(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformIMul instruction to the current block.

pub fn group_non_uniform_f_mul(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformFMul instruction to the current block.

pub fn insert_group_non_uniform_f_mul(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformFMul instruction to the current block.

pub fn group_non_uniform_s_min(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformSMin instruction to the current block.

pub fn insert_group_non_uniform_s_min(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformSMin instruction to the current block.

pub fn group_non_uniform_u_min(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformUMin instruction to the current block.

pub fn insert_group_non_uniform_u_min(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformUMin instruction to the current block.

pub fn group_non_uniform_f_min(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformFMin instruction to the current block.

pub fn insert_group_non_uniform_f_min(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformFMin instruction to the current block.

pub fn group_non_uniform_s_max(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformSMax instruction to the current block.

pub fn insert_group_non_uniform_s_max(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformSMax instruction to the current block.

pub fn group_non_uniform_u_max(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformUMax instruction to the current block.

pub fn insert_group_non_uniform_u_max(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformUMax instruction to the current block.

pub fn group_non_uniform_f_max(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformFMax instruction to the current block.

pub fn insert_group_non_uniform_f_max(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformFMax instruction to the current block.

pub fn group_non_uniform_bitwise_and(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformBitwiseAnd instruction to the current block.

pub fn insert_group_non_uniform_bitwise_and(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformBitwiseAnd instruction to the current block.

pub fn group_non_uniform_bitwise_or(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformBitwiseOr instruction to the current block.

pub fn insert_group_non_uniform_bitwise_or(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformBitwiseOr instruction to the current block.

pub fn group_non_uniform_bitwise_xor(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformBitwiseXor instruction to the current block.

pub fn insert_group_non_uniform_bitwise_xor(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformBitwiseXor instruction to the current block.

pub fn group_non_uniform_logical_and(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformLogicalAnd instruction to the current block.

pub fn insert_group_non_uniform_logical_and(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformLogicalAnd instruction to the current block.

pub fn group_non_uniform_logical_or(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformLogicalOr instruction to the current block.

pub fn insert_group_non_uniform_logical_or(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformLogicalOr instruction to the current block.

pub fn group_non_uniform_logical_xor(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformLogicalXor instruction to the current block.

pub fn insert_group_non_uniform_logical_xor(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    value: Word,
    cluster_size: Option<Word>
) -> Result<Word, Error>

Appends an OpGroupNonUniformLogicalXor instruction to the current block.

pub fn group_non_uniform_quad_broadcast(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformQuadBroadcast instruction to the current block.

pub fn insert_group_non_uniform_quad_broadcast(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformQuadBroadcast instruction to the current block.

pub fn group_non_uniform_quad_swap(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    direction: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformQuadSwap instruction to the current block.

pub fn insert_group_non_uniform_quad_swap(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    value: Word,
    direction: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformQuadSwap instruction to the current block.

pub fn copy_logical(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpCopyLogical instruction to the current block.

pub fn insert_copy_logical(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpCopyLogical instruction to the current block.

pub fn ptr_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpPtrEqual instruction to the current block.

pub fn insert_ptr_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpPtrEqual instruction to the current block.

pub fn ptr_not_equal(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpPtrNotEqual instruction to the current block.

pub fn insert_ptr_not_equal(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpPtrNotEqual instruction to the current block.

pub fn ptr_diff(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpPtrDiff instruction to the current block.

pub fn insert_ptr_diff(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpPtrDiff instruction to the current block.

pub fn subgroup_ballot_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    predicate: Word
) -> Result<Word, Error>

Appends an OpSubgroupBallotKHR instruction to the current block.

pub fn insert_subgroup_ballot_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    predicate: Word
) -> Result<Word, Error>

Appends an OpSubgroupBallotKHR instruction to the current block.

pub fn subgroup_first_invocation_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    value: Word
) -> Result<Word, Error>

Appends an OpSubgroupFirstInvocationKHR instruction to the current block.

pub fn insert_subgroup_first_invocation_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    value: Word
) -> Result<Word, Error>

Appends an OpSubgroupFirstInvocationKHR instruction to the current block.

pub fn subgroup_all_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    predicate: Word
) -> Result<Word, Error>

Appends an OpSubgroupAllKHR instruction to the current block.

pub fn insert_subgroup_all_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    predicate: Word
) -> Result<Word, Error>

Appends an OpSubgroupAllKHR instruction to the current block.

pub fn subgroup_any_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    predicate: Word
) -> Result<Word, Error>

Appends an OpSubgroupAnyKHR instruction to the current block.

pub fn insert_subgroup_any_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    predicate: Word
) -> Result<Word, Error>

Appends an OpSubgroupAnyKHR instruction to the current block.

pub fn subgroup_all_equal_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    predicate: Word
) -> Result<Word, Error>

Appends an OpSubgroupAllEqualKHR instruction to the current block.

pub fn insert_subgroup_all_equal_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    predicate: Word
) -> Result<Word, Error>

Appends an OpSubgroupAllEqualKHR instruction to the current block.

pub fn subgroup_read_invocation_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    value: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpSubgroupReadInvocationKHR instruction to the current block.

pub fn insert_subgroup_read_invocation_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    value: Word,
    index: Word
) -> Result<Word, Error>

Appends an OpSubgroupReadInvocationKHR instruction to the current block.

pub fn trace_ray_khr(
    &mut self,
    accel: Word,
    ray_flags: Word,
    cull_mask: Word,
    sbt_offset: Word,
    sbt_stride: Word,
    miss_index: Word,
    ray_origin: Word,
    ray_tmin: Word,
    ray_direction: Word,
    ray_tmax: Word,
    payload: Word
) -> Result<(), Error>

Appends an OpTraceRayKHR instruction to the current block.

pub fn insert_trace_ray_khr(
    &mut self,
    insert_point: InsertPoint,
    accel: Word,
    ray_flags: Word,
    cull_mask: Word,
    sbt_offset: Word,
    sbt_stride: Word,
    miss_index: Word,
    ray_origin: Word,
    ray_tmin: Word,
    ray_direction: Word,
    ray_tmax: Word,
    payload: Word
) -> Result<(), Error>

Appends an OpTraceRayKHR instruction to the current block.

pub fn execute_callable_khr(
    &mut self,
    sbt_index: Word,
    callable_data: Word
) -> Result<(), Error>

Appends an OpExecuteCallableKHR instruction to the current block.

pub fn insert_execute_callable_khr(
    &mut self,
    insert_point: InsertPoint,
    sbt_index: Word,
    callable_data: Word
) -> Result<(), Error>

Appends an OpExecuteCallableKHR instruction to the current block.

pub fn convert_u_to_acceleration_structure_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    accel: Word
) -> Result<Word, Error>

Appends an OpConvertUToAccelerationStructureKHR instruction to the current block.

pub fn insert_convert_u_to_acceleration_structure_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    accel: Word
) -> Result<Word, Error>

Appends an OpConvertUToAccelerationStructureKHR instruction to the current block.

pub fn ray_query_initialize_khr(
    &mut self,
    ray_query: Word,
    accel: Word,
    ray_flags: Word,
    cull_mask: Word,
    ray_origin: Word,
    ray_t_min: Word,
    ray_direction: Word,
    ray_t_max: Word
) -> Result<(), Error>

Appends an OpRayQueryInitializeKHR instruction to the current block.

pub fn insert_ray_query_initialize_khr(
    &mut self,
    insert_point: InsertPoint,
    ray_query: Word,
    accel: Word,
    ray_flags: Word,
    cull_mask: Word,
    ray_origin: Word,
    ray_t_min: Word,
    ray_direction: Word,
    ray_t_max: Word
) -> Result<(), Error>

Appends an OpRayQueryInitializeKHR instruction to the current block.

pub fn ray_query_terminate_khr(&mut self, ray_query: Word) -> Result<(), Error>

Appends an OpRayQueryTerminateKHR instruction to the current block.

pub fn insert_ray_query_terminate_khr(
    &mut self,
    insert_point: InsertPoint,
    ray_query: Word
) -> Result<(), Error>

Appends an OpRayQueryTerminateKHR instruction to the current block.

pub fn ray_query_generate_intersection_khr(
    &mut self,
    ray_query: Word,
    hit_t: Word
) -> Result<(), Error>

Appends an OpRayQueryGenerateIntersectionKHR instruction to the current block.

pub fn insert_ray_query_generate_intersection_khr(
    &mut self,
    insert_point: InsertPoint,
    ray_query: Word,
    hit_t: Word
) -> Result<(), Error>

Appends an OpRayQueryGenerateIntersectionKHR instruction to the current block.

pub fn ray_query_confirm_intersection_khr(
    &mut self,
    ray_query: Word
) -> Result<(), Error>

Appends an OpRayQueryConfirmIntersectionKHR instruction to the current block.

pub fn insert_ray_query_confirm_intersection_khr(
    &mut self,
    insert_point: InsertPoint,
    ray_query: Word
) -> Result<(), Error>

Appends an OpRayQueryConfirmIntersectionKHR instruction to the current block.

pub fn ray_query_proceed_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryProceedKHR instruction to the current block.

pub fn insert_ray_query_proceed_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryProceedKHR instruction to the current block.

pub fn ray_query_get_intersection_type_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionTypeKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_type_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionTypeKHR instruction to the current block.

pub fn group_i_add_non_uniform_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupIAddNonUniformAMD instruction to the current block.

pub fn insert_group_i_add_non_uniform_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupIAddNonUniformAMD instruction to the current block.

pub fn group_f_add_non_uniform_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFAddNonUniformAMD instruction to the current block.

pub fn insert_group_f_add_non_uniform_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFAddNonUniformAMD instruction to the current block.

pub fn group_f_min_non_uniform_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFMinNonUniformAMD instruction to the current block.

pub fn insert_group_f_min_non_uniform_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFMinNonUniformAMD instruction to the current block.

pub fn group_u_min_non_uniform_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupUMinNonUniformAMD instruction to the current block.

pub fn insert_group_u_min_non_uniform_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupUMinNonUniformAMD instruction to the current block.

pub fn group_s_min_non_uniform_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupSMinNonUniformAMD instruction to the current block.

pub fn insert_group_s_min_non_uniform_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupSMinNonUniformAMD instruction to the current block.

pub fn group_f_max_non_uniform_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFMaxNonUniformAMD instruction to the current block.

pub fn insert_group_f_max_non_uniform_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupFMaxNonUniformAMD instruction to the current block.

pub fn group_u_max_non_uniform_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupUMaxNonUniformAMD instruction to the current block.

pub fn insert_group_u_max_non_uniform_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupUMaxNonUniformAMD instruction to the current block.

pub fn group_s_max_non_uniform_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupSMaxNonUniformAMD instruction to the current block.

pub fn insert_group_s_max_non_uniform_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word,
    operation: GroupOperation,
    x: Word
) -> Result<Word, Error>

Appends an OpGroupSMaxNonUniformAMD instruction to the current block.

pub fn fragment_mask_fetch_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word
) -> Result<Word, Error>

Appends an OpFragmentMaskFetchAMD instruction to the current block.

pub fn insert_fragment_mask_fetch_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word
) -> Result<Word, Error>

Appends an OpFragmentMaskFetchAMD instruction to the current block.

pub fn fragment_fetch_amd(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    fragment_index: Word
) -> Result<Word, Error>

Appends an OpFragmentFetchAMD instruction to the current block.

pub fn insert_fragment_fetch_amd(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    fragment_index: Word
) -> Result<Word, Error>

Appends an OpFragmentFetchAMD instruction to the current block.

pub fn read_clock_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word
) -> Result<Word, Error>

Appends an OpReadClockKHR instruction to the current block.

pub fn insert_read_clock_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    execution: Word
) -> Result<Word, Error>

Appends an OpReadClockKHR instruction to the current block.

pub fn image_sample_footprint_nv(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    granularity: Word,
    coarse: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleFootprintNV instruction to the current block.

pub fn insert_image_sample_footprint_nv(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    sampled_image: Word,
    coordinate: Word,
    granularity: Word,
    coarse: Word,
    image_operands: Option<ImageOperands>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpImageSampleFootprintNV instruction to the current block.

pub fn group_non_uniform_partition_nv(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformPartitionNV instruction to the current block.

pub fn insert_group_non_uniform_partition_nv(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    value: Word
) -> Result<Word, Error>

Appends an OpGroupNonUniformPartitionNV instruction to the current block.

pub fn write_packed_primitive_indices4x8_nv(
    &mut self,
    index_offset: Word,
    packed_indices: Word
) -> Result<(), Error>

Appends an OpWritePackedPrimitiveIndices4x8NV instruction to the current block.

pub fn insert_write_packed_primitive_indices4x8_nv(
    &mut self,
    insert_point: InsertPoint,
    index_offset: Word,
    packed_indices: Word
) -> Result<(), Error>

Appends an OpWritePackedPrimitiveIndices4x8NV instruction to the current block.

pub fn report_intersection_nv(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    hit: Word,
    hit_kind: Word
) -> Result<Word, Error>

Appends an OpReportIntersectionNV instruction to the current block.

pub fn insert_report_intersection_nv(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    hit: Word,
    hit_kind: Word
) -> Result<Word, Error>

Appends an OpReportIntersectionNV instruction to the current block.

pub fn report_intersection_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    hit: Word,
    hit_kind: Word
) -> Result<Word, Error>

Appends an OpReportIntersectionKHR instruction to the current block.

pub fn insert_report_intersection_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    hit: Word,
    hit_kind: Word
) -> Result<Word, Error>

Appends an OpReportIntersectionKHR instruction to the current block.

pub fn ignore_intersection_nv(&mut self) -> Result<(), Error>

Appends an OpIgnoreIntersectionNV instruction to the current block.

pub fn insert_ignore_intersection_nv(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Appends an OpIgnoreIntersectionNV instruction to the current block.

pub fn terminate_ray_nv(&mut self) -> Result<(), Error>

Appends an OpTerminateRayNV instruction to the current block.

pub fn insert_terminate_ray_nv(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Appends an OpTerminateRayNV instruction to the current block.

pub fn trace_nv(
    &mut self,
    accel: Word,
    ray_flags: Word,
    cull_mask: Word,
    sbt_offset: Word,
    sbt_stride: Word,
    miss_index: Word,
    ray_origin: Word,
    ray_tmin: Word,
    ray_direction: Word,
    ray_tmax: Word,
    payload_id: Word
) -> Result<(), Error>

Appends an OpTraceNV instruction to the current block.

pub fn insert_trace_nv(
    &mut self,
    insert_point: InsertPoint,
    accel: Word,
    ray_flags: Word,
    cull_mask: Word,
    sbt_offset: Word,
    sbt_stride: Word,
    miss_index: Word,
    ray_origin: Word,
    ray_tmin: Word,
    ray_direction: Word,
    ray_tmax: Word,
    payload_id: Word
) -> Result<(), Error>

Appends an OpTraceNV instruction to the current block.

pub fn execute_callable_nv(
    &mut self,
    sbt_index: Word,
    callable_data_id: Word
) -> Result<(), Error>

Appends an OpExecuteCallableNV instruction to the current block.

pub fn insert_execute_callable_nv(
    &mut self,
    insert_point: InsertPoint,
    sbt_index: Word,
    callable_data_id: Word
) -> Result<(), Error>

Appends an OpExecuteCallableNV instruction to the current block.

pub fn cooperative_matrix_load_nv(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    stride: Word,
    column_major: Word,
    memory_access: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpCooperativeMatrixLoadNV instruction to the current block.

pub fn insert_cooperative_matrix_load_nv(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    stride: Word,
    column_major: Word,
    memory_access: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<Word, Error>

Appends an OpCooperativeMatrixLoadNV instruction to the current block.

pub fn cooperative_matrix_store_nv(
    &mut self,
    pointer: Word,
    object: Word,
    stride: Word,
    column_major: Word,
    memory_access: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpCooperativeMatrixStoreNV instruction to the current block.

pub fn insert_cooperative_matrix_store_nv(
    &mut self,
    insert_point: InsertPoint,
    pointer: Word,
    object: Word,
    stride: Word,
    column_major: Word,
    memory_access: Option<MemoryAccess>,
    additional_params: impl IntoIterator<Item = Operand>
) -> Result<(), Error>

Appends an OpCooperativeMatrixStoreNV instruction to the current block.

pub fn cooperative_matrix_mul_add_nv(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    a: Word,
    b: Word,
    c: Word
) -> Result<Word, Error>

Appends an OpCooperativeMatrixMulAddNV instruction to the current block.

pub fn insert_cooperative_matrix_mul_add_nv(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    a: Word,
    b: Word,
    c: Word
) -> Result<Word, Error>

Appends an OpCooperativeMatrixMulAddNV instruction to the current block.

pub fn cooperative_matrix_length_nv(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ty: Word
) -> Result<Word, Error>

Appends an OpCooperativeMatrixLengthNV instruction to the current block.

pub fn insert_cooperative_matrix_length_nv(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ty: Word
) -> Result<Word, Error>

Appends an OpCooperativeMatrixLengthNV instruction to the current block.

pub fn begin_invocation_interlock_ext(&mut self) -> Result<(), Error>

Appends an OpBeginInvocationInterlockEXT instruction to the current block.

pub fn insert_begin_invocation_interlock_ext(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Appends an OpBeginInvocationInterlockEXT instruction to the current block.

pub fn end_invocation_interlock_ext(&mut self) -> Result<(), Error>

Appends an OpEndInvocationInterlockEXT instruction to the current block.

pub fn insert_end_invocation_interlock_ext(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Appends an OpEndInvocationInterlockEXT instruction to the current block.

pub fn demote_to_helper_invocation_ext(&mut self) -> Result<(), Error>

Appends an OpDemoteToHelperInvocationEXT instruction to the current block.

pub fn insert_demote_to_helper_invocation_ext(
    &mut self,
    insert_point: InsertPoint
) -> Result<(), Error>

Appends an OpDemoteToHelperInvocationEXT instruction to the current block.

pub fn is_helper_invocation_ext(
    &mut self,
    result_type: Word,
    result_id: Option<Word>
) -> Result<Word, Error>

Appends an OpIsHelperInvocationEXT instruction to the current block.

pub fn insert_is_helper_invocation_ext(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>
) -> Result<Word, Error>

Appends an OpIsHelperInvocationEXT instruction to the current block.

pub fn subgroup_shuffle_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    data: Word,
    invocation_id: Word
) -> Result<Word, Error>

Appends an OpSubgroupShuffleINTEL instruction to the current block.

pub fn insert_subgroup_shuffle_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    data: Word,
    invocation_id: Word
) -> Result<Word, Error>

Appends an OpSubgroupShuffleINTEL instruction to the current block.

pub fn subgroup_shuffle_down_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    current: Word,
    next: Word,
    delta: Word
) -> Result<Word, Error>

Appends an OpSubgroupShuffleDownINTEL instruction to the current block.

pub fn insert_subgroup_shuffle_down_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    current: Word,
    next: Word,
    delta: Word
) -> Result<Word, Error>

Appends an OpSubgroupShuffleDownINTEL instruction to the current block.

pub fn subgroup_shuffle_up_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    previous: Word,
    current: Word,
    delta: Word
) -> Result<Word, Error>

Appends an OpSubgroupShuffleUpINTEL instruction to the current block.

pub fn insert_subgroup_shuffle_up_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    previous: Word,
    current: Word,
    delta: Word
) -> Result<Word, Error>

Appends an OpSubgroupShuffleUpINTEL instruction to the current block.

pub fn subgroup_shuffle_xor_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    data: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpSubgroupShuffleXorINTEL instruction to the current block.

pub fn insert_subgroup_shuffle_xor_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    data: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpSubgroupShuffleXorINTEL instruction to the current block.

pub fn subgroup_block_read_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ptr: Word
) -> Result<Word, Error>

Appends an OpSubgroupBlockReadINTEL instruction to the current block.

pub fn insert_subgroup_block_read_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ptr: Word
) -> Result<Word, Error>

Appends an OpSubgroupBlockReadINTEL instruction to the current block.

pub fn subgroup_block_write_intel(
    &mut self,
    ptr: Word,
    data: Word
) -> Result<(), Error>

Appends an OpSubgroupBlockWriteINTEL instruction to the current block.

pub fn insert_subgroup_block_write_intel(
    &mut self,
    insert_point: InsertPoint,
    ptr: Word,
    data: Word
) -> Result<(), Error>

Appends an OpSubgroupBlockWriteINTEL instruction to the current block.

pub fn subgroup_image_block_read_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word
) -> Result<Word, Error>

Appends an OpSubgroupImageBlockReadINTEL instruction to the current block.

pub fn insert_subgroup_image_block_read_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word
) -> Result<Word, Error>

Appends an OpSubgroupImageBlockReadINTEL instruction to the current block.

pub fn subgroup_image_block_write_intel(
    &mut self,
    image: Word,
    coordinate: Word,
    data: Word
) -> Result<(), Error>

Appends an OpSubgroupImageBlockWriteINTEL instruction to the current block.

pub fn insert_subgroup_image_block_write_intel(
    &mut self,
    insert_point: InsertPoint,
    image: Word,
    coordinate: Word,
    data: Word
) -> Result<(), Error>

Appends an OpSubgroupImageBlockWriteINTEL instruction to the current block.

pub fn subgroup_image_media_block_read_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    width: Word,
    height: Word
) -> Result<Word, Error>

Appends an OpSubgroupImageMediaBlockReadINTEL instruction to the current block.

pub fn insert_subgroup_image_media_block_read_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    image: Word,
    coordinate: Word,
    width: Word,
    height: Word
) -> Result<Word, Error>

Appends an OpSubgroupImageMediaBlockReadINTEL instruction to the current block.

pub fn subgroup_image_media_block_write_intel(
    &mut self,
    image: Word,
    coordinate: Word,
    width: Word,
    height: Word,
    data: Word
) -> Result<(), Error>

Appends an OpSubgroupImageMediaBlockWriteINTEL instruction to the current block.

pub fn insert_subgroup_image_media_block_write_intel(
    &mut self,
    insert_point: InsertPoint,
    image: Word,
    coordinate: Word,
    width: Word,
    height: Word,
    data: Word
) -> Result<(), Error>

Appends an OpSubgroupImageMediaBlockWriteINTEL instruction to the current block.

pub fn u_count_leading_zeros_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpUCountLeadingZerosINTEL instruction to the current block.

pub fn insert_u_count_leading_zeros_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpUCountLeadingZerosINTEL instruction to the current block.

pub fn u_count_trailing_zeros_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpUCountTrailingZerosINTEL instruction to the current block.

pub fn insert_u_count_trailing_zeros_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand: Word
) -> Result<Word, Error>

Appends an OpUCountTrailingZerosINTEL instruction to the current block.

pub fn abs_i_sub_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpAbsISubINTEL instruction to the current block.

pub fn insert_abs_i_sub_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpAbsISubINTEL instruction to the current block.

pub fn abs_u_sub_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpAbsUSubINTEL instruction to the current block.

pub fn insert_abs_u_sub_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpAbsUSubINTEL instruction to the current block.

pub fn i_add_sat_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAddSatINTEL instruction to the current block.

pub fn insert_i_add_sat_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAddSatINTEL instruction to the current block.

pub fn u_add_sat_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUAddSatINTEL instruction to the current block.

pub fn insert_u_add_sat_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUAddSatINTEL instruction to the current block.

pub fn i_average_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAverageINTEL instruction to the current block.

pub fn insert_i_average_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAverageINTEL instruction to the current block.

pub fn u_average_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUAverageINTEL instruction to the current block.

pub fn insert_u_average_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUAverageINTEL instruction to the current block.

pub fn i_average_rounded_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAverageRoundedINTEL instruction to the current block.

pub fn insert_i_average_rounded_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIAverageRoundedINTEL instruction to the current block.

pub fn u_average_rounded_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUAverageRoundedINTEL instruction to the current block.

pub fn insert_u_average_rounded_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUAverageRoundedINTEL instruction to the current block.

pub fn i_sub_sat_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpISubSatINTEL instruction to the current block.

pub fn insert_i_sub_sat_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpISubSatINTEL instruction to the current block.

pub fn u_sub_sat_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUSubSatINTEL instruction to the current block.

pub fn insert_u_sub_sat_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUSubSatINTEL instruction to the current block.

pub fn i_mul32x16_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIMul32x16INTEL instruction to the current block.

pub fn insert_i_mul32x16_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpIMul32x16INTEL instruction to the current block.

pub fn u_mul32x16_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUMul32x16INTEL instruction to the current block.

pub fn insert_u_mul32x16_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    operand_1: Word,
    operand_2: Word
) -> Result<Word, Error>

Appends an OpUMul32x16INTEL instruction to the current block.

pub fn loop_control_intel(
    &mut self,
    loop_control_parameters: impl IntoIterator<Item = u32>
) -> Result<(), Error>

Appends an OpLoopControlINTEL instruction to the current block.

pub fn insert_loop_control_intel(
    &mut self,
    insert_point: InsertPoint,
    loop_control_parameters: impl IntoIterator<Item = u32>
) -> Result<(), Error>

Appends an OpLoopControlINTEL instruction to the current block.

pub fn read_pipe_blocking_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReadPipeBlockingINTEL instruction to the current block.

pub fn insert_read_pipe_blocking_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpReadPipeBlockingINTEL instruction to the current block.

pub fn write_pipe_blocking_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpWritePipeBlockingINTEL instruction to the current block.

pub fn insert_write_pipe_blocking_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    packet_size: Word,
    packet_alignment: Word
) -> Result<Word, Error>

Appends an OpWritePipeBlockingINTEL instruction to the current block.

pub fn fpga_reg_intel(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    result: Word,
    input: Word
) -> Result<Word, Error>

Appends an OpFPGARegINTEL instruction to the current block.

pub fn insert_fpga_reg_intel(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    result: Word,
    input: Word
) -> Result<Word, Error>

Appends an OpFPGARegINTEL instruction to the current block.

pub fn ray_query_get_ray_t_min_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetRayTMinKHR instruction to the current block.

pub fn insert_ray_query_get_ray_t_min_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetRayTMinKHR instruction to the current block.

pub fn ray_query_get_ray_flags_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetRayFlagsKHR instruction to the current block.

pub fn insert_ray_query_get_ray_flags_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetRayFlagsKHR instruction to the current block.

pub fn ray_query_get_intersection_tkhr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionTKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_tkhr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionTKHR instruction to the current block.

pub fn ray_query_get_intersection_instance_custom_index_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionInstanceCustomIndexKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_instance_custom_index_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionInstanceCustomIndexKHR instruction to the current block.

pub fn ray_query_get_intersection_instance_id_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionInstanceIdKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_instance_id_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionInstanceIdKHR instruction to the current block.

pub fn ray_query_get_intersection_instance_shader_binding_table_record_offset_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_instance_shader_binding_table_record_offset_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR instruction to the current block.

pub fn ray_query_get_intersection_geometry_index_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionGeometryIndexKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_geometry_index_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionGeometryIndexKHR instruction to the current block.

pub fn ray_query_get_intersection_primitive_index_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionPrimitiveIndexKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_primitive_index_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionPrimitiveIndexKHR instruction to the current block.

pub fn ray_query_get_intersection_barycentrics_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionBarycentricsKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_barycentrics_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionBarycentricsKHR instruction to the current block.

pub fn ray_query_get_intersection_front_face_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionFrontFaceKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_front_face_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionFrontFaceKHR instruction to the current block.

pub fn ray_query_get_intersection_candidate_aabb_opaque_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionCandidateAABBOpaqueKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_candidate_aabb_opaque_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionCandidateAABBOpaqueKHR instruction to the current block.

pub fn ray_query_get_intersection_object_ray_direction_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionObjectRayDirectionKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_object_ray_direction_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionObjectRayDirectionKHR instruction to the current block.

pub fn ray_query_get_intersection_object_ray_origin_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionObjectRayOriginKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_object_ray_origin_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionObjectRayOriginKHR instruction to the current block.

pub fn ray_query_get_world_ray_direction_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetWorldRayDirectionKHR instruction to the current block.

pub fn insert_ray_query_get_world_ray_direction_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetWorldRayDirectionKHR instruction to the current block.

pub fn ray_query_get_world_ray_origin_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetWorldRayOriginKHR instruction to the current block.

pub fn insert_ray_query_get_world_ray_origin_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetWorldRayOriginKHR instruction to the current block.

pub fn ray_query_get_intersection_object_to_world_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionObjectToWorldKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_object_to_world_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionObjectToWorldKHR instruction to the current block.

pub fn ray_query_get_intersection_world_to_object_khr(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionWorldToObjectKHR instruction to the current block.

pub fn insert_ray_query_get_intersection_world_to_object_khr(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    ray_query: Word,
    intersection: Word
) -> Result<Word, Error>

Appends an OpRayQueryGetIntersectionWorldToObjectKHR instruction to the current block.

pub fn atomic_f_add_ext(
    &mut self,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicFAddEXT instruction to the current block.

pub fn insert_atomic_f_add_ext(
    &mut self,
    insert_point: InsertPoint,
    result_type: Word,
    result_id: Option<Word>,
    pointer: Word,
    memory: Word,
    semantics: Word,
    value: Word
) -> Result<Word, Error>

Appends an OpAtomicFAddEXT instruction to the current block.

Trait Implementations

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.