Proto commits in KhronosGroup/SPIRV-Tools

These commits are when the Protocol Buffers files have changed: (only the last 100 relevant commits are shown)

2022-01-26

Fix various source comment (doxygen) typos (#4680) Found via `codespell -q 3 -L fo,lod,parm

The documentation is generated from this commit.

2021-08-05

spirv-fuzz: Support AtomicStore (#4440) Adds support for atomic operations in TransformationStore and its associated fuzzer pass. Fixes #4337.

2021-08-03

spirv-fuzz: support AtomicLoad (#4330) Enhances the TransformationLoad transformation and associated fuzzer pass to support atomic operations. Fixes #4324.

2021-07-20

spirv-fuzz: TransformationWrapVectorSynonym that rewrites scalar operations using vectors (#4376) Adds a new transformation that rewrites a scalar operation (like OpFAdd, opISub) as an equivalent vector operation, adding a synonym between the scalar result and an appropriate component of the vector result. Fixes #4195.

2021-06-09

spirv-fuzz: Support bitwise or and xor in TransformationAddBitInstructionSynonym (#4310) Fixes #4172.

2021-05-12

spirv-fuzz: Respect control flow rules when merging returns (#4279) Fixes #4278. Some minor code cleanup is incorporated.

2021-04-27

spirv-fuzz: Swap positions of two functions in a module (#4236) Adds a new transformation class that swaps the syntactic position of two functions in the module, and a fuzzer pass to apply it. Fixes #4026.

2021-04-26

spirv-fuzz: Permute the order of variables at function scope issue (#4248) Fixes #4194.

2020-10-23

spirv-fuzz: Add expand vector reduction transformation (#3869) The following implementations are introduced: - Transformation and fuzzer pass for expanding vector reduction. - Unit tests to cover the instructions with different vector sizes. Fixes #3768.

2020-10-20

spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.

2020-10-16

spirv-fuzz: Wrap early terminators before merging returns (#3925) Incorporates some other fixes for issues that were brought to light by adding this functionality. Fixes #3717. Fixes #3924.

2020-10-13

spirv-fuzz: Fix to transformation that adds a synonym via a loop (#3898) Fixes #3897.

2020-10-08

spirv-fuzz: Wrap OpKill and similar in function calls (#3884) Part of #3717.

2020-10-06

spirv-fuzz: Replace dead-block terminators with OpKill etc. (#3882) Fixes #3615.

spirv-fuzz: TransformationPropagateInstructionDown (#3692) Fixes #3691.

spirv-fuzz: Transformation to add wrappers for OpKill and similar (#3881) Part of #3717.

2020-10-02

spirv-fuzz: Merge the return instructions in a function (#3838) This PR introduces TransformationMergeFunctionReturns, which changes a function so that it only has one reachable return statement. Fixes #3655.

2020-10-01

spirv-fuzz: TransformationWrapRegionInSelection (#3674) Fixes #3675.

2020-09-29

spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.

2020-09-26

spirv-fuzz: Support OpNot bit instruction case (#3841) This PR implements the OpNot instruction for the add bit instruction synonym transformation. In addition, some code improvements have been made.

2020-09-24

spirv-fuzz: Move IRContext parameter into constructor (#3837) This PR converts IRContext parameter in fact managers into a class field. Part of #3698.

2020-09-23

spirv-fuzz: Create synonym of int constant using a loop (#3790) This transformation, given a constant integer (scalar or vector) C, constants I and S of compatible type and scalar 32-bit integer constant N, such that C = I - S*N, adds a loop which subtracts S from I, N times, creating a synonym for C. The related fuzzer pass randomly chooses constants to which to add synonyms using this transformation, and the location where they should be added. Fixes #3616.

2020-09-15

spirv-fuzz: Add bit instruction synonym transformation (#3775) This PR implements part of the add bit instruction synonym transformation. For now, the implementation covers the OpBitwiseOr, OpBitwiseXor and OpBitwiseAnd cases.

spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.

2020-09-11

spirv-fuzz: Add TransformationDuplicateRegionWithSelection (#3773) Adds 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. Fixes #3614.

2020-09-03

spirv-fuzz: Transformation to convert OpSelect to conditional branch (#3681) This transformation takes an OpSelect instruction and replaces it with a conditional branch, selecting the correct value using an OpPhi instruction. Fixes part of the issue #3544.

2020-09-02

spirv-fuzz: Replace id in OpPhi coming from a dead predecessor (#3744) This transformation takes the id of an OpPhi instruction, of a dead predecessor of the block containing it and a replacement id of available to use and of the same type as the OpPhi, and changes the id in the OpPhi corresponding to the given predecessor. For example, %id = OpPhi %type %v1 %p1 %v2 %p2 becomes %id = OpPhi %type %v3 %p1 %v2 %p2 if the transformation is given %id, %p1 and %v3, %p1 is a dead block, %v3 is type type and it is available to use at the end of %p1. The fuzzer pass randomly decides to apply the transformation to OpPhi instructions for which at least one of the predecessors is dead Fixes #3726.

2020-09-01

spirv-fuzz: Transformation to replace the use of an irrelevant id (#3697) A transformation that replaces the use of an irrelevant id with another id of the same type. The related fuzzer pass, for every use of an irrelevant id, checks whether the id can be replaced in that use by another id of the same type and randomly decides whether to replace it. Fixes #3503.

spirv-fuzz: TransformationMutatePointer (#3737) Fixes #3624.

2020-08-27

spirv-fuzz: Create synonym via OpPhi and existing synonyms (#3701) A transformation that adds new OpPhi instructions to blocks with >=1 predecessors, so that its value depends on previously-defined ids of the right type, which are all synonymous. This instruction is also recorded as synonymous to the others. The related fuzzer pass still needs to be implemented. Fixes #3592 .

2020-08-25

spirv-fuzz: Add inline function transformation (#3517) Fixes #3505.

2020-08-19

spirv-fuzz: add FuzzerPassAddCompositeInserts (#3606) Adds FuzzerPassAddCompositeInserts, which randomly adds new OpCompositeInsert instructions. Each OpCompositeInsert instruction yields a copy of an original composite with one subcomponent replaced with an existing or newly added object. Synonym facts are added for the unchanged components in the original and added composite, and for the replaced subcomponent and the object, if possible. Fixes #2859

spirv-fuzz: Support pointer types in FuzzerPassAddParameters (#3627) For FuzzerPassAddParameters, adds pointer types (that have the storage class Function or Private) to the pool of available types for new parameters. If there are no variables of the chosen pointer type, it invokes TransformationAddLocalVariable / TransformationAddGlobalVariable to add one. Part of #3403

2020-08-11

spirv-fuzz: FuzzerPassPropagateInstructionsUp (#3478) Given an instruction (that may use an OpPhi result from the same block as an input operand), try to clone the instruction into each predecessor block, replacing the input operand with the corresponding OpPhi input operand in each case, if necessary. Fixes #3458.

2020-08-06

spirv-fuzz: TransformationReplaceAddSubMulWithCarryingExtended (#3598) Replaces OpIAdd with OpIAddCarry, OpISub with OpISubBorrow, OpIMul with OpUMulExtended or OpSMulExtended and stores the result into a fresh_id representing a structure. Extracts the first element of the result into the original result_id. This value is the same as the result of the original instruction. Fixes #3577

spirv-fuzz: Add TransformationMakeVectorOperationDynamic (#3597) Fixes #3588.

2020-08-03

spirv-fuzz: TransformationMoveInstructionDown (#3477) Swaps an instruction with the next instruction in the block. Fixes #3457.

2020-07-30

spirv-fuzz: Transformation to add loop preheader (#3599) This PR introduces TransformationAddLoopPreheader, which, given a loop header and enough fresh ids, adds a loop preheader, updating all the references so that this new block is the only out-of-loop predecessor of the header, which branches unconditionally to the header. See the discussion in #3095.

2020-07-29

spirv-fuzz: Implement the OpOuterProduct linear algebra case (#3617) Fixes #3354.

spirv-fuzz: Remove non-deterministic behaviour (#3608) Fixes #3607.

2020-07-27

spirv-fuzz: Implement the OpTranspose linear algebra case (#3589) This PR implements the OpTranspose case for the replace linear algebra instruction transformation.

spirv-fuzz: adds TransformationReplaceLoadStoreWithCopyMemory (#3586) Adds 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. Fixes #3353.

spirv-fuzz: Generalise transformation access chain (#3546) This PR generalises TransformationAddAccessChain so that dynamic indices for non-struct composites (with clamping to ensure that accesses are in-bound) are allowed. The transformation will add instructions to clamp any index to a non-struct composite, regardless of whether it is a constant or not. Fixes #3179.

2020-07-23

spirv-fuzz: adds TransformationReplaceCopyMemoryWithLoadStore (#3575) Adds a transformation that replaces instruction OpCopyMemory with loading the source variable to an intermediate value and storing this value into the target variable of the original OpCopyMemory instruction. Fixes #3352

spirv-fuzz: adds TransformationReplaceCopyObjectWithStoreLoad (#3567) Adds a transformation that replaces instruction OpCopyObject with storing into a new variable and immediately loading this variable to |result_id| of the original OpCopyObject instruction. Fixes #3351.

2020-07-21

spirv-fuzz: TransformationReplaceParamsWithStruct (#3455) Fixes #3453.

spirv-fuzz: Add is_irrelevant parameter (#3563) Part of #3177. Adjusts functions to create constants.

2020-07-20

spirv-fuzz: Add IdIsIrrelevant fact (#3561) Part of #3177. This PR adds a fact to the fact manager.

spirv-fuzz: add TransformationAddRelaxedDecoration (#3545) Add TransformationAddRelaxedDecoration, which adds the RelaxedPrecision decoration to ids of numeric instructions (those yielding 32-bit ints or floats) in dead blocks. Fixes #3502

2020-07-15

spirv-fuzz: Remove TransformationCopyObject (#3531) Fixes #3509.

2020-07-14

spirv-fuzz: Implement the OpMatrixTimesMatrix linear algebra case (#3527) This PR implements the OpMatrixTimesMatrix case for the replace linear algebra instruction transformation.

2020-07-12

spirv-fuzz: TransformationAddSynonyms (#3447) Part of #3440.

2020-07-10

Implement transformation to record synonymous constants. (#3494) Adds a fact-only transformation that records that two constants in the module are synonymous.

2020-07-09

spirv-fuzz: TransformationReplaceParameterWithGlobal (#3434) Fixes #3432.

Implement the OpMatrixTimesVector linear algebra case (#3500) This PR implements the OpMatrixTimesVector case for the replace linear algebra instruction transformation.

2020-07-08

spirv-fuzz: Add image sample unused components transformation (#3439) Fixes #3375.

2020-07-07

spirv-fuzz: Implement the OpVectorTimesMatrix linear algebra case (#3489) This PR implements the OpVectorTimesMatrix case for the replace linear algebra instruction transformation.

2020-07-03

spirv-fuzz: TransformationInvertComparisonOperator (#3475) Part of #3440.

2020-06-30

spirv-fuzz: Add FuzzerPassAddCopyMemoryInstructions (#3391) Fixes #3382.

spirv-fuzz: Add one parameter at a time (#3469) Fixes #3467. Fixes #3468.

2020-06-26

Implement the OpMatrixTimesScalar linear algebra case (#3450) This PR implements the OpMatrixTimesScalar case for the replace linear algebra instruction transformation.

2020-06-23

spirv-fuzz: Implement FuzzerPassAddParameters (#3399) Fixes #3384.

spirv-fuzz: Permute OpPhi instruction operands (#3421) Fixes #3415.

2020-06-19

spirv-fuzz: Refactor variable creation (#3414) Fixes #3413.

spirv-fuzz: Swap operands in OpBranchConditional (#3423) Fixes #3415.

2020-06-16

spirv-fuzz: Add replace linear algebra instruction transformation (#3402) This PR implements a transformation that replaces a linear algebra instruction with its mathematical definition.

2020-06-10

spirv-fuzz: Add support for OpSpecConstant* (#3373) Fixes #3371.

2020-05-29

spirv-fuzz: Add push id through variable transformation (#3359) Makes an id synonym by storing an id to a new variable and then loading it back from that variable. Fixes #3192.

2020-05-14

Add adjust branch weights transformation (#3336) In this PR, the classes that represent the adjust branch weights transformation and fuzzer pass were implemented. This transformation adjusts the branch weights of a OpBranchConditional instruction.

2020-04-20

spirv-fuzz: Make handling of synonym facts more efficient (#3301) The fact manager maintains an equivalence relation on data descriptors that tracks when one data descriptor could be used in place of another. An algorithm to compute the closure of such facts allows deducing new synonym facts from existing facts. E.g., for two 2D vectors u and v it is known that u.x is synonymous with v.x and u.y is synonymous with v.y, it can be deduced that u and v are synonymous. The closure computation algorithm is very expensive if we get large equivalence relations. This change addresses this in three ways: - The size of equivalence relations is reduced by limiting the extent to which the components of a composite are recursively noted as being equivalent, so that when we have large synonymous arrays we do not record all array elements as being pairwise equivalent. - When computing the closure of facts, equivalence classes above a certain size are simply skipped (which can lead to missed facts) - The closure computation is performed less frequently - it is invoked explicitly before fuzzer passes that will benefit from data synonym facts. A new transformation is used to control its invocation, so that fuzzing and replaying do not get out of sync. The change also tidies up the order in which some getters are declared in FuzzerContext.

2020-04-06

spirv-fuzz: Improve support for compute shaders in donation (#3277) (1) Runtime arrays are turned into fixed-size arrays, by turning OpTypeRuntimeArray into OpTypeArray and uses of OpArrayLength into uses of the constant used for the length of the fixed-size array. (2) Atomic instructions are not donated, and uses of their results are replaced with uses of constants of the result type.

2020-04-02

spirv-fuzz: Transformation to add OpConstantNull (#3273) Adds a transformation for adding OpConstantNull to a module, for appropriate data types.

2020-03-08

spirv-fuzz: Add toggle access chain instruction transformation (#3211) In this PR, the classes that represent the toggle access chain instruction transformation and fuzzer pass were implemented. This transformation toggles the instructions OpAccessChain and OpInBoundsAccessChain between them. Fixes #3193.

spirv-fuzz: Add fuzzer pass to permute function parameters (#3212) Fixes #3194.

2020-03-05

spirv-fuzz: Add swap commutable operands transformation (#3205) In this PR, the classes that represent the swap commutable operands transformation and the fuzzer pass were implemented. Fixes #3205.

2020-03-04

spirv-fuzz: Fuzzer pass to add equation instructions (#3202) This introduces a new fuzzer pass to add instructions to the module that define equations, and support in the fact manager for recording equation facts and deducing synonym facts from equation facts. Initially the only equations that are supported involve OpIAdd, OpISub, OpSNegate and OpLogicalNot, but there is scope for adding support for equations over various other operators.

2020-02-11

spirv-fuzz: Fuzzer pass that adds access chains (#3182) This change adds a fuzzer pass that sprinkles access chain instructions into a module at random. This allows other passes to have a richer set of pointers available to them, in particular the passes that add loads and stores.

2020-02-10

spirv-fuzz: Fuzzer pass to add function calls (#3178) Adds a fuzzer pass that inserts function calls into the module at random. Calls from dead blocks can be arbitrary (so long as they do not introduce recursion), while calls from other blocks can only be to livesafe functions. The change fixes some oversights in transformations to replace constants with uniforms and to obfuscate constants which testing of this fuzzer pass identified.

spirv-fuzz: Ensure that donated variables are always initialized (#3181) This change ensures that global and local variables donated from other modules are always initialized at their declaration in the module being transformed. This is to help limit issues related to undefined behaviour that might arise due to accessing uninitialized memory. The change also introduces some helper functions in fuzzer_util to make it easier to find the pointee types of pointer types.

2020-02-06

spirv-fuzz: Add fuzzer passes to add loads/stores (#3176) This change adds fuzzer passes that sprinkle loads and stores into a module at random, with stores restricted to occur in either dead blocks, or to use pointers for which it is known that the pointee value does not influence the module's overall behaviour. The change also generalises the VariableValueIsArbitrary fact to PointeeValueIsIrrelevant, to allow stores through access chains or object copies of variables whose values are known to be irrelevant. The change includes some other minor refactorings.

2020-02-05

spirv-fuzz: Fuzzer passes to add local and global variables (#3175) Adds two new fuzzer passes to add variables to a module: one that adds Private storage class global variables, another that adds Function storage class local variables.

2020-01-30

spirv-fuzz: Arbitrary variable facts (#3165) This change adds a new kind of fact to the fact manager, which records when a variable (or pointer parameter) refers to an arbitrary value, so that anything can be stored to it, without affecting the observable behaviour of the module, and nothing can be guaranteed about values loaded from it. Donated modules are the current source of such variables, and other transformations, such as outlining, have been adapted to propagate these facts appropriately.

2020-01-29

spirv-fuzz: Make functions "livesafe" during donation (#3146) This change allows the generator to (optionally and at random) make the functions of a module "livesafe" during donation. This involves introducing a loop limiter variable to each function and gating the number of total loop iterations for the function using that variable. It also involves eliminating OpKill and OpUnreachable instructions (changing them to OpReturn/OpReturnValue), and clamping access chain indices so that they are always in-bounds.

2020-01-13

spirv-fuzz: add dead blocks (#3135) This adds a new kind of fact to the fact manager that knows whether a block is dead - i.e. guaranteed to be statically unreachable - and a new transformation for adding a selection construct to a CFG that conditionally branches to a fresh, dead block, such that the branch will never be dynamically taken. Transformations that may create new blocks ('split block' and 'outline function') are updated to propagate dead block facts to newly-created blocks where appropriate. A fuzzer pass randomly adds dead blocks to the module. Future transformations will be able to exploit the fact that such blocks are known to be dead.

2019-12-19

spirv-fuzz: Transformation to add a new function to a module (#3114) This adds a large transformation that can add a new function to a SPIR-V module. This paves the way for donation of code from one module to another.

2019-12-16

spirv-fuzz: Transformations to add types, constants and variables (#3101) This change adds several transformations that allow types, constants, undefined values and global variables to be added to a module.

2019-12-12

spirv-fuzz: Fuzzer pass to merge blocks (#3097) This change adds a transformation and associated fuzzer pass for merging adjacent blocks in a module, re-using block merging code from the optimizer.

2019-12-10

spirv-fuzz: function outlining fuzzer pass (#3078) A new transformation and associated fuzzer pass in spirv-fuzz that selects single-entry single-exit control flow graph regions and for each selected region outlines the region into a new function and replaces the original region with a call to this function.

2019-11-07

spirv-fuzz: simplify transformation for replacing an id with a synonym (#3020) Prior to this change, TransformationReplaceIdWithSynonym was designed to be able to replace an id with some synonymous data descriptor, possibly necessitating extracting from a composite into a fresh id in order to get at the synonymous data. This change simplifies things so that TransformationReplaceIdWithSynonym just allows one id to be replaced by another id. It is the responsibility of the associated fuzzer pass - FuzzerPassApplyIdSynonyms - to perform the extraction operations, using e.g. TransformationCompositeExtract.

2019-11-06

spirv-fuzz: vector shuffle transformation (#3015) Inroduces a new transformation that adds a vector shuffle instruction to the module, with associated facts about how the result vector of the shuffle relates to the input vectors. A fuzzer pass to add such transformations is not yet in place.

2019-11-01

spirv-fuzz: improvements to representation of data synonym facts (#3006) This change fixes a bug in EquivalenceRelation, changes the interface of EquivalenceRelation to avoid exposing (potentially nondeterministic) unordered sets, and changes the interface of FactManager to allow querying data synonyms directly. These interface changes have required a lot of corresponding changes to client code and tests.

2019-10-28

spirv-fuzz: Transformation to extract from a composite object (#2991) At present, TransformationReplaceIdWithSynonym both extracts elements from composite objects and replaces uses of ids with synonyms. This new TransformationCompositeExtract class will allow that transformation to be broken into smaller transformations.

2019-10-27

spirv-fuzz: rename class, and fix bug related to dominance (#2990) Class TransformationConstructComposite has been renamed to TransformationCompositeConstruct, to correspond to the name of the SPIR-V instruction (as is done with e.g. TransformationCopyObject). Running tests revealed an issue related to checking dominance in TransformationReplaceIdWithSynonym, which is also fixed here.

2019-10-25

spirv-fuzz: Rework management of data synonyms (#2989) This change uses the recently-added equivalence relation class to re-work the way synonyms between data values are managed by the fact manager. The tests for 'transformation_replace_id_with_synonym' have been temporarily removed. This is because those tests are going to be split into a number of test classes in an upcoming PR, once some other refactorings have been applied, and it would be burdensome to temporarily refactor all the tests to be in a working state for this intermediate change.

2019-10-22

spirv-fuzz: fuzzer pass to adjust memory access operands (#2968) A new pass that gives spirv-fuzz the ability to adjust the memory operand masks associated with memory access instructions (such as OpLoad and OpCopy Memory). Fixes #2940.

2019-10-15

spirv-fuzz: Refactor 'copy object' and 'construct composite' transformations (#2966) Rework these transformations to identify instructions via (base, opcode, skip-count) triples, rather than (base, offset) pairs.

2019-10-14

spirv-fuzz: Refactor 'split blocks' to identify instructions differently (#2961) This change refactors the 'split blocks' transformation so that an instruction is identified via a base, opcode, and number of those opcodes to be skipped when searching from the base, as opposed to the previous design which used a base and offset.

2019-10-11

spirv-fuzz: Rework id descriptors (#2959) A refactoring that separates the identification of an instruction from the identification of a use in an instruction, to enable the former to be used independently of the latter.

spirv-fuzz: Add fuzzer pass to add NoContraction decorations (#2950) A new pass that allows the fuzzer to add NoContraction decorations to arithmetic instructions. Fixes #2936.

spirv-fuzz: Add fuzzer pass to change function controls (#2951) A new pass that allows the fuzzer to change the 'function control' operand of OpFunction instructions. Fixes #2939.