Struct rspirv::mr::Builder
[−]
[src]
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 unsed 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 optionalresult_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.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::FUNCTION_CONTROL_DONT_INLINE | spirv::FUNCTION_CONTROL_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.1\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
[src]
fn new() -> Builder
[src]
Creates a new empty builder.
fn module(self) -> Module
[src]
Returns the Module
under construction.
fn id(&mut self) -> Word
[src]
Returns the next unused id.
fn begin_function(
&mut self,
return_type: Word,
function_id: Option<Word>,
control: FunctionControl,
function_type: Word
) -> Result<Word, Error>
[src]
&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.
fn end_function(&mut self) -> Result<(), Error>
[src]
Ends building of the current function.
fn function_parameter(&mut self, result_type: Word) -> Result<Word, Error>
[src]
Declares a formal parameter for the current function.
fn begin_basic_block(&mut self, label_id: Option<Word>) -> Result<Word, Error>
[src]
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.
fn capability(&mut self, capability: Capability)
[src]
Appends an OpCapability instruction.
fn extension<T: Into<String>>(&mut self, extension: T)
[src]
Appends an OpExtension instruction.
fn ext_inst_import<T: Into<String>>(&mut self, extended_inst_set: T) -> Word
[src]
Appends an OpExtInstImport instruction and returns the result id.
fn memory_model(
&mut self,
addressing_model: AddressingModel,
memory_model: MemoryModel
)
[src]
&mut self,
addressing_model: AddressingModel,
memory_model: MemoryModel
)
Appends an OpMemoryModel instruction.
fn entry_point<T: Into<String>, U: AsRef<[Word]>>(
&mut self,
execution_model: ExecutionModel,
entry_point: Word,
name: T,
interface: U
)
[src]
&mut self,
execution_model: ExecutionModel,
entry_point: Word,
name: T,
interface: U
)
Appends an OpEntryPoint instruction.
fn execution_mode<T: AsRef<[u32]>>(
&mut self,
entry_point: Word,
execution_mode: ExecutionMode,
params: T
)
[src]
&mut self,
entry_point: Word,
execution_mode: ExecutionMode,
params: T
)
Appends an OpExecutionMode instruction.
impl Builder
[src]
fn type_void(&mut self) -> Word
[src]
Appends an OpTypeVoid instruction and returns the result id.
fn type_bool(&mut self) -> Word
[src]
Appends an OpTypeBool instruction and returns the result id.
fn type_int(&mut self, width: u32, signedness: u32) -> Word
[src]
Appends an OpTypeInt instruction and returns the result id.
fn type_float(&mut self, width: u32) -> Word
[src]
Appends an OpTypeFloat instruction and returns the result id.
fn type_vector(&mut self, component_type: Word, component_count: u32) -> Word
[src]
Appends an OpTypeVector instruction and returns the result id.
fn type_matrix(&mut self, column_type: Word, column_count: u32) -> Word
[src]
Appends an OpTypeMatrix instruction and returns the result id.
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
[src]
&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.
fn type_sampler(&mut self) -> Word
[src]
Appends an OpTypeSampler instruction and returns the result id.
fn type_sampled_image(&mut self, image_type: Word) -> Word
[src]
Appends an OpTypeSampledImage instruction and returns the result id.
fn type_array(&mut self, element_type: Word, length: Word) -> Word
[src]
Appends an OpTypeArray instruction and returns the result id.
fn type_runtime_array(&mut self, element_type: Word) -> Word
[src]
Appends an OpTypeRuntimeArray instruction and returns the result id.
fn type_struct<T: AsRef<[Word]>>(&mut self, field_types: T) -> Word
[src]
Appends an OpTypeStruct instruction and returns the result id.
fn type_function<T: AsRef<[Word]>>(
&mut self,
return_type: Word,
parameter_types: T
) -> Word
[src]
&mut self,
return_type: Word,
parameter_types: T
) -> Word
Appends an OpTypeFunction instruction and returns the result id.
fn type_event(&mut self) -> Word
[src]
Appends an OpTypeEvent instruction and returns the result id.
fn type_device_event(&mut self) -> Word
[src]
Appends an OpTypeDeviceEvent instruction and returns the result id.
fn type_reserve_id(&mut self) -> Word
[src]
Appends an OpTypeReserveId instruction and returns the result id.
fn type_queue(&mut self) -> Word
[src]
Appends an OpTypeQueue instruction and returns the result id.
fn type_pipe(&mut self, qualifier: AccessQualifier) -> Word
[src]
Appends an OpTypePipe instruction and returns the result id.
fn type_pipe_storage(&mut self) -> Word
[src]
Appends an OpTypePipeStorage instruction and returns the result id.
fn type_named_barrier(&mut self) -> Word
[src]
Appends an OpTypeNamedBarrier instruction and returns the result id.
impl Builder
[src]
fn constant_true(&mut self, result_type: Word) -> Word
[src]
Appends an OpConstantTrue instruction.
fn constant_false(&mut self, result_type: Word) -> Word
[src]
Appends an OpConstantFalse instruction.
fn constant_composite<T: AsRef<[Word]>>(
&mut self,
result_type: Word,
constituents: T
) -> Word
[src]
&mut self,
result_type: Word,
constituents: T
) -> Word
Appends an OpConstantComposite instruction.
fn constant_sampler(
&mut self,
result_type: Word,
sampler_addressing_mode: SamplerAddressingMode,
param: u32,
sampler_filter_mode: SamplerFilterMode
) -> Word
[src]
&mut self,
result_type: Word,
sampler_addressing_mode: SamplerAddressingMode,
param: u32,
sampler_filter_mode: SamplerFilterMode
) -> Word
Appends an OpConstantSampler instruction.
fn constant_null(&mut self, result_type: Word) -> Word
[src]
Appends an OpConstantNull instruction.
fn spec_constant_true(&mut self, result_type: Word) -> Word
[src]
Appends an OpSpecConstantTrue instruction.
fn spec_constant_false(&mut self, result_type: Word) -> Word
[src]
Appends an OpSpecConstantFalse instruction.
fn spec_constant_composite<T: AsRef<[Word]>>(
&mut self,
result_type: Word,
constituents: T
) -> Word
[src]
&mut self,
result_type: Word,
constituents: T
) -> Word
Appends an OpSpecConstantComposite instruction.
fn spec_constant_op(&mut self, result_type: Word, opcode: Op) -> Word
[src]
Appends an OpSpecConstantOp instruction.
fn constant_pipe_storage(
&mut self,
result_type: Word,
packet_size: u32,
packet_alignment: u32,
capacity: u32
) -> Word
[src]
&mut self,
result_type: Word,
packet_size: u32,
packet_alignment: u32,
capacity: u32
) -> Word
Appends an OpConstantPipeStorage instruction.
impl Builder
[src]
fn decorate<T: AsRef<[Operand]>>(
&mut self,
target: Word,
decoration: Decoration,
additional_params: T
)
[src]
&mut self,
target: Word,
decoration: Decoration,
additional_params: T
)
Appends an OpDecorate instruction.
fn member_decorate<T: AsRef<[Operand]>>(
&mut self,
structure_type: Word,
member: u32,
decoration: Decoration,
additional_params: T
)
[src]
&mut self,
structure_type: Word,
member: u32,
decoration: Decoration,
additional_params: T
)
Appends an OpMemberDecorate instruction.
fn group_decorate<T: AsRef<[Word]>>(
&mut self,
decoration_group: Word,
targets: T
)
[src]
&mut self,
decoration_group: Word,
targets: T
)
Appends an OpGroupDecorate instruction.
fn group_member_decorate<T: AsRef<[(Word, u32)]>>(
&mut self,
decoration_group: Word,
targets: T
)
[src]
&mut self,
decoration_group: Word,
targets: T
)
Appends an OpGroupMemberDecorate instruction.
impl Builder
[src]
fn branch(&mut self, target_label: Word) -> Result<(), Error>
[src]
Appends an OpBranch instruction and ends the current basic block.
fn branch_conditional<T: AsRef<[u32]>>(
&mut self,
condition: Word,
true_label: Word,
false_label: Word,
branch_weights: T
) -> Result<(), Error>
[src]
&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.
fn switch<T: AsRef<[(u32, Word)]>>(
&mut self,
selector: Word,
default: Word,
target: T
) -> Result<(), Error>
[src]
&mut self,
selector: Word,
default: Word,
target: T
) -> Result<(), Error>
Appends an OpSwitch instruction and ends the current basic block.
fn kill(&mut self) -> Result<(), Error>
[src]
Appends an OpKill instruction and ends the current basic block.
fn ret(&mut self) -> Result<(), Error>
[src]
Appends an OpReturn instruction and ends the current basic block.
fn ret_value(&mut self, value: Word) -> Result<(), Error>
[src]
Appends an OpReturnValue instruction and ends the current basic block.
fn unreachable(&mut self) -> Result<(), Error>
[src]
Appends an OpUnreachable instruction and ends the current basic block.
impl Builder
[src]
fn source_continued<T: Into<String>>(&mut self, continued_source: T)
[src]
Appends an OpSourceContinued instruction.
fn source<T: Into<String>>(
&mut self,
source_language: SourceLanguage,
version: u32,
file: Option<Word>,
source: Option<T>
)
[src]
&mut self,
source_language: SourceLanguage,
version: u32,
file: Option<Word>,
source: Option<T>
)
Appends an OpSource instruction.
fn source_extension<T: Into<String>>(&mut self, extension: T)
[src]
Appends an OpSourceExtension instruction.
fn name<T: Into<String>>(&mut self, target: Word, name: T)
[src]
Appends an OpName instruction.
fn member_name<T: Into<String>>(
&mut self,
target_type: Word,
member: u32,
name: T
)
[src]
&mut self,
target_type: Word,
member: u32,
name: T
)
Appends an OpMemberName instruction.
fn module_processed<T: Into<String>>(&mut self, process: T)
[src]
Appends an OpModuleProcessed instruction.
impl Builder
[src]
fn decoration_group(&mut self) -> Word
[src]
Appends an OpDecorationGroup instruction and returns the result id.
fn string<T: Into<String>>(&mut self, s: T) -> Word
[src]
fn line(&mut self, file: Word, line: Word, column: Word)
[src]
fn no_line(&mut self)
[src]
impl Builder
[src]
fn type_forward_pointer(
&mut self,
pointer_type: Word,
storage_class: StorageClass
)
[src]
&mut self,
pointer_type: Word,
storage_class: StorageClass
)
Appends an OpTypeForwardPointer instruction.
fn type_pointer(
&mut self,
result_id: Option<Word>,
storage_class: StorageClass,
pointee_type: Word
) -> Word
[src]
&mut self,
result_id: Option<Word>,
storage_class: StorageClass,
pointee_type: Word
) -> Word
Appends an OpTypePointer instruction and returns the result id.
fn type_opaque<T: Into<String>>(&mut self, type_name: T) -> Word
[src]
Appends an OpTypeOpaque instruction and returns the result id.
fn constant_f32(&mut self, result_type: Word, value: f32) -> Word
[src]
Appends an OpConstant instruction with the given 32-bit float value
.
or the module if no basic block is under construction.
fn constant_u32(&mut self, result_type: Word, value: u32) -> Word
[src]
Appends an OpConstant instruction with the given 32-bit integer value
.
or the module if no basic block is under construction.
fn spec_constant_f32(&mut self, result_type: Word, value: f32) -> Word
[src]
Appends an OpSpecConstant instruction with the given 32-bit float value
.
or the module if no basic block is under construction.
fn spec_constant_u32(&mut self, result_type: Word, value: u32) -> Word
[src]
Appends an OpSpecConstant instruction with the given 32-bit integer value
.
or the module if no basic block is under construction.
fn variable(
&mut self,
result_type: Word,
result_id: Option<Word>,
storage_class: StorageClass,
initializer: Option<Word>
) -> Word
[src]
&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.
fn undef(&mut self, result_type: Word, result_id: Option<Word>) -> Word
[src]
Appends an OpUndef instruction to either the current basic block or the module if no basic block is under construction.
impl Builder
[src]
fn nop(&mut self) -> Result<(), Error>
[src]
Appends an OpNop instruction to the current basic block.
fn ext_inst<T: AsRef<[Word]>>(
&mut self,
result_type: Word,
result_id: Option<Word>,
set: Word,
instruction: u32,
operands: T
) -> Result<Word, Error>
[src]
&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.
fn function_call<T: AsRef<[Word]>>(
&mut self,
result_type: Word,
result_id: Option<Word>,
function: Word,
arguments: T
) -> Result<Word, Error>
[src]
&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.
fn image_texel_pointer(
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word,
coordinate: Word,
sample: Word
) -> Result<Word, Error>
[src]
&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.
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>
[src]
&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.
fn store<T: AsRef<[Operand]>>(
&mut self,
pointer: Word,
object: Word,
memory_access: Option<MemoryAccess>,
additional_params: T
) -> Result<(), Error>
[src]
&mut self,
pointer: Word,
object: Word,
memory_access: Option<MemoryAccess>,
additional_params: T
) -> Result<(), Error>
Appends an OpStore instruction to the current basic block.
fn copy_memory<T: AsRef<[Operand]>>(
&mut self,
target: Word,
source: Word,
memory_access: Option<MemoryAccess>,
additional_params: T
) -> Result<(), Error>
[src]
&mut self,
target: Word,
source: Word,
memory_access: Option<MemoryAccess>,
additional_params: T
) -> Result<(), Error>
Appends an OpCopyMemory instruction to the current basic block.
fn copy_memory_sized<T: AsRef<[Operand]>>(
&mut self,
target: Word,
source: Word,
size: Word,
memory_access: Option<MemoryAccess>,
additional_params: T
) -> Result<(), Error>
[src]
&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.
fn access_chain<T: AsRef<[Word]>>(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word,
indexes: T
) -> Result<Word, Error>
[src]
&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.
fn in_bounds_access_chain<T: AsRef<[Word]>>(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word,
indexes: T
) -> Result<Word, Error>
[src]
&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.
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>
[src]
&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.
fn array_length(
&mut self,
result_type: Word,
result_id: Option<Word>,
structure: Word,
array_member: u32
) -> Result<Word, Error>
[src]
&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.
fn generic_ptr_mem_semantics(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
Appends an OpGenericPtrMemSemantics instruction to the current basic block.
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>
[src]
&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.
fn vector_extract_dynamic(
&mut self,
result_type: Word,
result_id: Option<Word>,
vector: Word,
index: Word
) -> Result<Word, Error>
[src]
&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.
fn vector_insert_dynamic(
&mut self,
result_type: Word,
result_id: Option<Word>,
vector: Word,
component: Word,
index: Word
) -> Result<Word, Error>
[src]
&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.
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>
[src]
&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.
fn composite_construct<T: AsRef<[Word]>>(
&mut self,
result_type: Word,
result_id: Option<Word>,
constituents: T
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
constituents: T
) -> Result<Word, Error>
Appends an OpCompositeConstruct instruction to the current basic block.
fn composite_extract<T: AsRef<[u32]>>(
&mut self,
result_type: Word,
result_id: Option<Word>,
composite: Word,
indexes: T
) -> Result<Word, Error>
[src]
&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.
fn composite_insert<T: AsRef<[u32]>>(
&mut self,
result_type: Word,
result_id: Option<Word>,
object: Word,
composite: Word,
indexes: T
) -> Result<Word, Error>
[src]
&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.
fn copy_object(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
Appends an OpCopyObject instruction to the current basic block.
fn transpose(
&mut self,
result_type: Word,
result_id: Option<Word>,
matrix: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
matrix: Word
) -> Result<Word, Error>
Appends an OpTranspose instruction to the current basic block.
fn sampled_image(
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word,
sampler: Word
) -> Result<Word, Error>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
fn image_write<T: AsRef<[Operand]>>(
&mut self,
image: Word,
coordinate: Word,
texel: Word,
image_operands: Option<ImageOperands>,
additional_params: T
) -> Result<(), Error>
[src]
&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.
fn image(
&mut self,
result_type: Word,
result_id: Option<Word>,
sampled_image: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
sampled_image: Word
) -> Result<Word, Error>
Appends an OpImage instruction to the current basic block.
fn image_query_format(
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
Appends an OpImageQueryFormat instruction to the current basic block.
fn image_query_order(
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
Appends an OpImageQueryOrder instruction to the current basic block.
fn image_query_size_lod(
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word,
level_of_detail: Word
) -> Result<Word, Error>
[src]
&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.
fn image_query_size(
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
Appends an OpImageQuerySize instruction to the current basic block.
fn image_query_lod(
&mut self,
result_type: Word,
result_id: Option<Word>,
sampled_image: Word,
coordinate: Word
) -> Result<Word, Error>
[src]
&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.
fn image_query_levels(
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
Appends an OpImageQueryLevels instruction to the current basic block.
fn image_query_samples(
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
image: Word
) -> Result<Word, Error>
Appends an OpImageQuerySamples instruction to the current basic block.
fn convert_fto_u(
&mut self,
result_type: Word,
result_id: Option<Word>,
float_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
float_value: Word
) -> Result<Word, Error>
Appends an OpConvertFToU instruction to the current basic block.
fn convert_fto_s(
&mut self,
result_type: Word,
result_id: Option<Word>,
float_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
float_value: Word
) -> Result<Word, Error>
Appends an OpConvertFToS instruction to the current basic block.
fn convert_sto_f(
&mut self,
result_type: Word,
result_id: Option<Word>,
signed_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
signed_value: Word
) -> Result<Word, Error>
Appends an OpConvertSToF instruction to the current basic block.
fn convert_uto_f(
&mut self,
result_type: Word,
result_id: Option<Word>,
unsigned_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
unsigned_value: Word
) -> Result<Word, Error>
Appends an OpConvertUToF instruction to the current basic block.
fn uconvert(
&mut self,
result_type: Word,
result_id: Option<Word>,
unsigned_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
unsigned_value: Word
) -> Result<Word, Error>
Appends an OpUConvert instruction to the current basic block.
fn sconvert(
&mut self,
result_type: Word,
result_id: Option<Word>,
signed_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
signed_value: Word
) -> Result<Word, Error>
Appends an OpSConvert instruction to the current basic block.
fn fconvert(
&mut self,
result_type: Word,
result_id: Option<Word>,
float_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
float_value: Word
) -> Result<Word, Error>
Appends an OpFConvert instruction to the current basic block.
fn quantize_to_f16(
&mut self,
result_type: Word,
result_id: Option<Word>,
value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
value: Word
) -> Result<Word, Error>
Appends an OpQuantizeToF16 instruction to the current basic block.
fn convert_ptr_to_u(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
Appends an OpConvertPtrToU instruction to the current basic block.
fn sat_convert_sto_u(
&mut self,
result_type: Word,
result_id: Option<Word>,
signed_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
signed_value: Word
) -> Result<Word, Error>
Appends an OpSatConvertSToU instruction to the current basic block.
fn sat_convert_uto_s(
&mut self,
result_type: Word,
result_id: Option<Word>,
unsigned_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
unsigned_value: Word
) -> Result<Word, Error>
Appends an OpSatConvertUToS instruction to the current basic block.
fn convert_uto_ptr(
&mut self,
result_type: Word,
result_id: Option<Word>,
integer_value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
integer_value: Word
) -> Result<Word, Error>
Appends an OpConvertUToPtr instruction to the current basic block.
fn ptr_cast_to_generic(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
Appends an OpPtrCastToGeneric instruction to the current basic block.
fn generic_cast_to_ptr(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
Appends an OpGenericCastToPtr instruction to the current basic block.
fn generic_cast_to_ptr_explicit(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
storage: StorageClass
) -> Result<Word, Error>
[src]
&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.
fn bitcast(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
Appends an OpBitcast instruction to the current basic block.
fn snegate(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
Appends an OpSNegate instruction to the current basic block.
fn fnegate(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
Appends an OpFNegate instruction to the current basic block.
fn iadd(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn fadd(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn isub(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn fsub(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn imul(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn fmul(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn udiv(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn sdiv(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn fdiv(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn umod(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn srem(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn smod(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn frem(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn fmod(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn vector_times_scalar(
&mut self,
result_type: Word,
result_id: Option<Word>,
vector: Word,
scalar: Word
) -> Result<Word, Error>
[src]
&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.
fn matrix_times_scalar(
&mut self,
result_type: Word,
result_id: Option<Word>,
matrix: Word,
scalar: Word
) -> Result<Word, Error>
[src]
&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.
fn vector_times_matrix(
&mut self,
result_type: Word,
result_id: Option<Word>,
vector: Word,
matrix: Word
) -> Result<Word, Error>
[src]
&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.
fn matrix_times_vector(
&mut self,
result_type: Word,
result_id: Option<Word>,
matrix: Word,
vector: Word
) -> Result<Word, Error>
[src]
&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.
fn matrix_times_matrix(
&mut self,
result_type: Word,
result_id: Option<Word>,
left_matrix: Word,
right_matrix: Word
) -> Result<Word, Error>
[src]
&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.
fn outer_product(
&mut self,
result_type: Word,
result_id: Option<Word>,
vector_1: Word,
vector_2: Word
) -> Result<Word, Error>
[src]
&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.
fn dot(
&mut self,
result_type: Word,
result_id: Option<Word>,
vector_1: Word,
vector_2: Word
) -> Result<Word, Error>
[src]
&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.
fn iadd_carry(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn isub_borrow(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn umul_extended(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn smul_extended(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn any(
&mut self,
result_type: Word,
result_id: Option<Word>,
vector: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
vector: Word
) -> Result<Word, Error>
Appends an OpAny instruction to the current basic block.
fn all(
&mut self,
result_type: Word,
result_id: Option<Word>,
vector: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
vector: Word
) -> Result<Word, Error>
Appends an OpAll instruction to the current basic block.
fn is_nan(
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
Appends an OpIsNan instruction to the current basic block.
fn is_inf(
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
Appends an OpIsInf instruction to the current basic block.
fn is_finite(
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
Appends an OpIsFinite instruction to the current basic block.
fn is_normal(
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
Appends an OpIsNormal instruction to the current basic block.
fn sign_bit_set(
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word
) -> Result<Word, Error>
Appends an OpSignBitSet instruction to the current basic block.
fn less_or_greater(
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word,
y: Word
) -> Result<Word, Error>
[src]
&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.
fn ordered(
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word,
y: Word
) -> Result<Word, Error>
[src]
&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.
fn unordered(
&mut self,
result_type: Word,
result_id: Option<Word>,
x: Word,
y: Word
) -> Result<Word, Error>
[src]
&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.
fn logical_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn logical_not_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn logical_or(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn logical_and(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn logical_not(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
Appends an OpLogicalNot instruction to the current basic block.
fn select(
&mut self,
result_type: Word,
result_id: Option<Word>,
condition: Word,
object_1: Word,
object_2: Word
) -> Result<Word, Error>
[src]
&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.
fn iequal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn inot_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn ugreater_than(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn sgreater_than(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn ugreater_than_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn sgreater_than_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn uless_than(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn sless_than(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn uless_than_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn sless_than_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn ford_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn funord_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn ford_not_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn funord_not_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn ford_less_than(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn funord_less_than(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn ford_greater_than(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn funord_greater_than(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn ford_less_than_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn funord_less_than_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn ford_greater_than_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn funord_greater_than_equal(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn shift_right_logical(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word,
shift: Word
) -> Result<Word, Error>
[src]
&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.
fn shift_right_arithmetic(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word,
shift: Word
) -> Result<Word, Error>
[src]
&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.
fn shift_left_logical(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word,
shift: Word
) -> Result<Word, Error>
[src]
&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.
fn bitwise_or(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn bitwise_xor(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn bitwise_and(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand_1: Word,
operand_2: Word
) -> Result<Word, Error>
[src]
&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.
fn not(
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
operand: Word
) -> Result<Word, Error>
Appends an OpNot instruction to the current basic block.
fn bit_field_insert(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word,
insert: Word,
offset: Word,
count: Word
) -> Result<Word, Error>
[src]
&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.
fn bit_field_sextract(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word,
offset: Word,
count: Word
) -> Result<Word, Error>
[src]
&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.
fn bit_field_uextract(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word,
offset: Word,
count: Word
) -> Result<Word, Error>
[src]
&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.
fn bit_reverse(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word
) -> Result<Word, Error>
Appends an OpBitReverse instruction to the current basic block.
fn bit_count(
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
base: Word
) -> Result<Word, Error>
Appends an OpBitCount instruction to the current basic block.
fn dpdx(
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
Appends an OpDPdx instruction to the current basic block.
fn dpdy(
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
Appends an OpDPdy instruction to the current basic block.
fn fwidth(
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
Appends an OpFwidth instruction to the current basic block.
fn dpdx_fine(
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
Appends an OpDPdxFine instruction to the current basic block.
fn dpdy_fine(
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
Appends an OpDPdyFine instruction to the current basic block.
fn fwidth_fine(
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
Appends an OpFwidthFine instruction to the current basic block.
fn dpdx_coarse(
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
Appends an OpDPdxCoarse instruction to the current basic block.
fn dpdy_coarse(
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
Appends an OpDPdyCoarse instruction to the current basic block.
fn fwidth_coarse(
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
p: Word
) -> Result<Word, Error>
Appends an OpFwidthCoarse instruction to the current basic block.
fn emit_vertex(&mut self) -> Result<(), Error>
[src]
Appends an OpEmitVertex instruction to the current basic block.
fn end_primitive(&mut self) -> Result<(), Error>
[src]
Appends an OpEndPrimitive instruction to the current basic block.
fn emit_stream_vertex(&mut self, stream: Word) -> Result<(), Error>
[src]
Appends an OpEmitStreamVertex instruction to the current basic block.
fn end_stream_primitive(&mut self, stream: Word) -> Result<(), Error>
[src]
Appends an OpEndStreamPrimitive instruction to the current basic block.
fn control_barrier(
&mut self,
execution: Word,
memory: Word,
semantics: Word
) -> Result<(), Error>
[src]
&mut self,
execution: Word,
memory: Word,
semantics: Word
) -> Result<(), Error>
Appends an OpControlBarrier instruction to the current basic block.
fn memory_barrier(&mut self, memory: Word, semantics: Word) -> Result<(), Error>
[src]
Appends an OpMemoryBarrier instruction to the current basic block.
fn atomic_load(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_store(
&mut self,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<(), Error>
[src]
&mut self,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<(), Error>
Appends an OpAtomicStore instruction to the current basic block.
fn atomic_exchange(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
fn atomic_iincrement(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_idecrement(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_iadd(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_isub(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_smin(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_umin(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_smax(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_umax(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_and(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_or(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_xor(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word,
value: Word
) -> Result<Word, Error>
[src]
&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.
fn phi<T: AsRef<[(Word, Word)]>>(
&mut self,
result_type: Word,
result_id: Option<Word>,
value_label_pairs: T
) -> Result<Word, Error>
[src]
&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.
fn loop_merge<T: AsRef<[Operand]>>(
&mut self,
merge_block: Word,
continue_target: Word,
loop_control: LoopControl,
additional_params: T
) -> Result<(), Error>
[src]
&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.
fn selection_merge(
&mut self,
merge_block: Word,
selection_control: SelectionControl
) -> Result<(), Error>
[src]
&mut self,
merge_block: Word,
selection_control: SelectionControl
) -> Result<(), Error>
Appends an OpSelectionMerge instruction to the current basic block.
fn lifetime_start(&mut self, pointer: Word, size: u32) -> Result<(), Error>
[src]
Appends an OpLifetimeStart instruction to the current basic block.
fn lifetime_stop(&mut self, pointer: Word, size: u32) -> Result<(), Error>
[src]
Appends an OpLifetimeStop instruction to the current basic block.
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>
[src]
&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.
fn group_wait_events(
&mut self,
execution: Word,
num_events: Word,
events_list: Word
) -> Result<(), Error>
[src]
&mut self,
execution: Word,
num_events: Word,
events_list: Word
) -> Result<(), Error>
Appends an OpGroupWaitEvents instruction to the current basic block.
fn group_all(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
predicate: Word
) -> Result<Word, Error>
[src]
&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.
fn group_any(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
predicate: Word
) -> Result<Word, Error>
[src]
&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.
fn group_broadcast(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
value: Word,
local_id: Word
) -> Result<Word, Error>
[src]
&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.
fn group_iadd(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
operation: GroupOperation,
x: Word
) -> Result<Word, Error>
[src]
&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.
fn group_fadd(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
operation: GroupOperation,
x: Word
) -> Result<Word, Error>
[src]
&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.
fn group_fmin(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
operation: GroupOperation,
x: Word
) -> Result<Word, Error>
[src]
&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.
fn group_umin(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
operation: GroupOperation,
x: Word
) -> Result<Word, Error>
[src]
&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.
fn group_smin(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
operation: GroupOperation,
x: Word
) -> Result<Word, Error>
[src]
&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.
fn group_fmax(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
operation: GroupOperation,
x: Word
) -> Result<Word, Error>
[src]
&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.
fn group_umax(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
operation: GroupOperation,
x: Word
) -> Result<Word, Error>
[src]
&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.
fn group_smax(
&mut self,
result_type: Word,
result_id: Option<Word>,
execution: Word,
operation: GroupOperation,
x: Word
) -> Result<Word, Error>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
fn commit_read_pipe(
&mut self,
pipe: Word,
reserve_id: Word,
packet_size: Word,
packet_alignment: Word
) -> Result<(), Error>
[src]
&mut self,
pipe: Word,
reserve_id: Word,
packet_size: Word,
packet_alignment: Word
) -> Result<(), Error>
Appends an OpCommitReadPipe instruction to the current basic block.
fn commit_write_pipe(
&mut self,
pipe: Word,
reserve_id: Word,
packet_size: Word,
packet_alignment: Word
) -> Result<(), Error>
[src]
&mut self,
pipe: Word,
reserve_id: Word,
packet_size: Word,
packet_alignment: Word
) -> Result<(), Error>
Appends an OpCommitWritePipe instruction to the current basic block.
fn is_valid_reserve_id(
&mut self,
result_type: Word,
result_id: Option<Word>,
reserve_id: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
reserve_id: Word
) -> Result<Word, Error>
Appends an OpIsValidReserveId instruction to the current basic block.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
fn group_commit_read_pipe(
&mut self,
execution: Word,
pipe: Word,
reserve_id: Word,
packet_size: Word,
packet_alignment: Word
) -> Result<(), Error>
[src]
&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.
fn group_commit_write_pipe(
&mut self,
execution: Word,
pipe: Word,
reserve_id: Word,
packet_size: Word,
packet_alignment: Word
) -> Result<(), Error>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
fn retain_event(&mut self, event: Word) -> Result<(), Error>
[src]
Appends an OpRetainEvent instruction to the current basic block.
fn release_event(&mut self, event: Word) -> Result<(), Error>
[src]
Appends an OpReleaseEvent instruction to the current basic block.
fn create_user_event(
&mut self,
result_type: Word,
result_id: Option<Word>
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>
) -> Result<Word, Error>
Appends an OpCreateUserEvent instruction to the current basic block.
fn is_valid_event(
&mut self,
result_type: Word,
result_id: Option<Word>,
event: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
event: Word
) -> Result<Word, Error>
Appends an OpIsValidEvent instruction to the current basic block.
fn set_user_event_status(
&mut self,
event: Word,
status: Word
) -> Result<(), Error>
[src]
&mut self,
event: Word,
status: Word
) -> Result<(), Error>
Appends an OpSetUserEventStatus instruction to the current basic block.
fn capture_event_profiling_info(
&mut self,
event: Word,
profiling_info: Word,
value: Word
) -> Result<(), Error>
[src]
&mut self,
event: Word,
profiling_info: Word,
value: Word
) -> Result<(), Error>
Appends an OpCaptureEventProfilingInfo instruction to the current basic block.
fn get_default_queue(
&mut self,
result_type: Word,
result_id: Option<Word>
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>
) -> Result<Word, Error>
Appends an OpGetDefaultQueue instruction to the current basic block.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
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>
[src]
&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.
fn image_sparse_texels_resident(
&mut self,
result_type: Word,
result_id: Option<Word>,
resident_code: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
resident_code: Word
) -> Result<Word, Error>
Appends an OpImageSparseTexelsResident instruction to the current basic block.
fn atomic_flag_test_and_set(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word,
scope: Word,
semantics: Word
) -> Result<Word, Error>
[src]
&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.
fn atomic_flag_clear(
&mut self,
pointer: Word,
scope: Word,
semantics: Word
) -> Result<(), Error>
[src]
&mut self,
pointer: Word,
scope: Word,
semantics: Word
) -> Result<(), Error>
Appends an OpAtomicFlagClear instruction to the current basic block.
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>
[src]
&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.
fn size_of(
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
pointer: Word
) -> Result<Word, Error>
Appends an OpSizeOf instruction to the current basic block.
fn create_pipe_from_pipe_storage(
&mut self,
result_type: Word,
result_id: Option<Word>,
pipe_storage: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
pipe_storage: Word
) -> Result<Word, Error>
Appends an OpCreatePipeFromPipeStorage instruction to the current basic block.
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>
[src]
&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.
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>
[src]
&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.
fn named_barrier_initialize(
&mut self,
result_type: Word,
result_id: Option<Word>,
subgroup_count: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
subgroup_count: Word
) -> Result<Word, Error>
Appends an OpNamedBarrierInitialize instruction to the current basic block.
fn memory_named_barrier(
&mut self,
named_barrier: Word,
memory: Word,
semantics: Word
) -> Result<(), Error>
[src]
&mut self,
named_barrier: Word,
memory: Word,
semantics: Word
) -> Result<(), Error>
Appends an OpMemoryNamedBarrier instruction to the current basic block.
fn subgroup_ballot_khr(
&mut self,
result_type: Word,
result_id: Option<Word>,
predicate: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
predicate: Word
) -> Result<Word, Error>
Appends an OpSubgroupBallotKHR instruction to the current basic block.
fn subgroup_first_invocation_khr(
&mut self,
result_type: Word,
result_id: Option<Word>,
value: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
value: Word
) -> Result<Word, Error>
Appends an OpSubgroupFirstInvocationKHR instruction to the current basic block.
fn subgroup_all_khr(
&mut self,
result_type: Word,
result_id: Option<Word>,
predicate: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
predicate: Word
) -> Result<Word, Error>
Appends an OpSubgroupAllKHR instruction to the current basic block.
fn subgroup_any_khr(
&mut self,
result_type: Word,
result_id: Option<Word>,
predicate: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
predicate: Word
) -> Result<Word, Error>
Appends an OpSubgroupAnyKHR instruction to the current basic block.
fn subgroup_all_equal_khr(
&mut self,
result_type: Word,
result_id: Option<Word>,
predicate: Word
) -> Result<Word, Error>
[src]
&mut self,
result_type: Word,
result_id: Option<Word>,
predicate: Word
) -> Result<Word, Error>
Appends an OpSubgroupAllEqualKHR instruction to the current basic block.
fn subgroup_read_invocation_khr(
&mut self,
result_type: Word,
result_id: Option<Word>,
value: Word,
index: Word
) -> Result<Word, Error>
[src]
&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.