Struct rspirv::mr::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 basic block is currently under construction or not. Intructions that can appear both in the module and basic block (e.g., OpVariable) will be inserted to the current basic 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 basic block construction (e.g., OpFunction and OpLabel).

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

Examples

extern crate rspirv;
extern crate spirv_headers as spirv;

use rspirv::binary::Disassemble;

fn main() {
    let mut b = rspirv::mr::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_basic_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");
}

Methods

impl Builder

pub fn new() -> Builder

Creates a new empty builder.

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 module(self) -> Module

Returns the Module under construction.

pub fn id(&mut self) -> Word

Returns the next unused id.

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_basic_block(     &mut self,     label_id: Option<Word> ) -> Result<Word, Error>

Begins building of a new basic block.

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

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

Appends an OpCapability instruction.

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

Appends an OpExtension instruction.

pub fn ext_inst_import<T: Into<String>>(&mut self, extended_inst_set: T) -> 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<T: Into<String>, U: AsRef<[Word]>>(     &mut self,     execution_model: ExecutionModel,     entry_point: Word,     name: T,     interface: U )

Appends an OpEntryPoint instruction.

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

Appends an OpExecutionMode instruction.

impl Builder

pub fn type_void(&mut self) -> Word

Appends an OpTypeVoid instruction and returns the result id.

pub fn type_bool(&mut self) -> Word

Appends an OpTypeBool instruction and returns the result id.

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

Appends an OpTypeInt instruction and returns the result id.

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

Appends an OpTypeFloat instruction and returns the result id.

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

Appends an OpTypeVector instruction and returns the result id.

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

Appends an OpTypeMatrix instruction and returns the result id.

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.

pub fn type_sampler(&mut self) -> Word

Appends an OpTypeSampler instruction and returns the result id.

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

Appends an OpTypeSampledImage instruction and returns the result id.

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

Appends an OpTypeArray instruction and returns the result id.

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

Appends an OpTypeRuntimeArray instruction and returns the result id.

pub fn type_struct<T: AsRef<[Word]>>(&mut self, field_types: T) -> Word

Appends an OpTypeStruct instruction and returns the result id.

pub fn type_function<T: AsRef<[Word]>>(     &mut self,     return_type: Word,     parameter_types: T ) -> Word

Appends an OpTypeFunction instruction and returns the result id.

pub fn type_event(&mut self) -> Word

Appends an OpTypeEvent instruction and returns the result id.

pub fn type_device_event(&mut self) -> Word

Appends an OpTypeDeviceEvent instruction and returns the result id.

pub fn type_reserve_id(&mut self) -> Word

Appends an OpTypeReserveId instruction and returns the result id.

pub fn type_queue(&mut self) -> Word

Appends an OpTypeQueue instruction and returns the result id.

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

Appends an OpTypePipe instruction and returns the result id.

pub fn type_pipe_storage(&mut self) -> Word

Appends an OpTypePipeStorage instruction and returns the result id.

pub fn type_named_barrier(&mut self) -> Word

Appends an OpTypeNamedBarrier instruction and returns the result id.

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<T: AsRef<[Word]>>(     &mut self,     result_type: Word,     constituents: T ) -> 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<T: AsRef<[Word]>>(     &mut self,     result_type: Word,     constituents: T ) -> Word

Appends an OpSpecConstantComposite instruction.

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

Appends an OpSpecConstantOp instruction.

pub fn constant_pipe_storage(     &mut self,     result_type: Word,     packet_size: u32,     packet_alignment: u32,     capacity: u32 ) -> Word

Appends an OpConstantPipeStorage instruction.

impl Builder

pub fn decorate<T: AsRef<[Operand]>>(     &mut self,     target: Word,     decoration: Decoration,     additional_params: T )

Appends an OpDecorate instruction.

pub fn member_decorate<T: AsRef<[Operand]>>(     &mut self,     structure_type: Word,     member: u32,     decoration: Decoration,     additional_params: T )

Appends an OpMemberDecorate instruction.

