package spvtools.fuzz.protobufs

Get desktop application:
View/edit binary Protocol Buffers messages

Used in: TransformationAddFunction

• uint32 access_chain_id = 1

  The result id of an OpAccessChain or OpInBoundsAccessChain instruction.

• repeated UInt32Pair compare_and_select_ids = 2

  A series of pairs of fresh ids, one per access chain index, for the results of a compare instruction and a select instruction, serving the roles of %t1 and %t2 in the above example.

Used in: FactDataSynonym

• uint32 object = 1

  The object being accessed - a scalar or composite

• repeated uint32 index = 2

  0 or more indices, used to index into a composite object

Used in: FactSequence

• oneof fact

  • FactConstantUniform constant_uniform_fact = 1

    Order the fact options by numeric id (rather than alphabetically).

  • FactDataSynonym data_synonym_fact = 2

  • FactBlockIsDead block_is_dead_fact = 3

  • FactFunctionIsLivesafe function_is_livesafe_fact = 4

  • FactPointeeValueIsIrrelevant pointee_value_is_irrelevant_fact = 5

  • FactIdEquation id_equation_fact = 6

  • FactIdIsIrrelevant id_is_irrelevant = 7

Used in: Fact

• uint32 block_id = 1

Used in: Fact

• optional UniformBufferElementDescriptor uniform_buffer_element_descriptor = 1

  An element of a uniform buffer

• repeated uint32 constant_word = 2

  The words of the associated constant

Used in: Fact

• optional DataDescriptor data1 = 1

  Data descriptors guaranteed to hold identical data.

• optional DataDescriptor data2 = 2

Used in: Fact

• uint32 function_id = 1

Used in: Fact

• uint32 lhs_id = 1

  The left-hand-side of the equation.

• uint32 opcode = 2

  A SPIR-V opcode, from a restricted set of instructions for which equation facts make sense.

• repeated uint32 rhs_id = 3

  The operands to the right-hand-side of the equation.

Used in: Fact

• uint32 result_id = 1

  An irrelevant id.

Used in: Fact

• uint32 pointer_id = 1

  A result id of pointer type

• repeated Fact fact = 1

Used in: TransformationReplaceBooleanConstantWithConstantBinary, TransformationReplaceConstantWithUniform, TransformationReplaceIdWithSynonym, TransformationReplaceIrrelevantId

• uint32 id_of_interest = 1

  An id that we would like to be able to find a use of.

• optional InstructionDescriptor enclosing_instruction = 2

  The input operand index at which the use is expected.

• uint32 in_operand_index = 3

Used in: TransformationAddFunction

• uint32 opcode = 1

  The instruction's opcode (e.g. OpLabel).

• uint32 result_type_id = 2

  The id of the instruction's result type; 0 if there is no result type.

• uint32 result_id = 3

  The id of the instruction's result; 0 if there is no result.

• repeated InstructionOperand input_operand = 4

  Zero or more input operands.

Used in: IdUseDescriptor, SideEffectWrapperInfo, TransformationAccessChain, TransformationAddCopyMemory, TransformationAddImageSampleUnusedComponents, TransformationAddSynonym, TransformationAdjustBranchWeights, TransformationCompositeConstruct, TransformationCompositeExtract, TransformationCompositeInsert, TransformationEquationInstruction, TransformationFunctionCall, TransformationLoad, TransformationMoveInstructionDown, TransformationMutatePointer, TransformationPushIdThroughVariable, TransformationReplaceCopyMemoryWithLoadStore, TransformationReplaceLinearAlgebraInstruction, TransformationReplaceLoadStoreWithCopyMemory, TransformationSetMemoryOperandsMask, TransformationSplitBlock, TransformationStore, TransformationSwapCommutableOperands, TransformationSwapConditionalBranchOperands, TransformationToggleAccessChainInstruction, TransformationVectorShuffle, TransformationWrapEarlyTerminatorInFunction

• uint32 base_instruction_result_id = 1

  The id of an instruction after which the instruction being described is believed to be located. It might be the using instruction itself.

• uint32 target_instruction_opcode = 2

  The opcode for the instruction being described.

• uint32 num_opcodes_to_ignore = 3

  The number of matching opcodes to skip over when searching from the base instruction to the instruction being described.

Used in: Instruction, TransformationAddSpecConstantOp

• uint32 operand_type = 1

  The type of the operand.

• repeated uint32 operand_data = 2

  The data associated with the operand. For most operands (e.g. ids, storage classes and literals) this will be a single word.

Used in: TransformationAddFunction

• uint32 loop_header_id = 1

  The header for the loop.

• uint32 load_id = 2

  A fresh id into which the loop limiter's current value can be loaded.

• uint32 increment_id = 3

  A fresh id that can be used to increment the loaded value by 1.

• uint32 compare_id = 4

  A fresh id that can be used to compare the loaded value with the loop limit.

• uint32 logical_op_id = 5

  A fresh id that can be used to compute the conjunction or disjunction of an original loop exit condition with |compare_id|, if the loop's back edge block can conditionally exit the loop.

• repeated uint32 phi_id = 6

  A sequence of ids suitable for extending OpPhi instructions of the loop merge block if it did not previously have an incoming edge from the loop back edge block.

TransformationMergeFunctionReturns needs to modify each merge block of loops containing return instructions, by: - adding instructions to decide whether the function is returning - adding instructions to pass on the return value of the function, if it is returning - changing the branch instruction (which must be an unconditional branch) to a conditional branch that, if the function is returning, branches to the merge block of the innermost loop that contains this merge block (which can be the new merge block introduced by the transformation). One such merge block of the form: %block = OpLabel %phi1 = OpPhi %type1 %val1_1 %pred1 %val1_2 %pred2 %phi2 = OpPhi %type2 %val2_1 %pred1 %val2_2 %pred2 OpBranch %next is transformed into: %block = OpLabel %is_returning_id = OpPhi %bool %false %pred1 %false %pred2 %true %ret_bb1 %is_bb2_returning %mer_bb2 %maybe_return_val_id = OpPhi %return_type %any_returnable_val %pred1 %any_returnable_val %pred2 %ret_val1 %ret_bb1 %ret_val2 %mer_bb2 %phi1 = OpPhi %type1 %val1_1 %pred1 %val1_2 %pred2 %any_suitable_id_1 %ret_bb1 %any_suitable_id_1 %mer_bb2 %phi2 = OpPhi %type2 %val2_1 %pred1 %val2_2 %pred2 %any_suitable_id_1 %ret_bb1 %any_suitable_id_1 %mer_bb2 OpBranchConditional %is_returning_id %innermost_loop_merge %next where %ret_bb1 is a block that originally contains a return instruction and %mer_bb2 is the merge block of an inner loop, from where the function might be returning. Note that the block is required to only have OpLabel, OpPhi or OpBranch instructions.

