AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-12-12 03:30:09 +00:00
Code Issues Packages Projects Releases Wiki Activity
b96c9a057e
SPIRV-Tools/source/opt/optimizer.cpp

950 lines
36 KiB
C++
Raw Normal View History

Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
// Copyright (c) 2016 Google Inc.
//
// 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.
Publish the C++ interface.
2016-09-16 20:12:04 +00:00
#include "spirv-tools/optimizer.hpp"
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
spvtools::Optimizer - don't assume original_binary and optimized_binary are aliased (#2799) If they are not aliased, the function will always print the message: "Binary unexpectedly changed despite optimizer saying there was no change" Which is (usually) totally bogus. Fixes #2798
2019-08-29 14:04:55 +00:00
#include <cassert>
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include "source/opt/build_module.h"
Add pass to inject code for robust-buffer-access semantics (#2771) spirv-opt: Add --graphics-robust-access Clamps access chain indices so they are always in bounds. Assumes: - Logical addressing mode - No runtime-array-descriptor-indexing - No variable pointers Adds stub code for clamping coordinate and samples for OpImageTexelPointer. Adds SinglePassRunAndFail optimizer test fixture. Android.mk: add source/opt/graphics_robust_access_pass.cpp Adds Constant::GetSignExtendedValue, Constant::GetZeroExtendedValue
2019-07-30 23:52:46 +00:00
#include "source/opt/graphics_robust_access_pass.h"
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include "source/opt/log.h"
#include "source/opt/pass_manager.h"
#include "source/opt/passes.h"
Fix header include syntax. (#2882)
2019-09-19 14:26:24 +00:00
#include "source/spirv_optimizer_options.h"
Move make_unique to source/util. (#1836) This MakeUnique code is used in places other then source/opt so move it to source/utils.
2018-08-14 16:44:54 +00:00
#include "source/util/make_unique.h"
Add option for the max id bound. (#1870) * Create a new entry point for the optimizer Creates a new struct to hold the options for the optimizer, and creates an entry point that take the optimizer options as a parameter. The old entry point that takes validator options are now deprecated. The validator options will be one of the optimizer options. Part of the optimizer options will also be the upper bound on the id bound. * Add a command line option to set the max value for the id bound. The default is 0x3FFFFF. * Modify `TakeNextIdBound` to return 0 when the limit is reached.
2018-09-10 15:49:41 +00:00
#include "source/util/string_utils.h"
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
namespace spvtools {
struct Optimizer::PassToken::Impl {
Impl(std::unique_ptr<opt::Pass> p) : pass(std::move(p)) {}
std::unique_ptr<opt::Pass> pass; // Internal implementation pass.
};
Optimizer::PassToken::PassToken(
std::unique_ptr<Optimizer::PassToken::Impl> impl)
: impl_(std::move(impl)) {}
Add external interface for creating a pass token Currently it's impossible for external code to register a pass because the only source file that can create pass tokens is optimizer.cpp. This makes it hard to add passes that can't be upstreamed since you can't run them from the usual pass sequence without reimplementing Optimizer. This change adds a PassToken constructor that takes unique_ptr to opt::Pass; if out-of-tree code implements opt::Pass it can register a custom pass without having to add it to SPIRV-Tools source code.
2018-05-22 21:31:26 +00:00
Optimizer::PassToken::PassToken(std::unique_ptr<opt::Pass>&& pass)
: impl_(MakeUnique<Optimizer::PassToken::Impl>(std::move(pass))) {}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer::PassToken::PassToken(PassToken&& that)
: impl_(std::move(that.impl_)) {}
Optimizer::PassToken& Optimizer::PassToken::operator=(PassToken&& that) {
impl_ = std::move(that.impl_);
return *this;
}
Optimizer::PassToken::~PassToken() {}
struct Optimizer::Impl {
explicit Impl(spv_target_env env) : target_env(env), pass_manager() {}
Expand bindless bounds checking to runtime-sized descriptor arrays (#2316)
2019-02-07 19:00:36 +00:00
spv_target_env target_env; // Target environment.
opt::PassManager pass_manager; // Internal implementation pass manager.
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
};
Optimizer::Optimizer(spv_target_env env) : impl_(new Impl(env)) {}
Optimizer::~Optimizer() {}
void Optimizer::SetMessageConsumer(MessageConsumer c) {
// All passes' message consumer needs to be updated.
for (uint32_t i = 0; i < impl_->pass_manager.NumPasses(); ++i) {
impl_->pass_manager.GetPass(i)->SetMessageConsumer(c);
}
impl_->pass_manager.SetMessageConsumer(std::move(c));
}
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
const MessageConsumer& Optimizer::consumer() const {
return impl_->pass_manager.consumer();
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer& Optimizer::RegisterPass(PassToken&& p) {
// Change to use the pass manager's consumer.
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
p.impl_->pass->SetMessageConsumer(consumer());
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
impl_->pass_manager.AddPass(std::move(p.impl_->pass));
return *this;
}
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// The legalization passes take a spir-v shader generated by an HLSL front-end
// and turn it into a valid vulkan spir-v shader. There are two ways in which
// the code will be invalid at the start:
//
// 1) There will be opaque objects, like images, which will be passed around
// in intermediate objects. Valid spir-v will have to replace the use of
// the opaque object with an intermediate object that is the result of the
// load of the global opaque object.
//
// 2) There will be variables that contain pointers to structured or uniform
// buffers. It be legal, the variables must be eliminated, and the
// references to the structured buffers must use the result of OpVariable
// in the Uniform storage class.
//
// Optimization in this list must accept shaders with these relaxation of the
// rules. There is not guarantee that this list of optimizations is able to
// legalize all inputs, but it is on a best effort basis.
//
// The legalization problem is essentially a very general copy propagation
// problem. The optimization we use are all used to either do copy propagation
// or enable more copy propagation.
Add RegisterLegalizationPasses() into the interface Add note to mention the use scenario. The original list came from Glslang.
2017-11-17 21:50:43 +00:00
Optimizer& Optimizer::RegisterLegalizationPasses() {
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
return
Replace OpKill With function call. (#2790) We are no able to inline OpKill instructions into a continue construct. See #2433. However, we have to be able to inline to correctly do legalization. This commit creates a pass that will wrap OpKill instructions into a function of its own. That way we are able to inline the rest of the code. The follow up to this will be to not inline any function that contains an OpKill. Fixes #2726
2019-08-14 13:27:12 +00:00
// Wrap OpKill instructions so all other code can be inlined.
RegisterPass(CreateWrapOpKillPass())
// Remove unreachable block so that merge return works.
.RegisterPass(CreateDeadBranchElimPass())
Change merge return pass to handle structured cfg. We are seeing shaders that have multiple returns in a functions. These functions must get inlined for legalization purposes; however, the inliner does not know how to inline functions that have multiple returns. The solution we will go with it to improve the merge return pass to handle structured control flow. Note that the merge return pass will assume the cfg has been cleanedup by dead branch elimination. Fixes #857.
2018-03-06 16:20:28 +00:00
// Merge the returns so we can inline.
.RegisterPass(CreateMergeReturnPass())
// Make sure uses and definitions are in the same function.
.RegisterPass(CreateInlineExhaustivePass())
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// Make private variable function scope
.RegisterPass(CreateEliminateDeadFunctionsPass())
.RegisterPass(CreatePrivateToLocalPass())
Add fix storage class code. (#2434) This pass tries to fix validation error due to a mismatch of storage classes in instructions. There is no guarantee that all such error will be fixed, and it is possible that in fixing these errors, it could lead to other errors. Fixes #2430.
2019-04-05 17:12:08 +00:00
// Fix up the storage classes that DXC may have purposely generated
// incorrectly. All functions are inlined, and a lot of dead code has
// been removed.
.RegisterPass(CreateFixStorageClassPass())
Clean up variables before sroa In some shaders there are a lot of very large and deeply nested structures. This creates a lot of work for scalar replacement. Also, since commit ca4457b we have been very aggressive as rewriting variables. This has causes a large increase in compile time in creating and then deleting the instructions. To help low the costs, I want to run a cleanup of some of the easy loads and stores to remove. This reduces the number of symbols sroa has to work on. It also reduces the amount of code the simplifier has to simplify because it was not generated by sroa. To confirm the improvement, I ran numbers on three different sets of shaders: Time to run --legalize-hlsl: Set #1: 55.89s -> 12.0s Set #2: 1m44s -> 1m40.5s Set #3: 6.8s -> 5.7s Time to run -O Set #1: 18.8s -> 10.9s Set #2: 5m44s -> 4m17s Set #3: 7.8s -> 7.8s Contributes to #1328.
2018-02-22 17:23:21 +00:00
// Propagate the value stored to the loads in very simple cases.
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add testing framework for tools. This forks the testing harness from https://github.com/google/shaderc to allow testing CLI tools. New features needed for SPIRV-Tools include: 1- A new PlaceHolder subclass for spirv shaders. This place holder calls spirv-as to convert assembly input into SPIRV bytecode. This is required for most tools in SPIRV-Tools. 2- A minimal testing file for testing basic functionality of spirv-opt. Add tests for all flags in spirv-opt. 1. Adds tests to check that known flags match the names that each pass advertises. 2. Adds tests to check that -O, -Os and --legalize-hlsl schedule the expected passes. 3. Adds more functionality to Expect classes to support regular expression matching on stderr. 4. Add checks for integer arguments to optimization flags. 5. Fixes #1817 by modifying the parsing of integer arguments in flags that take them. 6. Fixes -Oconfig file parsing (#1778). It reads every line of the file into a string and then parses that string by tokenizing every group of characters between whitespaces (using the standard cin reading operator). This mimics shell command-line parsing, but it does not support quoting (and I'm not planning to).
2018-08-03 22:08:46 +00:00
// Split up aggregates so they are easier to deal with.
Remove the limit on struct size in SROA. Removes the limit on scalar replacement for the lagalization passes. This is done by adding an option to the pass (and command line option) to set the limit on maximum size of the composite that scalar replacement is willing to divide. Fixes #1494.
2018-04-16 13:58:00 +00:00
.RegisterPass(CreateScalarReplacementPass(0))
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// Remove loads and stores so everything is in intermediate values.
// Takes care of copy propagation of non-members.
Update legalization passes I've a few passes the legalization passes. The first is to add the more specialized load-store removal passes to help improve the compile time, as was suggested in #1118. I've also added dead branch elimination while we wait for the behaviour of dead branch elimination to be folded into CFG cleanup. I did not add CCP because it seems like most of the constant propagation what is needed is already being done by the load-store removal passes, which call `ReplaceAllUsesWith`. We can reconsider this if needed.
2018-01-03 19:03:07 +00:00
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
.RegisterPass(CreateLocalMultiStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Make better use of simplification pass The simplification pass works better after all of the dead branches are removed. So swapping them around in the legalization passes. Also adding the simplification pass to performance passes right after dead branch elimination. Added CCP to the legalization passes so we can propagate the constants into the branchs, and remove as many branches a possible. CCP is designed to still get opportunities even if the branches are dead, so it is a good place for it. Fixes #1118
2018-02-15 17:14:39 +00:00
// Propagate constants to get as many constant conditions on branches
// as possible.
.RegisterPass(CreateCCPPass())
Add unrolling to the legalization passes (#1903) Adds unrolling to the legalization passes. After enabling unrolling I found a bug when there is a self-referencing phi node. That has been fixed. The test that checks for that the order of optimizations is correct also needed to be updated.
2018-09-19 20:40:09 +00:00
.RegisterPass(CreateLoopUnrollPass(true))
Make better use of simplification pass The simplification pass works better after all of the dead branches are removed. So swapping them around in the legalization passes. Also adding the simplification pass to performance passes right after dead branch elimination. Added CCP to the legalization passes so we can propagate the constants into the branchs, and remove as many branches a possible. CCP is designed to still get opportunities even if the branches are dead, so it is a good place for it. Fixes #1118
2018-02-15 17:14:39 +00:00
.RegisterPass(CreateDeadBranchElimPass())
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// Copy propagate members. Cleans up code sequences generated by
Make better use of simplification pass The simplification pass works better after all of the dead branches are removed. So swapping them around in the legalization passes. Also adding the simplification pass to performance passes right after dead branch elimination. Added CCP to the legalization passes so we can propagate the constants into the branchs, and remove as many branches a possible. CCP is designed to still get opportunities even if the branches are dead, so it is a good place for it. Fixes #1118
2018-02-15 17:14:39 +00:00
// scalar replacement. Also important for removing OpPhi nodes.
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
.RegisterPass(CreateSimplificationPass())
Copy propagate arrays The sprir-v generated from HLSL code contain many copyies of very large arrays. Not only are these time consumming, but they also cause problems for drivers because they require too much space. To work around this, we will implement an array copy propagation. Note that we will not implement a complete array data flow analysis in order to implement this. We will be looking for very simple cases: 1) The source must never be stored to. 2) The target must be stored to exactly once. 3) The store to the target must be a store to the entire array, and be a copy of the entire source. 4) All loads of the target must be dominated by the store. The hard part is keeping all of the types correct. We do not want to have to do too large a search to update everything, which may not be possible, do we give up if we see any instruction that might be hard to update. Also in types.h, the element decorations are not stored in an std::map. This change was done so the hashing algorithm for a Struct is consistent. With the std::unordered_map, the traversal order was non-deterministic leading to the same type getting hashed to different values. See |Struct::GetExtraHashWords|. Contributes to #1416.
2018-03-21 03:33:24 +00:00
.RegisterPass(CreateAggressiveDCEPass())
.RegisterPass(CreateCopyPropagateArraysPass())
Update the legalization passes. Changes the set of optimizations done for legalization. While doing this, I added documentation to explain why we want each optimization. A new option "--legalize-hlsl" is added so the legalization passes can be easily run from the command line. The legalize option implies skip-validation.
2017-12-19 20:08:54 +00:00
// May need loop unrolling here see
// https://github.com/Microsoft/DirectXShaderCompiler/pull/930
InsertExtractElim: Split out DeadInsertElim as separate pass
2018-01-27 00:05:33 +00:00
// Get rid of unused code that contain traces of illegal code
// or unused references to unbound external objects
Vector DCE (#1512) Introduce a pass that does a DCE type analysis for vector elements instead of the whole vector as a single element. It will then rewrite instructions that are not used with something else. For example, an instruction whose value are not used, even though it is referenced, is replaced with an OpUndef.
2018-04-23 15:13:07 +00:00
.RegisterPass(CreateVectorDCEPass())
Add Dead insert elmination back in.
2018-04-23 15:17:07 +00:00
.RegisterPass(CreateDeadInsertElimPass())
Add pass to fold a load feeding an extract. We have already disabled common uniform elimination because it created sequences of loads an entire uniform object, then we extract just a single element. This caused problems in some drivers, and is just generally slow because it loads more memory than needed. However, there are other way to get into this situation, so I've added a pass that looks specifically for this pattern and removes it when only a portion of the load is used. Fixes #1547.
2018-05-07 16:31:03 +00:00
.RegisterPass(CreateReduceLoadSizePass())
Remove redundant passes from legalization passes With work that Alan has done, some passes have become redundant. ADCE now removed unused variables. Dead branch elimination removes unreachable blocks. This means we can remove CFG Cleanup and dead variable elimination.
2018-01-12 20:15:57 +00:00
.RegisterPass(CreateAggressiveDCEPass());
Add RegisterLegalizationPasses() into the interface Add note to mention the use scenario. The original list came from Glslang.
2017-11-17 21:50:43 +00:00
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
Optimizer& Optimizer::RegisterPerformancePasses() {
Replace OpKill With function call. (#2790) We are no able to inline OpKill instructions into a continue construct. See #2433. However, we have to be able to inline to correctly do legalization. This commit creates a pass that will wrap OpKill instructions into a function of its own. That way we are able to inline the rest of the code. The follow up to this will be to not inline any function that contains an OpKill. Fixes #2726
2019-08-14 13:27:12 +00:00
return RegisterPass(CreateWrapOpKillPass())
.RegisterPass(CreateDeadBranchElimPass())
Check for unreachable blocks in merge-return. (#1966) Merge return assumes that the only unreachable blocks are those needed to keep the structured cfg valid. Even those must be essentially empty blocks. If this is not the case, we get unpredictable behaviour. This commit add a check in merge return, and emits an error if it is not the case. Added a pass of dead branch elimination before merge return in both the performance and size passes. It is a precondition of merge return. Fixes #1962.
2018-10-10 19:18:15 +00:00
.RegisterPass(CreateMergeReturnPass())
Initial implementation of merge return pass. Works with current DefUseManager infrastructure. Added merge return to the standard opts. Added validation to passes. Disabled pass for shader capabilty.
2017-11-08 21:22:10 +00:00
.RegisterPass(CreateInlineExhaustivePass())
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add private to local to optimization and size passes. Many optimization will run on function scope symbols only. When symbols are moved from private scope to function scople, then these optimizations can do more. I believe it is a good idea to run this pass with both -O and -Os. To get the most out of it it should be run ASAP after inlining and something that remove all of the dead functions.
2018-07-04 19:26:32 +00:00
.RegisterPass(CreatePrivateToLocalPass())
Clean up variables before sroa In some shaders there are a lot of very large and deeply nested structures. This creates a lot of work for scalar replacement. Also, since commit ca4457b we have been very aggressive as rewriting variables. This has causes a large increase in compile time in creating and then deleting the instructions. To help low the costs, I want to run a cleanup of some of the easy loads and stores to remove. This reduces the number of symbols sroa has to work on. It also reduces the amount of code the simplifier has to simplify because it was not generated by sroa. To confirm the improvement, I ran numbers on three different sets of shaders: Time to run --legalize-hlsl: Set #1: 55.89s -> 12.0s Set #2: 1m44s -> 1m40.5s Set #3: 6.8s -> 5.7s Time to run -O Set #1: 18.8s -> 10.9s Set #2: 5m44s -> 4m17s Set #3: 7.8s -> 7.8s Contributes to #1328.
2018-02-22 17:23:21 +00:00
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add scalar replacement Adds a scalar replacement pass. The pass considers all function scope variables of composite type. If there are accesses to individual elements (and it is legal) the pass replaces the variable with a variable for each composite element and updates all the uses. Added the pass to -O Added NumUses and NumUsers to DefUseManager Added some helper methods for the inst to block mapping in context Added some helper methods for specific constant types No longer generate duplicate pointer types. * Now searches for an existing pointer of the appropriate type instead of failing validation * Fixed spec constant extracts * Addressed changes for review * Changed RunSinglePassAndMatch to be able to run validation * current users do not enable it Added handling of acceptable decorations. * Decorations are also transfered where appropriate Refactored extension checking into FeatureManager * Context now owns a feature manager * consciously NOT an analysis * added some test * fixed some minor issues related to decorates * added some decorate related tests for scalar replacement
2017-11-30 22:03:06 +00:00
.RegisterPass(CreateScalarReplacementPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateLocalAccessChainConvertPass())
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Do not insert Phi nodes in CCP propagator. In CCP we should not need to insert Phi nodes because CCP never looks at loads/stores. This required adjusting two tests that relied on Phi instructions being inserted. I changed the tests to have the Phi instructions pre-inserted. I also added a new test to make sure that CCP does not try to look through stores and loads. Finally, given that CCP does not handle loads/stores, it's better to run mem2reg before it. I've changed the -O/-Os schedules to run local multi-store elimination before CCP. Although this is just an efficiency fix for CCP, it is also working around a bug in Phi insertion. When Phi instructions are inserted, they are never associated a basic block. This causes a segfault when the propagator tries to lookup CFG edges when analyzing Phi instructions.
2018-01-03 17:38:21 +00:00
.RegisterPass(CreateLocalMultiStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Fix constant propagation of induction variables. This fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1143. When an instruction transitions from constant to bottom (varying) in the lattice, we were telling the propagator that the instruction was varying, but never updating the actual value in the values table. This led to incorrect value substitutions at the end of propagation. The patch also re-enables CCP in -O and -Os.
2018-01-08 16:56:57 +00:00
.RegisterPass(CreateCCPPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Reordering performance passes ordering to produce better opts * Moved initial insert/extract passes later to cover more opportunities * Added an extra set of passes to clean up opportunities exposed later in the pipeline
2018-01-31 15:40:33 +00:00
.RegisterPass(CreateRedundancyEliminationPass())
Transform to combine consecutive access chains * Combines OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain and OpInBoundsPtrAccessChain * New folding rule to fold add with 0 for integers * Converts to a bitcast if the result type does not match the operand type V
2018-07-23 15:23:11 +00:00
.RegisterPass(CreateCombineAccessChainsPass())
Fold FMix feeding Extract, and use the simplification pass. We add a new rule to the folding rules to fold an FMix feeding an extract when the alpha value for the element being extracted is either 0 or 1. In those case, we can simple extract from one of the operands to the FMix. With that change the simplification pass completely subsumes the insert-extract elimination pass. So we remove the insert-extract elimination passes and replce them with calls to the simplification pass. In a follow up PR, we should delete the insert-extract elimination pass. Contributes to https://github.com/KhronosGroup/SPIRV-Tools/issues/1570.
2018-05-18 15:15:38 +00:00
.RegisterPass(CreateSimplificationPass())
Vector DCE (#1512) Introduce a pass that does a DCE type analysis for vector elements instead of the whole vector as a single element. It will then rewrite instructions that are not used with something else. For example, an instruction whose value are not used, even though it is referenced, is replaced with an OpUndef.
2018-04-23 15:13:07 +00:00
.RegisterPass(CreateVectorDCEPass())
Add Dead insert elmination back in.
2018-04-23 15:17:07 +00:00
.RegisterPass(CreateDeadInsertElimPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateDeadBranchElimPass())
Make better use of simplification pass The simplification pass works better after all of the dead branches are removed. So swapping them around in the legalization passes. Also adding the simplification pass to performance passes right after dead branch elimination. Added CCP to the legalization passes so we can propagate the constants into the branchs, and remove as many branches a possible. CCP is designed to still get opportunities even if the branches are dead, so it is a good place for it. Fixes #1118
2018-02-15 17:14:39 +00:00
.RegisterPass(CreateSimplificationPass())
Initial implementation of if conversion * Handles simple cases only * Identifies phis in blocks with two predecessors and attempts to convert the phi to an select * does not perform code motion currently so the converted values must dominate the join point (e.g. can't be defined in the branches) * limited for now to two predecessors, but can be extended to handle more cases * Adding if conversion to -O and -Os
2018-01-16 16:15:06 +00:00
.RegisterPass(CreateIfConversionPass())
In copy-prop-arrays, indentify copies via OpCompositeInsert When the original code copies an entire array or struct one element at a time, this turns into a series of OpCompositeInsert instruction followed by a store of the whole array. We currently miss opportunities in copy propagate arrays because we do not recognize this as a copy. This commit adds code to copy propagate arrays to identify this code pattern. Also updates the performance passed to run array copy propagation.
2018-03-28 16:27:19 +00:00
.RegisterPass(CreateCopyPropagateArraysPass())
Add pass to fold a load feeding an extract. We have already disabled common uniform elimination because it created sequences of loads an entire uniform object, then we extract just a single element. This caused problems in some drivers, and is just generally slow because it loads more memory than needed. However, there are other way to get into this situation, so I've added a pass that looks specifically for this pattern and removes it when only a portion of the load is used. Fixes #1547.
2018-05-07 16:31:03 +00:00
.RegisterPass(CreateReduceLoadSizePass())
Initial implementation of if conversion * Handles simple cases only * Identifies phis in blocks with two predecessors and attempts to convert the phi to an select * does not perform code motion currently so the converted values must dominate the join point (e.g. can't be defined in the branches) * limited for now to two predecessors, but can be extended to handle more cases * Adding if conversion to -O and -Os
2018-01-16 16:15:06 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateBlockMergePass())
Add global redundancy elimination Adds a pass that looks for redundant instruction in a function, and removes them. The algorithm is a hash table based value numbering algorithm that traverses the dominator tree. This pass removes completely redundant instructions, not partially redundant ones.
2017-12-04 17:29:51 +00:00
.RegisterPass(CreateRedundancyEliminationPass())
Reordering performance passes ordering to produce better opts * Moved initial insert/extract passes later to cover more opportunities * Added an extra set of passes to clean up opportunities exposed later in the pipeline
2018-01-31 15:40:33 +00:00
.RegisterPass(CreateDeadBranchElimPass())
.RegisterPass(CreateBlockMergePass())
Remove code sinking for -O. (#2340) Community feedback says it is not generaly benificial, so we will remove it from the standard optimization set.
2019-01-28 16:50:50 +00:00
.RegisterPass(CreateSimplificationPass());
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
}
Optimizer& Optimizer::RegisterSizePasses() {
Replace OpKill With function call. (#2790) We are no able to inline OpKill instructions into a continue construct. See #2433. However, we have to be able to inline to correctly do legalization. This commit creates a pass that will wrap OpKill instructions into a function of its own. That way we are able to inline the rest of the code. The follow up to this will be to not inline any function that contains an OpKill. Fixes #2726
2019-08-14 13:27:12 +00:00
return RegisterPass(CreateWrapOpKillPass())
.RegisterPass(CreateDeadBranchElimPass())
Check for unreachable blocks in merge-return. (#1966) Merge return assumes that the only unreachable blocks are those needed to keep the structured cfg valid. Even those must be essentially empty blocks. If this is not the case, we get unpredictable behaviour. This commit add a check in merge return, and emits an error if it is not the case. Added a pass of dead branch elimination before merge return in both the performance and size passes. It is a precondition of merge return. Fixes #1962.
2018-10-10 19:18:15 +00:00
.RegisterPass(CreateMergeReturnPass())
Initial implementation of merge return pass. Works with current DefUseManager infrastructure. Added merge return to the standard opts. Added validation to passes. Disabled pass for shader capabilty.
2017-11-08 21:22:10 +00:00
.RegisterPass(CreateInlineExhaustivePass())
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add private to local to optimization and size passes. Many optimization will run on function scope symbols only. When symbols are moved from private scope to function scople, then these optimizations can do more. I believe it is a good idea to run this pass with both -O and -Os. To get the most out of it it should be run ASAP after inlining and something that remove all of the dead functions.
2018-07-04 19:26:32 +00:00
.RegisterPass(CreatePrivateToLocalPass())
Opt: Add ScalarReplacement to RegisterSizePasses
2018-01-31 01:13:30 +00:00
.RegisterPass(CreateScalarReplacementPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateLocalAccessChainConvertPass())
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Fold FMix feeding Extract, and use the simplification pass. We add a new rule to the folding rules to fold an FMix feeding an extract when the alpha value for the element being extracted is either 0 or 1. In those case, we can simple extract from one of the operands to the FMix. With that change the simplification pass completely subsumes the insert-extract elimination pass. So we remove the insert-extract elimination passes and replce them with calls to the simplification pass. In a follow up PR, we should delete the insert-extract elimination pass. Contributes to https://github.com/KhronosGroup/SPIRV-Tools/issues/1570.
2018-05-18 15:15:38 +00:00
.RegisterPass(CreateSimplificationPass())
InsertExtractElim: Split out DeadInsertElim as separate pass
2018-01-27 00:05:33 +00:00
.RegisterPass(CreateDeadInsertElimPass())
Do not insert Phi nodes in CCP propagator. In CCP we should not need to insert Phi nodes because CCP never looks at loads/stores. This required adjusting two tests that relied on Phi instructions being inserted. I changed the tests to have the Phi instructions pre-inserted. I also added a new test to make sure that CCP does not try to look through stores and loads. Finally, given that CCP does not handle loads/stores, it's better to run mem2reg before it. I've changed the -O/-Os schedules to run local multi-store elimination before CCP. Although this is just an efficiency fix for CCP, it is also working around a bug in Phi insertion. When Phi instructions are inserted, they are never associated a basic block. This causes a segfault when the propagator tries to lookup CFG edges when analyzing Phi instructions.
2018-01-03 17:38:21 +00:00
.RegisterPass(CreateLocalMultiStoreElimPass())
Remove uses DCEInst and call ADCE The algorithm used in DCEInst to remove dead code is very slow. It is fine if you only want to remove a small number of instructions, but, if you need to remove a large number of instructions, then the algorithm in ADCE is much faster. This PR removes the calls to DCEInst in the load-store removal passes and adds a pass of ADCE afterwards. A number of different iterations of the order of optimization, and I believe this is the best I could find. The results I have on 3 sets of shaders are: Legalization: Set 1: 5.39 -> 5.01 Set 2: 13.98 -> 8.38 Set 3: 98.00 -> 96.26 Performance passes: Set 1: 6.90 -> 5.23 Set 2: 10.11 -> 6.62 Set 3: 253.69 -> 253.74 Size reduction passes: Set 1: 7.16 -> 7.25 Set 2: 17.17 -> 16.81 Set 3: 112.06 -> 107.71 Note that the third set's compile time is large because of the large number of basic blocks, not so much because of the number of instructions. That is why we don't see much gain there.
2018-02-22 21:05:37 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Fix constant propagation of induction variables. This fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1143. When an instruction transitions from constant to bottom (varying) in the lattice, we were telling the propagator that the instruction was varying, but never updating the actual value in the values table. This led to incorrect value substitutions at the end of propagation. The patch also re-enables CCP in -O and -Os.
2018-01-08 16:56:57 +00:00
.RegisterPass(CreateCCPPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateAggressiveDCEPass())
.RegisterPass(CreateDeadBranchElimPass())
Initial implementation of if conversion * Handles simple cases only * Identifies phis in blocks with two predecessors and attempts to convert the phi to an select * does not perform code motion currently so the converted values must dominate the join point (e.g. can't be defined in the branches) * limited for now to two predecessors, but can be extended to handle more cases * Adding if conversion to -O and -Os
2018-01-16 16:15:06 +00:00
.RegisterPass(CreateIfConversionPass())
.RegisterPass(CreateAggressiveDCEPass())
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
.RegisterPass(CreateBlockMergePass())
Fold FMix feeding Extract, and use the simplification pass. We add a new rule to the folding rules to fold an FMix feeding an extract when the alpha value for the element being extracted is either 0 or 1. In those case, we can simple extract from one of the operands to the FMix. With that change the simplification pass completely subsumes the insert-extract elimination pass. So we remove the insert-extract elimination passes and replce them with calls to the simplification pass. In a follow up PR, we should delete the insert-extract elimination pass. Contributes to https://github.com/KhronosGroup/SPIRV-Tools/issues/1570.
2018-05-18 15:15:38 +00:00
.RegisterPass(CreateSimplificationPass())
InsertExtractElim: Split out DeadInsertElim as separate pass
2018-01-27 00:05:33 +00:00
.RegisterPass(CreateDeadInsertElimPass())
Add global redundancy elimination Adds a pass that looks for redundant instruction in a function, and removes them. The algorithm is a hash table based value numbering algorithm that traverses the dominator tree. This pass removes completely redundant instructions, not partially redundant ones.
2017-12-04 17:29:51 +00:00
.RegisterPass(CreateRedundancyEliminationPass())
Implement SSA CCP (SSA Conditional Constant Propagation). This implements the conditional constant propagation pass proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The main logic resides in CCPPass::VisitInstruction. Instruction that may produce a constant value are evaluated with the constant folder. If they produce a new constant, the instruction is considered interesting. Otherwise, it's considered varying (for unfoldable instructions) or just not interesting (when not enough operands have a constant value). The other main piece of logic is in CCPPass::VisitBranch. This evaluates the selector of the branch. When it's found to be a known value, it computes the destination basic block and sets it. This tells the propagator which branches to follow. The patch required extensions to the constant manager as well. Instead of hashing the Constant pointers, this patch changes the constant pool to hash the contents of the Constant. This allows the lookups to be done using the actual values of the Constant, preventing duplicate definitions.
2017-12-05 16:39:25 +00:00
.RegisterPass(CreateCFGCleanupPass())
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
.RegisterPass(CreateAggressiveDCEPass());
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
}
Add WebGPU->Vulkan and Vulkan->WebGPU flags in spirv-opt (#2496) Renames the existing flag '--webgpu-mode' to '--vulkan-to-webgpu' for the Vulkan->WebGPU operation, and adds a new flag '--webgpu-to-vulkan' for the WebGPU->Vulkan operation. Currently '--webgpu-to-vulkan' doesn't have any passes associated with it yet, but further patches will implement them. Fixes #2495
2019-04-05 19:12:26 +00:00
Optimizer& Optimizer::RegisterVulkanToWebGPUPasses() {
Add strip-debug to webgpu-mode passes (#2368) Fixes #2366
2019-02-08 19:26:17 +00:00
return RegisterPass(CreateStripDebugInfoPass())
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
.RegisterPass(CreateStripAtomicCounterMemoryPass())
Add pass to generate needed initializers for WebGPU (#2481) Fixes #2387
2019-04-03 15:44:09 +00:00
.RegisterPass(CreateGenerateWebGPUInitializersPass())
Add pass to legalize OpVectorShuffle for WebGPU (#2509) In WebGPU, the component operand 0xFFFFFFFF is forbidden, but in Vulkan it is used to indicate a value is undefined. When converting to WebGPU, 0xFFFFFFFF needs to converted to a legal value, though the specific one does not matter, since it was used to indicate an undefined entry in the original code. Choosing to use 0, since the operands are required to be on [0, N-1], so 0 is guaranteed to always be valid. Fixes #2349
2019-04-12 16:14:23 +00:00
.RegisterPass(CreateLegalizeVectorShufflePass())
Add pass to fix some invalid unreachable blocks for WebGPU (#2563) Attempts to split up unreachable blocks that are used both as a merge-block and a continue-target. Fixes #2429
2019-05-09 16:56:10 +00:00
.RegisterPass(CreateSplitInvalidUnreachablePass())
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
.RegisterPass(CreateEliminateDeadConstantPass())
Add strip-debug to webgpu-mode passes (#2368) Fixes #2366
2019-02-08 19:26:17 +00:00
.RegisterPass(CreateFlattenDecorationPass())
Add flatten-decorations flag to webgpu-mode flags (#2348) Fixes #2272
2019-02-05 19:07:53 +00:00
.RegisterPass(CreateAggressiveDCEPass())
Add compact ids to WebGPU <-> Vulkan transformations (#2639) Fixes #2634
2019-05-29 19:58:37 +00:00
.RegisterPass(CreateDeadBranchElimPass())
.RegisterPass(CreateCompactIdsPass());
Implement initial --webgpu-mode flag (#2217) Fixes #2166
2018-12-18 20:10:34 +00:00
}
Implement WebGPU->Vulkan initializer conversion for 'Function' variables (#2513) WebGPU requires certain variables to be initialized, whereas there are known issues with using initializers in Vulkan. This PR is the first of three implementing a pass to decompose initialized variables into a variable declaration followed by a store. This has been broken up into multiple PRs, because there 3 distinct cases that need to be handled, which require separate implementations. This first PR implements the basic infrastructure that is needed, and handling of Function storage class variables. Private and Output will be handled in future PRs. This is part of resolving #2388
2019-04-16 18:31:36 +00:00
Optimizer& Optimizer::RegisterWebGPUToVulkanPasses() {
Add compact ids to WebGPU <-> Vulkan transformations (#2639) Fixes #2634
2019-05-29 19:58:37 +00:00
return RegisterPass(CreateDecomposeInitializedVariablesPass())
.RegisterPass(CreateCompactIdsPass());
Implement WebGPU->Vulkan initializer conversion for 'Function' variables (#2513) WebGPU requires certain variables to be initialized, whereas there are known issues with using initializers in Vulkan. This PR is the first of three implementing a pass to decompose initialized variables into a variable declaration followed by a store. This has been broken up into multiple PRs, because there 3 distinct cases that need to be handled, which require separate implementations. This first PR implements the basic infrastructure that is needed, and handling of Function storage class variables. Private and Output will be handled in future PRs. This is part of resolving #2388
2019-04-16 18:31:36 +00:00
}
Add WebGPU->Vulkan and Vulkan->WebGPU flags in spirv-opt (#2496) Renames the existing flag '--webgpu-mode' to '--vulkan-to-webgpu' for the Vulkan->WebGPU operation, and adds a new flag '--webgpu-to-vulkan' for the WebGPU->Vulkan operation. Currently '--webgpu-to-vulkan' doesn't have any passes associated with it yet, but further patches will implement them. Fixes #2495
2019-04-05 19:12:26 +00:00
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
bool Optimizer::RegisterPassesFromFlags(const std::vector<std::string>& flags) {
for (const auto& flag : flags) {
if (!RegisterPassFromFlag(flag)) {
return false;
}
}
return true;
}
bool Optimizer::FlagHasValidForm(const std::string& flag) const {
if (flag == "-O" || flag == "-Os") {
return true;
} else if (flag.size() > 2 && flag.substr(0, 2) == "--") {
return true;
}
Errorf(consumer(), nullptr, {},
"%s is not a valid flag. Flag passes should have the form "
"'--pass_name[=pass_args]'. Special flag names also accepted: -O "
"and -Os.",
flag.c_str());
return false;
}
bool Optimizer::RegisterPassFromFlag(const std::string& flag) {
if (!FlagHasValidForm(flag)) {
return false;
}
// Split flags of the form --pass_name=pass_args.
Add option for the max id bound. (#1870) * Create a new entry point for the optimizer Creates a new struct to hold the options for the optimizer, and creates an entry point that take the optimizer options as a parameter. The old entry point that takes validator options are now deprecated. The validator options will be one of the optimizer options. Part of the optimizer options will also be the upper bound on the id bound. * Add a command line option to set the max value for the id bound. The default is 0x3FFFFF. * Modify `TakeNextIdBound` to return 0 when the limit is reached.
2018-09-10 15:49:41 +00:00
auto p = utils::SplitFlagArgs(flag);
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
std::string pass_name = p.first;
std::string pass_args = p.second;
// FIXME(dnovillo): This should be re-factored so that pass names can be
// automatically checked against Pass::name() and PassToken instances created
// via a template function. Additionally, class Pass should have a desc()
// method that describes the pass (so it can be used in --help).
//
// Both Pass::name() and Pass::desc() should be static class members so they
// can be invoked without creating a pass instance.
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
if (pass_name == "strip-atomic-counter-memory") {
RegisterPass(CreateStripAtomicCounterMemoryPass());
} else if (pass_name == "strip-debug") {
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
RegisterPass(CreateStripDebugInfoPass());
} else if (pass_name == "strip-reflect") {
RegisterPass(CreateStripReflectInfoPass());
} else if (pass_name == "set-spec-const-default-value") {
if (pass_args.size() > 0) {
auto spec_ids_vals =
opt::SetSpecConstantDefaultValuePass::ParseDefaultValuesString(
pass_args.c_str());
if (!spec_ids_vals) {
Errorf(consumer(), nullptr, {},
"Invalid argument for --set-spec-const-default-value: %s",
pass_args.c_str());
return false;
}
RegisterPass(
CreateSetSpecConstantDefaultValuePass(std::move(*spec_ids_vals)));
} else {
Errorf(consumer(), nullptr, {},
"Invalid spec constant value string '%s'. Expected a string of "
"<spec id>:<default value> pairs.",
pass_args.c_str());
return false;
}
} else if (pass_name == "if-conversion") {
RegisterPass(CreateIfConversionPass());
} else if (pass_name == "freeze-spec-const") {
RegisterPass(CreateFreezeSpecConstantValuePass());
} else if (pass_name == "inline-entry-points-exhaustive") {
RegisterPass(CreateInlineExhaustivePass());
} else if (pass_name == "inline-entry-points-opaque") {
RegisterPass(CreateInlineOpaquePass());
Transform to combine consecutive access chains * Combines OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain and OpInBoundsPtrAccessChain * New folding rule to fold add with 0 for integers * Converts to a bitcast if the result type does not match the operand type V
2018-07-23 15:23:11 +00:00
} else if (pass_name == "combine-access-chains") {
RegisterPass(CreateCombineAccessChainsPass());
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else if (pass_name == "convert-local-access-chains") {
RegisterPass(CreateLocalAccessChainConvertPass());
Add descriptor array scalar replacement (#2742) Creates a pass that will replace a descriptor array with individual variables. See #2740 for details. Fixes #2740.
2019-08-08 14:53:19 +00:00
} else if (pass_name == "descriptor-scalar-replacement") {
RegisterPass(CreateDescriptorScalarReplacementPass());
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else if (pass_name == "eliminate-dead-code-aggressive") {
RegisterPass(CreateAggressiveDCEPass());
Add passes to propagate and eliminate redundant line instructions (#2027). (#2039) These are bookend passes designed to help preserve line information across passes which delete, move and clone instructions. The propagation pass attaches a debug line instruction to every instruction based on SPIR-V line propagation rules. It should be performed before optimization. The redundant line elimination pass eliminates all line instructions which match the previous line instruction. This pass should be performed at the end of optimization to reduce physical SPIR-V file size. Fixes #2027.
2018-11-15 19:06:17 +00:00
} else if (pass_name == "propagate-line-info") {
RegisterPass(CreatePropagateLineInfoPass());
} else if (pass_name == "eliminate-redundant-line-info") {
RegisterPass(CreateRedundantLineInfoElimPass());
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else if (pass_name == "eliminate-insert-extract") {
RegisterPass(CreateInsertExtractElimPass());
} else if (pass_name == "eliminate-local-single-block") {
RegisterPass(CreateLocalSingleBlockLoadStoreElimPass());
} else if (pass_name == "eliminate-local-single-store") {
RegisterPass(CreateLocalSingleStoreElimPass());
} else if (pass_name == "merge-blocks") {
RegisterPass(CreateBlockMergePass());
} else if (pass_name == "merge-return") {
RegisterPass(CreateMergeReturnPass());
} else if (pass_name == "eliminate-dead-branches") {
RegisterPass(CreateDeadBranchElimPass());
} else if (pass_name == "eliminate-dead-functions") {
RegisterPass(CreateEliminateDeadFunctionsPass());
} else if (pass_name == "eliminate-local-multi-store") {
RegisterPass(CreateLocalMultiStoreElimPass());
} else if (pass_name == "eliminate-dead-const") {
RegisterPass(CreateEliminateDeadConstantPass());
} else if (pass_name == "eliminate-dead-inserts") {
RegisterPass(CreateDeadInsertElimPass());
} else if (pass_name == "eliminate-dead-variables") {
RegisterPass(CreateDeadVariableEliminationPass());
Add pass to remove dead members. (#2379) Add a pass that looks for members of structs whose values do not affects the output of the shader. Those members are then removed and just treated like padding in the struct.
2019-02-14 18:42:35 +00:00
} else if (pass_name == "eliminate-dead-members") {
RegisterPass(CreateEliminateDeadMembersPass());
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else if (pass_name == "fold-spec-const-op-composite") {
RegisterPass(CreateFoldSpecConstantOpAndCompositePass());
} else if (pass_name == "loop-unswitch") {
RegisterPass(CreateLoopUnswitchPass());
} else if (pass_name == "scalar-replacement") {
if (pass_args.size() == 0) {
RegisterPass(CreateScalarReplacementPass());
} else {
Allow 0 as argument to scalar replacement. (#1917) A limit of 0 for the scalar replacement options it used to indicate that there is no limit. The current implementation does not allow 0. This should be fixed.
2018-09-26 13:58:28 +00:00
int limit = -1;
if (pass_args.find_first_not_of("0123456789") == std::string::npos) {
limit = atoi(pass_args.c_str());
}
if (limit >= 0) {
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
RegisterPass(CreateScalarReplacementPass(limit));
} else {
Error(consumer(), nullptr, {},
Allow 0 as argument to scalar replacement. (#1917) A limit of 0 for the scalar replacement options it used to indicate that there is no limit. The current implementation does not allow 0. This should be fixed.
2018-09-26 13:58:28 +00:00
"--scalar-replacement must have no arguments or a non-negative "
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
"integer argument");
return false;
}
}
} else if (pass_name == "strength-reduction") {
RegisterPass(CreateStrengthReductionPass());
} else if (pass_name == "unify-const") {
RegisterPass(CreateUnifyConstantPass());
} else if (pass_name == "flatten-decorations") {
RegisterPass(CreateFlattenDecorationPass());
} else if (pass_name == "compact-ids") {
RegisterPass(CreateCompactIdsPass());
} else if (pass_name == "cfg-cleanup") {
RegisterPass(CreateCFGCleanupPass());
} else if (pass_name == "local-redundancy-elimination") {
RegisterPass(CreateLocalRedundancyEliminationPass());
} else if (pass_name == "loop-invariant-code-motion") {
RegisterPass(CreateLoopInvariantCodeMotionPass());
} else if (pass_name == "reduce-load-size") {
RegisterPass(CreateReduceLoadSizePass());
} else if (pass_name == "redundancy-elimination") {
RegisterPass(CreateRedundancyEliminationPass());
} else if (pass_name == "private-to-local") {
RegisterPass(CreatePrivateToLocalPass());
} else if (pass_name == "remove-duplicates") {
RegisterPass(CreateRemoveDuplicatesPass());
} else if (pass_name == "workaround-1209") {
RegisterPass(CreateWorkaround1209Pass());
} else if (pass_name == "replace-invalid-opcode") {
RegisterPass(CreateReplaceInvalidOpcodePass());
Add base and core bindless validation instrumentation classes (#2014) * Add base and core bindless validation instrumentation classes * Fix formatting. * Few more formatting fixes * Fix build failure * More build fixes * Need to call non-const functions in order. Specifically, these are functions which call TakeNextId(). These need to be called in a specific order to guarantee that tests which do exact compares will work across all platforms. c++ pretty much does not guarantee order of evaluation of operands, so any such functions need to be called separately in individual statements to guarantee order. * More ordering. * And more ordering. * And more formatting. * Attempt to fix NDK build * Another attempt to address NDK build problem. * One more attempt at NDK build failure * Add instrument.hpp to BUILD.gn * Some name improvement in instrument.hpp * Change all types in instrument.hpp to int. * Improve documentation in instrument.hpp * Format fixes * Comment clean up in instrument.hpp * imageInst -> image_inst * Fix GetLabel() issue.
2018-11-08 18:54:54 +00:00
} else if (pass_name == "inst-bindless-check") {
Instrument: Add support for Buffer Device Address extension (#2792)
2019-08-16 13:18:34 +00:00
RegisterPass(CreateInstBindlessCheckPass(7, 23, false, false, 2));
RegisterPass(CreateSimplificationPass());
RegisterPass(CreateDeadBranchElimPass());
RegisterPass(CreateBlockMergePass());
RegisterPass(CreateAggressiveDCEPass());
} else if (pass_name == "inst-desc-idx-check") {
Instrument: Fix version 2 output record write for tess eval shaders. (#2782) Fix output record write for tess eval shaders. Also change command line for bindless instrumentation to use use output record version 2.
2019-08-09 12:22:41 +00:00
RegisterPass(CreateInstBindlessCheckPass(7, 23, true, true, 2));
Add base and core bindless validation instrumentation classes (#2014) * Add base and core bindless validation instrumentation classes * Fix formatting. * Few more formatting fixes * Fix build failure * More build fixes * Need to call non-const functions in order. Specifically, these are functions which call TakeNextId(). These need to be called in a specific order to guarantee that tests which do exact compares will work across all platforms. c++ pretty much does not guarantee order of evaluation of operands, so any such functions need to be called separately in individual statements to guarantee order. * More ordering. * And more ordering. * And more formatting. * Attempt to fix NDK build * Another attempt to address NDK build problem. * One more attempt at NDK build failure * Add instrument.hpp to BUILD.gn * Some name improvement in instrument.hpp * Change all types in instrument.hpp to int. * Improve documentation in instrument.hpp * Format fixes * Comment clean up in instrument.hpp * imageInst -> image_inst * Fix GetLabel() issue.
2018-11-08 18:54:54 +00:00
RegisterPass(CreateSimplificationPass());
RegisterPass(CreateDeadBranchElimPass());
RegisterPass(CreateBlockMergePass());
RegisterPass(CreateAggressiveDCEPass());
Instrument: Add support for Buffer Device Address extension (#2792)
2019-08-16 13:18:34 +00:00
} else if (pass_name == "inst-buff-addr-check") {
RegisterPass(CreateInstBuffAddrCheckPass(7, 23, 2));
RegisterPass(CreateAggressiveDCEPass());
Add --relax-float-ops and --convert-relaxed-to-half (#2808) The first pass applies the RelaxedPrecision decoration to all executable instructions with float32 based type results. The second pass converts all executable instructions with RelaxedPrecision result to the equivalent float16 type, inserting converts where necessary.
2019-09-03 17:22:13 +00:00
} else if (pass_name == "convert-relaxed-to-half") {
RegisterPass(CreateConvertRelaxedToHalfPass());
} else if (pass_name == "relax-float-ops") {
RegisterPass(CreateRelaxFloatOpsPass());
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else if (pass_name == "simplify-instructions") {
RegisterPass(CreateSimplificationPass());
} else if (pass_name == "ssa-rewrite") {
RegisterPass(CreateSSARewritePass());
} else if (pass_name == "copy-propagate-arrays") {
RegisterPass(CreateCopyPropagateArraysPass());
} else if (pass_name == "loop-fission") {
int register_threshold_to_split =
(pass_args.size() > 0) ? atoi(pass_args.c_str()) : -1;
if (register_threshold_to_split > 0) {
RegisterPass(CreateLoopFissionPass(
static_cast<size_t>(register_threshold_to_split)));
} else {
Error(consumer(), nullptr, {},
"--loop-fission must have a positive integer argument");
return false;
}
} else if (pass_name == "loop-fusion") {
int max_registers_per_loop =
(pass_args.size() > 0) ? atoi(pass_args.c_str()) : -1;
if (max_registers_per_loop > 0) {
RegisterPass(
CreateLoopFusionPass(static_cast<size_t>(max_registers_per_loop)));
} else {
Error(consumer(), nullptr, {},
Add testing framework for tools. This forks the testing harness from https://github.com/google/shaderc to allow testing CLI tools. New features needed for SPIRV-Tools include: 1- A new PlaceHolder subclass for spirv shaders. This place holder calls spirv-as to convert assembly input into SPIRV bytecode. This is required for most tools in SPIRV-Tools. 2- A minimal testing file for testing basic functionality of spirv-opt. Add tests for all flags in spirv-opt. 1. Adds tests to check that known flags match the names that each pass advertises. 2. Adds tests to check that -O, -Os and --legalize-hlsl schedule the expected passes. 3. Adds more functionality to Expect classes to support regular expression matching on stderr. 4. Add checks for integer arguments to optimization flags. 5. Fixes #1817 by modifying the parsing of integer arguments in flags that take them. 6. Fixes -Oconfig file parsing (#1778). It reads every line of the file into a string and then parses that string by tokenizing every group of characters between whitespaces (using the standard cin reading operator). This mimics shell command-line parsing, but it does not support quoting (and I'm not planning to).
2018-08-03 22:08:46 +00:00
"--loop-fusion must have a positive integer argument");
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
return false;
}
} else if (pass_name == "loop-unroll") {
RegisterPass(CreateLoopUnrollPass(true));
Update memory model (#1904) Upgrade to VulkanKHR memory model * Converts Logical GLSL450 memory model to Logical VulkanKHR * Adds extension and capability * Removes deprecated decorations and replaces them with appropriate flags on downstream instructions * Support for Workgroup upgrades * Support for copy memory * Adding support for image functions * Adding barrier upgrades and tests * Use QueueFamilyKHR scope instead of device
2018-11-30 19:15:51 +00:00
} else if (pass_name == "upgrade-memory-model") {
RegisterPass(CreateUpgradeMemoryModelPass());
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else if (pass_name == "vector-dce") {
RegisterPass(CreateVectorDCEPass());
} else if (pass_name == "loop-unroll-partial") {
int factor = (pass_args.size() > 0) ? atoi(pass_args.c_str()) : 0;
Add testing framework for tools. This forks the testing harness from https://github.com/google/shaderc to allow testing CLI tools. New features needed for SPIRV-Tools include: 1- A new PlaceHolder subclass for spirv shaders. This place holder calls spirv-as to convert assembly input into SPIRV bytecode. This is required for most tools in SPIRV-Tools. 2- A minimal testing file for testing basic functionality of spirv-opt. Add tests for all flags in spirv-opt. 1. Adds tests to check that known flags match the names that each pass advertises. 2. Adds tests to check that -O, -Os and --legalize-hlsl schedule the expected passes. 3. Adds more functionality to Expect classes to support regular expression matching on stderr. 4. Add checks for integer arguments to optimization flags. 5. Fixes #1817 by modifying the parsing of integer arguments in flags that take them. 6. Fixes -Oconfig file parsing (#1778). It reads every line of the file into a string and then parses that string by tokenizing every group of characters between whitespaces (using the standard cin reading operator). This mimics shell command-line parsing, but it does not support quoting (and I'm not planning to).
2018-08-03 22:08:46 +00:00
if (factor > 0) {
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
RegisterPass(CreateLoopUnrollPass(false, factor));
} else {
Error(consumer(), nullptr, {},
Add testing framework for tools. This forks the testing harness from https://github.com/google/shaderc to allow testing CLI tools. New features needed for SPIRV-Tools include: 1- A new PlaceHolder subclass for spirv shaders. This place holder calls spirv-as to convert assembly input into SPIRV bytecode. This is required for most tools in SPIRV-Tools. 2- A minimal testing file for testing basic functionality of spirv-opt. Add tests for all flags in spirv-opt. 1. Adds tests to check that known flags match the names that each pass advertises. 2. Adds tests to check that -O, -Os and --legalize-hlsl schedule the expected passes. 3. Adds more functionality to Expect classes to support regular expression matching on stderr. 4. Add checks for integer arguments to optimization flags. 5. Fixes #1817 by modifying the parsing of integer arguments in flags that take them. 6. Fixes -Oconfig file parsing (#1778). It reads every line of the file into a string and then parses that string by tokenizing every group of characters between whitespaces (using the standard cin reading operator). This mimics shell command-line parsing, but it does not support quoting (and I'm not planning to).
2018-08-03 22:08:46 +00:00
"--loop-unroll-partial must have a positive integer argument");
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
return false;
}
} else if (pass_name == "loop-peeling") {
RegisterPass(CreateLoopPeelingPass());
Add testing framework for tools. This forks the testing harness from https://github.com/google/shaderc to allow testing CLI tools. New features needed for SPIRV-Tools include: 1- A new PlaceHolder subclass for spirv shaders. This place holder calls spirv-as to convert assembly input into SPIRV bytecode. This is required for most tools in SPIRV-Tools. 2- A minimal testing file for testing basic functionality of spirv-opt. Add tests for all flags in spirv-opt. 1. Adds tests to check that known flags match the names that each pass advertises. 2. Adds tests to check that -O, -Os and --legalize-hlsl schedule the expected passes. 3. Adds more functionality to Expect classes to support regular expression matching on stderr. 4. Add checks for integer arguments to optimization flags. 5. Fixes #1817 by modifying the parsing of integer arguments in flags that take them. 6. Fixes -Oconfig file parsing (#1778). It reads every line of the file into a string and then parses that string by tokenizing every group of characters between whitespaces (using the standard cin reading operator). This mimics shell command-line parsing, but it does not support quoting (and I'm not planning to).
2018-08-03 22:08:46 +00:00
} else if (pass_name == "loop-peeling-threshold") {
int factor = (pass_args.size() > 0) ? atoi(pass_args.c_str()) : 0;
if (factor > 0) {
opt::LoopPeelingPass::SetLoopPeelingThreshold(factor);
} else {
Error(consumer(), nullptr, {},
"--loop-peeling-threshold must have a positive integer argument");
return false;
}
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else if (pass_name == "ccp") {
RegisterPass(CreateCCPPass());
Sink (#2284) Add code sinking pass. It will move OpLoad and OpAccessChain instructions as close as possible to their uses. Part of #1611.
2019-01-17 20:56:36 +00:00
} else if (pass_name == "code-sink") {
RegisterPass(CreateCodeSinkingPass());
Add fix storage class code. (#2434) This pass tries to fix validation error due to a mismatch of storage classes in instructions. There is no guarantee that all such error will be fixed, and it is possible that in fixing these errors, it could lead to other errors. Fixes #2430.
2019-04-05 17:12:08 +00:00
} else if (pass_name == "fix-storage-class") {
RegisterPass(CreateFixStorageClassPass());
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else if (pass_name == "O") {
RegisterPerformancePasses();
} else if (pass_name == "Os") {
RegisterSizePasses();
} else if (pass_name == "legalize-hlsl") {
RegisterLegalizationPasses();
Add pass to generate needed initializers for WebGPU (#2481) Fixes #2387
2019-04-03 15:44:09 +00:00
} else if (pass_name == "generate-webgpu-initializers") {
RegisterPass(CreateGenerateWebGPUInitializersPass());
Add pass to legalize OpVectorShuffle for WebGPU (#2509) In WebGPU, the component operand 0xFFFFFFFF is forbidden, but in Vulkan it is used to indicate a value is undefined. When converting to WebGPU, 0xFFFFFFFF needs to converted to a legal value, though the specific one does not matter, since it was used to indicate an undefined entry in the original code. Choosing to use 0, since the operands are required to be on [0, N-1], so 0 is guaranteed to always be valid. Fixes #2349
2019-04-12 16:14:23 +00:00
} else if (pass_name == "legalize-vector-shuffle") {
RegisterPass(CreateLegalizeVectorShufflePass());
Add in individual flags for Vulkan <-> WebGPU passes (#2615) Adds flags and/or documentation for individual transformation passes that had been missed in previous patches. Fixes #2574
2019-05-22 17:06:53 +00:00
} else if (pass_name == "split-invalid-unreachable") {
RegisterPass(CreateLegalizeVectorShufflePass());
} else if (pass_name == "decompose-initialized-variables") {
RegisterPass(CreateDecomposeInitializedVariablesPass());
Add pass to inject code for robust-buffer-access semantics (#2771) spirv-opt: Add --graphics-robust-access Clamps access chain indices so they are always in bounds. Assumes: - Logical addressing mode - No runtime-array-descriptor-indexing - No variable pointers Adds stub code for clamping coordinate and samples for OpImageTexelPointer. Adds SinglePassRunAndFail optimizer test fixture. Android.mk: add source/opt/graphics_robust_access_pass.cpp Adds Constant::GetSignExtendedValue, Constant::GetZeroExtendedValue
2019-07-30 23:52:46 +00:00
} else if (pass_name == "graphics-robust-access") {
RegisterPass(CreateGraphicsRobustAccessPass());
Replace OpKill With function call. (#2790) We are no able to inline OpKill instructions into a continue construct. See #2433. However, we have to be able to inline to correctly do legalization. This commit creates a pass that will wrap OpKill instructions into a function of its own. That way we are able to inline the rest of the code. The follow up to this will be to not inline any function that contains an OpKill. Fixes #2726
2019-08-14 13:27:12 +00:00
} else if (pass_name == "wrap-opkill") {
RegisterPass(CreateWrapOpKillPass());
Amd ext to khr (#2811) Add the first steps to removing the AMD extension VK_AMD_shader_ballot. Splitting up to make the PRs smaller. Adding utilities to add capabilities and change the version of the module. Replaces the instructions: OpGroupIAddNonUniformAMD = 5000 OpGroupFAddNonUniformAMD = 5001 OpGroupFMinNonUniformAMD = 5002 OpGroupUMinNonUniformAMD = 5003 OpGroupSMinNonUniformAMD = 5004 OpGroupFMaxNonUniformAMD = 5005 OpGroupUMaxNonUniformAMD = 5006 OpGroupSMaxNonUniformAMD = 5007 and extentend instructions WriteInvocationAMD = 3 MbcntAMD = 4 Part of #2814
2019-08-29 16:48:17 +00:00
} else if (pass_name == "amd-ext-to-khr") {
RegisterPass(CreateAmdExtToKhrPass());
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
} else {
Errorf(consumer(), nullptr, {},
"Unknown flag '--%s'. Use --help for a list of valid flags",
pass_name.c_str());
return false;
}
return true;
}
Add --target-env flag to spirv-opt (#2216) Fixes #2199
2018-12-17 21:54:23 +00:00
void Optimizer::SetTargetEnv(const spv_target_env env) {
impl_->target_env = env;
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
bool Optimizer::Run(const uint32_t* original_binary,
const size_t original_binary_size,
std::vector<uint32_t>* optimized_binary) const {
Validate the input to Optimizer::Run (#1799) * Run the validator in the optimization fuzzers. The optimizers assumes that the input to the optimizer is valid. Since the fuzzers do not check that the input is valid before passing the spir-v to the optimizer, we are getting a few errors. The solution is to run the validator in the optimizer to validate the input. For the legalization passes, we need to add an extra option to the validator to accept certain types of variable pointers, even if the capability is not given. At the same time, we changed the option "--legalize-hlsl" to relax the validator in the same way instead of turning it off.
2018-08-08 15:16:19 +00:00
return Run(original_binary, original_binary_size, optimized_binary,
Add option for the max id bound. (#1870) * Create a new entry point for the optimizer Creates a new struct to hold the options for the optimizer, and creates an entry point that take the optimizer options as a parameter. The old entry point that takes validator options are now deprecated. The validator options will be one of the optimizer options. Part of the optimizer options will also be the upper bound on the id bound. * Add a command line option to set the max value for the id bound. The default is 0x3FFFFF. * Modify `TakeNextIdBound` to return 0 when the limit is reached.
2018-09-10 15:49:41 +00:00
OptimizerOptions());
Validate the input to Optimizer::Run (#1799) * Run the validator in the optimization fuzzers. The optimizers assumes that the input to the optimizer is valid. Since the fuzzers do not check that the input is valid before passing the spir-v to the optimizer, we are getting a few errors. The solution is to run the validator in the optimizer to validate the input. For the legalization passes, we need to add an extra option to the validator to accept certain types of variable pointers, even if the capability is not given. At the same time, we changed the option "--legalize-hlsl" to relax the validator in the same way instead of turning it off.
2018-08-08 15:16:19 +00:00
}
bool Optimizer::Run(const uint32_t* original_binary,
const size_t original_binary_size,
std::vector<uint32_t>* optimized_binary,
Add option for the max id bound. (#1870) * Create a new entry point for the optimizer Creates a new struct to hold the options for the optimizer, and creates an entry point that take the optimizer options as a parameter. The old entry point that takes validator options are now deprecated. The validator options will be one of the optimizer options. Part of the optimizer options will also be the upper bound on the id bound. * Add a command line option to set the max value for the id bound. The default is 0x3FFFFF. * Modify `TakeNextIdBound` to return 0 when the limit is reached.
2018-09-10 15:49:41 +00:00
const ValidatorOptions& validator_options,
Reenable --skip-validation. (#1820) In previous changes, the option `--skip-validation` was disabled. This change is to reenable it.
2018-08-13 17:18:46 +00:00
bool skip_validation) const {
Add option for the max id bound. (#1870) * Create a new entry point for the optimizer Creates a new struct to hold the options for the optimizer, and creates an entry point that take the optimizer options as a parameter. The old entry point that takes validator options are now deprecated. The validator options will be one of the optimizer options. Part of the optimizer options will also be the upper bound on the id bound. * Add a command line option to set the max value for the id bound. The default is 0x3FFFFF. * Modify `TakeNextIdBound` to return 0 when the limit is reached.
2018-09-10 15:49:41 +00:00
OptimizerOptions opt_options;
opt_options.set_run_validator(!skip_validation);
opt_options.set_validator_options(validator_options);
return Run(original_binary, original_binary_size, optimized_binary,
opt_options);
}
bool Optimizer::Run(const uint32_t* original_binary,
const size_t original_binary_size,
std::vector<uint32_t>* optimized_binary,
const spv_optimizer_options opt_options) const {
Validate the input to Optimizer::Run (#1799) * Run the validator in the optimization fuzzers. The optimizers assumes that the input to the optimizer is valid. Since the fuzzers do not check that the input is valid before passing the spir-v to the optimizer, we are getting a few errors. The solution is to run the validator in the optimizer to validate the input. For the legalization passes, we need to add an extra option to the validator to accept certain types of variable pointers, even if the capability is not given. At the same time, we changed the option "--legalize-hlsl" to relax the validator in the same way instead of turning it off.
2018-08-08 15:16:19 +00:00
spvtools::SpirvTools tools(impl_->target_env);
tools.SetMessageConsumer(impl_->pass_manager.consumer());
Add option for the max id bound. (#1870) * Create a new entry point for the optimizer Creates a new struct to hold the options for the optimizer, and creates an entry point that take the optimizer options as a parameter. The old entry point that takes validator options are now deprecated. The validator options will be one of the optimizer options. Part of the optimizer options will also be the upper bound on the id bound. * Add a command line option to set the max value for the id bound. The default is 0x3FFFFF. * Modify `TakeNextIdBound` to return 0 when the limit is reached.
2018-09-10 15:49:41 +00:00
if (opt_options->run_validator_ &&
!tools.Validate(original_binary, original_binary_size,
&opt_options->val_options_)) {
Validate the input to Optimizer::Run (#1799) * Run the validator in the optimization fuzzers. The optimizers assumes that the input to the optimizer is valid. Since the fuzzers do not check that the input is valid before passing the spir-v to the optimizer, we are getting a few errors. The solution is to run the validator in the optimizer to validate the input. For the legalization passes, we need to add an extra option to the validator to accept certain types of variable pointers, even if the capability is not given. At the same time, we changed the option "--legalize-hlsl" to relax the validator in the same way instead of turning it off.
2018-08-08 15:16:19 +00:00
return false;
}
Add API to create passes out of a list of command-line flags. This re-implements the -Oconfig=<file> flag to use a new API that takes a list of command-line flags representing optimization passes. This moves the processing of flags that create new optimization passes out of spirv-opt and into the library API. Useful for other tools that want to incorporate a facility similar to -Oconfig. The main changes are: 1- Add a new public function Optimizer::RegisterPassesFromFlags. This takes a vector of strings. Each string is assumed to have the form '--pass_name[=pass_args]'. It creates and registers into the pass manager all the passes specified in the vector. Each pass is validated internally. Failure to create a pass instance causes the function to return false and a diagnostic is emitted to the registered message consumer. 2- Re-implements -Oconfig in spirv-opt to use the new API.
2018-07-25 19:21:44 +00:00
std::unique_ptr<opt::IRContext> context = BuildModule(
impl_->target_env, consumer(), original_binary, original_binary_size);
Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction * Added an internal option to LinkerOptions to verify merged ids are unique * Added a test for the linker to verify merged ids are unique * Updated MergeReturnPass to supply a context * Updated DecorationManager to supply a context for cloned decorations * Reworked several portions of the def use tests in anticipation of next set of changes
2017-11-14 19:11:50 +00:00
if (context == nullptr) return false;
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Add option for the max id bound. (#1870) * Create a new entry point for the optimizer Creates a new struct to hold the options for the optimizer, and creates an entry point that take the optimizer options as a parameter. The old entry point that takes validator options are now deprecated. The validator options will be one of the optimizer options. Part of the optimizer options will also be the upper bound on the id bound. * Add a command line option to set the max value for the id bound. The default is 0x3FFFFF. * Modify `TakeNextIdBound` to return 0 when the limit is reached.
2018-09-10 15:49:41 +00:00
context->set_max_id_bound(opt_options->max_id_bound_);
Add —preserve-bindings and —preserve-spec-constants (#2693) Add optimizer options to for preservation of spec constants and variable with binding decorations. They are to be preserved even if they are unused.
2019-07-10 18:12:19 +00:00
context->set_preserve_bindings(opt_options->preserve_bindings_);
context->set_preserve_spec_constants(opt_options->preserve_spec_constants_);
Add option for the max id bound. (#1870) * Create a new entry point for the optimizer Creates a new struct to hold the options for the optimizer, and creates an entry point that take the optimizer options as a parameter. The old entry point that takes validator options are now deprecated. The validator options will be one of the optimizer options. Part of the optimizer options will also be the upper bound on the id bound. * Add a command line option to set the max value for the id bound. The default is 0x3FFFFF. * Modify `TakeNextIdBound` to return 0 when the limit is reached.
2018-09-10 15:49:41 +00:00
Add option to validate after each pass (#2462) * New command-line option to opt: --validate-after-all * Pass manager will validate after each pass it runs
2019-03-26 18:38:59 +00:00
impl_->pass_manager.SetValidatorOptions(&opt_options->val_options_);
impl_->pass_manager.SetTargetEnv(impl_->target_env);
Adding an unique id to Instruction generated by IRContext Each instruction is given an unique id that can be used for ordering purposes. The ids are generated via the IRContext. Major changes: * Instructions now contain a uint32_t for unique id and a cached context pointer * Most constructors have been modified to take a context as input * unfortunately I cannot remove the default and copy constructors, but developers should avoid these * Added accessors to parents of basic block and function * Removed the copy constructors for BasicBlock and Function and replaced them with Clone functions * Reworked BuildModule to return an IRContext owning the built module * Since all instructions require a context, the context now becomes the basic unit for IR * Added a constructor to context to create an owned module internally * Replaced uses of Instruction's copy constructor with Clone whereever I found them * Reworked the linker functionality to perform clones into a different context instead of moves * Updated many tests to be consistent with the above changes * Still need to add new tests to cover added functionality * Added comparison operators to Instruction * Added an internal option to LinkerOptions to verify merged ids are unique * Added a test for the linker to verify merged ids are unique * Updated MergeReturnPass to supply a context * Updated DecorationManager to supply a context for cloned decorations * Reworked several portions of the def use tests in anticipation of next set of changes
2017-11-14 19:11:50 +00:00
auto status = impl_->pass_manager.Run(context.get());
spirv-opt: Behave a bit better in the face of unknown instructions (#2487) * opt/ir_loader: Don't silently drop unknown instructions on the floor Currently, if spirv-opt sees an instruction it does not know, it will silently ignore it and move to the next one. This changes it to be an error, as dropping it on the floor is likely to generate invalid SPIR-V output. * opt/optimizer: Complain a bit louder for unexpected binary changes If a binary change happens despite a pass saying that the binaries should be identical, this is indicative of a bug in the pass itself. This does not change behavior for it to be an error, but simply emits a warning in this case.
2019-04-05 17:36:42 +00:00
spvtools::Optimizer - don't assume original_binary and optimized_binary are aliased (#2799) If they are not aliased, the function will always print the message: "Binary unexpectedly changed despite optimizer saying there was no change" Which is (usually) totally bogus. Fixes #2798
2019-08-29 14:04:55 +00:00
if (status == opt::Pass::Status::Failure) {
return false;
spirv-opt: Behave a bit better in the face of unknown instructions (#2487) * opt/ir_loader: Don't silently drop unknown instructions on the floor Currently, if spirv-opt sees an instruction it does not know, it will silently ignore it and move to the next one. This changes it to be an error, as dropping it on the floor is likely to generate invalid SPIR-V output. * opt/optimizer: Complain a bit louder for unexpected binary changes If a binary change happens despite a pass saying that the binaries should be identical, this is indicative of a bug in the pass itself. This does not change behavior for it to be an error, but simply emits a warning in this case.
2019-04-05 17:36:42 +00:00
}
spvtools::Optimizer - don't assume original_binary and optimized_binary are aliased (#2799) If they are not aliased, the function will always print the message: "Binary unexpectedly changed despite optimizer saying there was no change" Which is (usually) totally bogus. Fixes #2798
2019-08-29 14:04:55 +00:00
#ifndef NDEBUG
if (status == opt::Pass::Status::SuccessWithoutChange) {
Keep NOPs when comparing with original binary (#2931) We have a check that ensures that the optimizer did not change the binary when it says that it did not. However, when the binary is converted back to a binary, we made a decision to remove OpNop instructions. This means that any spv file that contains a NOP originally will fail this check. To get around this, we convert the module to a second binary that keeps the OpNop instructions. That binary is compared against the original. Fixes https://crbug.com/1010191
2019-10-18 13:53:29 +00:00
std::vector<uint32_t> optimized_binary_with_nop;
context->module()->ToBinary(&optimized_binary_with_nop,
/* skip_nop = */ false);
[opt] Do not compare optimized binary with an invalidated buffer (#2999)
2019-10-30 17:01:28 +00:00
assert(optimized_binary_with_nop.size() == original_binary_size &&
"Binary size unexpectedly changed despite the optimizer saying "
"there was no change");
assert(memcmp(optimized_binary_with_nop.data(), original_binary,
original_binary_size) == 0 &&
"Binary content unexpectedly changed despite the optimizer saying "
"there was no change");
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
}
spvtools::Optimizer - don't assume original_binary and optimized_binary are aliased (#2799) If they are not aliased, the function will always print the message: "Binary unexpectedly changed despite optimizer saying there was no change" Which is (usually) totally bogus. Fixes #2798
2019-08-29 14:04:55 +00:00
#endif // !NDEBUG
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
[opt] Do not compare optimized binary with an invalidated buffer (#2999)
2019-10-30 17:01:28 +00:00
// Note that |original_binary| and |optimized_binary| may share the same
// buffer and the below will invalidate |original_binary|.
optimized_binary->clear();
context->module()->ToBinary(optimized_binary, /* skip_nop = */ true);
spvtools::Optimizer - don't assume original_binary and optimized_binary are aliased (#2799) If they are not aliased, the function will always print the message: "Binary unexpectedly changed despite optimizer saying there was no change" Which is (usually) totally bogus. Fixes #2798
2019-08-29 14:04:55 +00:00
return true;
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
}
Add --print-all optimizer option Adds optimizer API to write disassembly to a given output stream before each pass, and after the last pass. Adds spirv-opt --print-all option to write disassembly to stderr before each pass, and after the last pass.
2018-01-04 17:59:50 +00:00
Optimizer& Optimizer::SetPrintAll(std::ostream* out) {
impl_->pass_manager.SetPrintAll(out);
return *this;
}
Add --time-report to spirv-opt This patch adds a new option --time-report to spirv-opt. For each pass executed by spirv-opt, the flag prints resource utilization for the pass (CPU time, wall time, RSS and page faults) This fixes issue #1378
2018-03-07 14:25:51 +00:00
Optimizer& Optimizer::SetTimeReport(std::ostream* out) {
impl_->pass_manager.SetTimeReport(out);
return *this;
}
Add option to validate after each pass (#2462) * New command-line option to opt: --validate-after-all * Pass manager will validate after each pass it runs
2019-03-26 18:38:59 +00:00
Optimizer& Optimizer::SetValidateAfterAll(bool validate) {
impl_->pass_manager.SetValidateAfterAll(validate);
return *this;
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer::PassToken CreateNullPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::NullPass>());
}
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
Optimizer::PassToken CreateStripAtomicCounterMemoryPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::StripAtomicCounterMemoryPass>());
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer::PassToken CreateStripDebugInfoPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::StripDebugInfoPass>());
}
Add --strip-reflect pass Strips reflection info. This is limited to decorations and decoration instructions related to the SPV_GOOGLE_hlsl_functionality1 extension. It will remove the OpExtension for SPV_GOOGLE_hlsl_functionality1. It will also remove the OpExtension for SPV_GOOGLE_decorate_string if there are no further remaining uses of OpDecorateStringGOOGLE. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1398
2018-03-09 21:08:57 +00:00
Optimizer::PassToken CreateStripReflectInfoPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::StripReflectInfoPass>());
}
Create the dead function elimination pass Creates a pass called eliminate dead functions that looks for functions that could never be called, and deletes them from the module. To support this change a new function was added to the Pass class to traverse the call trees from diffent starting points. Includes a test to ensure that annotations are removed when deleting a dead function. They were not, so fixed that up as well. Did some cleanup of the assembly for the test in pass_test.cpp. Trying to make them smaller and easier to read.
2017-09-19 14:12:13 +00:00
Optimizer::PassToken CreateEliminateDeadFunctionsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::EliminateDeadFunctionsPass>());
}
Add pass to remove dead members. (#2379) Add a pass that looks for members of structs whose values do not affects the output of the shader. Those members are then removed and just treated like padding in the struct.
2019-02-14 18:42:35 +00:00
Optimizer::PassToken CreateEliminateDeadMembersPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::EliminateDeadMembersPass>());
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer::PassToken CreateSetSpecConstantDefaultValuePass(
const std::unordered_map<uint32_t, std::string>& id_value_map) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SetSpecConstantDefaultValuePass>(id_value_map));
}
Add bit pattern interface for setting default value for spec constants
2017-04-19 22:10:59 +00:00
Optimizer::PassToken CreateSetSpecConstantDefaultValuePass(
const std::unordered_map<uint32_t, std::vector<uint32_t>>& id_value_map) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SetSpecConstantDefaultValuePass>(id_value_map));
}
Add FlattenDecoration transform Add --flatten-decorations to spirv-opt Flattens decoration groups. That is, replace OpDecorationGroup and its uses in OpGroupDecorate and OpGroupMemberDecorate with ordinary OpDecorate and OpMemberDecorate instructions. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/602
2017-04-01 20:10:16 +00:00
Optimizer::PassToken CreateFlattenDecorationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::FlattenDecorationPass>());
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
Optimizer::PassToken CreateFreezeSpecConstantValuePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::FreezeSpecConstantValuePass>());
}
Optimizer::PassToken CreateFoldSpecConstantOpAndCompositePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::FoldSpecConstantOpAndCompositePass>());
}
Optimizer::PassToken CreateUnifyConstantPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::UnifyConstantPass>());
}
Optimizer::PassToken CreateEliminateDeadConstantPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::EliminateDeadConstantPass>());
}
Add pass to remove dead variables at the module level. There does not seem to be any pass that remove global variables. I think we could use one. This pass will look specifically for global variables that are not referenced and are not exported. Any decoration associated with the variable will also be removed. However, this could cause types or constants to become unreferenced. They will not be removed. Another pass will have to be called to remove those.
2017-10-20 16:17:41 +00:00
Optimizer::PassToken CreateDeadVariableEliminationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::DeadVariableElimination>());
}
Add strength reduction; for now replace multiply by power of 2 Create a new optimization pass, strength reduction, which will replace integer multiplication by a constant power of 2 with an equivalent bit shift. More changes could be added later. - Does not duplicate constants - Adds vector |Concat| utility function to a common test header.
2017-09-08 16:08:03 +00:00
Optimizer::PassToken CreateStrengthReductionPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::StrengthReductionPass>());
}
BlockMerge: Add BlockMergePass Also, add BasicBlock::tail()
2017-06-07 21:28:53 +00:00
Optimizer::PassToken CreateBlockMergePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::BlockMergePass>());
}
Inline: Split out InlineExhaustivePass from InlinePass
2017-08-01 23:20:13 +00:00
Optimizer::PassToken CreateInlineExhaustivePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::InlineExhaustivePass>());
Add exhaustive function call inlining to spirv-opt Inlining is done for all functions designated as entry points. Add optional validation to test fixture method SinglePassRunAndCheck.
2016-11-10 17:11:50 +00:00
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
Opt: Create InlineOpaquePass Only inline calls to functions with opaque params or return TODO: Handle parameter type or return type where the opqaue type is buried within an array.
2017-08-15 23:58:28 +00:00
Optimizer::PassToken CreateInlineOpaquePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::InlineOpaquePass>());
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
Mem2Reg: Add Local Access Chain Convert pass - Supports OpAccessChain and OpInBoundsAccessChain - Does not process modules with non-32-bit integer types.
2017-05-12 23:27:21 +00:00
Optimizer::PassToken CreateLocalAccessChainConvertPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LocalAccessChainConvertPass>());
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
mem2reg: Add pass to eliminate local loads and stores in single block.
2017-05-18 20:51:55 +00:00
Optimizer::PassToken CreateLocalSingleBlockLoadStoreElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LocalSingleBlockLoadStoreElimPass>());
}
Mem2Reg: Add Local Access Chain Convert pass - Supports OpAccessChain and OpInBoundsAccessChain - Does not process modules with non-32-bit integer types.
2017-05-12 23:27:21 +00:00
mem2reg: Add LocalSingleStoreElimPass Eliminate function scope variables with one store, if possible.
2017-05-19 23:31:28 +00:00
Optimizer::PassToken CreateLocalSingleStoreElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LocalSingleStoreElimPass>());
}
mem2reg: Add InsertExtractElimPass
2017-05-26 16:33:11 +00:00
Optimizer::PassToken CreateInsertExtractElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
Delete the insert-extract-elim pass. Replaces anything that creates an insert-extract-elim pass and create a simplifiation pass instead. Then delete the implementation of the pass. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1570.
2018-05-31 03:50:07 +00:00
MakeUnique<opt::SimplificationPass>());
mem2reg: Add InsertExtractElimPass
2017-05-26 16:33:11 +00:00
}
InsertExtractElim: Split out DeadInsertElim as separate pass
2018-01-27 00:05:33 +00:00
Optimizer::PassToken CreateDeadInsertElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::DeadInsertElimPass>());
}
DeadBranchElim: Add DeadBranchElimPass
2017-06-02 19:23:20 +00:00
Optimizer::PassToken CreateDeadBranchElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::DeadBranchElimPass>());
}
Add LocalMultiStoreElim pass A SSA local variable load/store elimination pass. For every entry point function, eliminate all loads and stores of function scope variables only referenced with non-access-chain loads and stores. Eliminate the variables as well. The presence of access chain references and function calls can inhibit the above optimization. Only shader modules with logical addressing are currently processed. Currently modules with any extensions enabled are not processed. This is left for future work. This pass is most effective if preceeded by Inlining and LocalAccessChainConvert. LocalSingleStoreElim and LocalSingleBlockElim will reduce the work that this pass has to do.
2017-06-16 21:37:31 +00:00
Optimizer::PassToken CreateLocalMultiStoreElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
Handle id overflow in the ssa rewriter. (#2845) * Handle id overflow in the ssa rewriter. Remove LocalSSAElim pass at the same time. It does the same thing as the SSARewrite pass. Then even share almost all of the same code. Fixes crbug.com/997246
2019-09-10 13:38:23 +00:00
MakeUnique<opt::SSARewritePass>());
Add LocalMultiStoreElim pass A SSA local variable load/store elimination pass. For every entry point function, eliminate all loads and stores of function scope variables only referenced with non-access-chain loads and stores. Eliminate the variables as well. The presence of access chain references and function calls can inhibit the above optimization. Only shader modules with logical addressing are currently processed. Currently modules with any extensions enabled are not processed. This is left for future work. This pass is most effective if preceeded by Inlining and LocalAccessChainConvert. LocalSingleStoreElim and LocalSingleBlockElim will reduce the work that this pass has to do.
2017-06-16 21:37:31 +00:00
}
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
Optimizer::PassToken CreateAggressiveDCEPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::AggressiveDCEPass>());
}
Add passes to propagate and eliminate redundant line instructions (#2027). (#2039) These are bookend passes designed to help preserve line information across passes which delete, move and clone instructions. The propagation pass attaches a debug line instruction to every instruction based on SPIR-V line propagation rules. It should be performed before optimization. The redundant line elimination pass eliminates all line instructions which match the previous line instruction. This pass should be performed at the end of optimization to reduce physical SPIR-V file size. Fixes #2027.
2018-11-15 19:06:17 +00:00
Optimizer::PassToken CreatePropagateLineInfoPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::ProcessLinesPass>(opt::kLinesPropagateLines));
}
Optimizer::PassToken CreateRedundantLineInfoElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::ProcessLinesPass>(opt::kLinesEliminateDeadLines));
}
Added --compact-ids to /tools/opt The pass remaps ids to a compact set which starts with %1 and has no gaps.
2017-04-11 19:11:04 +00:00
Optimizer::PassToken CreateCompactIdsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CompactIdsPass>());
}
Initial implementation of merge return pass. Works with current DefUseManager infrastructure. Added merge return to the standard opts. Added validation to passes. Disabled pass for shader capabilty.
2017-11-08 21:22:10 +00:00
Optimizer::PassToken CreateMergeReturnPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::MergeReturnPass>());
}
Add -O, -Os and -Oconfig flags. These flags are expanded to a series of spirv-opt flags with the following semantics: -O: expands to passes that attempt to improve the performance of the generated code. -Os: expands to passes that attempt to reduce the size of the generated code. -Oconfig=<file> expands to the sequence of passes determined by the flags specified in the user-provided file.
2017-08-30 18:19:22 +00:00
std::vector<const char*> Optimizer::GetPassNames() const {
std::vector<const char*> v;
for (uint32_t i = 0; i < impl_->pass_manager.NumPasses(); i++) {
v.push_back(impl_->pass_manager.GetPass(i)->name());
}
return v;
}
The reviewed cfg_cleanup optimize pass
2017-10-19 19:22:02 +00:00
Optimizer::PassToken CreateCFGCleanupPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CFGCleanupPass>());
}
Create a local value numbering pass Creates a pass that removes redundant instructions within the same basic block. This will be implemented using a hash based value numbering algorithm. Added a number of functions that check for the Vulkan descriptor types. These are used to determine if we are variables are read-only or not. Implemented a function to check if loads and variables are read-only. Implemented kernel specific and shader specific versions. A big change is that the Combinator analysis in ADCE is factored out into the IRContext as an analysis. This was done because it is being reused in the value number table.
2017-11-11 01:26:55 +00:00
Optimizer::PassToken CreateLocalRedundancyEliminationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LocalRedundancyEliminationPass>());
}
Add global redundancy elimination Adds a pass that looks for redundant instruction in a function, and removes them. The algorithm is a hash table based value numbering algorithm that traverses the dominator tree. This pass removes completely redundant instructions, not partially redundant ones.
2017-12-04 17:29:51 +00:00
Support loop fission. Adds support for spliting loops whose register pressure exceeds a user provided level. This pass will split a loop into two or more loops given that the loop is a top level loop and that spliting the loop is legal. Control flow is left intact for dead code elimination to remove. This pass is enabled with the --loop-fission flag to spirv-opt.
2018-04-23 20:01:12 +00:00
Optimizer::PassToken CreateLoopFissionPass(size_t threshold) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LoopFissionPass>(threshold));
}
Add a loop fusion pass. This pass will look for adjacent loops that are compatible and legal to be fused. Loops are compatible if: - they both have one induction variable - they have the same upper and lower bounds - same initial value - same condition - they have the same update step - they are adjacent - there are no break/continue in either of them Fusion is legal if: - fused loops do not have any dependencies with dependence distance greater than 0 that did not exist in the original loops. - there are no function calls in the loops (could have side-effects) - there are no barriers in the loops It will fuse all such loops as long as the number of registers used for the fused loop stays under the threshold defined by max_registers_per_loop.
2018-04-20 14:14:45 +00:00
Optimizer::PassToken CreateLoopFusionPass(size_t max_registers_per_loop) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LoopFusionPass>(max_registers_per_loop));
}
Loop invariant code motion initial implementation
2018-01-29 10:39:55 +00:00
Optimizer::PassToken CreateLoopInvariantCodeMotionPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::LICMPass>());
}
Add a loop peeling pass. For each loop in a function, the pass walks the loops from inner to outer most loop and tries to peel loop for which a certain amount of iteration can be done before or after the loop. To limit code growth, peeling will not happen if the growth in code size goes above a configurable threshold.
2018-03-29 11:22:42 +00:00
Optimizer::PassToken CreateLoopPeelingPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LoopPeelingPass>());
}
Add loop unswitch pass. It moves all conditional branching and switch whose conditions are loop invariant and uniform. Before performing the loop unswitch we check that the loop does not contain any instruction that would prevent it (barriers, group instructions etc.).
2018-02-12 21:42:15 +00:00
Optimizer::PassToken CreateLoopUnswitchPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LoopUnswitchPass>());
}
Add global redundancy elimination Adds a pass that looks for redundant instruction in a function, and removes them. The algorithm is a hash table based value numbering algorithm that traverses the dominator tree. This pass removes completely redundant instructions, not partially redundant ones.
2017-12-04 17:29:51 +00:00
Optimizer::PassToken CreateRedundancyEliminationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::RedundancyEliminationPass>());
}
Add scalar replacement Adds a scalar replacement pass. The pass considers all function scope variables of composite type. If there are accesses to individual elements (and it is legal) the pass replaces the variable with a variable for each composite element and updates all the uses. Added the pass to -O Added NumUses and NumUsers to DefUseManager Added some helper methods for the inst to block mapping in context Added some helper methods for specific constant types No longer generate duplicate pointer types. * Now searches for an existing pointer of the appropriate type instead of failing validation * Fixed spec constant extracts * Addressed changes for review * Changed RunSinglePassAndMatch to be able to run validation * current users do not enable it Added handling of acceptable decorations. * Decorations are also transfered where appropriate Refactored extension checking into FeatureManager * Context now owns a feature manager * consciously NOT an analysis * added some test * fixed some minor issues related to decorates * added some decorate related tests for scalar replacement
2017-11-30 22:03:06 +00:00
Improving the usability of the type manager. The type manager hashes types. This allows the lookup of type declaration ids from arbitrarily constructed types. Users should be cautious when dealing with non-unique types (structs and potentially pointers) to get the exact id if necessary. * Changed the spec composite constant folder to handle ambiguous composites * Added functionality to create necessary instructions for a type * Added ability to remove ids from the type manager
2017-12-08 20:33:19 +00:00
Optimizer::PassToken CreateRemoveDuplicatesPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::RemoveDuplicatesPass>());
}
Remove the limit on struct size in SROA. Removes the limit on scalar replacement for the lagalization passes. This is done by adding an option to the pass (and command line option) to set the limit on maximum size of the composite that scalar replacement is willing to divide. Fixes #1494.
2018-04-16 13:58:00 +00:00
Optimizer::PassToken CreateScalarReplacementPass(uint32_t size_limit) {
Add scalar replacement Adds a scalar replacement pass. The pass considers all function scope variables of composite type. If there are accesses to individual elements (and it is legal) the pass replaces the variable with a variable for each composite element and updates all the uses. Added the pass to -O Added NumUses and NumUsers to DefUseManager Added some helper methods for the inst to block mapping in context Added some helper methods for specific constant types No longer generate duplicate pointer types. * Now searches for an existing pointer of the appropriate type instead of failing validation * Fixed spec constant extracts * Addressed changes for review * Changed RunSinglePassAndMatch to be able to run validation * current users do not enable it Added handling of acceptable decorations. * Decorations are also transfered where appropriate Refactored extension checking into FeatureManager * Context now owns a feature manager * consciously NOT an analysis * added some test * fixed some minor issues related to decorates * added some decorate related tests for scalar replacement
2017-11-30 22:03:06 +00:00
return MakeUnique<Optimizer::PassToken::Impl>(
Remove the limit on struct size in SROA. Removes the limit on scalar replacement for the lagalization passes. This is done by adding an option to the pass (and command line option) to set the limit on maximum size of the composite that scalar replacement is willing to divide. Fixes #1494.
2018-04-16 13:58:00 +00:00
MakeUnique<opt::ScalarReplacementPass>(size_limit));
Add scalar replacement Adds a scalar replacement pass. The pass considers all function scope variables of composite type. If there are accesses to individual elements (and it is legal) the pass replaces the variable with a variable for each composite element and updates all the uses. Added the pass to -O Added NumUses and NumUsers to DefUseManager Added some helper methods for the inst to block mapping in context Added some helper methods for specific constant types No longer generate duplicate pointer types. * Now searches for an existing pointer of the appropriate type instead of failing validation * Fixed spec constant extracts * Addressed changes for review * Changed RunSinglePassAndMatch to be able to run validation * current users do not enable it Added handling of acceptable decorations. * Decorations are also transfered where appropriate Refactored extension checking into FeatureManager * Context now owns a feature manager * consciously NOT an analysis * added some test * fixed some minor issues related to decorates * added some decorate related tests for scalar replacement
2017-11-30 22:03:06 +00:00
}
Convert private variables to function scope. When a private variable is used in a single function, it can be converted to a function scope variable in that function. This adds a pass that does that. The pass can be enabled using the option `--private-to-local`. This transformation allows other transformations to act on these variables. Also moved `FindPointerToType` from the inline class to the type manager.
2017-12-11 18:10:24 +00:00
Optimizer::PassToken CreatePrivateToLocalPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::PrivateToLocalPass>());
}
Implement SSA CCP (SSA Conditional Constant Propagation). This implements the conditional constant propagation pass proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The main logic resides in CCPPass::VisitInstruction. Instruction that may produce a constant value are evaluated with the constant folder. If they produce a new constant, the instruction is considered interesting. Otherwise, it's considered varying (for unfoldable instructions) or just not interesting (when not enough operands have a constant value). The other main piece of logic is in CCPPass::VisitBranch. This evaluates the selector of the branch. When it's found to be a known value, it computes the destination basic block and sets it. This tells the propagator which branches to follow. The patch required extensions to the constant manager as well. Instead of hashing the Constant pointers, this patch changes the constant pool to hash the contents of the Constant. This allows the lookups to be done using the actual values of the Constant, preventing duplicate definitions.
2017-12-05 16:39:25 +00:00
Optimizer::PassToken CreateCCPPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::CCPPass>());
}
Create a pass to work around a driver bug related to OpUnreachable. We have come across a driver bug where and OpUnreachable inside a loop is causing the shader to go into an infinite loop. This commit will try to avoid this bug by turning OpUnreachable instructions that are contained in a loop into branches to the loop merge block. This is not added to "-O" and "-Os" because it should only be used if the driver being targeted has this problem. Fixes #1209.
2018-01-17 19:57:37 +00:00
Optimizer::PassToken CreateWorkaround1209Pass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::Workaround1209>());
}
Initial implementation of if conversion * Handles simple cases only * Identifies phis in blocks with two predecessors and attempts to convert the phi to an select * does not perform code motion currently so the converted values must dominate the join point (e.g. can't be defined in the branches) * limited for now to two predecessors, but can be extended to handle more cases * Adding if conversion to -O and -Os
2018-01-16 16:15:06 +00:00
Optimizer::PassToken CreateIfConversionPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::IfConversion>());
}
Add pass to reaplce invalid opcodes Creates a pass that will remove instructions that are invalid for the current shader stage. For the instruction to be considered for replacement 1) The opcode must be valid for a shader modules. 2) The opcode must be invalid for the current shader stage. 3) All entry points to the module must be for the same shader stage. 4) The function containing the instruction must be reachable from an entry point. Fixes #1247.
2018-01-30 16:24:03 +00:00
Optimizer::PassToken CreateReplaceInvalidOpcodePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::ReplaceInvalidOpcodePass>());
}
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
Optimizer::PassToken CreateSimplificationPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SimplificationPass>());
}
Initial support for loop unrolling. This patch adds initial support for loop unrolling in the form of a series of utility classes which perform the unrolling. The pass can be run with the command spirv-opt --loop-unroll. This will unroll loops within the module which have the unroll hint set. The unroller imposes a number of requirements on the loops it can unroll. These are documented in the comments for the LoopUtils::CanPerformUnroll method in loop_utils.h. Some of the restrictions will be lifted in future patches.
2018-02-14 17:03:12 +00:00
Unroller support for multiple induction variables Support for multiple induction variables within a loop and support for loop condition operands <= and >=.
2018-02-27 11:50:08 +00:00
Optimizer::PassToken CreateLoopUnrollPass(bool fully_unroll, int factor) {
Initial support for loop unrolling. This patch adds initial support for loop unrolling in the form of a series of utility classes which perform the unrolling. The pass can be run with the command spirv-opt --loop-unroll. This will unroll loops within the module which have the unroll hint set. The unroller imposes a number of requirements on the loops it can unroll. These are documented in the comments for the LoopUtils::CanPerformUnroll method in loop_utils.h. Some of the restrictions will be lifted in future patches.
2018-02-14 17:03:12 +00:00
return MakeUnique<Optimizer::PassToken::Impl>(
Unroller support for multiple induction variables Support for multiple induction variables within a loop and support for loop condition operands <= and >=.
2018-02-27 11:50:08 +00:00
MakeUnique<opt::LoopUnroller>(fully_unroll, factor));
Initial support for loop unrolling. This patch adds initial support for loop unrolling in the form of a series of utility classes which perform the unrolling. The pass can be run with the command spirv-opt --loop-unroll. This will unroll loops within the module which have the unroll hint set. The unroller imposes a number of requirements on the loops it can unroll. These are documented in the comments for the LoopUtils::CanPerformUnroll method in loop_utils.h. Some of the restrictions will be lifted in future patches.
2018-02-14 17:03:12 +00:00
}
SSA rewrite pass. This pass replaces the load/store elimination passes. It implements the SSA re-writing algorithm proposed in Simple and Efficient Construction of Static Single Assignment Form. Braun M., Buchwald S., Hack S., Leißa R., Mallon C., Zwinkau A. (2013) In: Jhala R., De Bosschere K. (eds) Compiler Construction. CC 2013. Lecture Notes in Computer Science, vol 7791. Springer, Berlin, Heidelberg https://link.springer.com/chapter/10.1007/978-3-642-37051-9_6 In contrast to common eager algorithms based on dominance and dominance frontier information, this algorithm works backwards from load operations. When a target variable is loaded, it queries the variable's reaching definition. If the reaching definition is unknown at the current location, it searches backwards in the CFG, inserting Phi instructions at join points in the CFG along the way until it finds the desired store instruction. The algorithm avoids repeated lookups using memoization. For reducible CFGs, which are a superset of the structured CFGs in SPIRV, this algorithm is proven to produce minimal SSA. That is, it inserts the minimal number of Phi instructions required to ensure the SSA property, but some Phi instructions may be dead (https://en.wikipedia.org/wiki/Static_single_assignment_form).
2018-02-22 21:18:29 +00:00
Optimizer::PassToken CreateSSARewritePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SSARewritePass>());
}
Copy propagate arrays The sprir-v generated from HLSL code contain many copyies of very large arrays. Not only are these time consumming, but they also cause problems for drivers because they require too much space. To work around this, we will implement an array copy propagation. Note that we will not implement a complete array data flow analysis in order to implement this. We will be looking for very simple cases: 1) The source must never be stored to. 2) The target must be stored to exactly once. 3) The store to the target must be a store to the entire array, and be a copy of the entire source. 4) All loads of the target must be dominated by the store. The hard part is keeping all of the types correct. We do not want to have to do too large a search to update everything, which may not be possible, do we give up if we see any instruction that might be hard to update. Also in types.h, the element decorations are not stored in an std::map. This change was done so the hashing algorithm for a Struct is consistent. With the std::unordered_map, the traversal order was non-deterministic leading to the same type getting hashed to different values. See |Struct::GetExtraHashWords|. Contributes to #1416.
2018-03-21 03:33:24 +00:00
Optimizer::PassToken CreateCopyPropagateArraysPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CopyPropagateArrays>());
}
Vector DCE (#1512) Introduce a pass that does a DCE type analysis for vector elements instead of the whole vector as a single element. It will then rewrite instructions that are not used with something else. For example, an instruction whose value are not used, even though it is referenced, is replaced with an OpUndef.
2018-04-23 15:13:07 +00:00
Optimizer::PassToken CreateVectorDCEPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::VectorDCE>());
}
Add pass to fold a load feeding an extract. We have already disabled common uniform elimination because it created sequences of loads an entire uniform object, then we extract just a single element. This caused problems in some drivers, and is just generally slow because it loads more memory than needed. However, there are other way to get into this situation, so I've added a pass that looks specifically for this pattern and removes it when only a portion of the load is used. Fixes #1547.
2018-05-07 16:31:03 +00:00
Optimizer::PassToken CreateReduceLoadSizePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::ReduceLoadSize>());
}
Transform to combine consecutive access chains * Combines OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain and OpInBoundsPtrAccessChain * New folding rule to fold add with 0 for integers * Converts to a bitcast if the result type does not match the operand type V
2018-07-23 15:23:11 +00:00
Optimizer::PassToken CreateCombineAccessChainsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CombineAccessChains>());
}
Add base and core bindless validation instrumentation classes (#2014) * Add base and core bindless validation instrumentation classes * Fix formatting. * Few more formatting fixes * Fix build failure * More build fixes * Need to call non-const functions in order. Specifically, these are functions which call TakeNextId(). These need to be called in a specific order to guarantee that tests which do exact compares will work across all platforms. c++ pretty much does not guarantee order of evaluation of operands, so any such functions need to be called separately in individual statements to guarantee order. * More ordering. * And more ordering. * And more formatting. * Attempt to fix NDK build * Another attempt to address NDK build problem. * One more attempt at NDK build failure * Add instrument.hpp to BUILD.gn * Some name improvement in instrument.hpp * Change all types in instrument.hpp to int. * Improve documentation in instrument.hpp * Format fixes * Comment clean up in instrument.hpp * imageInst -> image_inst * Fix GetLabel() issue.
2018-11-08 18:54:54 +00:00
Update memory model (#1904) Upgrade to VulkanKHR memory model * Converts Logical GLSL450 memory model to Logical VulkanKHR * Adds extension and capability * Removes deprecated decorations and replaces them with appropriate flags on downstream instructions * Support for Workgroup upgrades * Support for copy memory * Adding support for image functions * Adding barrier upgrades and tests * Use QueueFamilyKHR scope instead of device
2018-11-30 19:15:51 +00:00
Optimizer::PassToken CreateUpgradeMemoryModelPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::UpgradeMemoryModel>());
}
Add base and core bindless validation instrumentation classes (#2014) * Add base and core bindless validation instrumentation classes * Fix formatting. * Few more formatting fixes * Fix build failure * More build fixes * Need to call non-const functions in order. Specifically, these are functions which call TakeNextId(). These need to be called in a specific order to guarantee that tests which do exact compares will work across all platforms. c++ pretty much does not guarantee order of evaluation of operands, so any such functions need to be called separately in individual statements to guarantee order. * More ordering. * And more ordering. * And more formatting. * Attempt to fix NDK build * Another attempt to address NDK build problem. * One more attempt at NDK build failure * Add instrument.hpp to BUILD.gn * Some name improvement in instrument.hpp * Change all types in instrument.hpp to int. * Improve documentation in instrument.hpp * Format fixes * Comment clean up in instrument.hpp * imageInst -> image_inst * Fix GetLabel() issue.
2018-11-08 18:54:54 +00:00
Optimizer::PassToken CreateInstBindlessCheckPass(uint32_t desc_set,
Expand bindless bounds checking to runtime-sized descriptor arrays (#2316)
2019-02-07 19:00:36 +00:00
uint32_t shader_id,
Bindless Validation: Descriptor Initialization Check (#2419) If SPV_EXT_descriptor_indexing is enabled, add check that for a descriptor-based reference, the descriptor is initialized. Initialization data is stored in the debug input buffer, added to the length information already there. This feature must be seperately enabled on the pass creation routine. NOTE: Currently just supports image references; buffer references are still TODO.
2019-03-19 13:53:43 +00:00
bool input_length_enable,
Instrument: Add version 2 of record formats (#2630) New version has additional word in stage-specific section. Also some changes in content for tesselation and compute shaders. Either version can be invoked at pass creation. This is done to ease integration and updating of validation layers. Version 1 is deprecated and eventually will go away. Also sneaking in fix to version 1 compute shaders.
2019-05-29 19:08:21 +00:00
bool input_init_enable,
uint32_t version) {
Add base and core bindless validation instrumentation classes (#2014) * Add base and core bindless validation instrumentation classes * Fix formatting. * Few more formatting fixes * Fix build failure * More build fixes * Need to call non-const functions in order. Specifically, these are functions which call TakeNextId(). These need to be called in a specific order to guarantee that tests which do exact compares will work across all platforms. c++ pretty much does not guarantee order of evaluation of operands, so any such functions need to be called separately in individual statements to guarantee order. * More ordering. * And more ordering. * And more formatting. * Attempt to fix NDK build * Another attempt to address NDK build problem. * One more attempt at NDK build failure * Add instrument.hpp to BUILD.gn * Some name improvement in instrument.hpp * Change all types in instrument.hpp to int. * Improve documentation in instrument.hpp * Format fixes * Comment clean up in instrument.hpp * imageInst -> image_inst * Fix GetLabel() issue.
2018-11-08 18:54:54 +00:00
return MakeUnique<Optimizer::PassToken::Impl>(
Instrument: Add version 2 of record formats (#2630) New version has additional word in stage-specific section. Also some changes in content for tesselation and compute shaders. Either version can be invoked at pass creation. This is done to ease integration and updating of validation layers. Version 1 is deprecated and eventually will go away. Also sneaking in fix to version 1 compute shaders.
2019-05-29 19:08:21 +00:00
MakeUnique<opt::InstBindlessCheckPass>(desc_set, shader_id,
input_length_enable,
input_init_enable, version));
Add base and core bindless validation instrumentation classes (#2014) * Add base and core bindless validation instrumentation classes * Fix formatting. * Few more formatting fixes * Fix build failure * More build fixes * Need to call non-const functions in order. Specifically, these are functions which call TakeNextId(). These need to be called in a specific order to guarantee that tests which do exact compares will work across all platforms. c++ pretty much does not guarantee order of evaluation of operands, so any such functions need to be called separately in individual statements to guarantee order. * More ordering. * And more ordering. * And more formatting. * Attempt to fix NDK build * Another attempt to address NDK build problem. * One more attempt at NDK build failure * Add instrument.hpp to BUILD.gn * Some name improvement in instrument.hpp * Change all types in instrument.hpp to int. * Improve documentation in instrument.hpp * Format fixes * Comment clean up in instrument.hpp * imageInst -> image_inst * Fix GetLabel() issue.
2018-11-08 18:54:54 +00:00
}
Instrument: Add support for Buffer Device Address extension (#2792)
2019-08-16 13:18:34 +00:00
Optimizer::PassToken CreateInstBuffAddrCheckPass(uint32_t desc_set,
uint32_t shader_id,
uint32_t version) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::InstBuffAddrCheckPass>(desc_set, shader_id, version));
}
Add --relax-float-ops and --convert-relaxed-to-half (#2808) The first pass applies the RelaxedPrecision decoration to all executable instructions with float32 based type results. The second pass converts all executable instructions with RelaxedPrecision result to the equivalent float16 type, inserting converts where necessary.
2019-09-03 17:22:13 +00:00
Optimizer::PassToken CreateConvertRelaxedToHalfPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::ConvertToHalfPass>());
}
Optimizer::PassToken CreateRelaxFloatOpsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::RelaxFloatOpsPass>());
}
Sink (#2284) Add code sinking pass. It will move OpLoad and OpAccessChain instructions as close as possible to their uses. Part of #1611.
2019-01-17 20:56:36 +00:00
Optimizer::PassToken CreateCodeSinkingPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::CodeSinkingPass>());
}
Add pass to generate needed initializers for WebGPU (#2481) Fixes #2387
2019-04-03 15:44:09 +00:00
Optimizer::PassToken CreateGenerateWebGPUInitializersPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::GenerateWebGPUInitializersPass>());
}
Add fix storage class code. (#2434) This pass tries to fix validation error due to a mismatch of storage classes in instructions. There is no guarantee that all such error will be fixed, and it is possible that in fixing these errors, it could lead to other errors. Fixes #2430.
2019-04-05 17:12:08 +00:00
Optimizer::PassToken CreateFixStorageClassPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::FixStorageClass>());
}
Add pass to legalize OpVectorShuffle for WebGPU (#2509) In WebGPU, the component operand 0xFFFFFFFF is forbidden, but in Vulkan it is used to indicate a value is undefined. When converting to WebGPU, 0xFFFFFFFF needs to converted to a legal value, though the specific one does not matter, since it was used to indicate an undefined entry in the original code. Choosing to use 0, since the operands are required to be on [0, N-1], so 0 is guaranteed to always be valid. Fixes #2349
2019-04-12 16:14:23 +00:00
Optimizer::PassToken CreateLegalizeVectorShufflePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::LegalizeVectorShufflePass>());
}
Implement WebGPU->Vulkan initializer conversion for 'Function' variables (#2513) WebGPU requires certain variables to be initialized, whereas there are known issues with using initializers in Vulkan. This PR is the first of three implementing a pass to decompose initialized variables into a variable declaration followed by a store. This has been broken up into multiple PRs, because there 3 distinct cases that need to be handled, which require separate implementations. This first PR implements the basic infrastructure that is needed, and handling of Function storage class variables. Private and Output will be handled in future PRs. This is part of resolving #2388
2019-04-16 18:31:36 +00:00
Optimizer::PassToken CreateDecomposeInitializedVariablesPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::DecomposeInitializedVariablesPass>());
}
Add pass to fix some invalid unreachable blocks for WebGPU (#2563) Attempts to split up unreachable blocks that are used both as a merge-block and a continue-target. Fixes #2429
2019-05-09 16:56:10 +00:00
Optimizer::PassToken CreateSplitInvalidUnreachablePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SplitInvalidUnreachablePass>());
}
Add pass to inject code for robust-buffer-access semantics (#2771) spirv-opt: Add --graphics-robust-access Clamps access chain indices so they are always in bounds. Assumes: - Logical addressing mode - No runtime-array-descriptor-indexing - No variable pointers Adds stub code for clamping coordinate and samples for OpImageTexelPointer. Adds SinglePassRunAndFail optimizer test fixture. Android.mk: add source/opt/graphics_robust_access_pass.cpp Adds Constant::GetSignExtendedValue, Constant::GetZeroExtendedValue
2019-07-30 23:52:46 +00:00
Optimizer::PassToken CreateGraphicsRobustAccessPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::GraphicsRobustAccessPass>());
}
Add descriptor array scalar replacement (#2742) Creates a pass that will replace a descriptor array with individual variables. See #2740 for details. Fixes #2740.
2019-08-08 14:53:19 +00:00
Optimizer::PassToken CreateDescriptorScalarReplacementPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::DescriptorScalarReplacement>());
}
Replace OpKill With function call. (#2790) We are no able to inline OpKill instructions into a continue construct. See #2433. However, we have to be able to inline to correctly do legalization. This commit creates a pass that will wrap OpKill instructions into a function of its own. That way we are able to inline the rest of the code. The follow up to this will be to not inline any function that contains an OpKill. Fixes #2726
2019-08-14 13:27:12 +00:00
Optimizer::PassToken CreateWrapOpKillPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::WrapOpKill>());
}
Amd ext to khr (#2811) Add the first steps to removing the AMD extension VK_AMD_shader_ballot. Splitting up to make the PRs smaller. Adding utilities to add capabilities and change the version of the module. Replaces the instructions: OpGroupIAddNonUniformAMD = 5000 OpGroupFAddNonUniformAMD = 5001 OpGroupFMinNonUniformAMD = 5002 OpGroupUMinNonUniformAMD = 5003 OpGroupSMinNonUniformAMD = 5004 OpGroupFMaxNonUniformAMD = 5005 OpGroupUMaxNonUniformAMD = 5006 OpGroupSMaxNonUniformAMD = 5007 and extentend instructions WriteInvocationAMD = 3 MbcntAMD = 4 Part of #2814
2019-08-29 16:48:17 +00:00
Optimizer::PassToken CreateAmdExtToKhrPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::AmdExtensionToKhrPass>());
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
} // namespace spvtools
Reference in New Issue Copy Permalink