pub fn group_decorate<T: AsRef<[Word]>>(     &mut self,     decoration_group: Word,     targets: T )

Appends an OpGroupDecorate instruction.

pub fn group_member_decorate<T: AsRef<[(Word, u32)]>>(     &mut self,     decoration_group: Word,     targets: T )

Appends an OpGroupMemberDecorate instruction.

pub fn decorate_id<T: AsRef<[Operand]>>(     &mut self,     target: Word,     decoration: Decoration,     additional_params: T )

Appends an OpDecorateId instruction.

pub fn decorate_string_google<T: AsRef<[Operand]>>(     &mut self,     target: Word,     decoration: Decoration,     additional_params: T )

Appends an OpDecorateStringGOOGLE instruction.

pub fn member_decorate_string_google<T: AsRef<[Operand]>>(     &mut self,     struct_type: Word,     member: u32,     decoration: Decoration,     additional_params: T )

Appends an OpMemberDecorateStringGOOGLE instruction.

impl Builder

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

Appends an OpBranch instruction and ends the current basic block.

pub fn branch_conditional<T: AsRef<[u32]>>(     &mut self,     condition: Word,     true_label: Word,     false_label: Word,     branch_weights: T ) -> Result<(), Error>

Appends an OpBranchConditional instruction and ends the current basic block.

pub fn switch<T: AsRef<[(u32, Word)]>>(     &mut self,     selector: Word,     default: Word,     target: T ) -> Result<(), Error>

Appends an OpSwitch instruction and ends the current basic block.

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

Appends an OpKill instruction and ends the current basic block.

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

Appends an OpReturn instruction and ends the current basic block.

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

Appends an OpReturnValue instruction and ends the current basic block.

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

Appends an OpUnreachable instruction and ends the current basic block.

impl Builder

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

Appends an OpSourceContinued instruction.

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

Appends an OpSource instruction.

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

Appends an OpSourceExtension instruction.

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

Appends an OpName instruction.

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

Appends an OpMemberName instruction.

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

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<T: Into<String>>(&mut self, s: T) -> Word

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

pub fn no_line(&mut self)

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.

pub fn type_opaque<T: Into<String>>(&mut self, type_name: T) -> 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 basic block is under construction.

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 basic block is under construction.

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 basic block is under construction.

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 basic block is under construction.

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 basic block or the module if no basic 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 basic block or the module if no basic block is under construction.

impl Builder

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

Appends an OpNop instruction to the current basic block.

pub fn ext_inst<T: AsRef<[Word]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     set: Word,     instruction: u32,     operands: T ) -> Result<Word, Error>

Appends an OpExtInst instruction to the current basic block.

pub fn function_call<T: AsRef<[Word]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     function: Word,     arguments: T ) -> Result<Word, Error>

Appends an OpFunctionCall instruction to the current basic 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 basic block.

pub fn load<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     pointer: Word,     memory_access: Option<MemoryAccess>,     additional_params: T ) -> Result<Word, Error>

Appends an OpLoad instruction to the current basic block.

pub fn store<T: AsRef<[Operand]>>(     &mut self,     pointer: Word,     object: Word,     memory_access: Option<MemoryAccess>,     additional_params: T ) -> Result<(), Error>

Appends an OpStore instruction to the current basic block.

pub fn copy_memory<T: AsRef<[Operand]>>(     &mut self,     target: Word,     source: Word,     memory_access: Option<MemoryAccess>,     additional_params: T ) -> Result<(), Error>

Appends an OpCopyMemory instruction to the current basic block.

pub fn copy_memory_sized<T: AsRef<[Operand]>>(     &mut self,     target: Word,     source: Word,     size: Word,     memory_access: Option<MemoryAccess>,     additional_params: T ) -> Result<(), Error>

Appends an OpCopyMemorySized instruction to the current basic block.

pub fn access_chain<T: AsRef<[Word]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     base: Word,     indexes: T ) -> Result<Word, Error>

Appends an OpAccessChain instruction to the current basic block.