Used in: TransformationMergeFunctionReturns

• uint32 merge_block_id = 1

  The id of the merge block that needs to be modified.

• uint32 is_returning_id = 2

  A fresh id for a boolean OpPhi whose value will be true iff the function is returning. This will be used to decide whether to break out of the loop or to use the original branch of the function. This value will also be used by the merge block of the enclosing loop (if there is one) if the function is returning from this block.

• uint32 maybe_return_val_id = 3

  A fresh id that will get the value being returned, if the function is returning. If the function return type is void, this is ignored.

• repeated UInt32Pair opphi_to_suitable_id = 4

  A mapping from each existing OpPhi id to a suitable id of the same type available to use before the instruction.

When flattening a conditional branch, it is necessary to enclose instructions that have side effects inside conditionals, so that they are only executed if the condition holds. Otherwise, there might be unintended changes in memory, or crashes that would not originally happen. For example, the instruction %id = OpLoad %type %ptr, found in the true branch of the conditional, will be enclosed in a new conditional (assuming that the block containing it can be split around it) as follows: [previous instructions in the block] OpSelectionMerge %merge_block_id None OpBranchConditional %cond %execute_block_id %alternative_block_id %execute_block_id = OpLabel %actual_result_id = OpLoad %type %ptr OpBranch %merge_block_id %alternative_block_id = OpLabel %placeholder_result_id = OpCopyObject %type %value_to_copy_id OpBranch %merge_block_id %merge_block_id = OpLabel %id = OpPhi %type %actual_result_id %execute_block_id %placeholder_result_id %alternative_block_id [following instructions from the original block] If the instruction does not have a result id, this is simplified. For example, OpStore %ptr %value, found in the true branch of a conditional, is enclosed as follows: [previous instructions in the block] OpSelectionMerge %merge_block None OpBranchConditional %cond %execute_block_id %merge_block_id %execute_block_id = OpLabel OpStore %ptr %value OpBranch %merge_block_id %merge_block_id = OpLabel [following instructions from the original block] The same happens if the instruction is found in the false branch of the conditional being flattened, except that the label ids in the OpBranchConditional are swapped.

Used in: TransformationFlattenConditionalBranch

• optional InstructionDescriptor instruction = 1

  An instruction descriptor for identifying the instruction to be enclosed inside a conditional. An instruction descriptor is necessary because the instruction might not have a result id.

• uint32 merge_block_id = 2

  A fresh id for the new merge block.

• uint32 execute_block_id = 3

  A fresh id for the new block where the actual instruction is executed.

• uint32 actual_result_id = 4

  A fresh id for the result id of the instruction (the original one is used by the OpPhi instruction).

• uint32 alternative_block_id = 5

  A fresh id for the new block where the placeholder instruction is placed.

• uint32 placeholder_result_id = 6

  A fresh id for the placeholder instruction.

• uint32 value_to_copy_id = 7

  An id present in the module, available to use at this point in the program and with the same type as the original instruction, that can be used to create a placeholder OpCopyObject instruction.

Used in: TransformationSequence

