AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-29 22:41:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
0df791f97a
SPIRV-Tools/source/opt/optimizer.cpp

1218 lines
46 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>
opt: Add SwitchDescriptorSetPass (#5375) This is a simple pass to change DescriptorSet decoration values.
2023-08-22 00:16:35 +00:00
#include <charconv>
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 passes to eliminate dead output stores (#4970) This adds two passes to accomplish this: one pass to analyze a shader to determine the input slots that are live. The second pass is run on the preceding shader to eliminate any stores to output slots that are not consumed by the following shader. These passes support vert, tesc, tese, geom, and frag shaders. These passes are currently only available through the API. These passes together with dead code elimination, and elimination of dead input and output components and variables (WIP), will allow users to do dead code elimination across shader boundaries.
2022-11-02 17:23:25 +00:00
std::unordered_set<uint32_t> live_locs; // Arg to debug dead output passes
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
};
Remove WebGPU support (#4108) Leaves SPV_ENV_WEBGPU_0 enum in place, but marked deprecated, so users of the library are not broken by an API enum being removed. Fixes #4101
2021-01-14 21:45:18 +00:00
Optimizer::Optimizer(spv_target_env env) : impl_(new Impl(env)) {
assert(env != SPV_ENV_WEBGPU_0);
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
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.
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
Optimizer& Optimizer::RegisterLegalizationPasses(bool preserve_interface) {
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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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(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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
Add a new legalization pass to dedupe invocation interlock instructions (#5409) Add a new legalization pass to dedupe invocation interlock instructions DXC will be adding support for HLSL's rasterizer ordered views by using the SPV_EXT_fragment_shader_interlock_extension. That extension stipulates that if an entry point has an interlock ordering execution mode, it must dynamically execute OpBeginInvocationInterlockEXT and OpEndInvocationInterlockEXT, in that order, exactly once. This would be difficult to determine in DXC's SPIR-V backend, so instead we will emit these instructions potentially multiple times, and use this legalization pass to ensure that the final SPIR-V follows the specification. This PR uses data-flow analysis to determine where to place begin and end instructions; in essence, determining whether a block contains or is preceded by a begin instruction is similar to a specialized case of a reaching definitions analysis, where we have only a single definition, such as `bool has_begun = false`. For this simpler case, we can compute the set of blocks using BFS to determine the reachability of the begin instruction. We need to do this for both begin and end instructions, so I have generalized portions of the code to run both forward and backward over the CFG for each respective case.
2023-09-27 23:54:10 +00:00
.RegisterPass(CreateInterpolateFixupPass())
.RegisterPass(CreateInvocationInterlockPlacementPass());
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
}
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
Optimizer& Optimizer::RegisterLegalizationPasses() {
return RegisterLegalizationPasses(false);
}
Optimizer& Optimizer::RegisterPerformancePasses(bool preserve_interface) {
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())
Add dead function elimination to -O (#4015) Fixes #4003 Both legalization and size formulae already run dead function elimination after inlining. This change does the same for performance passes.
2020-11-05 18:03:45 +00:00
.RegisterPass(CreateEliminateDeadFunctionsPass())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
Add unrolling to performance passes (#3082) Unroll loops that are marked as unroll when doing -O. Add cleanup optimizations after unrolling. Fixes #3067
2020-05-20 19:43:13 +00:00
.RegisterPass(CreateLoopUnrollPass(true))
.RegisterPass(CreateDeadBranchElimPass())
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())
Add unrolling to performance passes (#3082) Unroll loops that are marked as unroll when doing -O. Add cleanup optimizations after unrolling. Fixes #3067
2020-05-20 19:43:13 +00:00
.RegisterPass(CreateScalarReplacementPass())
.RegisterPass(CreateLocalAccessChainConvertPass())
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
Add unrolling to performance passes (#3082) Unroll loops that are marked as unroll when doing -O. Add cleanup optimizations after unrolling. Fixes #3067
2020-05-20 19:43:13 +00:00
.RegisterPass(CreateSSARewritePass())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
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
}
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
Optimizer& Optimizer::RegisterPerformancePasses() {
return RegisterPerformancePasses(false);
}
Optimizer& Optimizer::RegisterSizePasses(bool preserve_interface) {
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())
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateEliminateDeadFunctionsPass())
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())
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateScalarReplacementPass(0))
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())
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())
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateLoopUnrollPass(true))
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())
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateSimplificationPass())
.RegisterPass(CreateScalarReplacementPass(0))
.RegisterPass(CreateLocalSingleStoreElimPass())
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())
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateSimplificationPass())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateDeadBranchElimPass())
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())
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateLocalAccessChainConvertPass())
.RegisterPass(CreateLocalSingleBlockLoadStoreElimPass())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateCopyPropagateArraysPass())
.RegisterPass(CreateVectorDCEPass())
InsertExtractElim: Split out DeadInsertElim as separate pass
2018-01-27 00:05:33 +00:00
.RegisterPass(CreateDeadInsertElimPass())
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateEliminateDeadMembersPass())
.RegisterPass(CreateLocalSingleStoreElimPass())
.RegisterPass(CreateBlockMergePass())
.RegisterPass(CreateLocalMultiStoreElimPass())
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())
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateSimplificationPass())
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
.RegisterPass(CreateAggressiveDCEPass(preserve_interface))
Improve RegisterSizePasses (#3059)
2019-11-27 14:41:50 +00:00
.RegisterPass(CreateCFGCleanupPass());
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
}
Expose preserve_interface in Optimizer::Register*Passes. (#5268) Fixes #5266
2023-06-14 14:00:26 +00:00
Optimizer& Optimizer::RegisterSizePasses() { return RegisterSizePasses(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
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.
Remove WebGPU support (#4108) Leaves SPV_ENV_WEBGPU_0 enum in place, but marked deprecated, so users of the library are not broken by an API enum being removed. Fixes #4101
2021-01-14 21:45:18 +00:00
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());
Rename strip reflect to strip nonsemantic (#4661) In https://github.com/KhronosGroup/SPIRV-Tools/pull/3110, the strip reflect pass was changed to also remove all explicitly nonsemantic instructions. This makes it so that the name of the pass no longer reflects what the pass actually does. This change renames the pass so that it reflects what the pass actaully does.
2021-12-15 14:55:30 +00:00
} else if (pass_name == "strip-nonsemantic") {
RegisterPass(CreateStripNonSemanticInfoPass());
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 == "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 spirv-opt pass to replace descriptor accesses based on variable indices (#4574) This commit adds a spirv-opt pass to replace accesses to descriptor array based on variable indices with constant elements. Before: ``` %descriptor = OpVariable %_ptr_array_Image Uniform ... %ac = OpAccessChain %_ptr_Image %descriptor %variable_index (some image instructions using %ac) ``` After: ``` %descriptor = OpVariable %_ptr_array_Image Uniform ... OpSwitch %variable_index 0 %case0 1 %case1 ... ... %case0 = OpLabel %ac = OpAccessChain %_ptr_Image %descriptor %uint_0 ... %case1 = OpLabel %ac = OpAccessChain %_ptr_Image %descriptor %uint_1 ... (use OpPhi for value with concrete type) ```
2021-10-26 21:20:58 +00:00
} else if (pass_name == "replace-desc-array-access-using-var-index") {
RegisterPass(CreateReplaceDescArrayAccessUsingVarIndexPass());
spirv-opt: add pass to Spread Volatile semantics (#4667) Add a pass to spread Volatile semantics to variables with SMIDNV, WarpIDNV, SubgroupSize, SubgroupLocalInvocationId, SubgroupEqMask, SubgroupGeMask, SubgroupGtMask, SubgroupLeMask, or SubgroupLtMask BuiltIn decorations or OpLoad for them when the shader model is the ray generation, closest hit, miss, intersection, or callable shaders. This pass can be used for VUID-StandaloneSpirv-VulkanMemoryModel-04678 and VUID-StandaloneSpirv-VulkanMemoryModel-04679 (See "Standalone SPIR-V Validation" section of Vulkan spec "Appendix A: Vulkan Environment for SPIR-V"). Handle variables used by multiple entry points: 1. Update error check to make it working regardless of the order of entry points. 2. For a variable, if it is used by two entry points E1 and E2 and it needs the Volatile semantics for E1 while it does not for E2 - If VulkanMemoryModel capability is enabled, which means we have to set memory operation of load instructions for the variable, we update load instructions in E1, but do not update the ones in E2. - If VulkanMemoryModel capability is disabled, which means we have to add Volatile decoration for the variable, we report an error because E1 needs to add Volatile decoration for the variable while E2 does not. For the simplicity of the implementation, we assume that all functions other than entry point functions are inlined.
2022-01-25 18:14:36 +00:00
} else if (pass_name == "spread-volatile-semantics") {
RegisterPass(CreateSpreadVolatileSemanticsPass());
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());
} 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") {
Set threshold for reduce-load-size pass (#4499) Allow uses to set the threshold for spirv-opt reduce-load-size pass
2021-09-02 14:45:51 +00:00
if (pass_args.size() == 0) {
RegisterPass(CreateReduceLoadSizePass());
} else {
double load_replacement_threshold = 0.9;
if (pass_args.find_first_not_of(".0123456789") == std::string::npos) {
load_replacement_threshold = atof(pass_args.c_str());
}
if (load_replacement_threshold >= 0) {
RegisterPass(CreateReduceLoadSizePass(load_replacement_threshold));
} else {
Error(consumer(), nullptr, {},
"--reduce-load-size must have no arguments or a non-negative "
"double 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 == "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());
instrument: Combine descriptor length and init state checking (#5274) Simplify what we add to user code by moving most of it into a function that checks both that the descriptor index is in bounds and the initialization state. Move error logging into this function as well. Remove many options to turn off parts of the instrumentation, because there were far too many permutations to keep working and test properly. Combine Buffer and TexBuffer error checking. This requires that VVL set the length of TexBuffers in the descriptor input state, rather than relying on the instrumentation code to call OpImageQuerySize. Since the error log includes the descriptor set and binding numbers we can use a single OOB error code rather than having 4 per-type error codes. Since the error codes are getting renumbered, make them start at 1 rather than 0 so it is easier to determine if the error code was actually set by the instrumentation.
2023-06-22 15:39:49 +00:00
} else if (pass_name == "inst-bindless-check" ||
pass_name == "inst-desc-idx-check" ||
pass_name == "inst-buff-oob-check") {
// preserve legacy names
instrument: Use Import linkage for instrumentation functions (#5355) These functions are getting far too complicated to code in SPIRV-Tools C++. Replace them with import stubs so that the real implementations can live in Vulkan-ValidationLayers where they belong. VVL will need to define these functions in spirv and link them to the instrumented version of the user's shader. From here on out, VVL can redefine the functions and any data they use without updating SPIRV-Tools. Changing the function declarations will still require both VVL and SPIRV-Tools to be updated in lock step.
2023-09-20 16:50:30 +00:00
RegisterPass(CreateInstBindlessCheckPass(23));
Add buffer oob check to bindless instrumentation (#3800)
2020-09-16 13:23:46 +00:00
RegisterPass(CreateSimplificationPass());
RegisterPass(CreateDeadBranchElimPass());
RegisterPass(CreateBlockMergePass());
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") {
instrument: Use Import linkage for instrumentation functions (#5355) These functions are getting far too complicated to code in SPIRV-Tools C++. Replace them with import stubs so that the real implementations can live in Vulkan-ValidationLayers where they belong. VVL will need to define these functions in spirv and link them to the instrumented version of the user's shader. From here on out, VVL can redefine the functions and any data they use without updating SPIRV-Tools. Changing the function declarations will still require both VVL and SPIRV-Tools to be updated in lock step.
2023-09-20 16:50:30 +00:00
RegisterPass(CreateInstBuffAddrCheckPass(23));
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());
Instrument: Debug Printf support (#3215) Create a pass to instrument OpDebugPrintf instructions. This pass replaces all OpDebugPrintf instructions with instructions to write a record containing the string id and the all specified values into a special printf output buffer (if space allows). This pass is designed to support the printf validation in the Vulkan validation layers. Fixes #3210
2020-03-12 13:19:52 +00:00
} else if (pass_name == "inst-debug-printf") {
Add comment to --inst-debug-printf option (#5466)
2023-11-14 18:00:54 +00:00
// This private option is not for user consumption.
// It is here to assist in debugging and fixing the debug printf
// instrumentation pass.
// For users who wish to utilize debug printf, see the white paper at
// https://www.lunarg.com/wp-content/uploads/2021/08/Using-Debug-Printf-02August2021.pdf
Instrument: Debug Printf support (#3215) Create a pass to instrument OpDebugPrintf instructions. This pass replaces all OpDebugPrintf instructions with instructions to write a record containing the string id and the all specified values into a special printf output buffer (if space allows). This pass is designed to support the printf validation in the Vulkan validation layers. Fixes #3210
2020-03-12 13:19:52 +00:00
RegisterPass(CreateInstDebugPrintfPass(7, 23));
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();
spirv-opt: A pass to removed unused input on OpEntryPoint instructions. (#4275) The new pass will removed interface variable on the OpEntryPoint instruction when they are not statically referenced in the call tree of the entry point. It can be enabled on the command line using the options `remove-unused-interface-variables`.
2021-06-29 15:33:58 +00:00
} else if (pass_name == "remove-unused-interface-variables") {
RegisterPass(CreateRemoveUnusedInterfaceVariablesPass());
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 interpolate legalization pass (#4220) This pass converts an internal form of GLSLstd450 Interpolate ops to the externally valid form. The external form takes the lvalue of the interpolant. The internal form can do a load of the interpolant. The pass replaces the load with its pointer. The internal form is generated by glslang and possibly other frontends for HLSL shaders. The new pass is called as part of HLSL legalization after all propagation is complete. Also adds internal interpolate form to pre-legalization validation
2021-03-31 18:26:36 +00:00
} else if (pass_name == "interpolate-fixup") {
RegisterPass(CreateInterpolateFixupPass());
Add pass to remove DontInline function control (#4747) Swift shader needs a way to inline all functions, even those marked as DontInline. See https://github.com/KhronosGroup/SPIRV-Tools/pull/4471. This implements the suggestion I made in the PR. We add a pass that will remove the DontInline function control, so that the inlining passes will inline them. SwiftShader will still have to modify their code to add this pass before the other passes are run.
2022-03-07 17:45:17 +00:00
} else if (pass_name == "remove-dont-inline") {
RegisterPass(CreateRemoveDontInlinePass());
spirv-opt: (WIP) Eliminate Dead Input Component Pass (#4720) This adds the --eliminate-dead-input-components pass which currently removes trailing unused components from input arrays. Fixes #4532
2022-03-23 02:50:52 +00:00
} else if (pass_name == "eliminate-dead-input-components") {
Split EliminateDeadInputComponents into safe and unsafe versions. (#4984) Safe version will only optimize vertex shaders. All other shaders will succeed without change. Change --eliminate-dead-input-components to use new safe version. Unsafe version (allowing non-vertex shaders) currently only available through API. Should only be used in combination with other optimizations to keep interfaces consistent. See optimizer.hpp for more details.
2022-11-14 18:44:26 +00:00
RegisterPass(CreateEliminateDeadInputComponentsSafePass());
spirv-opt : Add FixFuncCallArgumentsPass (#4775) spirv validation require OpFunctionCall with memory object, usually this is non issue as all the functions are inlined. This pass deal with some case for DontInline function. accesschain input operand would be replaced new created variable
2022-05-06 14:39:26 +00:00
} else if (pass_name == "fix-func-call-param") {
RegisterPass(CreateFixFuncCallArgumentsPass());
Add spirv-opt convert-to-sampled-image pass (#4340) convert-to-sampled-image pass converts images and/or samplers with given pairs of descriptor set and binding to sampled image. If a pair of an image and a sampler have the same pair of descriptor set and binding that is one of the given pairs, they will be converted to a sampled image. In addition, if only an image has the descriptor set and binding that is one of the given pairs, it will be converted to a sampled image as well. For example, when we have %a = OpLoad %type_2d_image %texture %b = OpLoad %type_sampler %sampler %combined = OpSampledImage %type_sampled_image %a %b %value = OpImageSampleExplicitLod %v4float %combined ... 1. If %texture and %sampler have the same descriptor set and binding %combine_texture_and_sampler = OpVaraible %ptr_type_sampled_image_Uniform ... %combined = OpLoad %type_sampled_image %combine_texture_and_sampler %value = OpImageSampleExplicitLod %v4float %combined ... 2. If %texture and %sampler have different pairs of descriptor set and binding %a = OpLoad %type_sampled_image %texture %extracted_image = OpImage %type_2d_image %a %b = OpLoad %type_sampler %sampler %combined = OpSampledImage %type_sampled_image %extracted_image %b %value = OpImageSampleExplicitLod %v4float %combined ...
2021-08-18 12:30:48 +00:00
} else if (pass_name == "convert-to-sampled-image") {
if (pass_args.size() > 0) {
auto descriptor_set_binding_pairs =
opt::ConvertToSampledImagePass::ParseDescriptorSetBindingPairsString(
pass_args.c_str());
if (!descriptor_set_binding_pairs) {
Errorf(consumer(), nullptr, {},
"Invalid argument for --convert-to-sampled-image: %s",
pass_args.c_str());
return false;
}
RegisterPass(CreateConvertToSampledImagePass(
std::move(*descriptor_set_binding_pairs)));
} else {
Errorf(consumer(), nullptr, {},
"Invalid pairs of descriptor set and binding '%s'. Expected a "
"string of <descriptor set>:<binding> pairs.",
pass_args.c_str());
return false;
}
opt: Add SwitchDescriptorSetPass (#5375) This is a simple pass to change DescriptorSet decoration values.
2023-08-22 00:16:35 +00:00
} else if (pass_name == "switch-descriptorset") {
if (pass_args.size() == 0) {
Error(consumer(), nullptr, {},
"--switch-descriptorset requires a from:to argument.");
return false;
}
uint32_t from_set, to_set;
const char* start = pass_args.data();
const char* end = pass_args.data() + pass_args.size();
auto result = std::from_chars(start, end, from_set);
if (result.ec != std::errc()) {
Errorf(consumer(), nullptr, {},
"Invalid argument for --switch-descriptorset: %s",
pass_args.c_str());
return false;
}
start = result.ptr;
if (start[0] != ':') {
Errorf(consumer(), nullptr, {},
"Invalid argument for --switch-descriptorset: %s",
pass_args.c_str());
return false;
}
start++;
result = std::from_chars(start, end, to_set);
if (result.ec != std::errc() || result.ptr != end) {
Errorf(consumer(), nullptr, {},
"Invalid argument for --switch-descriptorset: %s",
pass_args.c_str());
return false;
}
RegisterPass(CreateSwitchDescriptorSetPass(from_set, to_set));
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
Add data structure for DebugScope, DebugDeclare in spirv-opt (#3183) When DebugScope is given in SPIR-V, each instruction following the DebugScope is from the lexical scope pointed by the DebugScope in the high level language. We add DebugScope struction to keep the scope information in Instruction class. When ir_loader loads DebugScope/DebugNoScope, it keeps the scope information in |last_dbg_scope_| and lets following instructions have that scope information. In terms of DebugDeclare/DebugValue, if it is in a function body but outside of a basic block, we keep it in |debug_insts_in_header_| of Function class. If it is in a basic block, we keep it as a normal instruction i.e., in a instruction list of BasicBlock.
2020-03-23 15:01:18 +00:00
// We do not keep the result id of DebugScope in struct DebugScope.
Favour 'integrity' over 'coherence' as a replacement for 'sanity'. (#3619)
2020-09-10 13:52:21 +00:00
// Instead, we assign random ids for them, which results in integrity
Avoid integrity check failures caused by propagating line instructions (#4096) Propagating the OpLine/OpNoLine to preserve the debug information through transformations results in integrity check failures because of the extra line instructions. This commit lets spirv-opt skip the integrity check when the code contains OpLine or OpNoLine.
2021-01-13 14:08:28 +00:00
// check failures. In addition, propagating the OpLine/OpNoLine to preserve
// the debug information through transformations results in integrity
Favour 'integrity' over 'coherence' as a replacement for 'sanity'. (#3619)
2020-09-10 13:52:21 +00:00
// check failures. We want to skip the integrity check when the module
Avoid integrity check failures caused by propagating line instructions (#4096) Propagating the OpLine/OpNoLine to preserve the debug information through transformations results in integrity check failures because of the extra line instructions. This commit lets spirv-opt skip the integrity check when the code contains OpLine or OpNoLine.
2021-01-13 14:08:28 +00:00
// contains DebugScope or OpLine/OpNoLine instructions.
Add data structure for DebugScope, DebugDeclare in spirv-opt (#3183) When DebugScope is given in SPIR-V, each instruction following the DebugScope is from the lexical scope pointed by the DebugScope in the high level language. We add DebugScope struction to keep the scope information in Instruction class. When ir_loader loads DebugScope/DebugNoScope, it keeps the scope information in |last_dbg_scope_| and lets following instructions have that scope information. In terms of DebugDeclare/DebugValue, if it is in a function body but outside of a basic block, we keep it in |debug_insts_in_header_| of Function class. If it is in a basic block, we keep it as a normal instruction i.e., in a instruction list of BasicBlock.
2020-03-23 15:01:18 +00:00
if (status == opt::Pass::Status::SuccessWithoutChange &&
Avoid integrity check failures caused by propagating line instructions (#4096) Propagating the OpLine/OpNoLine to preserve the debug information through transformations results in integrity check failures because of the extra line instructions. This commit lets spirv-opt skip the integrity check when the code contains OpLine or OpNoLine.
2021-01-13 14:08:28 +00:00
!context->module()->ContainsDebugInfo()) {
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");
Do not check if the binary changed if encoding is different (#4824) There is an assert that verifies that the binary did not change when the optimizer said that it did not. However, if the input binary is in big endian format, the optimizer will encode the optimized binary in little endian. This causes the assert to fail. Since we do not believe that anybody cares about a big endien formate, we will disable the assert in that case. Fixes #4722
2022-06-21 19:58:21 +00:00
// Compare the magic number to make sure the binaries were encoded in the
// endianness. If not, the contents of the binaries will be different, so
// do not check the contents.
if (optimized_binary_with_nop[0] == original_binary[0]) {
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>());
}
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() {
Rename strip reflect to strip nonsemantic (#4661) In https://github.com/KhronosGroup/SPIRV-Tools/pull/3110, the strip reflect pass was changed to also remove all explicitly nonsemantic instructions. This makes it so that the name of the pass no longer reflects what the pass actually does. This change renames the pass so that it reflects what the pass actaully does.
2021-12-15 14:55:30 +00:00
return CreateStripNonSemanticInfoPass();
}
Optimizer::PassToken CreateStripNonSemanticInfoPass() {
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
return MakeUnique<Optimizer::PassToken::Impl>(
Rename strip reflect to strip nonsemantic (#4661) In https://github.com/KhronosGroup/SPIRV-Tools/pull/3110, the strip reflect pass was changed to also remove all explicitly nonsemantic instructions. This makes it so that the name of the pass no longer reflects what the pass actually does. This change renames the pass so that it reflects what the pass actaully does.
2021-12-15 14:55:30 +00:00
MakeUnique<opt::StripNonSemanticInfoPass>());
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
}
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
}
opt: fix spirv ABI on Linux again. (#5113) Breaking the ABI for this API isn't worth it when the fix is so simple.
2023-02-15 20:11:30 +00:00
Optimizer::PassToken CreateAggressiveDCEPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::AggressiveDCEPass>(false, false));
}
Optimizer::PassToken CreateAggressiveDCEPass(bool preserve_interface) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::AggressiveDCEPass>(preserve_interface, false));
}
Add option to ADCE to remove output variables from interface. (#4994) This can cause interface incompatibility and should only be done if ADCE has been applied to the following shader in the pipeline. For this reason this capability is not available through the CLI but rather only non-default through the API. This functionality is intended as part of a larger cross-shader dead code elimination sequence.
2022-11-23 17:48:58 +00:00
Optimizer::PassToken CreateAggressiveDCEPass(bool preserve_interface,
bool remove_outputs) {
optimizer: restore previous ABI. (#4653) The change in commit 4ac8e5e541ea992dc6f44a4d4eb065a8fe0888ec Author: Greg Fischer <greg@lunarg.com> Date: Wed Sep 15 12:38:34 2021 -0600 Add preserve_interface mode to aggressive_dead_code_elim (#4520) Broke the C++ ABI for spirv-tools shared libraries on Linux, for not a great reason. Restore the previous ABI.
2021-12-09 20:58:53 +00:00
return MakeUnique<Optimizer::PassToken::Impl>(
Add option to ADCE to remove output variables from interface. (#4994) This can cause interface incompatibility and should only be done if ADCE has been applied to the following shader in the pipeline. For this reason this capability is not available through the CLI but rather only non-default through the API. This functionality is intended as part of a larger cross-shader dead code elimination sequence.
2022-11-23 17:48:58 +00:00
MakeUnique<opt::AggressiveDCEPass>(preserve_interface, remove_outputs));
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
}
spirv-opt: A pass to removed unused input on OpEntryPoint instructions. (#4275) The new pass will removed interface variable on the OpEntryPoint instruction when they are not statically referenced in the call tree of the entry point. It can be enabled on the command line using the options `remove-unused-interface-variables`.
2021-06-29 15:33:58 +00:00
Optimizer::PassToken CreateRemoveUnusedInterfaceVariablesPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::RemoveUnusedInterfaceVariablesPass>());
}
Temporarily add EmptyPass to prevent glslang from failing (#4004) Removing PropagateLineInfoPass and RedundantLineInfoElimPass from 56d0f5035 makes unit tests of many open source projects fail. It will happen before submitting this glslang PR https://github.com/KhronosGroup/glslang/pull/2440. This commit will be git-reverted after merging the glslang PR.
2020-10-30 22:03:56 +00:00
Optimizer::PassToken CreatePropagateLineInfoPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::EmptyPass>());
}
Optimizer::PassToken CreateRedundantLineInfoElimPass() {
return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::EmptyPass>());
}
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>());
}
Set threshold for reduce-load-size pass (#4499) Allow uses to set the threshold for spirv-opt reduce-load-size pass
2021-09-02 14:45:51 +00:00
Optimizer::PassToken CreateReduceLoadSizePass(
double load_replacement_threshold) {
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
return MakeUnique<Optimizer::PassToken::Impl>(
Set threshold for reduce-load-size pass (#4499) Allow uses to set the threshold for spirv-opt reduce-load-size pass
2021-09-02 14:45:51 +00:00
MakeUnique<opt::ReduceLoadSize>(load_replacement_threshold));
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
}
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>());
}
instrument: Use Import linkage for instrumentation functions (#5355) These functions are getting far too complicated to code in SPIRV-Tools C++. Replace them with import stubs so that the real implementations can live in Vulkan-ValidationLayers where they belong. VVL will need to define these functions in spirv and link them to the instrumented version of the user's shader. From here on out, VVL can redefine the functions and any data they use without updating SPIRV-Tools. Changing the function declarations will still require both VVL and SPIRV-Tools to be updated in lock step.
2023-09-20 16:50:30 +00:00
Optimizer::PassToken CreateInstBindlessCheckPass(uint32_t shader_id) {
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: Use Import linkage for instrumentation functions (#5355) These functions are getting far too complicated to code in SPIRV-Tools C++. Replace them with import stubs so that the real implementations can live in Vulkan-ValidationLayers where they belong. VVL will need to define these functions in spirv and link them to the instrumented version of the user's shader. From here on out, VVL can redefine the functions and any data they use without updating SPIRV-Tools. Changing the function declarations will still require both VVL and SPIRV-Tools to be updated in lock step.
2023-09-20 16:50:30 +00:00
MakeUnique<opt::InstBindlessCheckPass>(shader_id));
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: Debug Printf support (#3215) Create a pass to instrument OpDebugPrintf instructions. This pass replaces all OpDebugPrintf instructions with instructions to write a record containing the string id and the all specified values into a special printf output buffer (if space allows). This pass is designed to support the printf validation in the Vulkan validation layers. Fixes #3210
2020-03-12 13:19:52 +00:00
Optimizer::PassToken CreateInstDebugPrintfPass(uint32_t desc_set,
uint32_t shader_id) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::InstDebugPrintfPass>(desc_set, shader_id));
}
instrument: Use Import linkage for instrumentation functions (#5355) These functions are getting far too complicated to code in SPIRV-Tools C++. Replace them with import stubs so that the real implementations can live in Vulkan-ValidationLayers where they belong. VVL will need to define these functions in spirv and link them to the instrumented version of the user's shader. From here on out, VVL can redefine the functions and any data they use without updating SPIRV-Tools. Changing the function declarations will still require both VVL and SPIRV-Tools to be updated in lock step.
2023-09-20 16:50:30 +00:00
Optimizer::PassToken CreateInstBuffAddrCheckPass(uint32_t shader_id) {
Instrument: Add support for Buffer Device Address extension (#2792)
2019-08-16 13:18:34 +00:00
return MakeUnique<Optimizer::PassToken::Impl>(
instrument: Use Import linkage for instrumentation functions (#5355) These functions are getting far too complicated to code in SPIRV-Tools C++. Replace them with import stubs so that the real implementations can live in Vulkan-ValidationLayers where they belong. VVL will need to define these functions in spirv and link them to the instrumented version of the user's shader. From here on out, VVL can redefine the functions and any data they use without updating SPIRV-Tools. Changing the function declarations will still require both VVL and SPIRV-Tools to be updated in lock step.
2023-09-20 16:50:30 +00:00
MakeUnique<opt::InstBuffAddrCheckPass>(shader_id));
Instrument: Add support for Buffer Device Address extension (#2792)
2019-08-16 13:18:34 +00:00
}
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 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 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 spirv-opt pass to replace descriptor accesses based on variable indices (#4574) This commit adds a spirv-opt pass to replace accesses to descriptor array based on variable indices with constant elements. Before: ``` %descriptor = OpVariable %_ptr_array_Image Uniform ... %ac = OpAccessChain %_ptr_Image %descriptor %variable_index (some image instructions using %ac) ``` After: ``` %descriptor = OpVariable %_ptr_array_Image Uniform ... OpSwitch %variable_index 0 %case0 1 %case1 ... ... %case0 = OpLabel %ac = OpAccessChain %_ptr_Image %descriptor %uint_0 ... %case1 = OpLabel %ac = OpAccessChain %_ptr_Image %descriptor %uint_1 ... (use OpPhi for value with concrete type) ```
2021-10-26 21:20:58 +00:00
Optimizer::PassToken CreateReplaceDescArrayAccessUsingVarIndexPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::ReplaceDescArrayAccessUsingVarIndex>());
}
spirv-opt: add pass to Spread Volatile semantics (#4667) Add a pass to spread Volatile semantics to variables with SMIDNV, WarpIDNV, SubgroupSize, SubgroupLocalInvocationId, SubgroupEqMask, SubgroupGeMask, SubgroupGtMask, SubgroupLeMask, or SubgroupLtMask BuiltIn decorations or OpLoad for them when the shader model is the ray generation, closest hit, miss, intersection, or callable shaders. This pass can be used for VUID-StandaloneSpirv-VulkanMemoryModel-04678 and VUID-StandaloneSpirv-VulkanMemoryModel-04679 (See "Standalone SPIR-V Validation" section of Vulkan spec "Appendix A: Vulkan Environment for SPIR-V"). Handle variables used by multiple entry points: 1. Update error check to make it working regardless of the order of entry points. 2. For a variable, if it is used by two entry points E1 and E2 and it needs the Volatile semantics for E1 while it does not for E2 - If VulkanMemoryModel capability is enabled, which means we have to set memory operation of load instructions for the variable, we update load instructions in E1, but do not update the ones in E2. - If VulkanMemoryModel capability is disabled, which means we have to add Volatile decoration for the variable, we report an error because E1 needs to add Volatile decoration for the variable while E2 does not. For the simplicity of the implementation, we assume that all functions other than entry point functions are inlined.
2022-01-25 18:14:36 +00:00
Optimizer::PassToken CreateSpreadVolatileSemanticsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SpreadVolatileSemantics>());
}
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 interpolate legalization pass (#4220) This pass converts an internal form of GLSLstd450 Interpolate ops to the externally valid form. The external form takes the lvalue of the interpolant. The internal form can do a load of the interpolant. The pass replaces the load with its pointer. The internal form is generated by glslang and possibly other frontends for HLSL shaders. The new pass is called as part of HLSL legalization after all propagation is complete. Also adds internal interpolate form to pre-legalization validation
2021-03-31 18:26:36 +00:00
Optimizer::PassToken CreateInterpolateFixupPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::InterpFixupPass>());
}
spirv-opt: (WIP) Eliminate Dead Input Component Pass (#4720) This adds the --eliminate-dead-input-components pass which currently removes trailing unused components from input arrays. Fixes #4532
2022-03-23 02:50:52 +00:00
Optimizer::PassToken CreateEliminateDeadInputComponentsPass() {
Split EliminateDeadInputComponents into safe and unsafe versions. (#4984) Safe version will only optimize vertex shaders. All other shaders will succeed without change. Change --eliminate-dead-input-components to use new safe version. Unsafe version (allowing non-vertex shaders) currently only available through API. Should only be used in combination with other optimizations to keep interfaces consistent. See optimizer.hpp for more details.
2022-11-14 18:44:26 +00:00
return MakeUnique<Optimizer::PassToken::Impl>(
Change EliminateDeadInputComponentsPass to EliminateDeadIOComponentsPass (#4997) To reflect processing of both Input and Output variables. Also renamed files as needed.
2022-11-25 23:48:13 +00:00
MakeUnique<opt::EliminateDeadIOComponentsPass>(spv::StorageClass::Input,
/* safe_mode */ false));
Split EliminateDeadInputComponents into safe and unsafe versions. (#4984) Safe version will only optimize vertex shaders. All other shaders will succeed without change. Change --eliminate-dead-input-components to use new safe version. Unsafe version (allowing non-vertex shaders) currently only available through API. Should only be used in combination with other optimizations to keep interfaces consistent. See optimizer.hpp for more details.
2022-11-14 18:44:26 +00:00
}
Optimizer::PassToken CreateEliminateDeadOutputComponentsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
Change EliminateDeadInputComponentsPass to EliminateDeadIOComponentsPass (#4997) To reflect processing of both Input and Output variables. Also renamed files as needed.
2022-11-25 23:48:13 +00:00
MakeUnique<opt::EliminateDeadIOComponentsPass>(spv::StorageClass::Output,
/* safe_mode */ false));
Split EliminateDeadInputComponents into safe and unsafe versions. (#4984) Safe version will only optimize vertex shaders. All other shaders will succeed without change. Change --eliminate-dead-input-components to use new safe version. Unsafe version (allowing non-vertex shaders) currently only available through API. Should only be used in combination with other optimizations to keep interfaces consistent. See optimizer.hpp for more details.
2022-11-14 18:44:26 +00:00
}
Optimizer::PassToken CreateEliminateDeadInputComponentsSafePass() {
spirv-opt: (WIP) Eliminate Dead Input Component Pass (#4720) This adds the --eliminate-dead-input-components pass which currently removes trailing unused components from input arrays. Fixes #4532
2022-03-23 02:50:52 +00:00
return MakeUnique<Optimizer::PassToken::Impl>(
Change EliminateDeadInputComponentsPass to EliminateDeadIOComponentsPass (#4997) To reflect processing of both Input and Output variables. Also renamed files as needed.
2022-11-25 23:48:13 +00:00
MakeUnique<opt::EliminateDeadIOComponentsPass>(spv::StorageClass::Input,
/* safe_mode */ true));
spirv-opt: (WIP) Eliminate Dead Input Component Pass (#4720) This adds the --eliminate-dead-input-components pass which currently removes trailing unused components from input arrays. Fixes #4532
2022-03-23 02:50:52 +00:00
}
Add passes to eliminate dead output stores (#4970) This adds two passes to accomplish this: one pass to analyze a shader to determine the input slots that are live. The second pass is run on the preceding shader to eliminate any stores to output slots that are not consumed by the following shader. These passes support vert, tesc, tese, geom, and frag shaders. These passes are currently only available through the API. These passes together with dead code elimination, and elimination of dead input and output components and variables (WIP), will allow users to do dead code elimination across shader boundaries.
2022-11-02 17:23:25 +00:00
Optimizer::PassToken CreateAnalyzeLiveInputPass(
std::unordered_set<uint32_t>* live_locs,
std::unordered_set<uint32_t>* live_builtins) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::AnalyzeLiveInputPass>(live_locs, live_builtins));
}
Optimizer::PassToken CreateEliminateDeadOutputStoresPass(
std::unordered_set<uint32_t>* live_locs,
std::unordered_set<uint32_t>* live_builtins) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::EliminateDeadOutputStoresPass>(live_locs, live_builtins));
}
Add spirv-opt convert-to-sampled-image pass (#4340) convert-to-sampled-image pass converts images and/or samplers with given pairs of descriptor set and binding to sampled image. If a pair of an image and a sampler have the same pair of descriptor set and binding that is one of the given pairs, they will be converted to a sampled image. In addition, if only an image has the descriptor set and binding that is one of the given pairs, it will be converted to a sampled image as well. For example, when we have %a = OpLoad %type_2d_image %texture %b = OpLoad %type_sampler %sampler %combined = OpSampledImage %type_sampled_image %a %b %value = OpImageSampleExplicitLod %v4float %combined ... 1. If %texture and %sampler have the same descriptor set and binding %combine_texture_and_sampler = OpVaraible %ptr_type_sampled_image_Uniform ... %combined = OpLoad %type_sampled_image %combine_texture_and_sampler %value = OpImageSampleExplicitLod %v4float %combined ... 2. If %texture and %sampler have different pairs of descriptor set and binding %a = OpLoad %type_sampled_image %texture %extracted_image = OpImage %type_2d_image %a %b = OpLoad %type_sampler %sampler %combined = OpSampledImage %type_sampled_image %extracted_image %b %value = OpImageSampleExplicitLod %v4float %combined ...
2021-08-18 12:30:48 +00:00
Optimizer::PassToken CreateConvertToSampledImagePass(
const std::vector<opt::DescriptorSetAndBinding>&
descriptor_set_binding_pairs) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::ConvertToSampledImagePass>(descriptor_set_binding_pairs));
}
spirv-opt: add pass for interface variable scalar replacement (#4779) Replace shader's stage variables whose types are array or matrix with scalars/vectors. For example, ``` Before: %foo = OpVariable %_ptr_Output__arr_v2float_uint_4 Output After: %foo = OpVariable %_ptr_Output_v2float Output %foo_0 = OpVariable %_ptr_Output_v2float Output %foo_1 = OpVariable %_ptr_Output_v2float Output %foo_2 = OpVariable %_ptr_Output_v2float Output ```
2022-05-09 18:04:52 +00:00
Optimizer::PassToken CreateInterfaceVariableScalarReplacementPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::InterfaceVariableScalarReplacement>());
}
Add pass to remove DontInline function control (#4747) Swift shader needs a way to inline all functions, even those marked as DontInline. See https://github.com/KhronosGroup/SPIRV-Tools/pull/4471. This implements the suggestion I made in the PR. We add a pass that will remove the DontInline function control, so that the inlining passes will inline them. SwiftShader will still have to modify their code to add this pass before the other passes are run.
2022-03-07 17:45:17 +00:00
Optimizer::PassToken CreateRemoveDontInlinePass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::RemoveDontInline>());
}
spirv-opt : Add FixFuncCallArgumentsPass (#4775) spirv validation require OpFunctionCall with memory object, usually this is non issue as all the functions are inlined. This pass deal with some case for DontInline function. accesschain input operand would be replaced new created variable
2022-05-06 14:39:26 +00:00
Optimizer::PassToken CreateFixFuncCallArgumentsPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::FixFuncCallArgumentsPass>());
}
opt: fix missing CreateTrimCapabilitiesPass definition (#5353)
2023-08-02 09:52:53 +00:00
Optimizer::PassToken CreateTrimCapabilitiesPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::TrimCapabilitiesPass>());
}
opt: Add SwitchDescriptorSetPass (#5375) This is a simple pass to change DescriptorSet decoration values.
2023-08-22 00:16:35 +00:00
Optimizer::PassToken CreateSwitchDescriptorSetPass(uint32_t from, uint32_t to) {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::SwitchDescriptorSetPass>(from, to));
}
Add a new legalization pass to dedupe invocation interlock instructions (#5409) Add a new legalization pass to dedupe invocation interlock instructions DXC will be adding support for HLSL's rasterizer ordered views by using the SPV_EXT_fragment_shader_interlock_extension. That extension stipulates that if an entry point has an interlock ordering execution mode, it must dynamically execute OpBeginInvocationInterlockEXT and OpEndInvocationInterlockEXT, in that order, exactly once. This would be difficult to determine in DXC's SPIR-V backend, so instead we will emit these instructions potentially multiple times, and use this legalization pass to ensure that the final SPIR-V follows the specification. This PR uses data-flow analysis to determine where to place begin and end instructions; in essence, determining whether a block contains or is preceded by a begin instruction is similar to a specialized case of a reaching definitions analysis, where we have only a single definition, such as `bool has_begun = false`. For this simpler case, we can compute the set of blocks using BFS to determine the reachability of the begin instruction. We need to do this for both begin and end instructions, so I have generalized portions of the code to run both forward and backward over the CFG for each respective case.
2023-09-27 23:54:10 +00:00
Optimizer::PassToken CreateInvocationInterlockPlacementPass() {
return MakeUnique<Optimizer::PassToken::Impl>(
MakeUnique<opt::InvocationInterlockPlacementPass>());
}
Add a C++ interface to the optimization functionalities.
2016-09-12 18:11:46 +00:00
} // namespace spvtools
Add C interface for Optimizer (#5030)
2023-02-01 13:58:52 +00:00
extern "C" {
SPIRV_TOOLS_EXPORT spv_optimizer_t* spvOptimizerCreate(spv_target_env env) {
return reinterpret_cast<spv_optimizer_t*>(new spvtools::Optimizer(env));
}
SPIRV_TOOLS_EXPORT void spvOptimizerDestroy(spv_optimizer_t* optimizer) {
delete reinterpret_cast<spvtools::Optimizer*>(optimizer);
}
SPIRV_TOOLS_EXPORT void spvOptimizerSetMessageConsumer(
spv_optimizer_t* optimizer, spv_message_consumer consumer) {
reinterpret_cast<spvtools::Optimizer*>(optimizer)->
SetMessageConsumer(
[consumer](spv_message_level_t level, const char* source,
const spv_position_t& position, const char* message) {
return consumer(level, source, &position, message);
});
}
SPIRV_TOOLS_EXPORT void spvOptimizerRegisterLegalizationPasses(
spv_optimizer_t* optimizer) {
reinterpret_cast<spvtools::Optimizer*>(optimizer)->
RegisterLegalizationPasses();
}
SPIRV_TOOLS_EXPORT void spvOptimizerRegisterPerformancePasses(
spv_optimizer_t* optimizer) {
reinterpret_cast<spvtools::Optimizer*>(optimizer)->
RegisterPerformancePasses();
}
SPIRV_TOOLS_EXPORT void spvOptimizerRegisterSizePasses(
spv_optimizer_t* optimizer) {
reinterpret_cast<spvtools::Optimizer*>(optimizer)->RegisterSizePasses();
}
SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassFromFlag(
spv_optimizer_t* optimizer, const char* flag)
{
return reinterpret_cast<spvtools::Optimizer*>(optimizer)->
RegisterPassFromFlag(flag);
}
SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassesFromFlags(
spv_optimizer_t* optimizer, const char** flags, const size_t flag_count) {
std::vector<std::string> opt_flags;
for (uint32_t i = 0; i < flag_count; i++) {
opt_flags.emplace_back(flags[i]);
}
return reinterpret_cast<spvtools::Optimizer*>(optimizer)->
RegisterPassesFromFlags(opt_flags);
}
SPIRV_TOOLS_EXPORT
spv_result_t spvOptimizerRun(spv_optimizer_t* optimizer,
const uint32_t* binary,
const size_t word_count,
spv_binary* optimized_binary,
const spv_optimizer_options options) {
std::vector<uint32_t> optimized;
if (!reinterpret_cast<spvtools::Optimizer*>(optimizer)->
Run(binary, word_count, &optimized, options)) {
return SPV_ERROR_INTERNAL;
}
auto result_binary = new spv_binary_t();
if (!result_binary) {
*optimized_binary = nullptr;
return SPV_ERROR_OUT_OF_MEMORY;
}
result_binary->code = new uint32_t[optimized.size()];
if (!result_binary->code) {
delete result_binary;
*optimized_binary = nullptr;
return SPV_ERROR_OUT_OF_MEMORY;
}
result_binary->wordCount = optimized.size();
memcpy(result_binary->code, optimized.data(),
optimized.size() * sizeof(uint32_t));
*optimized_binary = result_binary;
return SPV_SUCCESS;
}
} // extern "C"
Reference in New Issue Copy Permalink