pub fn in_bounds_access_chain<T: AsRef<[Word]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     base: Word,     indexes: T ) -> Result<Word, Error>

Appends an OpInBoundsAccessChain instruction to the current basic block.

pub fn ptr_access_chain<T: AsRef<[Word]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     base: Word,     element: Word,     indexes: T ) -> Result<Word, Error>

Appends an OpPtrAccessChain instruction to the current basic 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 basic 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 basic block.

pub fn in_bounds_ptr_access_chain<T: AsRef<[Word]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     base: Word,     element: Word,     indexes: T ) -> Result<Word, Error>

Appends an OpInBoundsPtrAccessChain instruction to the current basic 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 basic 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 basic block.

pub fn vector_shuffle<T: AsRef<[u32]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     vector_1: Word,     vector_2: Word,     components: T ) -> Result<Word, Error>

Appends an OpVectorShuffle instruction to the current basic block.

pub fn composite_construct<T: AsRef<[Word]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     constituents: T ) -> Result<Word, Error>

Appends an OpCompositeConstruct instruction to the current basic block.

pub fn composite_extract<T: AsRef<[u32]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     composite: Word,     indexes: T ) -> Result<Word, Error>

Appends an OpCompositeExtract instruction to the current basic block.

pub fn composite_insert<T: AsRef<[u32]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     object: Word,     composite: Word,     indexes: T ) -> Result<Word, Error>

Appends an OpCompositeInsert instruction to the current basic 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 basic 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 basic 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 basic block.

pub fn image_sample_implicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSampleImplicitLod instruction to the current basic block.

pub fn image_sample_explicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     image_operands: ImageOperands,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSampleExplicitLod instruction to the current basic block.

pub fn image_sample_dref_implicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSampleDrefImplicitLod instruction to the current basic block.

pub fn image_sample_dref_explicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: ImageOperands,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSampleDrefExplicitLod instruction to the current basic block.

pub fn image_sample_proj_implicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSampleProjImplicitLod instruction to the current basic block.

pub fn image_sample_proj_explicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     image_operands: ImageOperands,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSampleProjExplicitLod instruction to the current basic block.

pub fn image_sample_proj_dref_implicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSampleProjDrefImplicitLod instruction to the current basic block.

pub fn image_sample_proj_dref_explicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: ImageOperands,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSampleProjDrefExplicitLod instruction to the current basic block.

pub fn image_fetch<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     image: Word,     coordinate: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageFetch instruction to the current basic block.

pub fn image_gather<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     component: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageGather instruction to the current basic block.

pub fn image_dref_gather<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageDrefGather instruction to the current basic block.

pub fn image_read<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     image: Word,     coordinate: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageRead instruction to the current basic block.