• oneof transformation

  • TransformationMoveBlockDown move_block_down = 1

    Order the transformation options by numeric id (rather than alphabetically).

  • TransformationSplitBlock split_block = 2

  • TransformationAddConstantBoolean add_constant_boolean = 3

  • TransformationAddConstantScalar add_constant_scalar = 4

  • TransformationAddTypeBoolean add_type_boolean = 5

  • TransformationAddTypeFloat add_type_float = 6

  • TransformationAddTypeInt add_type_int = 7

  • TransformationAddDeadBreak add_dead_break = 8

  • TransformationReplaceBooleanConstantWithConstantBinary replace_boolean_constant_with_constant_binary = 9

  • TransformationAddTypePointer add_type_pointer = 10

  • TransformationReplaceConstantWithUniform replace_constant_with_uniform = 11

  • TransformationAddDeadContinue add_dead_continue = 12

  • TransformationReplaceIdWithSynonym replace_id_with_synonym = 13

  • TransformationSetSelectionControl set_selection_control = 14

  • TransformationCompositeConstruct composite_construct = 15

  • TransformationSetLoopControl set_loop_control = 16

  • TransformationSetFunctionControl set_function_control = 17

  • TransformationAddNoContractionDecoration add_no_contraction_decoration = 18

  • TransformationSetMemoryOperandsMask set_memory_operands_mask = 19

  • TransformationCompositeExtract composite_extract = 20

  • TransformationVectorShuffle vector_shuffle = 21

  • TransformationOutlineFunction outline_function = 22

  • TransformationMergeBlocks merge_blocks = 23

  • TransformationAddTypeVector add_type_vector = 24

  • TransformationAddTypeArray add_type_array = 25

  • TransformationAddTypeMatrix add_type_matrix = 26

  • TransformationAddTypeStruct add_type_struct = 27

  • TransformationAddTypeFunction add_type_function = 28

  • TransformationAddConstantComposite add_constant_composite = 29

  • TransformationAddGlobalVariable add_global_variable = 30

  • TransformationAddGlobalUndef add_global_undef = 31

  • TransformationAddFunction add_function = 32

  • TransformationAddDeadBlock add_dead_block = 33

  • TransformationAddLocalVariable add_local_variable = 34

  • TransformationLoad load = 35

  • TransformationStore store = 36

  • TransformationFunctionCall function_call = 37

  • TransformationAccessChain access_chain = 38

  • TransformationEquationInstruction equation_instruction = 39

  • TransformationSwapCommutableOperands swap_commutable_operands = 40

  • TransformationPermuteFunctionParameters permute_function_parameters = 41

  • TransformationToggleAccessChainInstruction toggle_access_chain_instruction = 42

  • TransformationAddConstantNull add_constant_null = 43

  • TransformationComputeDataSynonymFactClosure compute_data_synonym_fact_closure = 44

  • TransformationAdjustBranchWeights adjust_branch_weights = 45

  • TransformationPushIdThroughVariable push_id_through_variable = 46

  • TransformationAddSpecConstantOp add_spec_constant_op = 47

  • TransformationReplaceLinearAlgebraInstruction replace_linear_algebra_instruction = 48

  • TransformationSwapConditionalBranchOperands swap_conditional_branch_operands = 49

  • TransformationPermutePhiOperands permute_phi_operands = 50

  • TransformationAddParameter add_parameter = 51

  • TransformationAddCopyMemory add_copy_memory = 52

  • TransformationInvertComparisonOperator invert_comparison_operator = 53

  • TransformationAddImageSampleUnusedComponents add_image_sample_unused_components = 54

  • TransformationReplaceParameterWithGlobal replace_parameter_with_global = 55

  • TransformationRecordSynonymousConstants record_synonymous_constants = 56

  • TransformationAddSynonym add_synonym = 57

  • TransformationAddRelaxedDecoration add_relaxed_decoration = 58

  • TransformationReplaceParamsWithStruct replace_params_with_struct = 59

  • TransformationReplaceCopyObjectWithStoreLoad replace_copy_object_with_store_load = 60

  • TransformationReplaceCopyMemoryWithLoadStore replace_copy_memory_with_load_store = 61

  • TransformationReplaceLoadStoreWithCopyMemory replace_load_store_with_copy_memory = 62

  • TransformationAddLoopPreheader add_loop_preheader = 63

  • TransformationMoveInstructionDown move_instruction_down = 64

  • TransformationMakeVectorOperationDynamic make_vector_operation_dynamic = 65

  • TransformationReplaceAddSubMulWithCarryingExtended replace_add_sub_mul_with_carrying_extended = 66

  • TransformationPropagateInstructionUp propagate_instruction_up = 67

  • TransformationCompositeInsert composite_insert = 68

  • TransformationInlineFunction inline_function = 69

  • TransformationAddOpPhiSynonym add_opphi_synonym = 70

  • TransformationMutatePointer mutate_pointer = 71

  • TransformationReplaceIrrelevantId replace_irrelevant_id = 72

  • TransformationReplaceOpPhiIdFromDeadPredecessor replace_opphi_id_from_dead_predecessor = 73

  • TransformationReplaceOpSelectWithConditionalBranch replace_opselect_with_conditional_branch = 74

  • TransformationDuplicateRegionWithSelection duplicate_region_with_selection = 75

  • TransformationFlattenConditionalBranch flatten_conditional_branch = 76

  • TransformationAddBitInstructionSynonym add_bit_instruction_synonym = 77

  • TransformationAddLoopToCreateIntConstantSynonym add_loop_to_create_int_constant_synonym = 78

  • TransformationWrapRegionInSelection wrap_region_in_selection = 79

  • TransformationAddEarlyTerminatorWrapper add_early_terminator_wrapper = 80

  • TransformationPropagateInstructionDown propagate_instruction_down = 81

  • TransformationReplaceBranchFromDeadBlockWithExit replace_branch_from_dead_block_with_exit = 82

  • TransformationWrapEarlyTerminatorInFunction wrap_early_terminator_in_function = 83

  • TransformationMergeFunctionReturns merge_function_returns = 84

  • TransformationExpandVectorReduction expand_vector_reduction = 85

  • TransformationSwapFunctionVariables swap_function_variables = 86

  • TransformationSwapTwoFunctions swap_two_functions = 87

  • TransformationWrapVectorSynonym wrap_vector_synonym = 88

    Add additional option using the next available number.

Used in: Transformation

• uint32 fresh_id = 1

  Result id for the access chain

• uint32 pointer_id = 2

  The pointer from which the access chain starts

• repeated uint32 index_id = 3

  Zero or more access chain indices

• optional InstructionDescriptor instruction_to_insert_before = 4

  A descriptor for an instruction in a block before which the new OpAccessChain instruction should be inserted

• repeated UInt32Pair fresh_ids_for_clamping = 5

  Additional fresh ids, required to clamp index variables. A pair is needed for each access to a non-struct composite.

Used in: Transformation

• uint32 instruction_result_id = 1

  The bit instruction result id.

• repeated uint32 fresh_ids = 2

  The fresh ids required to apply the transformation.

Used in: Transformation

• uint32 fresh_id = 1

• bool is_true = 2

• bool is_irrelevant = 3

  If the constant should be marked as irrelevant.

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the composite

• uint32 type_id = 2

  A composite type id

• repeated uint32 constituent_id = 3

  Constituent ids for the composite

• bool is_irrelevant = 4

  If the constant should be marked as irrelevant.

Used in: Transformation

• uint32 fresh_id = 1

  Id for the constant

• uint32 type_id = 2

  Type of the constant

Used in: Transformation

• uint32 fresh_id = 1

  Id for the constant

• uint32 type_id = 2

  Id for the scalar type of the constant

• repeated uint32 word = 3

  Value of the constant

• bool is_irrelevant = 4

  If the constant should be marked as irrelevant.

Used in: Transformation

• optional InstructionDescriptor instruction_descriptor = 1

  OpCopyMemory will be inserted before this instruction.

• uint32 fresh_id = 2

  Fresh id to copy memory into.

• uint32 source_id = 3

  Source to copy memory from.

• uint32 storage_class = 4

  Storage class for the target variable. Can be either Function or Private.

• uint32 initializer_id = 5

  Result id for the variable's initializer operand. Its type must be equal to variable's pointee type.

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the dead block

• uint32 existing_block = 2

  Id of an existing block terminated with OpBranch, such that this OpBranch can be replaced with an OpBranchConditional to its exiting successor or the dead block

• bool condition_value = 3

  Determines whether the condition associated with the OpBranchConditional is true or false

Used in: Transformation

• uint32 from_block = 1

  The block to break from

• uint32 to_block = 2

  The merge block to break to

• bool break_condition_value = 3

  Determines whether the break condition is true or false

• repeated uint32 phi_id = 4

  A sequence of ids suitable for extending OpPhi instructions as a result of the new break edge

Used in: Transformation

• uint32 from_block = 1

  The block to continue from

• bool continue_condition_value = 2

  Determines whether the continue condition is true or false

• repeated uint32 phi_id = 3

  A sequence of ids suitable for extending OpPhi instructions as a result of the new break edge

Used in: Transformation

• uint32 function_fresh_id = 1

  Fresh id for the function.

• uint32 label_fresh_id = 2

  Fresh id for the single basic block in the function.

• uint32 opcode = 3

  One of OpKill, OpUnreachable, OpTerminateInvocation. If additional early termination instructions are added to SPIR-V they should also be handled here.

