| // Copyright (c) 2019 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // This file is specifically named spvtools_fuzz.proto so that the string |
| // 'spvtools_fuzz' appears in the names of global-scope symbols that protoc |
| // generates when targeting C++. This is to reduce the potential for name |
| // clashes with other globally-scoped symbols. |
| |
| syntax = "proto3"; |
| |
| package spvtools.fuzz.protobufs; |
| |
| message UInt32Pair { |
| |
| // A pair of uint32s; useful for defining mappings. |
| |
| uint32 first = 1; |
| |
| uint32 second = 2; |
| |
| } |
| |
| message InstructionDescriptor { |
| |
| // Describes an instruction in some block of a function with respect to a |
| // base instruction. |
| |
| // The id of an instruction after which the instruction being described is |
| // believed to be located. It might be the using instruction itself. |
| uint32 base_instruction_result_id = 1; |
| |
| // The opcode for the instruction being described. |
| uint32 target_instruction_opcode = 2; |
| |
| // The number of matching opcodes to skip over when searching from the base |
| // instruction to the instruction being described. |
| uint32 num_opcodes_to_ignore = 3; |
| |
| } |
| |
| message IdUseDescriptor { |
| |
| // Describes a use of an id as an input operand to an instruction in some |
| // block of a function. |
| |
| // Example: |
| // - id_of_interest = 42 |
| // - enclosing_instruction = ( |
| // base_instruction_result_id = 50, |
| // target_instruction_opcode = OpStore |
| // num_opcodes_to_ignore = 7 |
| // ) |
| // - in_operand_index = 1 |
| // represents a use of id 42 as input operand 1 to an OpStore instruction, |
| // such that the OpStore instruction can be found in the same basic block as |
| // the instruction with result id 50, and in particular is the 8th OpStore |
| // instruction found from instruction 50 onwards (i.e. 7 OpStore |
| // instructions are skipped). |
| |
| // An id that we would like to be able to find a use of. |
| uint32 id_of_interest = 1; |
| |
| // The input operand index at which the use is expected. |
| InstructionDescriptor enclosing_instruction = 2; |
| |
| uint32 in_operand_index = 3; |
| |
| } |
| |
| message DataDescriptor { |
| |
| // Represents a data element that can be accessed from an id, by walking the |
| // type hierarchy via a sequence of 0 or more indices. |
| // |
| // Very similar to a UniformBufferElementDescriptor, except that a |
| // DataDescriptor is rooted at the id of a scalar or composite. |
| |
| // The object being accessed - a scalar or composite |
| uint32 object = 1; |
| |
| // 0 or more indices, used to index into a composite object |
| repeated uint32 index = 2; |
| |
| } |
| |
| message UniformBufferElementDescriptor { |
| |
| // Represents a data element inside a uniform buffer. The element is |
| // specified via (a) the result id of a uniform variable in which the element |
| // is contained, and (b) a series of indices that need to be followed to get |
| // to the element (via fields and array/vector indices). |
| // |
| // Example: suppose there is a uniform variable with descriptor set 7 and |
| // binding 9, and that the uniform variable has the following type (using |
| // GLSL-like syntax): |
| // |
| // struct S { |
| // float f; |
| // vec3 g; |
| // int4 h[10]; |
| // }; |
| // |
| // Then: |
| // - (7, 9, [0]) describes the 'f' field. |
| // - (7, 9, [1,1]) describes the y component of the 'g' field. |
| // - (7, 9, [2,7,3]) describes the w component of element 7 of the 'h' field |
| |
| // The descriptor set and binding associated with a uniform variable. |
| uint32 descriptor_set = 1; |
| uint32 binding = 2; |
| |
| // An ordered sequence of indices through composite structures in the |
| // uniform buffer. |
| repeated uint32 index = 3; |
| |
| } |
| |
| message InstructionOperand { |
| |
| // Represents an operand to a SPIR-V instruction. |
| |
| // The type of the operand. |
| uint32 operand_type = 1; |
| |
| // The data associated with the operand. For most operands (e.g. ids, |
| // storage classes and literals) this will be a single word. |
| repeated uint32 operand_data = 2; |
| |
| } |
| |
| message Instruction { |
| |
| // Represents a SPIR-V instruction. |
| |
| // The instruction's opcode (e.g. OpLabel). |
| uint32 opcode = 1; |
| |
| // The id of the instruction's result type; 0 if there is no result type. |
| uint32 result_type_id = 2; |
| |
| // The id of the instruction's result; 0 if there is no result. |
| uint32 result_id = 3; |
| |
| // Zero or more input operands. |
| repeated InstructionOperand input_operand = 4; |
| |
| } |
| |
| message FactSequence { |
| repeated Fact fact = 1; |
| } |
| |
| message Fact { |
| oneof fact { |
| // Order the fact options by numeric id (rather than alphabetically). |
| FactConstantUniform constant_uniform_fact = 1; |
| 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; |
| } |
| } |
| |
| // Keep fact message types in alphabetical order: |
| |
| message FactBlockIsDead { |
| |
| // Records the fact that a block is guaranteed to be dynamically unreachable. |
| // This is useful because it informs the fuzzer that rather arbitrary changes |
| // can be made to this block. |
| |
| uint32 block_id = 1; |
| |
| } |
| |
| message FactConstantUniform { |
| |
| // Records the fact that a uniform buffer element is guaranteed to be equal |
| // to a particular constant value. spirv-fuzz can use such guarantees to |
| // obfuscate code, e.g. to manufacture an expression that will (due to the |
| // guarantee) evaluate to a particular value at runtime but in a manner that |
| // cannot be predicted at compile-time. |
| |
| // An element of a uniform buffer |
| UniformBufferElementDescriptor uniform_buffer_element_descriptor = 1; |
| |
| // The words of the associated constant |
| repeated uint32 constant_word = 2; |
| |
| } |
| |
| message FactDataSynonym { |
| |
| // Records the fact that the data held in two data descriptors are guaranteed |
| // to be equal. spirv-fuzz can use this to replace uses of one piece of data |
| // with a known-to-be-equal piece of data. |
| |
| // Data descriptors guaranteed to hold identical data. |
| DataDescriptor data1 = 1; |
| |
| DataDescriptor data2 = 2; |
| |
| } |
| |
| message FactFunctionIsLivesafe { |
| |
| // Records the fact that a function is guaranteed to be "livesafe", meaning |
| // that it will not make out-of-bounds accesses, does not contain reachable |
| // OpKill or OpUnreachable instructions, does not contain loops that will |
| // execute for large numbers of iterations, and only invokes other livesafe |
| // functions. |
| |
| uint32 function_id = 1; |
| |
| } |
| |
| message FactIdEquation { |
| |
| // Records the fact that the equation: |
| // |
| // lhs_id = opcode rhs_id[0] rhs_id[1] ... rhs_id[N-1] |
| // |
| // holds; e.g. that the equation: |
| // |
| // %12 = OpIAdd %13 %14 |
| // |
| // holds in the case where lhs_id is 12, rhs_id is [13, 14], and the opcode is |
| // OpIAdd. |
| |
| // The left-hand-side of the equation. |
| uint32 lhs_id = 1; |
| |
| // A SPIR-V opcode, from a restricted set of instructions for which equation |
| // facts make sense. |
| uint32 opcode = 2; |
| |
| // The operands to the right-hand-side of the equation. |
| repeated uint32 rhs_id = 3; |
| |
| } |
| |
| message FactIdIsIrrelevant { |
| |
| // Records a fact that |result_id| is irrelevant (i.e. it's usage doesn't |
| // change the semantics of the module). This implies that a use of this id |
| // can later be replaced with some other id of the same type, or the |
| // definition of |result_id| can be changed so that it yields a different value. |
| |
| // An irrelevant id. |
| uint32 result_id = 1; |
| |
| } |
| |
| message FactPointeeValueIsIrrelevant { |
| |
| // Records the fact that value of the data pointed to by a pointer id does |
| // not influence the observable behaviour of the module. This means that |
| // arbitrary stores can be made through the pointer, and that nothing can be |
| // guaranteed about the values that are loaded via the pointer. |
| |
| // A result id of pointer type |
| uint32 pointer_id = 1; |
| |
| } |
| |
| message AccessChainClampingInfo { |
| |
| // When making a function livesafe it is necessary to clamp the indices that |
| // occur as operands to access chain instructions so that they are guaranteed |
| // to be in bounds. This message type allows an access chain instruction to |
| // have an associated sequence of ids that are reserved for comparing an |
| // access chain index with a bound (e.g. an array size), and selecting |
| // between the access chain index (if it is within bounds) and the bound (if |
| // it is not). |
| // |
| // This allows turning an instruction of the form: |
| // |
| // %result = OpAccessChain %type %object ... %index ... |
| // |
| // into: |
| // |
| // %t1 = OpULessThanEqual %bool %index %bound_minus_one |
| // %t2 = OpSelect %int_type %t1 %index %bound_minus_one |
| // %result = OpAccessChain %type %object ... %t2 ... |
| |
| // The result id of an OpAccessChain or OpInBoundsAccessChain instruction. |
| uint32 access_chain_id = 1; |
| |
| // 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. |
| repeated UInt32Pair compare_and_select_ids = 2; |
| |
| } |
| |
| message SideEffectWrapperInfo { |
| // 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. |
| |
| |
| // 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. |
| InstructionDescriptor instruction = 1; |
| |
| // A fresh id for the new merge block. |
| uint32 merge_block_id = 2; |
| |
| // A fresh id for the new block where the actual instruction is |
| // executed. |
| uint32 execute_block_id = 3; |
| |
| // The following fields are only needed if the original instruction has a |
| // result id. They can be set to 0 if not needed. |
| |
| // A fresh id for the result id of the instruction (the original |
| // one is used by the OpPhi instruction). |
| uint32 actual_result_id = 4; |
| |
| // A fresh id for the new block where the placeholder instruction |
| // is placed. |
| uint32 alternative_block_id = 5; |
| |
| // A fresh id for the placeholder instruction. |
| uint32 placeholder_result_id = 6; |
| |
| // 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. |
| uint32 value_to_copy_id = 7; |
| } |
| |
| message ReturnMergingInfo { |
| // 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. |
| |
| // The id of the merge block that needs to be modified. |
| uint32 merge_block_id = 1; |
| |
| // 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 is_returning_id = 2; |
| |
| // 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. |
| uint32 maybe_return_val_id = 3; |
| |
| // A mapping from each existing OpPhi id to a suitable id of the same type |
| // available to use before the instruction. |
| repeated UInt32Pair opphi_to_suitable_id = 4; |
| } |
| |
| message LoopLimiterInfo { |
| |
| // Structure capturing the information required to manipulate a loop limiter |
| // at a loop header. |
| |
| // The header for the loop. |
| uint32 loop_header_id = 1; |
| |
| // A fresh id into which the loop limiter's current value can be loaded. |
| uint32 load_id = 2; |
| |
| // A fresh id that can be used to increment the loaded value by 1. |
| uint32 increment_id = 3; |
| |
| // A fresh id that can be used to compare the loaded value with the loop |
| // limit. |
| uint32 compare_id = 4; |
| |
| // 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. |
| uint32 logical_op_id = 5; |
| |
| // 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. |
| repeated uint32 phi_id = 6; |
| |
| } |
| |
| message TransformationSequence { |
| repeated Transformation transformation = 1; |
| } |
| |
| message Transformation { |
| oneof transformation { |
| // Order the transformation options by numeric id (rather than |
| // alphabetically). |
| TransformationMoveBlockDown move_block_down = 1; |
| 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. |
| } |
| } |
| |
| // Keep transformation message types in alphabetical order: |
| |
| message TransformationAccessChain { |
| |
| // Adds an access chain instruction based on a given pointer and indices. |
| |
| // When accessing a struct, the corresponding indices must be 32-bit integer constants. |
| // For any other composite, the indices can be any 32-bit integer, and the transformation |
| // adds two instructions for each such index to clamp it to the bound, as follows: |
| // |
| // %t1 = OpULessThanEqual %bool %index %bound_minus_one |
| // %t2 = OpSelect %int_type %t1 %index %bound_minus_one |
| |
| // Result id for the access chain |
| uint32 fresh_id = 1; |
| |
| // The pointer from which the access chain starts |
| uint32 pointer_id = 2; |
| |
| // Zero or more access chain indices |
| repeated uint32 index_id = 3; |
| |
| // A descriptor for an instruction in a block before which the new |
| // OpAccessChain instruction should be inserted |
| InstructionDescriptor instruction_to_insert_before = 4; |
| |
| // Additional fresh ids, required to clamp index variables. A pair is needed |
| // for each access to a non-struct composite. |
| repeated UInt32Pair fresh_ids_for_clamping = 5; |
| |
| } |
| |
| message TransformationAddBitInstructionSynonym { |
| |
| // A transformation that adds synonyms for bit instructions by evaluating |
| // each bit with the corresponding operation. There is a SPIR-V code example in the |
| // header file of the transformation class that can help understand the transformation. |
| |
| // This transformation is only applicable if the described instruction has one of the following opcodes. |
| // Supported: |
| // OpBitwiseOr |
| // OpBitwiseXor |
| // OpBitwiseAnd |
| // OpNot |
| // To be supported in the future: |
| // OpShiftRightLogical |
| // OpShiftRightArithmetic |
| // OpShiftLeftLogical |
| // OpBitReverse |
| // OpBitCount |
| |
| // The bit instruction result id. |
| uint32 instruction_result_id = 1; |
| |
| // The fresh ids required to apply the transformation. |
| repeated uint32 fresh_ids = 2; |
| |
| } |
| |
| message TransformationAddConstantBoolean { |
| |
| // Supports adding the constants true and false to a module, which may be |
| // necessary in order to enable other transformations if they are not present. |
| // Also, creates an IdIsIrrelevant fact about |fresh_id| if |is_irrelevant| is true. |
| |
| uint32 fresh_id = 1; |
| bool is_true = 2; |
| |
| // If the constant should be marked as irrelevant. |
| bool is_irrelevant = 3; |
| |
| } |
| |
| message TransformationAddConstantComposite { |
| |
| // Adds a constant of the given composite type to the module. |
| // Also, creates an IdIsIrrelevant fact about |fresh_id| if |
| // |is_irrelevant| is true. |
| |
| // Fresh id for the composite |
| uint32 fresh_id = 1; |
| |
| // A composite type id |
| uint32 type_id = 2; |
| |
| // Constituent ids for the composite |
| repeated uint32 constituent_id = 3; |
| |
| // If the constant should be marked as irrelevant. |
| bool is_irrelevant = 4; |
| |
| } |
| |
| message TransformationAddConstantNull { |
| |
| // Adds a null constant. |
| |
| // Id for the constant |
| uint32 fresh_id = 1; |
| |
| // Type of the constant |
| uint32 type_id = 2; |
| |
| } |
| |
| message TransformationAddConstantScalar { |
| |
| // Adds a constant of the given scalar type. |
| // Also, creates an IdIsIrrelevant fact about |
| // |fresh_id| if |is_irrelevant| is true. |
| |
| // Id for the constant |
| uint32 fresh_id = 1; |
| |
| // Id for the scalar type of the constant |
| uint32 type_id = 2; |
| |
| // Value of the constant |
| repeated uint32 word = 3; |
| |
| // If the constant should be marked as irrelevant. |
| bool is_irrelevant = 4; |
| |
| } |
| |
| message TransformationAddCopyMemory { |
| |
| // Adds an OpCopyMemory instruction into the module. |
| // Creates either a global or a local variable (based on |
| // |storage_class| field) to copy the target into. |
| |
| // OpCopyMemory will be inserted before this instruction. |
| InstructionDescriptor instruction_descriptor = 1; |
| |
| // Fresh id to copy memory into. |
| uint32 fresh_id = 2; |
| |
| // Source to copy memory from. |
| uint32 source_id = 3; |
| |
| // Storage class for the target variable. Can be either Function or Private. |
| uint32 storage_class = 4; |
| |
| // Result id for the variable's initializer operand. Its type must be equal to |
| // variable's pointee type. |
| uint32 initializer_id = 5; |
| |
| } |
| |
| message TransformationAddDeadBlock { |
| |
| // Adds a new block to the module that is statically reachable from an |
| // existing block, but dynamically unreachable. |
| |
| // Fresh id for the dead block |
| uint32 fresh_id = 1; |
| |
| // 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 |
| uint32 existing_block = 2; |
| |
| // Determines whether the condition associated with the OpBranchConditional |
| // is true or false |
| bool condition_value = 3; |
| |
| } |
| |
| message TransformationAddDeadBreak { |
| |
| // A transformation that turns a basic block that unconditionally branches to |
| // its successor into a block that potentially breaks out of a structured |
| // control flow construct, but in such a manner that the break cannot actually |
| // be taken. |
| |
| // The block to break from |
| uint32 from_block = 1; |
| |
| // The merge block to break to |
| uint32 to_block = 2; |
| |
| // Determines whether the break condition is true or false |
| bool break_condition_value = 3; |
| |
| // A sequence of ids suitable for extending OpPhi instructions as a result of |
| // the new break edge |
| repeated uint32 phi_id = 4; |
| |
| } |
| |
| message TransformationAddDeadContinue { |
| |
| // A transformation that turns a basic block appearing in a loop and that |
| // unconditionally branches to its successor into a block that potentially |
| // branches to the continue target of the loop, but in such a manner that the |
| // continue branch cannot actually be taken. |
| |
| // The block to continue from |
| uint32 from_block = 1; |
| |
| // Determines whether the continue condition is true or false |
| bool continue_condition_value = 2; |
| |
| // A sequence of ids suitable for extending OpPhi instructions as a result of |
| // the new break edge |
| repeated uint32 phi_id = 3; |
| |
| } |
| |
| message TransformationAddEarlyTerminatorWrapper { |
| |
| // Adds a function to the module containing a single block with a single non- |
| // label instruction that is either OpKill, OpUnreachable, or |
| // OpTerminateInvocation. The purpose of this is to allow such instructions |
| // to be subsequently replaced with wrapper functions, which can then enable |
| // transformations (such as inlining) that are hard in the direct presence |
| // of these instructions. |
| |
| // Fresh id for the function. |
| uint32 function_fresh_id = 1; |
| |
| // Fresh id for the single basic block in the function. |
| uint32 label_fresh_id = 2; |
| |
| // One of OpKill, OpUnreachable, OpTerminateInvocation. If additional early |
| // termination instructions are added to SPIR-V they should also be handled |
| // here. |
| uint32 opcode = 3; |
| |
| } |
| |
| message TransformationAddFunction { |
| |
| // Adds a SPIR-V function to the module. |
| |
| // The series of instructions that comprise the function. |
| repeated Instruction instruction = 1; |
| |
| // True if and only if the given function should be made livesafe (see |
| // FactFunctionIsLivesafe for definition). |
| bool is_livesafe = 2; |
| |
| // Fresh id for a new variable that will serve as a "loop limiter" for the |
| // function; only relevant if |is_livesafe| holds. |
| uint32 loop_limiter_variable_id = 3; |
| |
| // 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. |
| uint32 loop_limit_constant_id = 4; |
| |
| // Fresh ids for each loop in the function that allow the loop limiter to be |
| // manipulated; only relevant if |is_livesafe| holds. |
| repeated LoopLimiterInfo loop_limiter_info = 5; |
| |
| // 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. |
| uint32 kill_unreachable_return_value_id = 6; |
| |
| // 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. |
| repeated AccessChainClampingInfo access_chain_clamping_info = 7; |
| |
| } |
| |
| message TransformationAddGlobalUndef { |
| |
| // Adds an undefined value of a given type to the module at global scope. |
| |
| // Fresh id for the undefined value |
| uint32 fresh_id = 1; |
| |
| // The type of the undefined value |
| uint32 type_id = 2; |
| |
| } |
| |
| message TransformationAddGlobalVariable { |
| |
| // Adds a global variable of the given type to the module, with Private or |
| // Workgroup storage class, and optionally (for the Private case) with an |
| // initializer. |
| |
| // Fresh id for the global variable |
| uint32 fresh_id = 1; |
| |
| // The type of the global variable |
| uint32 type_id = 2; |
| |
| uint32 storage_class = 3; |
| |
| // Initial value of the variable |
| uint32 initializer_id = 4; |
| |
| // 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. |
| bool value_is_irrelevant = 5; |
| |
| } |
| |
| message TransformationAddImageSampleUnusedComponents { |
| |
| // A transformation that adds unused components to an image sample coordinate. |
| |
| // An vector id with the original coordinate and the unused components. |
| uint32 coordinate_with_unused_components_id = 1; |
| |
| // A descriptor for an image sample instruction. |
| InstructionDescriptor instruction_descriptor = 2; |
| |
| } |
| |
| message TransformationAddLocalVariable { |
| |
| // Adds a local variable of the given type (which must be a pointer with |
| // Function storage class) to the given function, initialized to the given |
| // id. |
| |
| // Fresh id for the local variable |
| uint32 fresh_id = 1; |
| |
| // The type of the local variable |
| uint32 type_id = 2; |
| |
| // The id of the function to which the local variable should be added |
| uint32 function_id = 3; |
| |
| // Initial value of the variable |
| uint32 initializer_id = 4; |
| |
| // 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. |
| bool value_is_irrelevant = 5; |
| |
| } |
| |
| message TransformationAddLoopPreheader { |
| |
| // A transformation that adds a loop preheader block before the given loop header. |
| |
| // The id of the loop header block |
| uint32 loop_header_block = 1; |
| |
| // A fresh id for the preheader block |
| uint32 fresh_id = 2; |
| |
| // 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 |
| repeated uint32 phi_id = 3; |
| |
| } |
| |
| message TransformationAddLoopToCreateIntConstantSynonym { |
| // 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. |
| |
| // The following are existing ids. |
| |
| // The id of the integer constant C that we want a synonym of. |
| uint32 constant_id = 1; |
| |
| // The id of the initial value integer constant I. |
| uint32 initial_val_id = 2; |
| |
| // The id of the step value integer constant S. |
| uint32 step_val_id = 3; |
| |
| // The id of the integer scalar constant, its value being the number of |
| // iterations N. |
| uint32 num_iterations_id = 4; |
| |
| // The label id of the block before which the loop must be inserted. |
| uint32 block_after_loop_id = 5; |
| |
| |
| // The following are fresh ids. |
| |
| // A fresh id for the synonym. |
| uint32 syn_id = 6; |
| |
| // A fresh id for the label of the loop, |
| uint32 loop_id = 7; |
| |
| // A fresh id for the counter. |
| uint32 ctr_id = 8; |
| |
| // A fresh id taking the value I - S * ctr at the ctr-th iteration. |
| uint32 temp_id = 9; |
| |
| // 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 eventual_syn_id = 10; |
| |
| // A fresh id for the incremented counter. |
| uint32 incremented_ctr_id = 11; |
| |
| // A fresh id for the loop condition. |
| uint32 cond_id = 12; |
| |
| // The instructions in the loop can also be laid out in two basic blocks, as follows: |
| // |
| // %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 |
| // OpLoopMerge %block_after_loop_id %additional_block_id None |
| // OpBranch %additional_block_id |
| // |
| // %additional_block_id = OpLabel |
| // %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 |
| // OpBranchConditional %cond_id %loop_id %block_after_loop_id |
| |
| // A fresh id for the additional block. If this is 0, it means that only one |
| // block is to be created. |
| uint32 additional_block_id = 13; |
| } |
| |
| message TransformationAddNoContractionDecoration { |
| |
| // Applies OpDecorate NoContraction to the given result id |
| |
| // Result id to be decorated |
| uint32 result_id = 1; |
| |
| } |
| |
| message TransformationAddOpPhiSynonym { |
| |
| // Adds an OpPhi instruction at the start of a block with n predecessors (pred_1, pred_2, ..., pred_n) |
| // and n related ids (id_1, id_2, ..., id_n) which are pairwise synonymous. |
| // The instruction will be of the form: |
| // %fresh_id = OpPhi %type %id_1 %pred_1 %id_2 %pred_2 ... %id_n %pred_n |
| // and fresh_id will be recorded as being synonymous with all the other ids. |
| |
| // Label id of the block |
| uint32 block_id = 1; |
| |
| // Pairs (pred_i, id_i) |
| repeated UInt32Pair pred_to_id = 2; |
| |
| // Fresh id for the new instruction |
| uint32 fresh_id = 3; |
| } |
| |
| message TransformationAddParameter { |
| |
| // Adds a new parameter into the function. |
| |
| // Result id of the function to add parameters to. |
| uint32 function_id = 1; |
| |
| // Fresh id for a new parameter. |
| uint32 parameter_fresh_id = 2; |
| |
| // Type id for a new parameter. |
| uint32 parameter_type_id = 3; |
| |
| // 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. |
| repeated UInt32Pair call_parameter_ids = 4; |
| |
| // 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. |
| uint32 function_type_fresh_id = 5; |
| |
| } |
| |
| message TransformationAddRelaxedDecoration { |
| |
| // Applies OpDecorate RelaxedPrecision to the given result id |
| |
| // Result id to be decorated |
| uint32 result_id = 1; |
| |
| } |
| |
| message TransformationAddSpecConstantOp { |
| |
| // Adds OpSpecConstantOp into the module. |
| |
| // Result id for the new instruction. |
| uint32 fresh_id = 1; |
| |
| // Type id for the new instruction. |
| uint32 type_id = 2; |
| |
| // Opcode operand of the OpSpecConstantOp instruction. |
| uint32 opcode = 3; |
| |
| // Operands of the |opcode| instruction. |
| repeated InstructionOperand operand = 4; |
| |
| } |
| |
| message TransformationAddSynonym { |
| |
| // Adds a |synonymous_instruction| before |insert_before| instruction with |
| // and creates a fact that |result_id| and the result id of |synonymous_instruction| |
| // are synonymous. |
| |
| // Result id of the first synonym. |
| uint32 result_id = 1; |
| |
| // 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. |
| enum SynonymType { |
| // New synonym is derived by adding zero to the |result_id|. |
| ADD_ZERO = 0; |
| |
| // New synonym is derived by subtracting zero from the |result_id|. |
| SUB_ZERO = 1; |
| |
| // New synonym is derived by multiplying |result_id| by one. |
| MUL_ONE = 2; |
| |
| // New synonym is derived by applying OpCopyObject instruction to |result_id|. |
| COPY_OBJECT = 3; |
| |
| // New synonym is derived by applying OpLogicalOr to |result_id| with the second |
| // operand being 'false'. |
| LOGICAL_OR = 4; |
| |
| // New synonym is derived by applying OpLogicalAnd to |result_id| with the second |
| // operand being 'true'. |
| LOGICAL_AND = 5; |
| |
| // 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_OR = 6; |
| |
| // 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| |
| BITWISE_XOR = 7; |
| } |
| |
| // Type of the synonym to create. See SynonymType for more details. |
| SynonymType synonym_type = 2; |
| |
| // Fresh result id for a created synonym. |
| uint32 synonym_fresh_id = 3; |
| |
| // An instruction to insert a new synonym before. |
| InstructionDescriptor insert_before = 4; |
| |
| } |
| |
| message TransformationAddTypeArray { |
| |
| // Adds an array type of the given element type and size to the module |
| |
| // Fresh id for the array type |
| uint32 fresh_id = 1; |
| |
| // The array's element type |
| uint32 element_type_id = 2; |
| |
| // The array's size |
| uint32 size_id = 3; |
| |
| } |
| |
| message TransformationAddTypeBoolean { |
| |
| // Adds OpTypeBool to the module |
| |
| // Id to be used for the type |
| uint32 fresh_id = 1; |
| |
| } |
| |
| message TransformationAddTypeFloat { |
| |
| // Adds OpTypeFloat to the module with the given width |
| |
| // Id to be used for the type |
| uint32 fresh_id = 1; |
| |
| // Floating-point width |
| uint32 width = 2; |
| |
| } |
| |
| message TransformationAddTypeFunction { |
| |
| // Adds a function type to the module |
| |
| // Fresh id for the function type |
| uint32 fresh_id = 1; |
| |
| // The function's return type |
| uint32 return_type_id = 2; |
| |
| // The function's argument types |
| repeated uint32 argument_type_id = 3; |
| |
| } |
| |
| message TransformationAddTypeInt { |
| |
| // Adds OpTypeInt to the module with the given width and signedness |
| |
| // Id to be used for the type |
| uint32 fresh_id = 1; |
| |
| // Integer width |
| uint32 width = 2; |
| |
| // True if and only if this is a signed type |
| bool is_signed = 3; |
| |
| } |
| |
| message TransformationAddTypeMatrix { |
| |
| // Adds a matrix type to the module |
| |
| // Fresh id for the matrix type |
| uint32 fresh_id = 1; |
| |
| // The matrix's column type, which must be a floating-point vector (as per |
| // the "data rules" in the SPIR-V specification). |
| uint32 column_type_id = 2; |
| |
| // The matrix's column count |
| uint32 column_count = 3; |
| |
| } |
| |
| message TransformationAddTypePointer { |
| |
| // Adds OpTypePointer to the module, with the given storage class and base |
| // type |
| |
| // Id to be used for the type |
| uint32 fresh_id = 1; |
| |
| // Pointer storage class |
| uint32 storage_class = 2; |
| |
| // Id of the base type for the pointer |
| uint32 base_type_id = 3; |
| |
| } |
| |
| message TransformationAddTypeStruct { |
| |
| // Adds a struct type to the module |
| |
| // Fresh id for the struct type |
| uint32 fresh_id = 1; |
| |
| // The struct's member types |
| repeated uint32 member_type_id = 3; |
| |
| } |
| |
| message TransformationAddTypeVector { |
| |
| // Adds a vector type to the module |
| |
| // Fresh id for the vector type |
| uint32 fresh_id = 1; |
| |
| // The vector's component type |
| uint32 component_type_id = 2; |
| |
| // The vector's component count |
| uint32 component_count = 3; |
| |
| } |
| |
| message TransformationAdjustBranchWeights { |
| |
| // A transformation that adjusts the branch weights |
| // of a branch conditional instruction. |
| |
| // A descriptor for a branch conditional instruction. |
| InstructionDescriptor instruction_descriptor = 1; |
| |
| // Branch weights of a branch conditional instruction. |
| UInt32Pair branch_weights = 2; |
| |
| } |
| |
| message TransformationCompositeConstruct { |
| |
| // A transformation that introduces an OpCompositeConstruct instruction to |
| // make a composite object. |
| |
| // Id of the type of the composite that is to be constructed |
| uint32 composite_type_id = 1; |
| |
| // Ids of the objects that will form the components of the composite |
| repeated uint32 component = 2; |
| |
| // A descriptor for an instruction in a block before which the new |
| // OpCompositeConstruct instruction should be inserted |
| InstructionDescriptor instruction_to_insert_before = 3; |
| |
| // A fresh id for the composite object |
| uint32 fresh_id = 4; |
| |
| } |
| |
| message TransformationCompositeExtract { |
| |
| // A transformation that adds an instruction to extract an element from a |
| // composite. |
| |
| // A descriptor for an instruction in a block before which the new |
| // OpCompositeExtract instruction should be inserted |
| InstructionDescriptor instruction_to_insert_before = 1; |
| |
| // Result id for the extract operation. |
| uint32 fresh_id = 2; |
| |
| // Id of the composite from which data is to be extracted. |
| uint32 composite_id = 3; |
| |
| // Indices that indicate which part of the composite should be extracted. |
| repeated uint32 index = 4; |
| |
| } |
| |
| message TransformationCompositeInsert { |
| |
| // A transformation that adds an instruction OpCompositeInsert which creates |
| // a new composite from an existing composite, with an element inserted. |
| |
| // A descriptor for an instruction before which the new instruction |
| // OpCompositeInsert should be inserted. |
| InstructionDescriptor instruction_to_insert_before = 1; |
| |
| // Result id of the inserted OpCompositeInsert instruction. |
| uint32 fresh_id = 2; |
| |
| // Id of the composite used as the basis for the insertion. |
| uint32 composite_id = 3; |
| |
| // Id of the object to be inserted. |
| uint32 object_id = 4; |
| |
| // Indices that indicate which part of the composite should be inserted into. |
| repeated uint32 index = 5; |
| |
| } |
| |
| message TransformationComputeDataSynonymFactClosure { |
| |
| // A transformation that impacts the fact manager only, forcing a computation |
| // of the closure of data synonym facts, so that e.g. if the components of |
| // vectors v and w are known to be pairwise synonymous, it is deduced that v |
| // and w are themselves synonymous. |
| |
| // When searching equivalence classes for implied facts, equivalence classes |
| // larger than this size will be skipped. |
| uint32 maximum_equivalence_class_size = 1; |
| |
| } |
| |
| message TransformationDuplicateRegionWithSelection { |
| |
| // A transformation that inserts a conditional statement with a boolean expression |
| // of arbitrary value and duplicates a given single-entry, single-exit region, so |
| // that it is present in each conditional branch and will be executed regardless |
| // of which branch will be taken. |
| |
| // Fresh id for a label of the new entry block. |
| uint32 new_entry_fresh_id = 1; |
| |
| // Id for a boolean expression. |
| uint32 condition_id = 2; |
| |
| // Fresh id for a label of the merge block of the conditional. |
| uint32 merge_label_fresh_id = 3; |
| |
| // Block id of the entry block of the original region. |
| uint32 entry_block_id = 4; |
| |
| // Block id of the exit block of the original region. |
| uint32 exit_block_id = 5; |
| |
| // Map that maps from a label in the original region to the corresponding label |
| // in the duplicated region. |
| repeated UInt32Pair original_label_to_duplicate_label = 6; |
| |
| // 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_duplicate_id = 7; |
| |
| // Map that maps from a result id in the original region to the result id of the |
| // corresponding OpPhi instruction. |
| repeated UInt32Pair original_id_to_phi_id = 8; |
| } |
| |
| message TransformationEquationInstruction { |
| |
| // A transformation that adds an instruction to the module that defines an |
| // equation between its result id and input operand ids, such that the |
| // equation is guaranteed to hold at any program point where all ids involved |
| // are available (i.e. at any program point dominated by the instruction). |
| |
| // The result id of the new instruction |
| uint32 fresh_id = 1; |
| |
| // The instruction's opcode |
| uint32 opcode = 2; |
| |
| // The input operands to the instruction |
| repeated uint32 in_operand_id = 3; |
| |
| // A descriptor for an instruction in a block before which the new |
| // instruction should be inserted |
| InstructionDescriptor instruction_to_insert_before = 4; |
| |
| } |
| |
| message TransformationExpandVectorReduction { |
| |
| // A transformation that adds synonyms for OpAny and OpAll instructions by |
| // evaluating each vector component with the corresponding logical operation. |
| // There is a SPIR-V code example in the header file of the transformation |
| // class that can help understand the transformation. |
| |
| // The OpAny or OpAll instruction result id. |
| uint32 instruction_result_id = 1; |
| |
| // The fresh ids required to apply the transformation. |
| repeated uint32 fresh_ids = 2; |
| |
| } |
| |
| message TransformationFlattenConditionalBranch { |
| |
| // A transformation that takes a selection construct with a header |
| // containing an OpBranchConditional instruction and flattens it. |
| // For example, something of the form: |
| // |
| // %1 = OpLabel |
| // [header instructions] |
| // OpSelectionMerge %4 None |
| // OpBranchConditional %cond %2 %3 |
| // %2 = OpLabel |
| // [true branch instructions] |
| // OpBranch %4 |
| // %3 = OpLabel |
| // [false branch instructions] |
| // OpBranch %4 |
| // %4 = OpLabel |
| // ... |
| // |
| // becomes: |
| // |
| // %1 = OpLabel |
| // [header instructions] |
| // OpBranch %2 |
| // %2 = OpLabel |
| // [true branch instructions] |
| // OpBranch %3 |
| // %3 = OpLabel |
| // [false branch instructions] |
| // OpBranch %4 |
| // %4 = OpLabel |
| // ... |
| // |
| // If all of the instructions in the true or false branches have |
| // no side effects, this is semantics-preserving. |
| // Side-effecting instructions will instead be enclosed by smaller |
| // conditionals. For more details, look at the definition for the |
| // SideEffectWrapperInfo message. |
| // |
| // Nested conditionals or loops are not supported. The false branch |
| // could also be executed before the true branch, depending on the |
| // |true_branch_first| field. |
| |
| // The label id of the header block |
| uint32 header_block_id = 1; |
| |
| // 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. |
| bool true_branch_first = 2; |
| |
| // 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_bvec2_selector = 3; |
| |
| // The same as |fresh_id_for_bvec2_selector| but for the bvec3 case. |
| uint32 fresh_id_for_bvec3_selector = 4; |
| |
| // The same as |fresh_id_for_bvec2_selector| but for the bvec4 case. |
| uint32 fresh_id_for_bvec4_selector = 5; |
| |
| // 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. |
| repeated SideEffectWrapperInfo side_effect_wrapper_info = 6; |
| } |
| |
| message TransformationFunctionCall { |
| |
| // A transformation that introduces an OpFunctionCall instruction. The call |
| // must not make the module's call graph cyclic. Beyond that, if the call |
| // is in a dead block it can be to any function with arbitrary suitably-typed |
| // arguments; otherwise it must be to a livesafe function, with injected |
| // variables as pointer arguments and arbitrary non-pointer arguments. |
| |
| // A fresh id for the result of the call |
| uint32 fresh_id = 1; |
| |
| // Id of the function to be called |
| uint32 callee_id = 2; |
| |
| // Ids for arguments to the function |
| repeated uint32 argument_id = 3; |
| |
| // A descriptor for an instruction in a block before which the new |
| // OpFunctionCall instruction should be inserted |
| InstructionDescriptor instruction_to_insert_before = 4; |
| |
| } |
| |
| message TransformationInlineFunction { |
| |
| // This transformation inlines a function by mapping the function instructions to fresh ids. |
| |
| // Result id of the function call instruction. |
| uint32 function_call_id = 1; |
| |
| // 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. |
| repeated UInt32Pair result_id_map = 2; |
| |
| } |
| |
| message TransformationInvertComparisonOperator { |
| |
| // For some instruction with result id |operator_id| that |
| // represents a binary comparison operator (e.g. <, >, <=), this transformation |
| // will replace that instruction's result id with |fresh_id|, |
| // invert the opcode (< will become >=) and insert OpLogicalNot |
| // instruction with result id |operator_id| below. |
| |
| // Result id of the instruction to invert. |
| uint32 operator_id = 1; |
| |
| // Fresh id that will be used by the operator after the inversion. |
| uint32 fresh_id = 2; |
| |
| } |
| |
| message TransformationLoad { |
| |
| // Transformation that adds an OpLoad or OpAtomicLoad instruction from a pointer into an id. |
| |
| // The result of the load instruction. |
| uint32 fresh_id = 1; |
| |
| // The pointer to be loaded from. |
| uint32 pointer_id = 2; |
| |
| // True if and only if the load should be atomic. |
| bool is_atomic = 3; |
| |
| // The memory scope for the atomic load. Ignored unless |is_atomic| is true. |
| uint32 memory_scope_id = 4; |
| |
| // The memory semantics for the atomic load. Ignored unless |is_atomic| is true. |
| uint32 memory_semantics_id = 5; |
| |
| // A descriptor for an instruction in a block before which the new OpLoad |
| // instruction should be inserted. |
| InstructionDescriptor instruction_to_insert_before = 6; |
| |
| } |
| |
| message TransformationMakeVectorOperationDynamic { |
| |
| // A transformation that replaces the OpCompositeExtract and OpCompositeInsert |
| // instructions with the OpVectorExtractDynamic and OpVectorInsertDynamic instructions. |
| |
| // The composite instruction result id. |
| uint32 instruction_result_id = 1; |
| |
| // 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. |
| uint32 constant_index_id = 2; |
| |
| } |
| |
| message TransformationMergeBlocks { |
| |
| // A transformation that merges a block with its predecessor. |
| |
| // The id of the block that is to be merged with its predecessor; the merged |
| // block will have the *predecessor's* id. |
| uint32 block_id = 1; |
| |
| } |
| |
| message TransformationMergeFunctionReturns { |
| |
| // A transformation that modifies a function so that it does not return early, |
| // so it only has one return statement (ignoring unreachable blocks). |
| // |
| // The function is enclosed inside an outer loop, that is only executed once, |
| // and whose merge block is the new return block of the function. |
| // |
| // Each return instruction is replaced by: |
| // OpBranch %innermost_loop_merge |
| // where %innermost_loop_merge is the innermost loop containing the return |
| // instruction. |
| // |
| // Each merge block whose associated loop contains return instructions is |
| // changed so that it branches to the merge block of the loop containing it, |
| // as explained in the comments to the ReturnMergingInfo message. |
| // |
| // The new return block (the merge block of the new outer loop) will be of |
| // the following form (if the return type is not void): |
| // %outer_return_id = OpLabel |
| // %return_val_id = OpPhi %return_type %val1 %block_1 %val2 %block_2 ... |
| // OpReturnValue %return_val_id |
| // where %block_k is either a return block that, in the original function, is |
| // outside of any loops, or the merge block of a loop that contains return |
| // instructions and is not, originally, nested inside another loop, and |
| // %block_k is the corresponding return value. |
| // If the function has void type, there will be no OpPhi instruction and the |
| // last instruction will be OpReturn. |
| |
| // The id of the function to which the transformation is being applied. |
| uint32 function_id = 1; |
| |
| // A fresh id for the header of the new outer loop. |
| uint32 outer_header_id = 2; |
| |
| // A fresh id for an unreachable continue construct for the new outer loop. |
| uint32 unreachable_continue_id = 7; |
| |
| // A fresh id for the new return block of the function, |
| // i.e. the merge block of the new outer loop. |
| uint32 outer_return_id = 3; |
| |
| // A fresh id for the value that will be returned. |
| // This is ignored if the function has void return type. |
| uint32 return_val_id = 4; |
| |
| // 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. |
| uint32 any_returnable_val_id = 5; |
| |
| // The information needed to modify the merge blocks of |
| // loops containing return instructions. |
| repeated ReturnMergingInfo return_merging_info = 6; |
| } |
| |
| message TransformationMoveBlockDown { |
| |
| // A transformation that moves a basic block to be one position lower in |
| // program order. |
| |
| // The id of the block to move down. |
| uint32 block_id = 1; |
| } |
| |
| message TransformationMoveInstructionDown { |
| |
| // Swaps |instruction| with the next instruction in the block. |
| |
| // The instruction to move down. |
| InstructionDescriptor instruction = 1; |
| |
| } |
| |
| message TransformationMutatePointer { |
| |
| // Backs up value of the pointer, writes into the pointer and |
| // restores the original value. |
| |
| // Result id of the pointer instruction to mutate. |
| uint32 pointer_id = 1; |
| |
| // Fresh id for the OpLoad instruction. |
| uint32 fresh_id = 2; |
| |
| // Instruction to insert backup, mutation and restoration code before. |
| InstructionDescriptor insert_before = 3; |
| |
| } |
| |
| message TransformationOutlineFunction { |
| |
| // A transformation that outlines a single-entry single-exit region of a |
| // control flow graph into a separate function, and replaces the region with |
| // a call to that function. |
| |
| // Id of the entry block of the single-entry single-exit region to be outlined |
| uint32 entry_block = 1; |
| |
| // Id of the exit block of the single-entry single-exit region to be outlined |
| uint32 exit_block = 2; |
| |
| // Id of a struct that will store the return values of the new function |
| uint32 new_function_struct_return_type_id = 3; |
| |
| // A fresh id for the type of the outlined function |
| uint32 new_function_type_id = 4; |
| |
| // A fresh id for the outlined function itself |
| uint32 new_function_id = 5; |
| |
| // A fresh id to represent the block in the outlined function that represents |
| // the first block of the outlined region. |
| uint32 new_function_region_entry_block = 6; |
| |
| // A fresh id for the result of the OpFunctionCall instruction that will call |
| // the outlined function |
| uint32 new_caller_result_id = 7; |
| |
| // A fresh id to capture the return value of the outlined function - the |
| // argument to OpReturn |
| uint32 new_callee_result_id = 8; |
| |
| // 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 input_id_to_fresh_id = 9; |
| |
| // 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. |
| repeated UInt32Pair output_id_to_fresh_id = 10; |
| |
| } |
| |
| message TransformationPermuteFunctionParameters { |
| |
| // A transformation that, given a non-entry-point function taking n |
| // parameters and a permutation of the set [0, n-1]: |
| // - Introduces a new function type that is the same as the original |
| // function's type but with the order of arguments permuted |
| // (only if it doesn't already exist) |
| // - Changes the type of the function to this type |
| // - Adjusts all calls to the function so that their arguments are permuted |
| |
| // Function, whose parameters will be permuted |
| uint32 function_id = 1; |
| |
| // 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. |
| uint32 function_type_fresh_id = 2; |
| |
| // 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) |
| repeated uint32 permutation = 3; |
| |
| } |
| |
| message TransformationPermutePhiOperands { |
| |
| // Permutes operands of some OpPhi instruction. |
| |
| // Result id of the instruction to apply the transformation to. |
| uint32 result_id = 1; |
| |
| // 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|. |
| repeated uint32 permutation = 2; |
| |
| } |
| |
| message TransformationPropagateInstructionDown { |
| |
| // Propagates an instruction from |block_id| into its successors. |
| // Concretely, the transformation clones the propagated instruction |
| // into some of the successors of |block_id| and removes the original |
| // instruction. Additionally, an OpPhi instruction may be added to make sure |
| // that the transformation can be applied in various scenarios. |
| // |
| // Note that the instruction might not be propagated down into every successor |
| // of |block_id| since it might make the module invalid. |
| |
| // 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 block_id = 1; |
| |
| // 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). |
| uint32 phi_fresh_id = 2; |
| |
| // 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|. |
| repeated UInt32Pair successor_id_to_fresh_id = 3; |
| |
| } |
| |
| message TransformationPropagateInstructionUp { |
| |
| // Propagates an instruction in the block into the block's predecessors. |
| // Concretely, this transformation clones some particular instruction from |
| // the |block_id| into every block's predecessor and replaces the original |
| // instruction with OpPhi. Take a look at the transformation class to learn |
| // more about how we choose what instruction to propagate. |
| |
| // Id of the block to propagate an instruction from. |
| uint32 block_id = 1; |
| |
| // 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. |
| repeated UInt32Pair predecessor_id_to_fresh_id = 2; |
| |
| } |
| |
| message TransformationPushIdThroughVariable { |
| |
| // A transformation that makes |value_synonym_id| and |value_id| to be |
| // synonymous by storing |value_id| into |variable_id| and |
| // loading |variable_id| to |value_synonym_id|. |
| |
| // The value to be stored. |
| uint32 value_id = 1; |
| |
| // A fresh id for the result of the load instruction. |
| uint32 value_synonym_id = 2; |
| |
| // A fresh id for the variable to be stored to. |
| uint32 variable_id = 3; |
| |
| // Constant to initialize the variable from. |
| uint32 initializer_id = 4; |
| |
| // The variable storage class (global or local). |
| uint32 variable_storage_class = 5; |
| |
| // A descriptor for an instruction which the new OpStore |
| // and OpLoad instructions might be inserted before. |
| InstructionDescriptor instruction_descriptor = 6; |
| |
| } |
| |
| message TransformationRecordSynonymousConstants { |
| |
| // A transformation that, given the IDs to two synonymous constants, |
| // records the fact that they are synonymous. The module is not changed. |
| // Two constants are synonymous if: |
| // - they have the same type (ignoring the presence of integer sign) |
| // - they have the same opcode (one of OpConstant, OpConstantTrue, |
| // OpConstantFalse, OpConstantNull) |
| // - they have the same value |
| // If the types are the same, OpConstantNull is equivalent to |
| // OpConstantFalse or OpConstant with value zero. |
| |
| // The id of a constant |
| uint32 constant1_id = 1; |
| |
| // The id of the synonym |
| uint32 constant2_id = 2; |
| |
| } |
| |
| message TransformationReplaceAddSubMulWithCarryingExtended { |
| |
| // Replaces OpIAdd with OpIAddCarry, OpISub with OpISubBorrow, OpIMul |
| // with OpUMulExtended or OpSMulExtended (depending on the signedness |
| // of the operands) and stores the result into a |struct_fresh_id|. |
| // In the original instruction the result type id and the type ids of |
| // the operands must be the same. Then the transformation extracts |
| // the first element of the result into the original |result_id|. |
| // This value is the same as the result of the original instruction. |
| |
| // The fresh id of the intermediate result. |
| uint32 struct_fresh_id = 1; |
| |
| // The result id of the original instruction. |
| uint32 result_id = 2; |
| |
| } |
| |
| message TransformationReplaceBranchFromDeadBlockWithExit { |
| |
| // Given a dead block that ends with OpBranch, replaces OpBranch with an |
| // "exit" instruction; one of OpReturn/OpReturnValue, OpKill (in a fragment |
| // shader) or OpUnreachable. |
| |
| // The dead block whose terminator is to be replaced. |
| uint32 block_id = 1; |
| |
| // The opcode of the new terminator. |
| uint32 opcode = 2; |
| |
| // Ignored unless opcode is OpReturnValue, in which case this field provides |
| // a suitable result id to be returned. |
| uint32 return_value_id = 3; |
| |
| } |
| |
| message TransformationReplaceParameterWithGlobal { |
| |
| // Removes parameter with result id |parameter_id| from its function |
| // and creates a global variable to pass its value to the function instead. |
| |
| // 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 function_type_fresh_id = 2; |
| |
| // Result id of the OpFunctionParameter instruction to remove. |
| uint32 parameter_id = 3; |
| |
| // Fresh id of a global variable used to pass parameter's value to the function. |
| uint32 global_variable_fresh_id = 4; |
| |
| } |
| |
| message TransformationReplaceBooleanConstantWithConstantBinary { |
| |
| // A transformation to capture replacing a use of a boolean constant with |
| // binary operation on two constant values |
| |
| // A descriptor for the boolean constant id we would like to replace |
| IdUseDescriptor id_use_descriptor = 1; |
| |
| // Id for the constant to be used on the LHS of the comparison |
| uint32 lhs_id = 2; |
| |
| // Id for the constant to be used on the RHS of the comparison |
| uint32 rhs_id = 3; |
| |
| // Opcode for binary operator |
| uint32 opcode = 4; |
| |
| // Id that will store the result of the binary operation instruction |
| uint32 fresh_id_for_binary_operation = 5; |
| |
| } |
| |
| message TransformationReplaceConstantWithUniform { |
| |
| // Replaces a use of a constant id with the result of a load from an |
| // element of uniform buffer known to hold the same value as the constant |
| |
| // A descriptor for the id we would like to replace |
| IdUseDescriptor id_use_descriptor = 1; |
| |
| // Uniform descriptor to identify which uniform value to choose |
| UniformBufferElementDescriptor uniform_descriptor = 2; |
| |
| // Id that will store the result of an access chain |
| uint32 fresh_id_for_access_chain = 3; |
| |
| // Id that will store the result of a load |
| uint32 fresh_id_for_load = 4; |
| |
| } |
| |
| message TransformationReplaceCopyMemoryWithLoadStore { |
| |
| // A transformation that replaces instructions OpCopyMemory with loading |
| // the source variable to an intermediate value and storing this value into the |
| // target variable of the original OpCopyMemory instruction. |
| |
| // The intermediate value. |
| uint32 fresh_id = 1; |
| |
| // The instruction descriptor to OpCopyMemory. It is necessary, because |
| // OpCopyMemory doesn't have a result id. |
| InstructionDescriptor copy_memory_instruction_descriptor = 2; |
| } |
| |
| message TransformationReplaceCopyObjectWithStoreLoad { |
| |
| // A transformation that replaces instruction OpCopyObject with |
| // storing into a new variable and immediately loading from this |
| // variable to |result_id| of the original OpCopyObject instruction. |
| |
| // The result id of initial OpCopyObject instruction |
| uint32 copy_object_result_id = 1; |
| |
| // A fresh id for the variable to be stored to. |
| uint32 fresh_variable_id = 2; |
| |
| // The variable storage class (Function or Private). |
| uint32 variable_storage_class = 3; |
| |
| // Constant to initialize the variable with. |
| uint32 variable_initializer_id = 4; |
| } |
| |
| message TransformationReplaceIdWithSynonym { |
| |
| // Replaces a use of an id with an id that is known to be synonymous, e.g. |
| // because it was obtained via applying OpCopyObject |
| |
| // The id use that is to be replaced |
| IdUseDescriptor id_use_descriptor = 1; |
| |
| // The synonymous id |
| uint32 synonymous_id = 2; |
| |
| } |
| |
| message TransformationReplaceIrrelevantId { |
| |
| // Replaces an irrelevant id with another id of the same type. |
| |
| // The id use that is to be replaced |
| IdUseDescriptor id_use_descriptor = 1; |
| |
| // The replacement id |
| uint32 replacement_id = 2; |
| } |
| |
| message TransformationReplaceLinearAlgebraInstruction { |
| |
| // Replaces a linear algebra instruction with its |
| // mathematical definition. |
| |
| // The fresh ids needed to apply the transformation. |
| repeated uint32 fresh_ids = 1; |
| |
| // A descriptor for a linear algebra instruction. |
| InstructionDescriptor instruction_descriptor = 2; |
| |
| } |
| |
| message TransformationReplaceLoadStoreWithCopyMemory { |
| // 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. |
| |
| // The instruction descriptor to OpLoad |
| InstructionDescriptor load_instruction_descriptor = 1; |
| |
| // The instruction descriptor to OpStore |
| InstructionDescriptor store_instruction_descriptor = 2; |
| } |
| |
| message TransformationReplaceOpPhiIdFromDeadPredecessor { |
| |
| // Replaces one of the ids used by an OpPhi instruction, when |
| // the corresponding predecessor is dead, with any available id |
| // of the correct type. |
| |
| // The result id of the OpPhi instruction. |
| uint32 opphi_id = 1; |
| |
| // 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 pred_label_id = 2; |
| |
| // The id that, after the transformation, will be associated with |
| // the given predecessor. |
| uint32 replacement_id = 3; |
| |
| } |
| |
| message TransformationReplaceOpSelectWithConditionalBranch { |
| |
| // A transformation that takes an OpSelect instruction with a |
| // scalar boolean condition and replaces it with a conditional |
| // branch and an OpPhi instruction. |
| // The OpSelect instruction must be the first instruction in its |
| // block, which must have a unique predecessor. The block will |
| // become the merge block of a new construct, while its predecessor |
| // will become the header. |
| // Given the original OpSelect instruction: |
| // %id = OpSelect %type %cond %then %else |
| // The branching instruction of the header will be: |
| // OpBranchConditional %cond %true_block_id %false_block_id |
| // and the OpSelect instruction will be turned into: |
| // %id = OpPhi %type %then %true_block_id %else %false_block_id |
| // At most one of |true_block_id| and |false_block_id| can be zero. In |
| // that case, there will be no such block and all references to it |
| // will be replaced by %merge_block (where %merge_block is the |
| // block containing the OpSelect instruction). |
| |
| // The result id of the OpSelect instruction. |
| uint32 select_id = 1; |
| |
| // A fresh id for the new block that the predecessor of the block |
| // containing |select_id| will branch to if the condition holds. |
| 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 does not |
| // hold. |
| uint32 false_block_id = 3; |
| } |
| |
| message TransformationReplaceParamsWithStruct { |
| |
| // Replaces parameters of the function with a struct containing |
| // values of those parameters. |
| |
| // Result ids of parameters to replace. |
| repeated uint32 parameter_id = 1; |
| |
| // 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_function_type_id = 2; |
| |
| // Fresh id for a new struct function parameter to be used as a replacement. |
| uint32 fresh_parameter_id = 3; |
| |
| // 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 UInt32Pair caller_id_to_fresh_composite_id = 4; |
| |
| } |
| |
| message TransformationSetFunctionControl { |
| |
| // A transformation that sets the function control operand of an OpFunction |
| // instruction. |
| |
| // The result id of an OpFunction instruction |
| uint32 function_id = 1; |
| |
| // The value to which the 'function control' operand should be set. |
| uint32 function_control = 2; |
| |
| } |
| |
| message TransformationSetLoopControl { |
| |
| // A transformation that sets the loop control operand of an OpLoopMerge |
| // instruction. |
| |
| // The id of a basic block that should contain OpLoopMerge |
| uint32 block_id = 1; |
| |
| // The value to which the 'loop control' operand should be set. |
| // This must be a legal loop control mask. |
| uint32 loop_control = 2; |
| |
| // 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 peel_count = 3; |
| |
| // 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). |
| uint32 partial_count = 4; |
| |
| } |
| |
| message TransformationSetMemoryOperandsMask { |
| |
| // A transformation that sets the memory operands mask of a memory access |
| // instruction. |
| |
| // A descriptor for a memory access instruction, e.g. an OpLoad |
| InstructionDescriptor memory_access_instruction = 1; |
| |
| // 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 = 2; |
| |
| // Some memory access instructions allow more than one mask to be specified; |
| // this field indicates which mask should be set |
| uint32 memory_operands_mask_index = 3; |
| |
| } |
| |
| message TransformationSetSelectionControl { |
| |
| // A transformation that sets the selection control operand of an |
| // OpSelectionMerge instruction. |
| |
| // The id of a basic block that should contain OpSelectionMerge |
| uint32 block_id = 1; |
| |
| // 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. |
| uint32 selection_control = 2; |
| |
| } |
| |
| message TransformationSplitBlock { |
| |
| // A transformation that splits a basic block into two basic blocks |
| |
| // A descriptor for an instruction such that the block containing the |
| // described instruction should be split right before the instruction. |
| InstructionDescriptor instruction_to_split_before = 1; |
| |
| // 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. |
| uint32 fresh_id = 2; |
| |
| } |
| |
| message TransformationStore { |
| |
| // Transformation that adds an OpStore or OpAtomicStore instruction of an id to a pointer. |
| |
| // The pointer to be stored to. |
| uint32 pointer_id = 1; |
| |
| // True if and only if the load should be atomic. |
| bool is_atomic = 2; |
| |
| // The memory scope for the atomic load. Ignored unless |is_atomic| is true. |
| uint32 memory_scope_id = 3; |
| |
| // The memory semantics for the atomic load. Ignored unless |is_atomic| is true. |
| uint32 memory_semantics_id = 4; |
| |
| // The value to be stored. |
| uint32 value_id = 5; |
| |
| // A descriptor for an instruction in a block before which the new OpStore |
| // instruction should be inserted. |
| InstructionDescriptor instruction_to_insert_before = 6; |
| |
| } |
| |
| message TransformationSwapCommutableOperands { |
| |
| // A transformation that swaps the operands of a commutative instruction. |
| |
| // A descriptor for a commutative instruction |
| InstructionDescriptor instruction_descriptor = 1; |
| |
| } |
| |
| message TransformationSwapConditionalBranchOperands { |
| |
| // Swaps label ids in OpBranchConditional instruction. |
| // Additionally, inverts the guard and swaps branch weights |
| // if present. |
| |
| // Descriptor of the instruction to swap operands of. |
| InstructionDescriptor instruction_descriptor = 1; |
| |
| // Fresh result id for the OpLogicalNot instruction, used |
| // to invert the guard. |
| uint32 fresh_id = 2; |
| |
| } |
| |
| message TransformationSwapFunctionVariables { |
| // A transformation that swaps function variables |
| |
| // Result id of the first variable. |
| uint32 result_id1 = 1; |
| // Result id of the second variable. |
| uint32 result_id2 = 2; |
| |
| } |
| |
| message TransformationSwapTwoFunctions { |
| // A transformation that swaps the position of two functions within the same module. |
| |
| // the IDs for the two functions that are swapped. |
| uint32 function_id1 = 1; |
| uint32 function_id2 = 2; |
| } |
| |
| message TransformationToggleAccessChainInstruction { |
| |
| // A transformation that toggles an access chain instruction. |
| |
| // A descriptor for an access chain instruction |
| InstructionDescriptor instruction_descriptor = 1; |
| |
| } |
| |
| message TransformationVectorShuffle { |
| |
| // A transformation that adds a vector shuffle instruction. |
| |
| // A descriptor for an instruction in a block before which the new |
| // OpVectorShuffle instruction should be inserted |
| InstructionDescriptor instruction_to_insert_before = 1; |
| |
| // Result id for the shuffle operation. |
| uint32 fresh_id = 2; |
| |
| // Id of the first vector operand. |
| uint32 vector1 = 3; |
| |
| // Id of the second vector operand. |
| uint32 vector2 = 4; |
| |
| // Indices that indicate which components of the input vectors should be used. |
| repeated uint32 component = 5; |
| |
| } |
| |
| message TransformationWrapEarlyTerminatorInFunction { |
| |
| // Replaces an early terminator - OpKill, OpReachable or OpTerminateInvocation |
| // - with a call to a wrapper function for the terminator. |
| |
| // A fresh id for a new OpFunctionCall instruction. |
| uint32 fresh_id = 1; |
| |
| // A descriptor for an OpKill, OpUnreachable or OpTerminateInvocation |
| // instruction. |
| InstructionDescriptor early_terminator_instruction = 2; |
| |
| // 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. |
| uint32 returned_value_id = 3; |
| |
| } |
| |
| message TransformationWrapRegionInSelection { |
| |
| // Transforms a single-entry-single-exit region R into |
| // if (|branch_condition|) { R } else { R } |
| // The entry block for R becomes a selection header and |
| // the exit block - a selection merge. |
| // |
| // Note that the region R is not duplicated. Thus, the effect of |
| // this transformation can be represented as follows: |
| // entry |
| // entry / \ |
| // | \ / |
| // R --> R |
| // | | |
| // exit exit |
| |
| // This behaviour is different from TransformationDuplicateRegionWithSelection |
| // that copies the blocks in R. |
| |
| // The entry block for the region R. |
| uint32 region_entry_block_id = 1; |
| |
| // The exit block for the region R. |
| uint32 region_exit_block_id = 2; |
| |
| // Boolean value for the condition expression. |
| bool branch_condition = 3; |
| |
| } |
| |
| message TransformationWrapVectorSynonym { |
| // 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]. |
| |
| // The result if of the original scalar operation instruction. |
| uint32 instruction_id = 1; |
| |
| // The result id for the first vector that contains the first value of the scalar operation. |
| uint32 vector_operand1 = 2; |
| |
| // The result id for the second vector that contains the second value of the scalar operation. |
| uint32 vector_operand2 = 3; |
| |
| // A fresh id for the resulted vector from the addition of the first and second vector. |
| uint32 fresh_id = 4; |
| |
| // The position in the vector where the value of original instruction is located. Must be in |
| // the corresponding vector range. |
| uint32 scalar_position = 5; |
| |
| } |