pub fn image_write<T: AsRef<[Operand]>>(     &mut self,     image: Word,     coordinate: Word,     texel: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<(), Error>

Appends an OpImageWrite instruction to the current basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

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

Appends an OpConvertFToU instruction to the current basic block.

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

Appends an OpConvertFToS instruction to the current basic block.

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

Appends an OpConvertSToF instruction to the current basic block.

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

Appends an OpConvertUToF instruction to the current basic block.

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

Appends an OpUConvert instruction to the current basic block.

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

Appends an OpSConvert instruction to the current basic block.

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

Appends an OpFConvert instruction to the current basic 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 basic 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 basic block.

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

Appends an OpSatConvertSToU instruction to the current basic block.

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

Appends an OpSatConvertUToS instruction to the current basic block.

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

Appends an OpConvertUToPtr instruction to the current basic 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 basic 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 basic 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 basic 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 basic block.

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

Appends an OpSNegate instruction to the current basic block.

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

Appends an OpFNegate instruction to the current basic block.

pub fn iadd(     &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 basic block.

pub fn fadd(     &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 basic block.

pub fn isub(     &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 basic block.

pub fn fsub(     &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 basic block.

pub fn imul(     &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 basic block.

pub fn fmul(     &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 basic block.

pub fn udiv(     &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 basic block.

pub fn sdiv(     &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 basic block.

pub fn fdiv(     &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 basic block.

pub fn umod(     &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 basic block.

pub fn srem(     &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 basic block.

pub fn smod(     &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 basic block.

pub fn frem(     &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 basic block.

pub fn fmod(     &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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

pub fn iadd_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 basic block.

pub fn isub_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 basic block.

pub fn umul_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 basic block.

pub fn smul_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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

pub fn iequal(     &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 basic block.

pub fn inot_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 basic block.

pub fn ugreater_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 basic block.

pub fn sgreater_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 basic block.

pub fn ugreater_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 basic block.

pub fn sgreater_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 basic block.

pub fn uless_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 basic block.

pub fn sless_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 basic block.

pub fn uless_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 basic block.

pub fn sless_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 basic block.

pub fn ford_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 basic block.

pub fn funord_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 basic block.

pub fn ford_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 basic block.

pub fn funord_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 basic block.

pub fn ford_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 basic block.

pub fn funord_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 basic block.

pub fn ford_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 basic block.

pub fn funord_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 basic block.

pub fn ford_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 basic block.

pub fn funord_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 basic block.

pub fn ford_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 basic block.

pub fn funord_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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

pub fn bit_field_sextract(     &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 basic block.

pub fn bit_field_uextract(     &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 basic 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 basic 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 basic block.

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

Appends an OpDPdx instruction to the current basic block.

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

Appends an OpDPdy instruction to the current basic 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 basic block.

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

Appends an OpDPdxFine instruction to the current basic block.

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

Appends an OpDPdyFine instruction to the current basic 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 basic block.

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

Appends an OpDPdxCoarse instruction to the current basic block.

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

Appends an OpDPdyCoarse instruction to the current basic 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 basic block.

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

Appends an OpEmitVertex instruction to the current basic block.

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

Appends an OpEndPrimitive instruction to the current basic block.

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

Appends an OpEmitStreamVertex instruction to the current basic block.

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

Appends an OpEndStreamPrimitive instruction to the current basic block.

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

Appends an OpControlBarrier instruction to the current basic block.

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

Appends an OpMemoryBarrier instruction to the current basic block.

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

Appends an OpAtomicLoad instruction to the current basic block.

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

Appends an OpAtomicStore instruction to the current basic block.

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

Appends an OpAtomicExchange instruction to the current basic block.

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

Appends an OpAtomicCompareExchange instruction to the current basic block.

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

Appends an OpAtomicCompareExchangeWeak instruction to the current basic block.

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

Appends an OpAtomicIIncrement instruction to the current basic block.

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

Appends an OpAtomicIDecrement instruction to the current basic block.

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

Appends an OpAtomicIAdd instruction to the current basic block.

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

Appends an OpAtomicISub instruction to the current basic block.

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

Appends an OpAtomicSMin instruction to the current basic block.

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

Appends an OpAtomicUMin instruction to the current basic block.

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

Appends an OpAtomicSMax instruction to the current basic block.

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

Appends an OpAtomicUMax instruction to the current basic block.

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

Appends an OpAtomicAnd instruction to the current basic block.

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

Appends an OpAtomicOr instruction to the current basic block.

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

Appends an OpAtomicXor instruction to the current basic block.

pub fn phi<T: AsRef<[(Word, Word)]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     value_label_pairs: T ) -> Result<Word, Error>

Appends an OpPhi instruction to the current basic block.

pub fn loop_merge<T: AsRef<[Operand]>>(     &mut self,     merge_block: Word,     continue_target: Word,     loop_control: LoopControl,     additional_params: T ) -> Result<(), Error>

Appends an OpLoopMerge instruction to the current basic block.

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

Appends an OpSelectionMerge instruction to the current basic block.

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

Appends an OpLifetimeStart instruction to the current basic block.

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

Appends an OpLifetimeStop instruction to the current basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

pub fn group_iadd(     &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 basic block.

pub fn group_fadd(     &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 basic block.

pub fn group_fmin(     &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 basic block.

pub fn group_umin(     &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 basic block.

pub fn group_smin(     &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 basic block.

pub fn group_fmax(     &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 basic block.

pub fn group_umax(     &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 basic block.

pub fn group_smax(     &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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

pub fn enqueue_kernel<T: AsRef<[Word]>>(     &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: T ) -> Result<Word, Error>

Appends an OpEnqueueKernel instruction to the current basic block.

pub fn get_kernel_ndrange_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 basic block.

pub fn get_kernel_ndrange_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 basic 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 basic 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 basic block.

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

Appends an OpRetainEvent instruction to the current basic block.

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

Appends an OpReleaseEvent instruction to the current basic 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 basic 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 basic block.

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

Appends an OpSetUserEventStatus instruction to the current basic 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 basic 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 basic block.

pub fn build_ndrange(     &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 basic block.

pub fn image_sparse_sample_implicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseSampleImplicitLod instruction to the current basic block.

pub fn image_sparse_sample_explicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     image_operands: ImageOperands,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseSampleExplicitLod instruction to the current basic block.

pub fn image_sparse_sample_dref_implicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseSampleDrefImplicitLod instruction to the current basic block.

pub fn image_sparse_sample_dref_explicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: ImageOperands,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseSampleDrefExplicitLod instruction to the current basic block.

pub fn image_sparse_sample_proj_implicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseSampleProjImplicitLod instruction to the current basic block.

pub fn image_sparse_sample_proj_explicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     image_operands: ImageOperands,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseSampleProjExplicitLod instruction to the current basic block.

pub fn image_sparse_sample_proj_dref_implicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseSampleProjDrefImplicitLod instruction to the current basic block.

pub fn image_sparse_sample_proj_dref_explicit_lod<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: ImageOperands,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseSampleProjDrefExplicitLod instruction to the current basic block.

pub fn image_sparse_fetch<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     image: Word,     coordinate: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseFetch instruction to the current basic block.

pub fn image_sparse_gather<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     component: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseGather instruction to the current basic block.

pub fn image_sparse_dref_gather<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     sampled_image: Word,     coordinate: Word,     dref: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseDrefGather instruction to the current basic 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 basic block.

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

Appends an OpAtomicFlagTestAndSet instruction to the current basic block.

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

Appends an OpAtomicFlagClear instruction to the current basic block.

pub fn image_sparse_read<T: AsRef<[Operand]>>(     &mut self,     result_type: Word,     result_id: Option<Word>,     image: Word,     coordinate: Word,     image_operands: Option<ImageOperands>,     additional_params: T ) -> Result<Word, Error>

Appends an OpImageSparseRead instruction to the current basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

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

Appends an OpMemoryNamedBarrier instruction to the current basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

pub fn group_non_uniform_iadd(     &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 basic block.

pub fn group_non_uniform_fadd(     &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 basic block.

pub fn group_non_uniform_imul(     &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 basic block.

pub fn group_non_uniform_fmul(     &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 basic block.

pub fn group_non_uniform_smin(     &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 basic block.

pub fn group_non_uniform_umin(     &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 basic block.

pub fn group_non_uniform_fmin(     &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 basic block.

pub fn group_non_uniform_smax(     &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 basic block.

pub fn group_non_uniform_umax(     &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 basic block.

pub fn group_non_uniform_fmax(     &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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

pub fn group_iadd_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 basic block.

pub fn group_fadd_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 basic block.

pub fn group_fmin_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 basic block.

pub fn group_umin_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 basic block.

pub fn group_smin_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 basic block.

pub fn group_fmax_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 basic block.

pub fn group_umax_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 basic block.

pub fn group_smax_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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic 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 basic block.

pub fn subgroup_block_write_intel(     &mut self,     ptr: Word,     data: Word ) -> Result<(), Error>

Appends an OpSubgroupBlockWriteINTEL instruction to the current basic 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 basic 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 basic 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 basic block.

Trait Implementations

impl Default for Builder

fn default() -> Builder

Returns the "default value" for a type.