Used in: Transformation

• repeated Instruction instruction = 1

  The series of instructions that comprise the function.

• bool is_livesafe = 2

  True if and only if the given function should be made livesafe (see FactFunctionIsLivesafe for definition).

• uint32 loop_limiter_variable_id = 3

  Fresh id for a new variable that will serve as a "loop limiter" for the function; only relevant if |is_livesafe| holds.

• uint32 loop_limit_constant_id = 4

  Id of an existing unsigned integer constant providing the maximum value that the loop limiter can reach before the loop is broken from; only relevant if |is_livesafe| holds.

• repeated LoopLimiterInfo loop_limiter_info = 5

  Fresh ids for each loop in the function that allow the loop limiter to be manipulated; only relevant if |is_livesafe| holds.

• uint32 kill_unreachable_return_value_id = 6

  Id of an existing global value with the same return type as the function that can be used to replace OpKill and OpReachable instructions with ReturnValue instructions. Ignored if the function has void return type. Only relevant if |is_livesafe| holds.

• repeated AccessChainClampingInfo access_chain_clamping_info = 7

  A mapping (represented as a sequence) from every access chain result id in the function to the ids required to clamp its indices to ensure they are in bounds; only relevant if |is_livesafe| holds.

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the undefined value

• uint32 type_id = 2

  The type of the undefined value

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the global variable

• uint32 type_id = 2

  The type of the global variable

• uint32 storage_class = 3

• uint32 initializer_id = 4

  Initial value of the variable

• bool value_is_irrelevant = 5

  True if and only if the behaviour of the module should not depend on the value of the variable, in which case stores to the variable can be performed in an arbitrary fashion.

Used in: Transformation

• uint32 coordinate_with_unused_components_id = 1

  An vector id with the original coordinate and the unused components.

• optional InstructionDescriptor instruction_descriptor = 2

  A descriptor for an image sample instruction.

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the local variable

• uint32 type_id = 2

  The type of the local variable

• uint32 function_id = 3

  The id of the function to which the local variable should be added

• uint32 initializer_id = 4

  Initial value of the variable

• bool value_is_irrelevant = 5

  True if and only if the behaviour of the module should not depend on the value of the variable, in which case stores to the variable can be performed in an arbitrary fashion.

Used in: Transformation

• uint32 loop_header_block = 1

  The id of the loop header block

• uint32 fresh_id = 2

  A fresh id for the preheader block

• repeated uint32 phi_id = 3

  Fresh ids for splitting the OpPhi instructions in the header. A new OpPhi instruction in the preheader is needed for each OpPhi instruction in the header, if the header has more than one predecessor outside of the loop. This allows turning instructions of the form: %loop_header_block = OpLabel %id1 = OpPhi %type %val1 %pred1_id %val2 %pred2_id %val3 %backedge_block_id into: %fresh_id = OpLabel %phi_id1 = OpPhi %type %val1 %pred1_id %val2 %pred2_id OpBranch %header_id %loop_header_block = OpLabel %id1 = OpPhi %type %phi_id1 %fresh_id %val3 %backedge_block_id

A transformation that uses a loop to create a synonym for an integer constant C (scalar or vector) using an initial value I, a step value S and a number of iterations N such that C = I - N * S. For each iteration, S is subtracted from the total. The loop can be made up of one or two blocks, and it is inserted before a block with a single predecessor. In the one-block case, it is of the form: %loop_id = OpLabel %ctr_id = OpPhi %int %int_0 %pred %incremented_ctr_id %loop_id %temp_id = OpPhi %type_of_I %I %pred %eventual_syn_id %loop_id %eventual_syn_id = OpISub %type_of_I %temp_id %step_val_id %incremented_ctr_id = OpIAdd %int %ctr_id %int_1 %cond_id = OpSLessThan %bool %incremented_ctr_id %num_iterations_id OpLoopMerge %block_after_loop_id %loop_id None OpBranchConditional %cond_id %loop_id %block_after_loop_id A new OpPhi instruction is then added to %block_after_loop_id, as follows: %block_after_loop_id = OpLabel %syn_id = OpPhi %type_of_I %eventual_syn_id %loop_id This can be translated, assuming that N > 0, to: int syn = I; for (int ctr = 0; ctr < N; ctr++) syn = syn - S; All existing OpPhi instructions in %block_after_loop_id are also updated to reflect the fact that its predecessor is now %loop_id.

Used in: Transformation

• uint32 constant_id = 1

  The id of the integer constant C that we want a synonym of.

• uint32 initial_val_id = 2

  The id of the initial value integer constant I.

• uint32 step_val_id = 3

  The id of the step value integer constant S.

• uint32 num_iterations_id = 4

  The id of the integer scalar constant, its value being the number of iterations N.

• uint32 block_after_loop_id = 5

  The label id of the block before which the loop must be inserted.

• uint32 syn_id = 6

  A fresh id for the synonym.

• uint32 loop_id = 7

  A fresh id for the label of the loop,

• uint32 ctr_id = 8

  A fresh id for the counter.

• uint32 temp_id = 9

  A fresh id taking the value I - S * ctr at the ctr-th iteration.

• uint32 eventual_syn_id = 10

  A fresh id taking the value I - S * (ctr + 1) at the ctr-th iteration, and thus I - S * N at the last iteration.

• uint32 incremented_ctr_id = 11

  A fresh id for the incremented counter.

• uint32 cond_id = 12

  A fresh id for the loop condition.

• uint32 additional_block_id = 13

  A fresh id for the additional block. If this is 0, it means that only one block is to be created.

Used in: Transformation

• uint32 result_id = 1

  Result id to be decorated

Used in: Transformation

• uint32 block_id = 1

  Label id of the block

• repeated UInt32Pair pred_to_id = 2

  Pairs (pred_i, id_i)

• uint32 fresh_id = 3

  Fresh id for the new instruction

Used in: Transformation

• uint32 function_id = 1

  Result id of the function to add parameters to.

• uint32 parameter_fresh_id = 2

  Fresh id for a new parameter.

• uint32 parameter_type_id = 3

  Type id for a new parameter.

• repeated UInt32Pair call_parameter_ids = 4

  A map that maps from the OpFunctionCall id to the id that will be passed as the new parameter at that call site. It must have the same type as that of the new parameter.

• uint32 function_type_fresh_id = 5

  A fresh id for a new function type. This might not be used if a required function type already exists or if we can change the old function type.

Used in: Transformation

• uint32 result_id = 1

  Result id to be decorated

Used in: Transformation

• uint32 fresh_id = 1

  Result id for the new instruction.

• uint32 type_id = 2

  Type id for the new instruction.

• uint32 opcode = 3

  Opcode operand of the OpSpecConstantOp instruction.

• repeated InstructionOperand operand = 4

  Operands of the |opcode| instruction.

Used in: Transformation

• uint32 result_id = 1

  Result id of the first synonym.

• TransformationAddSynonym.SynonymType synonym_type = 2

  Type of the synonym to create. See SynonymType for more details.

• uint32 synonym_fresh_id = 3

  Fresh result id for a created synonym.

• optional InstructionDescriptor insert_before = 4

  An instruction to insert a new synonym before.

Type of the synonym to apply. Some types might produce instructions with commutative operands. Such types do not specify the order of the operands since we have a special transformation to swap commutable operands. TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3499): Consider adding more types here.

Used in: TransformationAddSynonym

• ADD_ZERO = 0

  New synonym is derived by adding zero to the |result_id|.

• SUB_ZERO = 1

  New synonym is derived by subtracting zero from the |result_id|.

• MUL_ONE = 2

  New synonym is derived by multiplying |result_id| by one.

• COPY_OBJECT = 3

  New synonym is derived by applying OpCopyObject instruction to |result_id|.

• LOGICAL_OR = 4

  New synonym is derived by applying OpLogicalOr to |result_id| with the second operand being 'false'.

• LOGICAL_AND = 5

  New synonym is derived by applying OpLogicalAnd to |result_id| with the second operand being 'true'.

• BITWISE_OR = 6

  New synonym is derived by applying OpBitwiseOr to |result_id| with the second operand being 0 taken with the same bit length as |result_id|

• BITWISE_XOR = 7

  New synonym is derived by applying OpBitwiseXor to |result_id| with the second operand being 0 taken with the same bit length as |result_id|

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the array type

• uint32 element_type_id = 2

  The array's element type

• uint32 size_id = 3

  The array's size

Used in: Transformation

• uint32 fresh_id = 1

  Id to be used for the type

Used in: Transformation

• uint32 fresh_id = 1

  Id to be used for the type

• uint32 width = 2

  Floating-point width

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the function type

• uint32 return_type_id = 2

  The function's return type

• repeated uint32 argument_type_id = 3

  The function's argument types

Used in: Transformation

• uint32 fresh_id = 1

  Id to be used for the type

• uint32 width = 2

  Integer width

• bool is_signed = 3

  True if and only if this is a signed type

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the matrix type

• uint32 column_type_id = 2

  The matrix's column type, which must be a floating-point vector (as per the "data rules" in the SPIR-V specification).

• uint32 column_count = 3

  The matrix's column count

Used in: Transformation

• uint32 fresh_id = 1

  Id to be used for the type

• uint32 storage_class = 2

  Pointer storage class

• uint32 base_type_id = 3

  Id of the base type for the pointer

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the struct type

• repeated uint32 member_type_id = 3

  The struct's member types

Used in: Transformation

• uint32 fresh_id = 1

  Fresh id for the vector type

• uint32 component_type_id = 2

  The vector's component type

• uint32 component_count = 3

  The vector's component count

Used in: Transformation

• optional InstructionDescriptor instruction_descriptor = 1

  A descriptor for a branch conditional instruction.

• optional UInt32Pair branch_weights = 2

  Branch weights of a branch conditional instruction.

Used in: Transformation

• uint32 composite_type_id = 1

  Id of the type of the composite that is to be constructed

• repeated uint32 component = 2

  Ids of the objects that will form the components of the composite

• optional InstructionDescriptor instruction_to_insert_before = 3

  A descriptor for an instruction in a block before which the new OpCompositeConstruct instruction should be inserted

• uint32 fresh_id = 4

  A fresh id for the composite object

Used in: Transformation

• optional InstructionDescriptor instruction_to_insert_before = 1

  A descriptor for an instruction in a block before which the new OpCompositeExtract instruction should be inserted

• uint32 fresh_id = 2

  Result id for the extract operation.

• uint32 composite_id = 3

  Id of the composite from which data is to be extracted.

• repeated uint32 index = 4

  Indices that indicate which part of the composite should be extracted.

Used in: Transformation

• optional InstructionDescriptor instruction_to_insert_before = 1

  A descriptor for an instruction before which the new instruction OpCompositeInsert should be inserted.

• uint32 fresh_id = 2

  Result id of the inserted OpCompositeInsert instruction.

• uint32 composite_id = 3

  Id of the composite used as the basis for the insertion.

• uint32 object_id = 4

  Id of the object to be inserted.

• repeated uint32 index = 5

  Indices that indicate which part of the composite should be inserted into.

Used in: Transformation

• uint32 maximum_equivalence_class_size = 1

  When searching equivalence classes for implied facts, equivalence classes larger than this size will be skipped.

Used in: Transformation

• uint32 new_entry_fresh_id = 1

  Fresh id for a label of the new entry block.

• uint32 condition_id = 2

  Id for a boolean expression.

• uint32 merge_label_fresh_id = 3

  Fresh id for a label of the merge block of the conditional.

• uint32 entry_block_id = 4

  Block id of the entry block of the original region.

• uint32 exit_block_id = 5

  Block id of the exit block of the original region.

• repeated UInt32Pair original_label_to_duplicate_label = 6

  Map that maps from a label in the original region to the corresponding label in the duplicated region.

• repeated UInt32Pair original_id_to_duplicate_id = 7

  Map that maps from a result id in the original region to the corresponding result id in the duplicated region.

• repeated UInt32Pair original_id_to_phi_id = 8

  Map that maps from a result id in the original region to the result id of the corresponding OpPhi instruction.

Used in: Transformation

• uint32 fresh_id = 1

  The result id of the new instruction

• uint32 opcode = 2

  The instruction's opcode

• repeated uint32 in_operand_id = 3

  The input operands to the instruction

• optional InstructionDescriptor instruction_to_insert_before = 4

  A descriptor for an instruction in a block before which the new instruction should be inserted

Used in: Transformation

• uint32 instruction_result_id = 1

  The OpAny or OpAll instruction result id.

• repeated uint32 fresh_ids = 2

  The fresh ids required to apply the transformation.

Used in: Transformation

• uint32 header_block_id = 1

  The label id of the header block

• bool true_branch_first = 2

  A boolean field deciding the order in which the original branches will be laid out: the true branch will be laid out first iff this field is true.

• uint32 fresh_id_for_bvec2_selector = 3

  If the convergence block contains an OpPhi with bvec2 result type, it may be necessary to introduce a bvec2 with the selection construct's condition in both components in order to turn the OpPhi into an OpSelect. This this field provides a fresh id for an OpCompositeConstruct instruction for this purpose. It should be set to 0 if no such instruction is required.

• uint32 fresh_id_for_bvec3_selector = 4

  The same as |fresh_id_for_bvec2_selector| but for the bvec3 case.

• uint32 fresh_id_for_bvec4_selector = 5

  The same as |fresh_id_for_bvec2_selector| but for the bvec4 case.

• repeated SideEffectWrapperInfo side_effect_wrapper_info = 6

  A list of instructions with side effects, which must be enclosed inside smaller conditionals before flattening the main one, and the corresponding fresh ids and module ids needed.

Used in: Transformation

• uint32 fresh_id = 1

  A fresh id for the result of the call

• uint32 callee_id = 2

  Id of the function to be called

• repeated uint32 argument_id = 3

  Ids for arguments to the function

• optional InstructionDescriptor instruction_to_insert_before = 4

  A descriptor for an instruction in a block before which the new OpFunctionCall instruction should be inserted

Used in: Transformation

• uint32 function_call_id = 1

  Result id of the function call instruction.

• repeated UInt32Pair result_id_map = 2

  For each result id defined by the called function, this map provides an associated fresh id that can be used in the inlined version of the function call.

Used in: Transformation

• uint32 operator_id = 1

  Result id of the instruction to invert.

• uint32 fresh_id = 2

  Fresh id that will be used by the operator after the inversion.

Used in: Transformation

• uint32 fresh_id = 1

  The result of the load instruction.

• uint32 pointer_id = 2

  The pointer to be loaded from.

• bool is_atomic = 3

  True if and only if the load should be atomic.

• uint32 memory_scope_id = 4

  The memory scope for the atomic load. Ignored unless |is_atomic| is true.

• uint32 memory_semantics_id = 5

  The memory semantics for the atomic load. Ignored unless |is_atomic| is true.

• optional InstructionDescriptor instruction_to_insert_before = 6

  A descriptor for an instruction in a block before which the new OpLoad instruction should be inserted.

Used in: Transformation

• uint32 instruction_result_id = 1

  The composite instruction result id.

• uint32 constant_index_id = 2

  The OpCompositeExtract/Insert instructions accept integer literals as indices to the composite object. However, the OpVectorInsert/ExtractDynamic instructions require its single index to be an integer instruction. This is the result id of the integer instruction.

Used in: Transformation

• uint32 block_id = 1

  The id of the block that is to be merged with its predecessor; the merged block will have the *predecessor's* id.

Used in: Transformation

• uint32 function_id = 1

  The id of the function to which the transformation is being applied.

• uint32 outer_header_id = 2

  A fresh id for the header of the new outer loop.

• uint32 unreachable_continue_id = 7

  A fresh id for an unreachable continue construct for the new outer loop.

• uint32 outer_return_id = 3

  A fresh id for the new return block of the function, i.e. the merge block of the new outer loop.

• uint32 return_val_id = 4

  A fresh id for the value that will be returned. This is ignored if the function has void return type.

• uint32 any_returnable_val_id = 5

  An existing id of the same type as the return value, which is available to use at the end of the entry block. This is ignored if the function has void return type or if no loops in the function contain a return instruction. If the function is not void, the transformation will add an OpPhi instruction to each merge block whose associated loop contains at least a return instruction. The value associated with existing predecessors from which the function cannot be returning will be this id, used as a placeholder.

• repeated ReturnMergingInfo return_merging_info = 6

  The information needed to modify the merge blocks of loops containing return instructions.

Used in: Transformation

• uint32 block_id = 1

  The id of the block to move down.

Used in: Transformation

• optional InstructionDescriptor instruction = 1

  The instruction to move down.

Used in: Transformation

• uint32 pointer_id = 1

  Result id of the pointer instruction to mutate.

• uint32 fresh_id = 2

  Fresh id for the OpLoad instruction.

• optional InstructionDescriptor insert_before = 3

  Instruction to insert backup, mutation and restoration code before.

Used in: Transformation

• uint32 entry_block = 1

  Id of the entry block of the single-entry single-exit region to be outlined

• uint32 exit_block = 2

  Id of the exit block of the single-entry single-exit region to be outlined

• uint32 new_function_struct_return_type_id = 3

  Id of a struct that will store the return values of the new function

• uint32 new_function_type_id = 4

  A fresh id for the type of the outlined function

• uint32 new_function_id = 5

  A fresh id for the outlined function itself

• uint32 new_function_region_entry_block = 6

  A fresh id to represent the block in the outlined function that represents the first block of the outlined region.

• uint32 new_caller_result_id = 7

  A fresh id for the result of the OpFunctionCall instruction that will call the outlined function

• uint32 new_callee_result_id = 8

  A fresh id to capture the return value of the outlined function - the argument to OpReturn

• repeated UInt32Pair input_id_to_fresh_id = 9

  Ids defined outside the region and used inside the region will become parameters to the outlined function. This is a mapping from used ids to fresh parameter ids.

• repeated UInt32Pair output_id_to_fresh_id = 10

  Ids defined inside the region and used outside the region will become fresh ids defined by the outlined function, which get copied into the function's struct return value and then copied into their destination ids by the caller. This is a mapping from original ids to corresponding fresh ids.

Used in: Transformation

• uint32 function_id = 1

  Function, whose parameters will be permuted

• uint32 function_type_fresh_id = 2

  Fresh id for a new type of the function. This might not be used if a required function type already exists or if we can change the old function type.

• repeated uint32 permutation = 3

  An array of size |n|, where |n| is a number of arguments to a function with |function_id|. For each i: 0 <= permutation[i] < n. i-th element of this array contains a position for an i-th function's argument (i.e. i-th argument will be permutation[i]-th after running this transformation)

Used in: Transformation

• uint32 result_id = 1

  Result id of the instruction to apply the transformation to.

• repeated uint32 permutation = 2

  A sequence of numbers in the range [0, n/2 - 1] where |n| is the number of operands of the OpPhi instruction with |result_id|.

Used in: Transformation

• uint32 block_id = 1

  Id of the block to propagate an instruction from. The decision on what instruction to propagate is made based on whether the instruction interacts with memory, whether that instruction is used in its block etc (see the transformation class for more details).

• uint32 phi_fresh_id = 2

  A fresh id for an OpPhi instruction. This might not be used by the transformation since an OpPhi instruction is created only if needed (e.g. an instruction is propagated into divergent blocks).

• repeated UInt32Pair successor_id_to_fresh_id = 3

  A map from the id of some successor of the |block_id| to the fresh id. The map contains a fresh id for at least every successor of the |block_id|. Every fresh id in the map corresponds to the result id of the clone, propagated into the corresponding successor block. This transformation might use overflow ids if they are available and this field doesn't account for every successor of |block_id|.

Used in: Transformation

• uint32 block_id = 1

  Id of the block to propagate an instruction from.

• repeated UInt32Pair predecessor_id_to_fresh_id = 2

  A map from the id of some predecessor of the |block_id| to the fresh id. The map contains a fresh id for at least every predecessor of the |block_id|. The instruction is propagated by creating a number of clones - one clone for each predecessor. Fresh ids from this field are used as result ids of cloned instructions.

Used in: Transformation

• uint32 value_id = 1

  The value to be stored.

• uint32 value_synonym_id = 2

  A fresh id for the result of the load instruction.

• uint32 variable_id = 3

  A fresh id for the variable to be stored to.

• uint32 initializer_id = 4

  Constant to initialize the variable from.

• uint32 variable_storage_class = 5

  The variable storage class (global or local).

• optional InstructionDescriptor instruction_descriptor = 6

  A descriptor for an instruction which the new OpStore and OpLoad instructions might be inserted before.

Used in: Transformation

• uint32 constant1_id = 1

  The id of a constant

• uint32 constant2_id = 2

  The id of the synonym

Used in: Transformation

• uint32 struct_fresh_id = 1

  The fresh id of the intermediate result.

• uint32 result_id = 2

  The result id of the original instruction.

Used in: Transformation

• optional IdUseDescriptor id_use_descriptor = 1

  A descriptor for the boolean constant id we would like to replace

• uint32 lhs_id = 2

  Id for the constant to be used on the LHS of the comparison

• uint32 rhs_id = 3

  Id for the constant to be used on the RHS of the comparison

• uint32 opcode = 4

  Opcode for binary operator

• uint32 fresh_id_for_binary_operation = 5

  Id that will store the result of the binary operation instruction

Used in: Transformation

• uint32 block_id = 1

  The dead block whose terminator is to be replaced.

• uint32 opcode = 2

  The opcode of the new terminator.

• uint32 return_value_id = 3

  Ignored unless opcode is OpReturnValue, in which case this field provides a suitable result id to be returned.

Used in: Transformation

• optional IdUseDescriptor id_use_descriptor = 1

  A descriptor for the id we would like to replace

• optional UniformBufferElementDescriptor uniform_descriptor = 2

  Uniform descriptor to identify which uniform value to choose

• uint32 fresh_id_for_access_chain = 3

  Id that will store the result of an access chain

• uint32 fresh_id_for_load = 4

  Id that will store the result of a load

Used in: Transformation

• uint32 fresh_id = 1

  The intermediate value.

• optional InstructionDescriptor copy_memory_instruction_descriptor = 2

  The instruction descriptor to OpCopyMemory. It is necessary, because OpCopyMemory doesn't have a result id.

Used in: Transformation

• uint32 copy_object_result_id = 1

  The result id of initial OpCopyObject instruction

• uint32 fresh_variable_id = 2

  A fresh id for the variable to be stored to.

• uint32 variable_storage_class = 3

  The variable storage class (Function or Private).

• uint32 variable_initializer_id = 4

  Constant to initialize the variable with.

Used in: Transformation

• optional IdUseDescriptor id_use_descriptor = 1

  The id use that is to be replaced

• uint32 synonymous_id = 2

  The synonymous id

Used in: Transformation

• optional IdUseDescriptor id_use_descriptor = 1

  The id use that is to be replaced

• uint32 replacement_id = 2

  The replacement id

Used in: Transformation

• repeated uint32 fresh_ids = 1

  The fresh ids needed to apply the transformation.

• optional InstructionDescriptor instruction_descriptor = 2

  A descriptor for a linear algebra instruction.

A transformation that takes a pair of instruction descriptors to OpLoad and OpStore that have the same intermediate value and replaces the OpStore with an equivalent OpCopyMemory.

Used in: Transformation

• optional InstructionDescriptor load_instruction_descriptor = 1

  The instruction descriptor to OpLoad

• optional InstructionDescriptor store_instruction_descriptor = 2

  The instruction descriptor to OpStore

Used in: Transformation

• uint32 opphi_id = 1

  The result id of the OpPhi instruction.

• uint32 pred_label_id = 2

  The label id of one of the predecessors of the block containing the OpPhi instruction, corresponding to the id that we want to replace.

• uint32 replacement_id = 3

  The id that, after the transformation, will be associated with the given predecessor.

Used in: Transformation

• uint32 select_id = 1

  The result id of the OpSelect instruction.

• uint32 true_block_id = 2

  A fresh id for the new block that the predecessor of the block containing |select_id| will branch to if the condition holds.

• uint32 false_block_id = 3

  A fresh id for the new block that the predecessor of the block containing |select_id| will branch to if the condition does not hold.

Used in: Transformation

• uint32 function_type_fresh_id = 2

  Fresh id for a new function type. This might not be used if a required function type already exists or if we can change the old function type.

• uint32 parameter_id = 3

  Result id of the OpFunctionParameter instruction to remove.

• uint32 global_variable_fresh_id = 4

  Fresh id of a global variable used to pass parameter's value to the function.

Used in: Transformation

• repeated uint32 parameter_id = 1

  Result ids of parameters to replace.

• uint32 fresh_function_type_id = 2

  Fresh id for a new function type. This might be unused if the required type already exists in the module or if we can change the old type.

• uint32 fresh_parameter_id = 3

  Fresh id for a new struct function parameter to be used as a replacement.

• repeated UInt32Pair caller_id_to_fresh_composite_id = 4

  Fresh ids for struct objects containing values of replaced parameters. This field contains a fresh id for at least every result id of a relevant OpFunctionCall instruction.

• repeated Transformation transformation = 1

Used in: Transformation

• uint32 function_id = 1

  The result id of an OpFunction instruction

• uint32 function_control = 2

  The value to which the 'function control' operand should be set.

Used in: Transformation

• uint32 block_id = 1

  The id of a basic block that should contain OpLoopMerge

• uint32 loop_control = 2

  The value to which the 'loop control' operand should be set. This must be a legal loop control mask.

• uint32 peel_count = 3

  Provides a peel count value for the loop. Used if and only if the PeelCount bit is set. Must be zero if the PeelCount bit is not set (can still be zero if this bit is set).

• uint32 partial_count = 4

  Provides a partial count value for the loop. Used if and only if the PartialCount bit is set. Must be zero if the PartialCount bit is not set (can still be zero if this bit is set).

Used in: Transformation

• optional InstructionDescriptor memory_access_instruction = 1

  A descriptor for a memory access instruction, e.g. an OpLoad

• uint32 memory_operands_mask = 2

  A mask of memory operands to be applied to the instruction. It must be the same as the original mask, except that Volatile can be added, and Nontemporal can be added or removed.

• uint32 memory_operands_mask_index = 3

  Some memory access instructions allow more than one mask to be specified; this field indicates which mask should be set

Used in: Transformation

• uint32 block_id = 1

  The id of a basic block that should contain OpSelectionMerge

• uint32 selection_control = 2

  The value to which the 'selection control' operand should be set. Although technically 'selection control' is a literal mask that can be some combination of 'None', 'Flatten' and 'DontFlatten', the combination 'Flatten | DontFlatten' does not make sense and is not allowed here.

Used in: Transformation

• optional InstructionDescriptor instruction_to_split_before = 1

  A descriptor for an instruction such that the block containing the described instruction should be split right before the instruction.

• uint32 fresh_id = 2

  An id that must not yet be used by the module to which this transformation is applied. Rather than having the transformation choose a suitable id on application, we require the id to be given upfront in order to facilitate reducing fuzzed shaders by removing transformations. The reason is that future transformations may refer to the fresh id introduced by this transformation, and if we end up changing what that id is, due to removing earlier transformations, it may inhibit later transformations from applying.

Used in: Transformation

• uint32 pointer_id = 1

  The pointer to be stored to.

• bool is_atomic = 2

  True if and only if the load should be atomic.

• uint32 memory_scope_id = 3

  The memory scope for the atomic load. Ignored unless |is_atomic| is true.

• uint32 memory_semantics_id = 4

  The memory semantics for the atomic load. Ignored unless |is_atomic| is true.

• uint32 value_id = 5

  The value to be stored.

• optional InstructionDescriptor instruction_to_insert_before = 6

  A descriptor for an instruction in a block before which the new OpStore instruction should be inserted.

Used in: Transformation

• optional InstructionDescriptor instruction_descriptor = 1

  A descriptor for a commutative instruction

Used in: Transformation

• optional InstructionDescriptor instruction_descriptor = 1

  Descriptor of the instruction to swap operands of.

• uint32 fresh_id = 2

  Fresh result id for the OpLogicalNot instruction, used to invert the guard.

A transformation that swaps function variables

Used in: Transformation

• uint32 result_id1 = 1

  Result id of the first variable.

• uint32 result_id2 = 2

  Result id of the second variable.

A transformation that swaps the position of two functions within the same module.

Used in: Transformation

• uint32 function_id1 = 1

  the IDs for the two functions that are swapped.

• uint32 function_id2 = 2

Used in: Transformation

• optional InstructionDescriptor instruction_descriptor = 1

  A descriptor for an access chain instruction

Used in: Transformation

• optional InstructionDescriptor instruction_to_insert_before = 1

  A descriptor for an instruction in a block before which the new OpVectorShuffle instruction should be inserted

• uint32 fresh_id = 2

  Result id for the shuffle operation.

• uint32 vector1 = 3

  Id of the first vector operand.

• uint32 vector2 = 4

  Id of the second vector operand.

• repeated uint32 component = 5

  Indices that indicate which components of the input vectors should be used.

Used in: Transformation

• uint32 fresh_id = 1

  A fresh id for a new OpFunctionCall instruction.

• optional InstructionDescriptor early_terminator_instruction = 2

  A descriptor for an OpKill, OpUnreachable or OpTerminateInvocation instruction.

• uint32 returned_value_id = 3

  An id with the same type as the enclosing function's return type that is available at the early terminator. This is used to change the terminator to OpReturnValue. Ignored if the enclosing function has void return type, in which case OpReturn can be used as the new terminator.

Used in: Transformation

• uint32 region_entry_block_id = 1

  The entry block for the region R.

• uint32 region_exit_block_id = 2

  The exit block for the region R.

• bool branch_condition = 3

  Boolean value for the condition expression.

A transformation that wraps an arithmetic operation into a vector operation and get the result of the original operation from the corresponding index. For instance, for this transformation, an scalar operation between two scalars: define op ∈ {+, -, *} c = a op b requires the availability of two vectors: va = vector(..., a, ...) vb = vector(..., b, ...) where a and b are in the same position i in each of their corresponding vector and a is synonymous with va[i] and b is synonymous with vb[i]. The transformation then add an instruction vc = va op vb where c is synonymous with vc[i].

Used in: Transformation

• uint32 instruction_id = 1

  The result if of the original scalar operation instruction.

• uint32 vector_operand1 = 2

  The result id for the first vector that contains the first value of the scalar operation.

• uint32 vector_operand2 = 3

  The result id for the second vector that contains the second value of the scalar operation.

• uint32 fresh_id = 4

  A fresh id for the resulted vector from the addition of the first and second vector.

• uint32 scalar_position = 5

  The position in the vector where the value of original instruction is located. Must be in the corresponding vector range.

Used in: AccessChainClampingInfo, ReturnMergingInfo, TransformationAccessChain, TransformationAddOpPhiSynonym, TransformationAddParameter, TransformationAdjustBranchWeights, TransformationDuplicateRegionWithSelection, TransformationInlineFunction, TransformationOutlineFunction, TransformationPropagateInstructionDown, TransformationPropagateInstructionUp, TransformationReplaceParamsWithStruct

• uint32 first = 1

• uint32 second = 2

Used in: FactConstantUniform, TransformationReplaceConstantWithUniform

• uint32 descriptor_set = 1

  The descriptor set and binding associated with a uniform variable.

• uint32 binding = 2

• repeated uint32 index = 3

  An ordered sequence of indices through composite structures in the uniform buffer.