AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-10-18 19:20:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
033768c24b
SPIRV-Tools/source/opt/ir_context.cpp

1045 lines
38 KiB
C++
Raw Normal View History

Add the IRContext (part 1) This is the first part of adding the IRContext. This class is meant to hold the extra data that is build on top of the module that it owns. The first part will simply create the IRContext class and get it passed to the passes in place of the module. For now it does not have any functionality of its own, but it acts more as a wrapper for the module. The functions that I added to the IRContext are those that either traverse the headers or add to them. I did this because we may decide to have other ways of dealing with these sections (for example adding a type pool, or use the decoration manager). I also added the function that add to the header because the IRContext needs to know when an instruction is added to update other data structures appropriately. Note that there is still lots of work that needs to be done. There are still many places that change the module, and do not inform the context. That will be the next step.
2017-10-30 15:13:24 +00:00
// Copyright (c) 2017 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.
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/ir_context.h"
Add a new constant manager class. This patch adds a new constant manager class to interface with analysis::Constant. The new constant manager lives in ir::IRContext together with the type manager (analysis::TypeManager). The new analysis::ConstantManager is used by the spec constant folder and the constant propagator (in progress). Another cleanup introduced by this patch removes the ID management from the fold spec constant pass, and ir::IRContext and moves it to ir::Module. SSA IDs were maintained by IRContext and Module. That's pointless and leads to mismatch IDs. Fixed by moving all the bookkeeping to ir::Module.
2017-12-07 21:42:27 +00:00
#include <cstring>
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
Preserve debug info in eliminate-dead-functions (#3251) * Preserve debug info in eliminate-dead-functions The elimination of dead functions makes OpFunction operand of DebugFunction invalid. This commit replaces the operand with DebugInfoNone.
2020-04-13 13:29:36 +00:00
#include "OpenCLDebugInfo100.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/latest_version_glsl_std_450_header.h"
#include "source/opt/log.h"
#include "source/opt/mem_pass.h"
#include "source/opt/reflect.h"
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
namespace {
static const int kSpvDecorateTargetIdInIdx = 0;
static const int kSpvDecorateDecorationInIdx = 1;
static const int kSpvDecorateBuiltinInIdx = 2;
static const int kEntryPointInterfaceInIdx = 3;
Don't inline recursive functions. (#2130) * Move ProcessFunction* function from pass to the context. There are a few functions that are used to traverse the call tree. They currently live in the Pass class, but they have nothing to do with a pass, and may be needed outside of a pass. They would be better in the ir context, or in a specific call tree class if we ever have a need for it. * Don't inline recursive functions. Inlining does not check if a function is recursive or not. This has been fine as long as the shader was a Vulkan shader, which forbid recursive functions. However, not all shaders are vulkan, so either we limit inlining to Vulkan shaders or we teach it to look for recursive functions. I prefer to keep the passes as general as is reasonable. The change does not require much new code in inlining and gives a reason to refactor some other code. The changes are to add a member function to the Function class that checks if that function is recursive or not. Then this is used in inlining to not inlining a function call if it calls a recursive function. * Add id to function analysis There are a few places that build a map from ids to Function whose result is that id. I decided to add an analysis to the context for this to reduce that code, and simplify some of the functions. * Add missing file.
2018-11-29 19:24:58 +00:00
static const int kEntryPointFunctionIdInIdx = 1;
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
Preserve debug info in eliminate-dead-functions (#3251) * Preserve debug info in eliminate-dead-functions The elimination of dead functions makes OpFunction operand of DebugFunction invalid. This commit replaces the operand with DebugInfoNone.
2020-04-13 13:29:36 +00:00
// Constants for OpenCL.DebugInfo.100 extension instructions.
static const uint32_t kDebugFunctionOperandFunctionIndex = 13;
static const uint32_t kDebugGlobalVariableOperandVariableIndex = 11;
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
} // anonymous namespace
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
namespace spvtools {
Move the ir namespace to opt. (#1680) This CL moves the files in opt/ to consistenly be under the opt:: namespace. This frees up the ir:: namespace so it can be used to make a shared ir represenation.
2018-07-09 15:32:29 +00:00
namespace opt {
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
void IRContext::BuildInvalidAnalyses(IRContext::Analysis set) {
if (set & kAnalysisDefUse) {
BuildDefUseManager();
}
Add analysis to compute mappings between instructions and basic blocks. This analysis builds a map from instructions to the basic block that contains them. It is accessed via get_instr_block(). Once built, it is kept up-to-date by the IRContext, as long as instructions are removed via KillInst. I have not yet marked passes that preserve this analysis. I will do it in a separate change. Other changes: - Add documentation about analysis values requirement to be powers of 2. - Force a re-build of the def-use manager in tests. - Fix AllPreserveFirstOnlyAfterPassWithChange to use the DummyPassPreservesFirst pass. - Fix sentinel value for IRContext::Analysis enum. - Fix logic for checking if the instr<->block mapping is valid in KillInst.
2017-11-10 14:39:00 +00:00
if (set & kAnalysisInstrToBlockMapping) {
BuildInstrToBlockMapping();
}
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
if (set & kAnalysisDecorations) {
BuildDecorationManager();
}
Convert the CFG to an on-demand analysis - NFC. This fixes some TODOs by moving the CFG into the IRContext as an analysis.
2017-11-27 19:20:32 +00:00
if (set & kAnalysisCFG) {
BuildCFG();
}
Dominator Tree Analysis (#3) Support for dominator and post dominator analysis on ir::Functions. This patch contains a DominatorTree class for building the tree and DominatorAnalysis and DominatorAnalysisPass classes for interfacing and caching the built trees.
2017-11-27 21:21:26 +00:00
if (set & kAnalysisDominatorAnalysis) {
Add loop descriptors and some required dominator tree extensions. Add post-order tree iterator. Add DominatorTreeNode extensions: - Add begin/end methods to do pre-order and post-order tree traversal from a given DominatorTreeNode Add DominatorTree extensions: - Add begin/end methods to do pre-order and post-order tree traversal - Tree traversal ignore by default the pseudo entry block - Retrieve a DominatorTreeNode from a basic block Add loop descriptor: - Add a LoopDescriptor class to register all loops in a given function. - Add a Loop class to describe a loop: - Loop parent - Nested loops - Loop depth - Loop header, merge, continue and preheader - Basic blocks that belong to the loop Correct a bug that forced dominator tree to be constantly rebuilt.
2017-12-21 14:47:25 +00:00
ResetDominatorAnalysis();
Dominator Tree Analysis (#3) Support for dominator and post dominator analysis on ir::Functions. This patch contains a DominatorTree class for building the tree and DominatorAnalysis and DominatorAnalysisPass classes for interfacing and caching the built trees.
2017-11-27 21:21:26 +00:00
}
Add LoopDescriptor as an IRContext analysis. Move some function definitions from header to source to avoid circular definition.
2018-01-25 10:33:06 +00:00
if (set & kAnalysisLoopAnalysis) {
ResetLoopAnalysis();
}
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
if (set & kAnalysisBuiltinVarId) {
ResetBuiltinAnalysis();
}
Add id to name map Adding a map from an id to it set of OpName and OpMemberName instructions. This will be used in KillNameAndDecorates to kill the names for the ids that are being removed. In my test, the compile time for 50 shaders went from 1m57s to 55s. This was on linux using the release build. Fixes #1290.
2018-02-13 04:28:38 +00:00
if (set & kAnalysisNameMap) {
BuildIdToNameMap();
}
Initial patch for scalar evolution analysis This patch adds support for the analysis of scalars in loops. It works by traversing the defuse chain to build a DAG of scalar operations and then simplifies the DAG by folding constants and grouping like terms. It represents induction variables as recurrent expressions with respect to a given loop and can simplify DAGs containing recurrent expression by rewritting the entire DAG to be a recurrent expression with respect to the same loop.
2018-03-28 13:19:55 +00:00
if (set & kAnalysisScalarEvolution) {
BuildScalarEvolutionAnalysis();
}
Add register liveness analysis. For each function, the analysis determine which SSA registers are live at the beginning of each basic block and which one are killed at the end of the basic block. It also includes utilities to simulate the register pressure for loop fusion and fission. The implementation is based on the paper "A non-iterative data-flow algorithm for computing liveness sets in strict ssa programs" from Boissinot et al.
2018-04-17 14:31:09 +00:00
if (set & kAnalysisRegisterPressure) {
BuildRegPressureAnalysis();
}
Allow hoisting code in if-conversion. When doing if-conversion, we do not currently move code out of the side nodes. The reason for this is that it can increase the number of instructions that get executed because both side nods will have to be executed now. In this commit, we add code to move an instruction, and all of the instructions it depends on, out of a side node and into the header of the selection construct. However to keep the cost down, we only do it when the two values in the OpPhi node compute the same value. This way we have to move only one of the instructions and the other becomes unused most of the time. So no real extra cost. Makes the value number table an alalysis in the ir context. Added more opcodes to list of code motion safe opcodes. Fixes #1526.
2018-04-26 19:07:48 +00:00
if (set & kAnalysisValueNumberTable) {
BuildValueNumberTable();
}
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
if (set & kAnalysisStructuredCFG) {
BuildStructuredCFGAnalysis();
}
Don't inline recursive functions. (#2130) * Move ProcessFunction* function from pass to the context. There are a few functions that are used to traverse the call tree. They currently live in the Pass class, but they have nothing to do with a pass, and may be needed outside of a pass. They would be better in the ir context, or in a specific call tree class if we ever have a need for it. * Don't inline recursive functions. Inlining does not check if a function is recursive or not. This has been fine as long as the shader was a Vulkan shader, which forbid recursive functions. However, not all shaders are vulkan, so either we limit inlining to Vulkan shaders or we teach it to look for recursive functions. I prefer to keep the passes as general as is reasonable. The change does not require much new code in inlining and gives a reason to refactor some other code. The changes are to add a member function to the Function class that checks if that function is recursive or not. Then this is used in inlining to not inlining a function call if it calls a recursive function. * Add id to function analysis There are a few places that build a map from ids to Function whose result is that id. I decided to add an analysis to the context for this to reduce that code, and simplify some of the functions. * Add missing file.
2018-11-29 19:24:58 +00:00
if (set & kAnalysisIdToFuncMapping) {
BuildIdToFuncMapping();
}
Make the constant and type manager analyses. (#2250) Currently it is impossible to invalidate the constnat and type manager. However, the compact ids pass changes the ids for the types and constants, which makes them invalid. This change will make them analyses that have to been explicitly marked as preserved by passes. This will allow compact ids to invalidate them. Fixes #2220.
2018-12-20 18:00:05 +00:00
if (set & kAnalysisConstants) {
BuildConstantManager();
}
if (set & kAnalysisTypes) {
BuildTypeManager();
}
Add debug information analysis (#3305) We need an analysis for OpenCL.DebugInfo.100 extension instructions such as a map between function id and its DebugFunction. This commit add an analysis for it.
2020-04-27 19:18:55 +00:00
if (set & kAnalysisDebugInfo) {
BuildDebugInfoManager();
}
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
}
Re-format files in source, source/opt, source/util, source/val and tools. NFC. This just makes sure every file is formatted following the formatting definition in .clang-format. Re-formatted with: $ clang-format -i $(find source tools include -name '*.cpp') $ clang-format -i $(find source tools include -name '*.h')
2017-11-08 17:40:02 +00:00
void IRContext::InvalidateAnalysesExceptFor(
IRContext::Analysis preserved_analyses) {
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
uint32_t analyses_to_invalidate = valid_analyses_ & (~preserved_analyses);
Add analysis to compute mappings between instructions and basic blocks. This analysis builds a map from instructions to the basic block that contains them. It is accessed via get_instr_block(). Once built, it is kept up-to-date by the IRContext, as long as instructions are removed via KillInst. I have not yet marked passes that preserve this analysis. I will do it in a separate change. Other changes: - Add documentation about analysis values requirement to be powers of 2. - Force a re-build of the def-use manager in tests. - Fix AllPreserveFirstOnlyAfterPassWithChange to use the DummyPassPreservesFirst pass. - Fix sentinel value for IRContext::Analysis enum. - Fix logic for checking if the instr<->block mapping is valid in KillInst.
2017-11-10 14:39:00 +00:00
InvalidateAnalyses(static_cast<IRContext::Analysis>(analyses_to_invalidate));
}
void IRContext::InvalidateAnalyses(IRContext::Analysis analyses_to_invalidate) {
[spirv-opt] debug info preservation in ssa-rewrite (#3356) Add OpenCL.DebugInfo.100 `DebugValue` instructions for store and phi instructions of local variables to provide the debugger with the updated values of local variables correctly.
2020-06-19 18:57:43 +00:00
// The ConstantManager and DebugInfoManager contain Type pointers. If the
// TypeManager goes away, the ConstantManager and DebugInfoManager have to
// go away.
Fix Constants Analyses bug inserted by #2302 (#2306) Need to also remove Constants from the valid_analyses set when invalidated, otherwise Constants is not reinitialized before used.
2019-01-21 17:34:12 +00:00
if (analyses_to_invalidate & kAnalysisTypes) {
analyses_to_invalidate |= kAnalysisConstants;
Add debug information analysis (#3305) We need an analysis for OpenCL.DebugInfo.100 extension instructions such as a map between function id and its DebugFunction. This commit add an analysis for it.
2020-04-27 19:18:55 +00:00
analyses_to_invalidate |= kAnalysisDebugInfo;
Fix Constants Analyses bug inserted by #2302 (#2306) Need to also remove Constants from the valid_analyses set when invalidated, otherwise Constants is not reinitialized before used.
2019-01-21 17:34:12 +00:00
}
Link cfg and dominator analysis in the context (#2946) Fixes #2889
2019-10-08 14:16:18 +00:00
// The dominator analysis hold the psuedo entry and exit nodes from the CFG.
// Also if the CFG change the dominators many changed as well, so the
// dominator analysis should be invalidated as well.
if (analyses_to_invalidate & kAnalysisCFG) {
analyses_to_invalidate |= kAnalysisDominatorAnalysis;
}
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
if (analyses_to_invalidate & kAnalysisDefUse) {
def_use_mgr_.reset(nullptr);
}
Add analysis to compute mappings between instructions and basic blocks. This analysis builds a map from instructions to the basic block that contains them. It is accessed via get_instr_block(). Once built, it is kept up-to-date by the IRContext, as long as instructions are removed via KillInst. I have not yet marked passes that preserve this analysis. I will do it in a separate change. Other changes: - Add documentation about analysis values requirement to be powers of 2. - Force a re-build of the def-use manager in tests. - Fix AllPreserveFirstOnlyAfterPassWithChange to use the DummyPassPreservesFirst pass. - Fix sentinel value for IRContext::Analysis enum. - Fix logic for checking if the instr<->block mapping is valid in KillInst.
2017-11-10 14:39:00 +00:00
if (analyses_to_invalidate & kAnalysisInstrToBlockMapping) {
instr_to_block_.clear();
}
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
if (analyses_to_invalidate & kAnalysisDecorations) {
decoration_mgr_.reset(nullptr);
}
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
if (analyses_to_invalidate & kAnalysisCombinators) {
combinator_ops_.clear();
}
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
if (analyses_to_invalidate & kAnalysisBuiltinVarId) {
builtin_var_id_map_.clear();
}
Convert the CFG to an on-demand analysis - NFC. This fixes some TODOs by moving the CFG into the IRContext as an analysis.
2017-11-27 19:20:32 +00:00
if (analyses_to_invalidate & kAnalysisCFG) {
cfg_.reset(nullptr);
}
Dominator Tree Analysis (#3) Support for dominator and post dominator analysis on ir::Functions. This patch contains a DominatorTree class for building the tree and DominatorAnalysis and DominatorAnalysisPass classes for interfacing and caching the built trees.
2017-11-27 21:21:26 +00:00
if (analyses_to_invalidate & kAnalysisDominatorAnalysis) {
dominator_trees_.clear();
post_dominator_trees_.clear();
}
Add id to name map Adding a map from an id to it set of OpName and OpMemberName instructions. This will be used in KillNameAndDecorates to kill the names for the ids that are being removed. In my test, the compile time for 50 shaders went from 1m57s to 55s. This was on linux using the release build. Fixes #1290.
2018-02-13 04:28:38 +00:00
if (analyses_to_invalidate & kAnalysisNameMap) {
id_to_name_.reset(nullptr);
}
Allow hoisting code in if-conversion. When doing if-conversion, we do not currently move code out of the side nodes. The reason for this is that it can increase the number of instructions that get executed because both side nods will have to be executed now. In this commit, we add code to move an instruction, and all of the instructions it depends on, out of a side node and into the header of the selection construct. However to keep the cost down, we only do it when the two values in the OpPhi node compute the same value. This way we have to move only one of the instructions and the other becomes unused most of the time. So no real extra cost. Makes the value number table an alalysis in the ir context. Added more opcodes to list of code motion safe opcodes. Fixes #1526.
2018-04-26 19:07:48 +00:00
if (analyses_to_invalidate & kAnalysisValueNumberTable) {
vn_table_.reset(nullptr);
}
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
if (analyses_to_invalidate & kAnalysisStructuredCFG) {
struct_cfg_analysis_.reset(nullptr);
}
Don't inline recursive functions. (#2130) * Move ProcessFunction* function from pass to the context. There are a few functions that are used to traverse the call tree. They currently live in the Pass class, but they have nothing to do with a pass, and may be needed outside of a pass. They would be better in the ir context, or in a specific call tree class if we ever have a need for it. * Don't inline recursive functions. Inlining does not check if a function is recursive or not. This has been fine as long as the shader was a Vulkan shader, which forbid recursive functions. However, not all shaders are vulkan, so either we limit inlining to Vulkan shaders or we teach it to look for recursive functions. I prefer to keep the passes as general as is reasonable. The change does not require much new code in inlining and gives a reason to refactor some other code. The changes are to add a member function to the Function class that checks if that function is recursive or not. Then this is used in inlining to not inlining a function call if it calls a recursive function. * Add id to function analysis There are a few places that build a map from ids to Function whose result is that id. I decided to add an analysis to the context for this to reduce that code, and simplify some of the functions. * Add missing file.
2018-11-29 19:24:58 +00:00
if (analyses_to_invalidate & kAnalysisIdToFuncMapping) {
id_to_func_.clear();
}
Make the constant and type manager analyses. (#2250) Currently it is impossible to invalidate the constnat and type manager. However, the compact ids pass changes the ids for the types and constants, which makes them invalid. This change will make them analyses that have to been explicitly marked as preserved by passes. This will allow compact ids to invalidate them. Fixes #2220.
2018-12-20 18:00:05 +00:00
if (analyses_to_invalidate & kAnalysisConstants) {
constant_mgr_.reset(nullptr);
}
if (analyses_to_invalidate & kAnalysisTypes) {
type_mgr_.reset(nullptr);
}
Dominator Tree Analysis (#3) Support for dominator and post dominator analysis on ir::Functions. This patch contains a DominatorTree class for building the tree and DominatorAnalysis and DominatorAnalysisPass classes for interfacing and caching the built trees.
2017-11-27 21:21:26 +00:00
Add debug information analysis (#3305) We need an analysis for OpenCL.DebugInfo.100 extension instructions such as a map between function id and its DebugFunction. This commit add an analysis for it.
2020-04-27 19:18:55 +00:00
if (analyses_to_invalidate & kAnalysisDebugInfo) {
debug_info_mgr_.reset(nullptr);
}
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
valid_analyses_ = Analysis(valid_analyses_ & ~analyses_to_invalidate);
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
Instruction* IRContext::KillInst(Instruction* inst) {
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
if (!inst) {
Change IRContext::KillInst to delete instructions. The current method of removing an instruction is to call ToNop. The problem with this is that it leaves around an instruction that later passes will look at. We should just delete the instruction. In MemPass there is a utility routine called DCEInst. It can delete essentially any instruction, which can invalidate pointers now that they are actually deleted. The interface was changed to add a call back that can be used to update any local data structures that contain ir::Intruction*.
2017-11-21 19:47:46 +00:00
return nullptr;
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
}
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
KillNamesAndDecorates(inst);
Preserve debug info in eliminate-dead-functions (#3251) * Preserve debug info in eliminate-dead-functions The elimination of dead functions makes OpFunction operand of DebugFunction invalid. This commit replaces the operand with DebugInfoNone.
2020-04-13 13:29:36 +00:00
KillOperandFromDebugInstructions(inst);
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
if (AreAnalysesValid(kAnalysisDefUse)) {
get_def_use_mgr()->ClearInst(inst);
}
Add analysis to compute mappings between instructions and basic blocks. This analysis builds a map from instructions to the basic block that contains them. It is accessed via get_instr_block(). Once built, it is kept up-to-date by the IRContext, as long as instructions are removed via KillInst. I have not yet marked passes that preserve this analysis. I will do it in a separate change. Other changes: - Add documentation about analysis values requirement to be powers of 2. - Force a re-build of the def-use manager in tests. - Fix AllPreserveFirstOnlyAfterPassWithChange to use the DummyPassPreservesFirst pass. - Fix sentinel value for IRContext::Analysis enum. - Fix logic for checking if the instr<->block mapping is valid in KillInst.
2017-11-10 14:39:00 +00:00
if (AreAnalysesValid(kAnalysisInstrToBlockMapping)) {
instr_to_block_.erase(inst);
}
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
if (AreAnalysesValid(kAnalysisDecorations)) {
if (inst->IsDecoration()) {
decoration_mgr_->RemoveDecoration(inst);
}
}
[spirv-opt] debug info preservation in ssa-rewrite (#3356) Add OpenCL.DebugInfo.100 `DebugValue` instructions for store and phi instructions of local variables to provide the debugger with the updated values of local variables correctly.
2020-06-19 18:57:43 +00:00
if (AreAnalysesValid(kAnalysisDebugInfo)) {
Correctly replace debug lexical scope of instruction (#3718) When we update OpenCL.DebugInfo.100 lexical scopes e.g., DebugFunction, we have to replace DebugScope of each instruction that uses the lexical scope correctly.
2020-08-31 14:05:38 +00:00
get_debug_info_mgr()->ClearDebugScopeAndInlinedAtUses(inst);
[spirv-opt] debug info preservation in ssa-rewrite (#3356) Add OpenCL.DebugInfo.100 `DebugValue` instructions for store and phi instructions of local variables to provide the debugger with the updated values of local variables correctly.
2020-06-19 18:57:43 +00:00
get_debug_info_mgr()->ClearDebugInfo(inst);
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
if (type_mgr_ && IsTypeInst(inst->opcode())) {
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
type_mgr_->RemoveId(inst->result_id());
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
if (constant_mgr_ && IsConstantInst(inst->opcode())) {
Remove constants from constant manager in KillInst Registering a constant in constant manager establishes a relation between instruction that defined it and constant object. On complex shaders this could result in the constant definition getting removed as part of one of the DCE pass, and a subsequent simplification pass trying to use the defining instruction for the constant. To fix this, we now remove associated constant entries from constant manager when killing constant instructions; the constant object is still registered and can be remapped to a new instruction later. GetDefiningInstruction shouldn't ever return nullptr after this change so add an assertion to check for that.
2018-02-15 20:27:38 +00:00
constant_mgr_->RemoveId(inst->result_id());
}
Check feature mgr in context consistency check (#2818) We add a check that the feature manager is correcter after each pass. This resulted in a couple failing tests cases. Those are fixed. Part of #2814
2019-08-28 15:49:16 +00:00
if (inst->opcode() == SpvOpCapability || inst->opcode() == SpvOpExtension) {
// We reset the feature manager, instead of updating it, because it is just
// as much work. We would have to remove all capabilities implied by this
// capability that are not also implied by the remaining OpCapability
// instructions. We could update extensions, but we will see if it is
// needed.
ResetFeatureManager();
}
Remove constants from constant manager in KillInst Registering a constant in constant manager establishes a relation between instruction that defined it and constant object. On complex shaders this could result in the constant definition getting removed as part of one of the DCE pass, and a subsequent simplification pass trying to use the defining instruction for the constant. To fix this, we now remove associated constant entries from constant manager when killing constant instructions; the constant object is still registered and can be remapped to a new instruction later. GetDefiningInstruction shouldn't ever return nullptr after this change so add an assertion to check for that.
2018-02-15 20:27:38 +00:00
Add id to name map Adding a map from an id to it set of OpName and OpMemberName instructions. This will be used in KillNameAndDecorates to kill the names for the ids that are being removed. In my test, the compile time for 50 shaders went from 1m57s to 55s. This was on linux using the release build. Fixes #1290.
2018-02-13 04:28:38 +00:00
RemoveFromIdToName(inst);
Change IRContext::KillInst to delete instructions. The current method of removing an instruction is to call ToNop. The problem with this is that it leaves around an instruction that later passes will look at. We should just delete the instruction. In MemPass there is a utility routine called DCEInst. It can delete essentially any instruction, which can invalidate pointers now that they are actually deleted. The interface was changed to add a call back that can be used to update any local data structures that contain ir::Intruction*.
2017-11-21 19:47:46 +00:00
Instruction* next_instruction = nullptr;
if (inst->IsInAList()) {
next_instruction = inst->NextNode();
inst->RemoveFromList();
delete inst;
} else {
// Needed for instructions that are not part of a list like OpLabels,
// OpFunction, OpFunctionEnd, etc..
inst->ToNop();
}
return next_instruction;
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
}
Fix crash when optimizing shaders with DebugPrintf (#4280) Fixes #4219
2021-05-13 17:19:56 +00:00
void IRContext::CollectNonSemanticTree(
Instruction* inst, std::unordered_set<Instruction*>* to_kill) {
Improve non-semantic instruction handling in the optimizer (#3693) * No longer blindly add global non-semantic info instructions to global types and values * functions now have a list of non-semantic instructions that succeed them in the global scope * global non-semantic instructions go in global types and values if they appear before any function, otherwise they are attached to the immediate function predecessor in the module * changed ADCE to use the function removal utility * Modified EliminateFunction to have special handling for non-semantic instructions in the global scope * non-semantic instructions are moved to an earlier function (or full global set) if the function they are attached to is eliminated * Added IRContext::KillNonSemanticInfo to remove the tree of non-semantic instructions that use an instruction * this is used in function elimination * There is still significant work in the optimizer to handle non-semantic instructions fully in the optimizer
2020-08-13 18:54:14 +00:00
if (!inst->HasResultId()) return;
std::vector<Instruction*> work_list;
std::unordered_set<Instruction*> seen;
work_list.push_back(inst);
while (!work_list.empty()) {
auto* i = work_list.back();
work_list.pop_back();
get_def_use_mgr()->ForEachUser(
Fix crash when optimizing shaders with DebugPrintf (#4280) Fixes #4219
2021-05-13 17:19:56 +00:00
i, [&work_list, to_kill, &seen](Instruction* user) {
Improve non-semantic instruction handling in the optimizer (#3693) * No longer blindly add global non-semantic info instructions to global types and values * functions now have a list of non-semantic instructions that succeed them in the global scope * global non-semantic instructions go in global types and values if they appear before any function, otherwise they are attached to the immediate function predecessor in the module * changed ADCE to use the function removal utility * Modified EliminateFunction to have special handling for non-semantic instructions in the global scope * non-semantic instructions are moved to an earlier function (or full global set) if the function they are attached to is eliminated * Added IRContext::KillNonSemanticInfo to remove the tree of non-semantic instructions that use an instruction * this is used in function elimination * There is still significant work in the optimizer to handle non-semantic instructions fully in the optimizer
2020-08-13 18:54:14 +00:00
if (user->IsNonSemanticInstruction() && seen.insert(user).second) {
work_list.push_back(user);
Fix crash when optimizing shaders with DebugPrintf (#4280) Fixes #4219
2021-05-13 17:19:56 +00:00
to_kill->insert(user);
Improve non-semantic instruction handling in the optimizer (#3693) * No longer blindly add global non-semantic info instructions to global types and values * functions now have a list of non-semantic instructions that succeed them in the global scope * global non-semantic instructions go in global types and values if they appear before any function, otherwise they are attached to the immediate function predecessor in the module * changed ADCE to use the function removal utility * Modified EliminateFunction to have special handling for non-semantic instructions in the global scope * non-semantic instructions are moved to an earlier function (or full global set) if the function they are attached to is eliminated * Added IRContext::KillNonSemanticInfo to remove the tree of non-semantic instructions that use an instruction * this is used in function elimination * There is still significant work in the optimizer to handle non-semantic instructions fully in the optimizer
2020-08-13 18:54:14 +00:00
}
});
}
}
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
bool IRContext::KillDef(uint32_t id) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
Instruction* def = get_def_use_mgr()->GetDef(id);
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
if (def != nullptr) {
KillInst(def);
return true;
}
return false;
}
bool IRContext::ReplaceAllUsesWith(uint32_t before, uint32_t after) {
Correctly replace debug lexical scope of instruction (#3718) When we update OpenCL.DebugInfo.100 lexical scopes e.g., DebugFunction, we have to replace DebugScope of each instruction that uses the lexical scope correctly.
2020-08-31 14:05:38 +00:00
return ReplaceAllUsesWithPredicate(before, after,
[](Instruction*) { return true; });
Don't move debug or decorations when folding (#2772) Fixes #2764 * Don't replace all uses when simplifying instructions, instead only update non-debug, non-decoration uses * added a test * Add a new version of RAUW that takes a predicate to decide whether to replace the use or not * used in simplification pass
2019-07-29 20:20:43 +00:00
}
bool IRContext::ReplaceAllUsesWithPredicate(
uint32_t before, uint32_t after,
Correctly replace debug lexical scope of instruction (#3718) When we update OpenCL.DebugInfo.100 lexical scopes e.g., DebugFunction, we have to replace DebugScope of each instruction that uses the lexical scope correctly.
2020-08-31 14:05:38 +00:00
const std::function<bool(Instruction*)>& predicate) {
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
if (before == after) return false;
Correctly replace debug lexical scope of instruction (#3718) When we update OpenCL.DebugInfo.100 lexical scopes e.g., DebugFunction, we have to replace DebugScope of each instruction that uses the lexical scope correctly.
2020-08-31 14:05:38 +00:00
if (AreAnalysesValid(kAnalysisDebugInfo)) {
get_debug_info_mgr()->ReplaceAllUsesInDebugScopeWithPredicate(before, after,
predicate);
}
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
// Ensure that |after| has been registered as def.
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
assert(get_def_use_mgr()->GetDef(after) &&
"'after' is not a registered def.");
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::vector<std::pair<Instruction*, uint32_t>> uses_to_update;
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
get_def_use_mgr()->ForEachUse(
Don't move debug or decorations when folding (#2772) Fixes #2764 * Don't replace all uses when simplifying instructions, instead only update non-debug, non-decoration uses * added a test * Add a new version of RAUW that takes a predicate to decide whether to replace the use or not * used in simplification pass
2019-07-29 20:20:43 +00:00
before, [&predicate, &uses_to_update](Instruction* user, uint32_t index) {
Correctly replace debug lexical scope of instruction (#3718) When we update OpenCL.DebugInfo.100 lexical scopes e.g., DebugFunction, we have to replace DebugScope of each instruction that uses the lexical scope correctly.
2020-08-31 14:05:38 +00:00
if (predicate(user)) {
Don't move debug or decorations when folding (#2772) Fixes #2764 * Don't replace all uses when simplifying instructions, instead only update non-debug, non-decoration uses * added a test * Add a new version of RAUW that takes a predicate to decide whether to replace the use or not * used in simplification pass
2019-07-29 20:20:43 +00:00
uses_to_update.emplace_back(user, index);
}
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
});
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
Instruction* prev = nullptr;
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
for (auto p : uses_to_update) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
Instruction* user = p.first;
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
uint32_t index = p.second;
if (prev == nullptr || prev != user) {
ForgetUses(user);
prev = user;
}
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
const uint32_t type_result_id_count =
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
(user->result_id() != 0) + (user->type_id() != 0);
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
if (index < type_result_id_count) {
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
// Update the type_id. Note that result id is immutable so it should
// never be updated.
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
if (user->type_id() != 0 && index == 0) {
user->SetResultType(after);
} else if (user->type_id() == 0) {
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
SPIRV_ASSERT(consumer_, false,
"Result type id considered as use while the instruction "
Re-format files in source, source/opt, source/util, source/val and tools. NFC. This just makes sure every file is formatted following the formatting definition in .clang-format. Re-formatted with: $ clang-format -i $(find source tools include -name '*.cpp') $ clang-format -i $(find source tools include -name '*.h')
2017-11-08 17:40:02 +00:00
"doesn't have a result type id.");
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
(void)consumer_; // Makes the compiler happy for release build.
} else {
SPIRV_ASSERT(consumer_, false,
"Trying setting the immutable result id.");
}
} else {
// Update an in-operand.
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
uint32_t in_operand_pos = index - type_result_id_count;
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
// Make the modification in the instruction.
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
user->SetInOperand(in_operand_pos, {after});
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
}
Adding new def -> use mapping container Replaced representation of uses * Changed uses from unordered_map<uint32_t, UseList> to set<pairInstruction*, Instruction*>> * Replaced GetUses with ForEachUser and ForEachUse functions * updated passes to use new functions * partially updated tests * lots of cleanup still todo 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 Adding tests for Instruction, IRContext and IR loading Fixed some header comments for BuildModule Fixes to get tests passing again * Reordered two linker steps to avoid use/def problems * Fixed def/use manager uses in merge return pass * Added early return for GetAnnotations * Changed uses of Instruction::ToNop in passes to IRContext::KillInst Simplifying the uses for some contexts in passes
2017-11-14 19:11:50 +00:00
AnalyzeUses(user);
Fix readbility/braces warnings (#1804)
2018-08-07 13:09:47 +00:00
}
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
return true;
}
Have all MemPasses preserve the def-use manager. Originally the passes that extended from MemPass were those that are of the def-use manager. I am assuming they would be able to preserve it because of that. Added a check to verify consistency of the IRContext. The IRContext relies on the pass to tell it if something is invalidated. It is possible that the pass lied. To help identify those situations, we will check if the valid analyses are correct after each pass. This will be enabled by default for the debug build, and disabled in the production build. It can be disabled in the debug build by adding "-DSPIRV_CHECK_CONTEXT=OFF" to the cmake command.
2017-11-09 16:24:41 +00:00
bool IRContext::IsConsistent() {
#ifndef SPIRV_CHECK_CONTEXT
return true;
Remove unreachable code. (#3304)
2020-04-15 18:41:52 +00:00
#else
Have all MemPasses preserve the def-use manager. Originally the passes that extended from MemPass were those that are of the def-use manager. I am assuming they would be able to preserve it because of that. Added a check to verify consistency of the IRContext. The IRContext relies on the pass to tell it if something is invalidated. It is possible that the pass lied. To help identify those situations, we will check if the valid analyses are correct after each pass. This will be enabled by default for the debug build, and disabled in the production build. It can be disabled in the debug build by adding "-DSPIRV_CHECK_CONTEXT=OFF" to the cmake command.
2017-11-09 16:24:41 +00:00
if (AreAnalysesValid(kAnalysisDefUse)) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
analysis::DefUseManager new_def_use(module());
Have all MemPasses preserve the def-use manager. Originally the passes that extended from MemPass were those that are of the def-use manager. I am assuming they would be able to preserve it because of that. Added a check to verify consistency of the IRContext. The IRContext relies on the pass to tell it if something is invalidated. It is possible that the pass lied. To help identify those situations, we will check if the valid analyses are correct after each pass. This will be enabled by default for the debug build, and disabled in the production build. It can be disabled in the debug build by adding "-DSPIRV_CHECK_CONTEXT=OFF" to the cmake command.
2017-11-09 16:24:41 +00:00
if (*get_def_use_mgr() != new_def_use) {
return false;
}
}
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
Kill the id-to-func map after wrap-opkill (#3055) Wrap-opkill will create a new function, invalidating the id-to-func map. The preserved analyses for the pass have been updated to reflect that. Also adding consistency check for the id-to-func map. With this new check, old tests identify this problem. No new tests are needed. Fixes #3038
2019-11-19 14:44:53 +00:00
if (AreAnalysesValid(kAnalysisIdToFuncMapping)) {
for (auto& fn : *module_) {
if (id_to_func_[fn.result_id()] != &fn) {
return false;
}
}
}
Maintain instruction to block mapping in phi insertion * Changed MemPass::InsertPhiInstructions to set basic blocks for new phis * Local SSA elim now maintains instr to block mapping * Added a test and confirmed it fails without the updated phis * IRContext::set_instr_block no longer builds the map if the analysis is invalid * Added instruction to block mapping verification to IRContext::IsConsistent()
2018-01-11 20:05:39 +00:00
if (AreAnalysesValid(kAnalysisInstrToBlockMapping)) {
for (auto& func : *module()) {
for (auto& block : func) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
if (!block.WhileEachInst([this, &block](Instruction* inst) {
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
if (get_instr_block(inst) != &block) {
return false;
}
Adding early exit versions of several ForEach* methods * Looked through code for instances where code would benefit from early exit * Added a corresponding WhileEach* method and updated the code
2018-01-12 20:05:53 +00:00
return true;
}))
return false;
Maintain instruction to block mapping in phi insertion * Changed MemPass::InsertPhiInstructions to set basic blocks for new phis * Local SSA elim now maintains instr to block mapping * Added a test and confirmed it fails without the updated phis * IRContext::set_instr_block no longer builds the map if the analysis is invalid * Added instruction to block mapping verification to IRContext::IsConsistent()
2018-01-11 20:05:39 +00:00
}
}
}
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
if (!CheckCFG()) {
return false;
}
Invalidate the decoration manager at the start of ADCE. (#2189) * Invalidate the decoration manager at the start of ADCE. If the decoration manager is kept live the the contex will try to keep it up to date. ADCE deals with group decorations by changing the operands in |OpGroupDecorate| instructions directly without informing the decoration manager. This puts it in an invalid state, which will cause an error when the context tries to update it. To Avoid this problem, we will invalidate the decoration manager upfront. At the same time, the decoration manager is now considered when checking the consistency of the decoration manager.
2018-12-10 18:24:33 +00:00
if (AreAnalysesValid(kAnalysisDecorations)) {
analysis::DecorationManager* dec_mgr = get_decoration_mgr();
analysis::DecorationManager current(module());
if (*dec_mgr != current) {
return false;
}
}
Check feature mgr in context consistency check (#2818) We add a check that the feature manager is correcter after each pass. This resulted in a couple failing tests cases. Those are fixed. Part of #2814
2019-08-28 15:49:16 +00:00
if (feature_mgr_ != nullptr) {
FeatureManager current(grammar_);
current.Analyze(module());
if (current != *feature_mgr_) {
return false;
}
}
Have all MemPasses preserve the def-use manager. Originally the passes that extended from MemPass were those that are of the def-use manager. I am assuming they would be able to preserve it because of that. Added a check to verify consistency of the IRContext. The IRContext relies on the pass to tell it if something is invalidated. It is possible that the pass lied. To help identify those situations, we will check if the valid analyses are correct after each pass. This will be enabled by default for the debug build, and disabled in the production build. It can be disabled in the debug build by adding "-DSPIRV_CHECK_CONTEXT=OFF" to the cmake command.
2017-11-09 16:24:41 +00:00
return true;
Remove unreachable code. (#3304)
2020-04-15 18:41:52 +00:00
#endif
Have all MemPasses preserve the def-use manager. Originally the passes that extended from MemPass were those that are of the def-use manager. I am assuming they would be able to preserve it because of that. Added a check to verify consistency of the IRContext. The IRContext relies on the pass to tell it if something is invalidated. It is possible that the pass lied. To help identify those situations, we will check if the valid analyses are correct after each pass. This will be enabled by default for the debug build, and disabled in the production build. It can be disabled in the debug build by adding "-DSPIRV_CHECK_CONTEXT=OFF" to the cmake command.
2017-11-09 16:24:41 +00:00
}
Change libspirv to spvtools namespace (#1678) This CL changes all of the libspirv namespace code to spvtools to match the rest of the code base.
2018-07-07 13:38:00 +00:00
void IRContext::ForgetUses(Instruction* inst) {
Have all MemPasses preserve the def-use manager. Originally the passes that extended from MemPass were those that are of the def-use manager. I am assuming they would be able to preserve it because of that. Added a check to verify consistency of the IRContext. The IRContext relies on the pass to tell it if something is invalidated. It is possible that the pass lied. To help identify those situations, we will check if the valid analyses are correct after each pass. This will be enabled by default for the debug build, and disabled in the production build. It can be disabled in the debug build by adding "-DSPIRV_CHECK_CONTEXT=OFF" to the cmake command.
2017-11-09 16:24:41 +00:00
if (AreAnalysesValid(kAnalysisDefUse)) {
get_def_use_mgr()->EraseUseRecordsOfOperandIds(inst);
}
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
if (AreAnalysesValid(kAnalysisDecorations)) {
if (inst->IsDecoration()) {
get_decoration_mgr()->RemoveDecoration(inst);
}
}
Clear debug information for kill and replacement (#3459) For many spirv-opt passes such as simplify-instructions pass, we have to correctly clear the OpenCL.DebugInfo.100 debug information for KillInst() and ReplaceAllUses(). If we keep some debug information that disappeared because of KillInst() and ReplaceAllUses(), adding new DebugValue instructions based on the existing DebugDeclare information will generate incorrect information. This CL update DebugInfoManager and IRContext to correctly clear debug information.
2020-06-25 19:48:26 +00:00
if (AreAnalysesValid(kAnalysisDebugInfo)) {
get_debug_info_mgr()->ClearDebugInfo(inst);
}
Add id to name map Adding a map from an id to it set of OpName and OpMemberName instructions. This will be used in KillNameAndDecorates to kill the names for the ids that are being removed. In my test, the compile time for 50 shaders went from 1m57s to 55s. This was on linux using the release build. Fixes #1290.
2018-02-13 04:28:38 +00:00
RemoveFromIdToName(inst);
Have all MemPasses preserve the def-use manager. Originally the passes that extended from MemPass were those that are of the def-use manager. I am assuming they would be able to preserve it because of that. Added a check to verify consistency of the IRContext. The IRContext relies on the pass to tell it if something is invalidated. It is possible that the pass lied. To help identify those situations, we will check if the valid analyses are correct after each pass. This will be enabled by default for the debug build, and disabled in the production build. It can be disabled in the debug build by adding "-DSPIRV_CHECK_CONTEXT=OFF" to the cmake command.
2017-11-09 16:24:41 +00:00
}
void IRContext::AnalyzeUses(Instruction* inst) {
if (AreAnalysesValid(kAnalysisDefUse)) {
get_def_use_mgr()->AnalyzeInstUse(inst);
}
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
if (AreAnalysesValid(kAnalysisDecorations)) {
if (inst->IsDecoration()) {
get_decoration_mgr()->AddDecoration(inst);
}
}
Clear debug information for kill and replacement (#3459) For many spirv-opt passes such as simplify-instructions pass, we have to correctly clear the OpenCL.DebugInfo.100 debug information for KillInst() and ReplaceAllUses(). If we keep some debug information that disappeared because of KillInst() and ReplaceAllUses(), adding new DebugValue instructions based on the existing DebugDeclare information will generate incorrect information. This CL update DebugInfoManager and IRContext to correctly clear debug information.
2020-06-25 19:48:26 +00:00
if (AreAnalysesValid(kAnalysisDebugInfo)) {
get_debug_info_mgr()->AnalyzeDebugInst(inst);
}
Add id to name map Adding a map from an id to it set of OpName and OpMemberName instructions. This will be used in KillNameAndDecorates to kill the names for the ids that are being removed. In my test, the compile time for 50 shaders went from 1m57s to 55s. This was on linux using the release build. Fixes #1290.
2018-02-13 04:28:38 +00:00
if (id_to_name_ &&
(inst->opcode() == SpvOpName || inst->opcode() == SpvOpMemberName)) {
id_to_name_->insert({inst->GetSingleWordInOperand(0), inst});
}
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
}
void IRContext::KillNamesAndDecorates(uint32_t id) {
Get KillNameAndDecorates to handle group decorations. (#1919) It seems like the current implementation of KillNameAndDecorates does not handle group decorations correctly. The id being removed is not removed from the OpGroupDecorate instructions. Even worst, any decorations that apply to that group are removed. The solution is to use the function in the decoration manager that will remove the decorations and update the instructions instead of doing the work itself.
2018-09-25 16:57:44 +00:00
analysis::DecorationManager* dec_mgr = get_decoration_mgr();
dec_mgr->RemoveDecorationsFrom(id);
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::vector<Instruction*> name_to_kill;
Add id to name map Adding a map from an id to it set of OpName and OpMemberName instructions. This will be used in KillNameAndDecorates to kill the names for the ids that are being removed. In my test, the compile time for 50 shaders went from 1m57s to 55s. This was on linux using the release build. Fixes #1290.
2018-02-13 04:28:38 +00:00
for (auto name : GetNames(id)) {
name_to_kill.push_back(name.second);
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* name_inst : name_to_kill) {
Add id to name map Adding a map from an id to it set of OpName and OpMemberName instructions. This will be used in KillNameAndDecorates to kill the names for the ids that are being removed. In my test, the compile time for 50 shaders went from 1m57s to 55s. This was on linux using the release build. Fixes #1290.
2018-02-13 04:28:38 +00:00
KillInst(name_inst);
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
}
}
void IRContext::KillNamesAndDecorates(Instruction* inst) {
const uint32_t rId = inst->result_id();
if (rId == 0) return;
KillNamesAndDecorates(rId);
Have all MemPasses preserve the def-use manager. Originally the passes that extended from MemPass were those that are of the def-use manager. I am assuming they would be able to preserve it because of that. Added a check to verify consistency of the IRContext. The IRContext relies on the pass to tell it if something is invalidated. It is possible that the pass lied. To help identify those situations, we will check if the valid analyses are correct after each pass. This will be enabled by default for the debug build, and disabled in the production build. It can be disabled in the debug build by adding "-DSPIRV_CHECK_CONTEXT=OFF" to the cmake command.
2017-11-09 16:24:41 +00:00
}
Add analysis to compute mappings between instructions and basic blocks. This analysis builds a map from instructions to the basic block that contains them. It is accessed via get_instr_block(). Once built, it is kept up-to-date by the IRContext, as long as instructions are removed via KillInst. I have not yet marked passes that preserve this analysis. I will do it in a separate change. Other changes: - Add documentation about analysis values requirement to be powers of 2. - Force a re-build of the def-use manager in tests. - Fix AllPreserveFirstOnlyAfterPassWithChange to use the DummyPassPreservesFirst pass. - Fix sentinel value for IRContext::Analysis enum. - Fix logic for checking if the instr<->block mapping is valid in KillInst.
2017-11-10 14:39:00 +00:00
Preserve debug info in eliminate-dead-functions (#3251) * Preserve debug info in eliminate-dead-functions The elimination of dead functions makes OpFunction operand of DebugFunction invalid. This commit replaces the operand with DebugInfoNone.
2020-04-13 13:29:36 +00:00
void IRContext::KillOperandFromDebugInstructions(Instruction* inst) {
const auto opcode = inst->opcode();
const uint32_t id = inst->result_id();
// Kill id of OpFunction from DebugFunction.
if (opcode == SpvOpFunction) {
for (auto it = module()->ext_inst_debuginfo_begin();
it != module()->ext_inst_debuginfo_end(); ++it) {
if (it->GetOpenCL100DebugOpcode() != OpenCLDebugInfo100DebugFunction)
continue;
auto& operand = it->GetOperand(kDebugFunctionOperandFunctionIndex);
if (operand.words[0] == id) {
Add debug information analysis (#3305) We need an analysis for OpenCL.DebugInfo.100 extension instructions such as a map between function id and its DebugFunction. This commit add an analysis for it.
2020-04-27 19:18:55 +00:00
operand.words[0] =
get_debug_info_mgr()->GetDebugInfoNone()->result_id();
[spirv-opt] debug info preservation in ssa-rewrite (#3356) Add OpenCL.DebugInfo.100 `DebugValue` instructions for store and phi instructions of local variables to provide the debugger with the updated values of local variables correctly.
2020-06-19 18:57:43 +00:00
get_def_use_mgr()->AnalyzeInstUse(&*it);
Preserve debug info in eliminate-dead-functions (#3251) * Preserve debug info in eliminate-dead-functions The elimination of dead functions makes OpFunction operand of DebugFunction invalid. This commit replaces the operand with DebugInfoNone.
2020-04-13 13:29:36 +00:00
}
}
}
// Kill id of OpVariable for global variable from DebugGlobalVariable.
if (opcode == SpvOpVariable || IsConstantInst(opcode)) {
for (auto it = module()->ext_inst_debuginfo_begin();
it != module()->ext_inst_debuginfo_end(); ++it) {
if (it->GetOpenCL100DebugOpcode() !=
OpenCLDebugInfo100DebugGlobalVariable)
continue;
auto& operand = it->GetOperand(kDebugGlobalVariableOperandVariableIndex);
if (operand.words[0] == id) {
Add debug information analysis (#3305) We need an analysis for OpenCL.DebugInfo.100 extension instructions such as a map between function id and its DebugFunction. This commit add an analysis for it.
2020-04-27 19:18:55 +00:00
operand.words[0] =
get_debug_info_mgr()->GetDebugInfoNone()->result_id();
[spirv-opt] debug info preservation in ssa-rewrite (#3356) Add OpenCL.DebugInfo.100 `DebugValue` instructions for store and phi instructions of local variables to provide the debugger with the updated values of local variables correctly.
2020-06-19 18:57:43 +00:00
get_def_use_mgr()->AnalyzeInstUse(&*it);
Preserve debug info in eliminate-dead-functions (#3251) * Preserve debug info in eliminate-dead-functions The elimination of dead functions makes OpFunction operand of DebugFunction invalid. This commit replaces the operand with DebugInfoNone.
2020-04-13 13:29:36 +00:00
}
}
}
}
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
void IRContext::AddCombinatorsForCapability(uint32_t capability) {
if (capability == SpvCapabilityShader) {
Allow ADCE to remove more instructions. At this time, DCE will only remove an instruction if it is a combinator. However, there are certain non-combinator instructions that can be safely removed if their results are not used. The derivative instructions are on example. We are also missing some instructions from the list of combinators those are added as the same time.
2018-05-02 18:54:26 +00:00
combinator_ops_[0].insert({SpvOpNop,
SpvOpUndef,
SpvOpConstant,
SpvOpConstantTrue,
SpvOpConstantFalse,
SpvOpConstantComposite,
SpvOpConstantSampler,
SpvOpConstantNull,
SpvOpTypeVoid,
SpvOpTypeBool,
SpvOpTypeInt,
SpvOpTypeFloat,
SpvOpTypeVector,
SpvOpTypeMatrix,
SpvOpTypeImage,
SpvOpTypeSampler,
SpvOpTypeSampledImage,
Added additional changes for the new AccelerationStructureNV type. (#2218) * Added additional changes for the new AccelerationStructureNV type. * Added additional changes for the new AccelerationStructureNV type. Change tabs to space... * Added additional changes for the new accelerationStructureNV type -- add proper type name. Fix TypeManager.TypeStrings test: [----------] 29 tests from TypeManager [ RUN ] TypeManager.TypeStrings [ OK ] TypeManager.TypeStrings (7 ms)
2018-12-19 21:42:39 +00:00
SpvOpTypeAccelerationStructureNV,
Add support for KHR_ray_{query,tracing} extensions (#3235) Update validator for SPV_KHR_ray_tracing. * Added handling for new enum types * Add SpvScopeShaderCallKHR as a valid scope * update spirv-headers Co-authored-by: alelenv <alele@nvidia.com> Co-authored-by: Torosdagli <ntorosda@amd.com> Co-authored-by: Tobias Hector <tobias.hector@amd.com> Co-authored-by: Steven Perron <stevenperron@google.com>
2020-03-17 19:30:19 +00:00
SpvOpTypeAccelerationStructureKHR,
Update MeshShadingNV dependencies (and land Ray tracing updates) (#4028) * Update to final ray tracing extensions Drop Provisional from ray tracing enums sed -ie 's/RayQueryProvisionalKHR/RayQueryKHR/g' **/* sed -ie 's/RayTracingProvisionalKHR/RayTracingKHR/g' **/* Add terminator support for SpvOpIgnoreIntersectionKHR and SpvOpTerminateRayKHR Update deps for SPIRV-Headers * Update capability dependencies for MeshShadingNV Accommodate https://github.com/KhronosGroup/SPIRV-Headers/pull/180 MeshShadingNV: enables PrimitiveId, Layer, and ViewportIndex Co-authored-by: Daniel Koch <dkoch@nvidia.com>
2020-11-23 17:23:54 +00:00
SpvOpTypeRayQueryKHR,
Allow ADCE to remove more instructions. At this time, DCE will only remove an instruction if it is a combinator. However, there are certain non-combinator instructions that can be safely removed if their results are not used. The derivative instructions are on example. We are also missing some instructions from the list of combinators those are added as the same time.
2018-05-02 18:54:26 +00:00
SpvOpTypeArray,
SpvOpTypeRuntimeArray,
SpvOpTypeStruct,
SpvOpTypeOpaque,
SpvOpTypePointer,
SpvOpTypeFunction,
SpvOpTypeEvent,
SpvOpTypeDeviceEvent,
SpvOpTypeReserveId,
SpvOpTypeQueue,
SpvOpTypePipe,
SpvOpTypeForwardPointer,
SpvOpVariable,
SpvOpImageTexelPointer,
SpvOpLoad,
SpvOpAccessChain,
SpvOpInBoundsAccessChain,
SpvOpArrayLength,
SpvOpVectorExtractDynamic,
SpvOpVectorInsertDynamic,
SpvOpVectorShuffle,
SpvOpCompositeConstruct,
SpvOpCompositeExtract,
SpvOpCompositeInsert,
SpvOpCopyObject,
SpvOpTranspose,
SpvOpSampledImage,
SpvOpImageSampleImplicitLod,
SpvOpImageSampleExplicitLod,
SpvOpImageSampleDrefImplicitLod,
SpvOpImageSampleDrefExplicitLod,
SpvOpImageSampleProjImplicitLod,
SpvOpImageSampleProjExplicitLod,
SpvOpImageSampleProjDrefImplicitLod,
SpvOpImageSampleProjDrefExplicitLod,
SpvOpImageFetch,
SpvOpImageGather,
SpvOpImageDrefGather,
SpvOpImageRead,
SpvOpImage,
SpvOpImageQueryFormat,
SpvOpImageQueryOrder,
SpvOpImageQuerySizeLod,
SpvOpImageQuerySize,
SpvOpImageQueryLevels,
SpvOpImageQuerySamples,
SpvOpConvertFToU,
SpvOpConvertFToS,
SpvOpConvertSToF,
SpvOpConvertUToF,
SpvOpUConvert,
SpvOpSConvert,
SpvOpFConvert,
SpvOpQuantizeToF16,
SpvOpBitcast,
SpvOpSNegate,
SpvOpFNegate,
SpvOpIAdd,
SpvOpFAdd,
SpvOpISub,
SpvOpFSub,
SpvOpIMul,
SpvOpFMul,
SpvOpUDiv,
SpvOpSDiv,
SpvOpFDiv,
SpvOpUMod,
SpvOpSRem,
SpvOpSMod,
SpvOpFRem,
SpvOpFMod,
SpvOpVectorTimesScalar,
SpvOpMatrixTimesScalar,
SpvOpVectorTimesMatrix,
SpvOpMatrixTimesVector,
SpvOpMatrixTimesMatrix,
SpvOpOuterProduct,
SpvOpDot,
SpvOpIAddCarry,
SpvOpISubBorrow,
SpvOpUMulExtended,
SpvOpSMulExtended,
SpvOpAny,
SpvOpAll,
SpvOpIsNan,
SpvOpIsInf,
SpvOpLogicalEqual,
SpvOpLogicalNotEqual,
SpvOpLogicalOr,
SpvOpLogicalAnd,
SpvOpLogicalNot,
SpvOpSelect,
SpvOpIEqual,
SpvOpINotEqual,
SpvOpUGreaterThan,
SpvOpSGreaterThan,
SpvOpUGreaterThanEqual,
SpvOpSGreaterThanEqual,
SpvOpULessThan,
SpvOpSLessThan,
SpvOpULessThanEqual,
SpvOpSLessThanEqual,
SpvOpFOrdEqual,
SpvOpFUnordEqual,
SpvOpFOrdNotEqual,
SpvOpFUnordNotEqual,
SpvOpFOrdLessThan,
SpvOpFUnordLessThan,
SpvOpFOrdGreaterThan,
SpvOpFUnordGreaterThan,
SpvOpFOrdLessThanEqual,
SpvOpFUnordLessThanEqual,
SpvOpFOrdGreaterThanEqual,
SpvOpFUnordGreaterThanEqual,
SpvOpShiftRightLogical,
SpvOpShiftRightArithmetic,
SpvOpShiftLeftLogical,
SpvOpBitwiseOr,
SpvOpBitwiseXor,
SpvOpBitwiseAnd,
SpvOpNot,
SpvOpBitFieldInsert,
SpvOpBitFieldSExtract,
SpvOpBitFieldUExtract,
SpvOpBitReverse,
SpvOpBitCount,
SpvOpPhi,
SpvOpImageSparseSampleImplicitLod,
SpvOpImageSparseSampleExplicitLod,
SpvOpImageSparseSampleDrefImplicitLod,
SpvOpImageSparseSampleDrefExplicitLod,
SpvOpImageSparseSampleProjImplicitLod,
SpvOpImageSparseSampleProjExplicitLod,
SpvOpImageSparseSampleProjDrefImplicitLod,
SpvOpImageSparseSampleProjDrefExplicitLod,
SpvOpImageSparseFetch,
SpvOpImageSparseGather,
SpvOpImageSparseDrefGather,
SpvOpImageSparseTexelsResident,
SpvOpImageSparseRead,
SpvOpSizeOf});
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
}
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
void IRContext::AddCombinatorsForExtension(Instruction* extension) {
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
assert(extension->opcode() == SpvOpExtInstImport &&
"Expecting an import of an extension's instruction set.");
const char* extension_name =
reinterpret_cast<const char*>(&extension->GetInOperand(0).words[0]);
if (!strcmp(extension_name, "GLSL.std.450")) {
combinator_ops_[extension->result_id()] = {GLSLstd450Round,
GLSLstd450RoundEven,
GLSLstd450Trunc,
GLSLstd450FAbs,
GLSLstd450SAbs,
GLSLstd450FSign,
GLSLstd450SSign,
GLSLstd450Floor,
GLSLstd450Ceil,
GLSLstd450Fract,
GLSLstd450Radians,
GLSLstd450Degrees,
GLSLstd450Sin,
GLSLstd450Cos,
GLSLstd450Tan,
GLSLstd450Asin,
GLSLstd450Acos,
GLSLstd450Atan,
GLSLstd450Sinh,
GLSLstd450Cosh,
GLSLstd450Tanh,
GLSLstd450Asinh,
GLSLstd450Acosh,
GLSLstd450Atanh,
GLSLstd450Atan2,
GLSLstd450Pow,
GLSLstd450Exp,
GLSLstd450Log,
GLSLstd450Exp2,
GLSLstd450Log2,
GLSLstd450Sqrt,
GLSLstd450InverseSqrt,
GLSLstd450Determinant,
GLSLstd450MatrixInverse,
GLSLstd450ModfStruct,
GLSLstd450FMin,
GLSLstd450UMin,
GLSLstd450SMin,
GLSLstd450FMax,
GLSLstd450UMax,
GLSLstd450SMax,
GLSLstd450FClamp,
GLSLstd450UClamp,
GLSLstd450SClamp,
GLSLstd450FMix,
GLSLstd450IMix,
GLSLstd450Step,
GLSLstd450SmoothStep,
GLSLstd450Fma,
GLSLstd450FrexpStruct,
GLSLstd450Ldexp,
GLSLstd450PackSnorm4x8,
GLSLstd450PackUnorm4x8,
GLSLstd450PackSnorm2x16,
GLSLstd450PackUnorm2x16,
GLSLstd450PackHalf2x16,
GLSLstd450PackDouble2x32,
GLSLstd450UnpackSnorm2x16,
GLSLstd450UnpackUnorm2x16,
GLSLstd450UnpackHalf2x16,
GLSLstd450UnpackSnorm4x8,
GLSLstd450UnpackUnorm4x8,
GLSLstd450UnpackDouble2x32,
GLSLstd450Length,
GLSLstd450Distance,
GLSLstd450Cross,
GLSLstd450Normalize,
GLSLstd450FaceForward,
GLSLstd450Reflect,
GLSLstd450Refract,
GLSLstd450FindILsb,
GLSLstd450FindSMsb,
GLSLstd450FindUMsb,
GLSLstd450InterpolateAtCentroid,
GLSLstd450InterpolateAtSample,
GLSLstd450InterpolateAtOffset,
GLSLstd450NMin,
GLSLstd450NMax,
GLSLstd450NClamp};
} else {
// Map the result id to the empty set.
combinator_ops_[extension->result_id()];
}
}
void IRContext::InitializeCombinators() {
ADCE: Fix combinator initialization The combinator initialization was only looking at the capabilities in the shader and not the inferred capabilities. Geometry and tessellation shaders were not setting the Shader capability which is inferred. So the combinator set was not initialized correctly causing problems for ADCE.
2018-02-02 23:57:39 +00:00
get_feature_mgr()->GetCapabilities()->ForEach(
[this](SpvCapability cap) { AddCombinatorsForCapability(cap); });
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
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
for (auto& extension : module()->ext_inst_imports()) {
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
AddCombinatorsForExtension(&extension);
}
valid_analyses_ |= kAnalysisCombinators;
}
Dominator Tree Analysis (#3) Support for dominator and post dominator analysis on ir::Functions. This patch contains a DominatorTree class for building the tree and DominatorAnalysis and DominatorAnalysisPass classes for interfacing and caching the built trees.
2017-11-27 21:21:26 +00:00
Add id to name map Adding a map from an id to it set of OpName and OpMemberName instructions. This will be used in KillNameAndDecorates to kill the names for the ids that are being removed. In my test, the compile time for 50 shaders went from 1m57s to 55s. This was on linux using the release build. Fixes #1290.
2018-02-13 04:28:38 +00:00
void IRContext::RemoveFromIdToName(const Instruction* inst) {
if (id_to_name_ &&
(inst->opcode() == SpvOpName || inst->opcode() == SpvOpMemberName)) {
auto range = id_to_name_->equal_range(inst->GetSingleWordInOperand(0));
for (auto it = range.first; it != range.second; ++it) {
if (it->second == inst) {
id_to_name_->erase(it);
break;
}
}
}
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
LoopDescriptor* IRContext::GetLoopDescriptor(const Function* f) {
Add LoopDescriptor as an IRContext analysis. Move some function definitions from header to source to avoid circular definition.
2018-01-25 10:33:06 +00:00
if (!AreAnalysesValid(kAnalysisLoopAnalysis)) {
ResetLoopAnalysis();
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
std::unordered_map<const Function*, LoopDescriptor>::iterator it =
Add LoopDescriptor as an IRContext analysis. Move some function definitions from header to source to avoid circular definition.
2018-01-25 10:33:06 +00:00
loop_descriptors_.find(f);
if (it == loop_descriptors_.end()) {
Remove the module from opt::Function. (#1717) The function class provides a {Set|Get}Parent call in order to provide the context to the LoopDescriptor methods. This CL removes the module from Function and provides the needed context directly to LoopDescriptor on creation.
2018-07-12 18:42:05 +00:00
return &loop_descriptors_
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
.emplace(std::make_pair(f, LoopDescriptor(this, f)))
Add LoopDescriptor as an IRContext analysis. Move some function definitions from header to source to avoid circular definition.
2018-01-25 10:33:06 +00:00
.first->second;
}
return &it->second;
}
Instrument: Add version 2 of record formats (#2630) New version has additional word in stage-specific section. Also some changes in content for tesselation and compute shaders. Either version can be invoked at pass creation. This is done to ease integration and updating of validation layers. Version 1 is deprecated and eventually will go away. Also sneaking in fix to version 1 compute shaders.
2019-05-29 19:08:21 +00:00
uint32_t IRContext::FindBuiltinInputVar(uint32_t builtin) {
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
for (auto& a : module_->annotations()) {
if (a.opcode() != SpvOpDecorate) continue;
if (a.GetSingleWordInOperand(kSpvDecorateDecorationInIdx) !=
SpvDecorationBuiltIn)
continue;
if (a.GetSingleWordInOperand(kSpvDecorateBuiltinInIdx) != builtin) continue;
uint32_t target_id = a.GetSingleWordInOperand(kSpvDecorateTargetIdInIdx);
Instruction* b_var = get_def_use_mgr()->GetDef(target_id);
if (b_var->opcode() != SpvOpVariable) continue;
Instrument: Add version 2 of record formats (#2630) New version has additional word in stage-specific section. Also some changes in content for tesselation and compute shaders. Either version can be invoked at pass creation. This is done to ease integration and updating of validation layers. Version 1 is deprecated and eventually will go away. Also sneaking in fix to version 1 compute shaders.
2019-05-29 19:08:21 +00:00
if (b_var->GetSingleWordInOperand(0) != SpvStorageClassInput) continue;
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 target_id;
}
return 0;
}
void IRContext::AddVarToEntryPoints(uint32_t var_id) {
uint32_t ocnt = 0;
for (auto& e : module()->entry_points()) {
bool found = false;
e.ForEachInOperand([&ocnt, &found, &var_id](const uint32_t* idp) {
if (ocnt >= kEntryPointInterfaceInIdx) {
if (*idp == var_id) found = true;
}
++ocnt;
});
if (!found) {
e.AddOperand({SPV_OPERAND_TYPE_ID, {var_id}});
get_def_use_mgr()->AnalyzeInstDefUse(&e);
}
}
}
Instrument: Add version 2 of record formats (#2630) New version has additional word in stage-specific section. Also some changes in content for tesselation and compute shaders. Either version can be invoked at pass creation. This is done to ease integration and updating of validation layers. Version 1 is deprecated and eventually will go away. Also sneaking in fix to version 1 compute shaders.
2019-05-29 19:08:21 +00:00
uint32_t IRContext::GetBuiltinInputVarId(uint32_t builtin) {
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
if (!AreAnalysesValid(kAnalysisBuiltinVarId)) ResetBuiltinAnalysis();
// If cached, return it.
std::unordered_map<uint32_t, uint32_t>::iterator it =
builtin_var_id_map_.find(builtin);
if (it != builtin_var_id_map_.end()) return it->second;
// Look for one in shader
Instrument: Add version 2 of record formats (#2630) New version has additional word in stage-specific section. Also some changes in content for tesselation and compute shaders. Either version can be invoked at pass creation. This is done to ease integration and updating of validation layers. Version 1 is deprecated and eventually will go away. Also sneaking in fix to version 1 compute shaders.
2019-05-29 19:08:21 +00:00
uint32_t var_id = FindBuiltinInputVar(builtin);
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
if (var_id == 0) {
// If not found, create it
// TODO(greg-lunarg): Add support for all builtins
analysis::TypeManager* type_mgr = get_type_mgr();
analysis::Type* reg_type;
switch (builtin) {
case SpvBuiltInFragCoord: {
analysis::Float float_ty(32);
analysis::Type* reg_float_ty = type_mgr->GetRegisteredType(&float_ty);
analysis::Vector v4float_ty(reg_float_ty, 4);
reg_type = type_mgr->GetRegisteredType(&v4float_ty);
break;
}
Fix vertex instrumentation to use VertexIndex and InstanceIndex (#2294) ...instead of VertexId and InstanceId
2019-01-16 23:02:07 +00:00
case SpvBuiltInVertexIndex:
case SpvBuiltInInstanceIndex:
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
case SpvBuiltInPrimitiveId:
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
case SpvBuiltInInvocationId:
case SpvBuiltInSubgroupLocalInvocationId: {
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
analysis::Integer uint_ty(32, false);
reg_type = type_mgr->GetRegisteredType(&uint_ty);
Update type for loaded builtin GlobalInvocationID in pass instrumentation (#2705) When working on descriptor indexing validation for compute shaders, the gl_GlobalInvocationID builtin was being loaded as uint which would cause compute shaders instrumented by the bindless check pass to have: %83 = OpLoad %uint %gl_GlobalInvocationID %84 = OpCompositeExtract %uint %83 0 %85 = OpCompositeExtract %uint %83 1 %86 = OpCompositeExtract %uint %83 2 which results in validation failures: error: line 127: Reached non-composite type while indexes still remain to be traversed. %84 = OpCompositeExtract %uint %83 0 for trying to extract a uint from a uint.
2019-06-28 13:46:16 +00:00
break;
}
Allow ray tracing shaders in inst bindle check pass. (#2733) Adds the ray tracing stages (ray gen, intersection, any hit, closest hit, miss, and callable) to the allowed stages in pass instrumentation and add debug records for these stages to output the global launch id. More information for ray tracing shaders: - https://github.com/KhronosGroup/GLSL/blob/master/extensions/nv/GLSL_NV_ray_tracing.txt
2019-07-15 20:24:42 +00:00
case SpvBuiltInGlobalInvocationId:
case SpvBuiltInLaunchIdNV: {
Update type for loaded builtin GlobalInvocationID in pass instrumentation (#2705) When working on descriptor indexing validation for compute shaders, the gl_GlobalInvocationID builtin was being loaded as uint which would cause compute shaders instrumented by the bindless check pass to have: %83 = OpLoad %uint %gl_GlobalInvocationID %84 = OpCompositeExtract %uint %83 0 %85 = OpCompositeExtract %uint %83 1 %86 = OpCompositeExtract %uint %83 2 which results in validation failures: error: line 127: Reached non-composite type while indexes still remain to be traversed. %84 = OpCompositeExtract %uint %83 0 for trying to extract a uint from a uint.
2019-06-28 13:46:16 +00:00
analysis::Integer uint_ty(32, false);
analysis::Type* reg_uint_ty = type_mgr->GetRegisteredType(&uint_ty);
analysis::Vector v3uint_ty(reg_uint_ty, 3);
reg_type = type_mgr->GetRegisteredType(&v3uint_ty);
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
break;
}
Instrument: Fix version 2 output record write for tess eval shaders. (#2782) Fix output record write for tess eval shaders. Also change command line for bindless instrumentation to use use output record version 2.
2019-08-09 12:22:41 +00:00
case SpvBuiltInTessCoord: {
analysis::Float float_ty(32);
analysis::Type* reg_float_ty = type_mgr->GetRegisteredType(&float_ty);
analysis::Vector v3float_ty(reg_float_ty, 3);
reg_type = type_mgr->GetRegisteredType(&v3float_ty);
break;
}
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
case SpvBuiltInSubgroupLtMask: {
analysis::Integer uint_ty(32, false);
analysis::Type* reg_uint_ty = type_mgr->GetRegisteredType(&uint_ty);
analysis::Vector v4uint_ty(reg_uint_ty, 4);
reg_type = type_mgr->GetRegisteredType(&v4uint_ty);
break;
}
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
default: {
assert(false && "unhandled builtin");
return 0;
}
}
uint32_t type_id = type_mgr->GetTypeInstruction(reg_type);
uint32_t varTyPtrId =
type_mgr->FindPointerToType(type_id, SpvStorageClassInput);
Document in the context what happens with id overflow. (#2159) Added documentation to the ir context to indicates that TakeNextId() returns 0 when the max id is reached. TODOs were added to each call sight so that we know where we have to start to handle this case. Handle id overflow in |SplitLoopHeader|. Handle id overflow in |GetOrCreatePreHeaderBlock|. Handle failure to create preheader in LICM. Part of https://github.com/KhronosGroup/SPIRV-Tools/issues/1841.
2018-12-06 14:07:00 +00:00
// TODO(1841): Handle id overflow.
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
var_id = TakeNextId();
std::unique_ptr<Instruction> newVarOp(
new Instruction(this, SpvOpVariable, varTyPtrId, var_id,
{{spv_operand_type_t::SPV_OPERAND_TYPE_LITERAL_INTEGER,
{SpvStorageClassInput}}}));
get_def_use_mgr()->AnalyzeInstDefUse(&*newVarOp);
module()->AddGlobalValue(std::move(newVarOp));
get_decoration_mgr()->AddDecorationVal(var_id, SpvDecorationBuiltIn,
builtin);
AddVarToEntryPoints(var_id);
}
builtin_var_id_map_[builtin] = var_id;
return var_id;
}
Don't inline recursive functions. (#2130) * Move ProcessFunction* function from pass to the context. There are a few functions that are used to traverse the call tree. They currently live in the Pass class, but they have nothing to do with a pass, and may be needed outside of a pass. They would be better in the ir context, or in a specific call tree class if we ever have a need for it. * Don't inline recursive functions. Inlining does not check if a function is recursive or not. This has been fine as long as the shader was a Vulkan shader, which forbid recursive functions. However, not all shaders are vulkan, so either we limit inlining to Vulkan shaders or we teach it to look for recursive functions. I prefer to keep the passes as general as is reasonable. The change does not require much new code in inlining and gives a reason to refactor some other code. The changes are to add a member function to the Function class that checks if that function is recursive or not. Then this is used in inlining to not inlining a function call if it calls a recursive function. * Add id to function analysis There are a few places that build a map from ids to Function whose result is that id. I decided to add an analysis to the context for this to reduce that code, and simplify some of the functions. * Add missing file.
2018-11-29 19:24:58 +00:00
void IRContext::AddCalls(const Function* func, std::queue<uint32_t>* todo) {
for (auto bi = func->begin(); bi != func->end(); ++bi)
for (auto ii = bi->begin(); ii != bi->end(); ++ii)
if (ii->opcode() == SpvOpFunctionCall)
todo->push(ii->GetSingleWordInOperand(0));
}
bool IRContext::ProcessEntryPointCallTree(ProcessFunction& pfn) {
// Collect all of the entry points as the roots.
std::queue<uint32_t> roots;
for (auto& e : module()->entry_points()) {
roots.push(e.GetSingleWordInOperand(kEntryPointFunctionIdInIdx));
}
return ProcessCallTreeFromRoots(pfn, &roots);
}
bool IRContext::ProcessReachableCallTree(ProcessFunction& pfn) {
std::queue<uint32_t> roots;
// Add all entry points since they can be reached from outside the module.
for (auto& e : module()->entry_points())
roots.push(e.GetSingleWordInOperand(kEntryPointFunctionIdInIdx));
// Add all exported functions since they can be reached from outside the
// module.
for (auto& a : annotations()) {
// TODO: Handle group decorations as well. Currently not generate by any
// front-end, but could be coming.
if (a.opcode() == SpvOp::SpvOpDecorate) {
if (a.GetSingleWordOperand(1) ==
SpvDecoration::SpvDecorationLinkageAttributes) {
uint32_t lastOperand = a.NumOperands() - 1;
if (a.GetSingleWordOperand(lastOperand) ==
SpvLinkageType::SpvLinkageTypeExport) {
uint32_t id = a.GetSingleWordOperand(0);
if (GetFunction(id)) {
roots.push(id);
}
}
}
}
}
return ProcessCallTreeFromRoots(pfn, &roots);
}
bool IRContext::ProcessCallTreeFromRoots(ProcessFunction& pfn,
std::queue<uint32_t>* roots) {
// Process call tree
bool modified = false;
std::unordered_set<uint32_t> done;
while (!roots->empty()) {
const uint32_t fi = roots->front();
roots->pop();
if (done.insert(fi).second) {
Function* fn = GetFunction(fi);
Kill the id-to-func map after wrap-opkill (#3055) Wrap-opkill will create a new function, invalidating the id-to-func map. The preserved analyses for the pass have been updated to reflect that. Also adding consistency check for the id-to-func map. With this new check, old tests identify this problem. No new tests are needed. Fixes #3038
2019-11-19 14:44:53 +00:00
assert(fn && "Trying to process a function that does not exist.");
Don't inline recursive functions. (#2130) * Move ProcessFunction* function from pass to the context. There are a few functions that are used to traverse the call tree. They currently live in the Pass class, but they have nothing to do with a pass, and may be needed outside of a pass. They would be better in the ir context, or in a specific call tree class if we ever have a need for it. * Don't inline recursive functions. Inlining does not check if a function is recursive or not. This has been fine as long as the shader was a Vulkan shader, which forbid recursive functions. However, not all shaders are vulkan, so either we limit inlining to Vulkan shaders or we teach it to look for recursive functions. I prefer to keep the passes as general as is reasonable. The change does not require much new code in inlining and gives a reason to refactor some other code. The changes are to add a member function to the Function class that checks if that function is recursive or not. Then this is used in inlining to not inlining a function call if it calls a recursive function. * Add id to function analysis There are a few places that build a map from ids to Function whose result is that id. I decided to add an analysis to the context for this to reduce that code, and simplify some of the functions. * Add missing file.
2018-11-29 19:24:58 +00:00
modified = pfn(fn) || modified;
AddCalls(fn, roots);
}
}
return modified;
}
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
void IRContext::EmitErrorMessage(std::string message, Instruction* inst) {
if (!consumer()) {
return;
}
Instruction* line_inst = inst;
while (line_inst != nullptr) { // Stop at the beginning of the basic block.
if (!line_inst->dbg_line_insts().empty()) {
line_inst = &line_inst->dbg_line_insts().back();
if (line_inst->opcode() == SpvOpNoLine) {
line_inst = nullptr;
}
break;
}
line_inst = line_inst->PreviousNode();
}
uint32_t line_number = 0;
uint32_t col_number = 0;
char* source = nullptr;
if (line_inst != nullptr) {
Instruction* file_name =
get_def_use_mgr()->GetDef(line_inst->GetSingleWordInOperand(0));
source = reinterpret_cast<char*>(&file_name->GetInOperand(0).words[0]);
// Get the line number and column number.
line_number = line_inst->GetSingleWordInOperand(1);
col_number = line_inst->GetSingleWordInOperand(2);
}
message +=
"\n " + inst->PrettyPrint(SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES);
consumer()(SPV_MSG_ERROR, source, {line_number, col_number, 0},
message.c_str());
}
Dominator Tree Analysis (#3) Support for dominator and post dominator analysis on ir::Functions. This patch contains a DominatorTree class for building the tree and DominatorAnalysis and DominatorAnalysisPass classes for interfacing and caching the built trees.
2017-11-27 21:21:26 +00:00
// Gets the dominator analysis for function |f|.
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
DominatorAnalysis* IRContext::GetDominatorAnalysis(const Function* f) {
Add loop descriptors and some required dominator tree extensions. Add post-order tree iterator. Add DominatorTreeNode extensions: - Add begin/end methods to do pre-order and post-order tree traversal from a given DominatorTreeNode Add DominatorTree extensions: - Add begin/end methods to do pre-order and post-order tree traversal - Tree traversal ignore by default the pseudo entry block - Retrieve a DominatorTreeNode from a basic block Add loop descriptor: - Add a LoopDescriptor class to register all loops in a given function. - Add a Loop class to describe a loop: - Loop parent - Nested loops - Loop depth - Loop header, merge, continue and preheader - Basic blocks that belong to the loop Correct a bug that forced dominator tree to be constantly rebuilt.
2017-12-21 14:47:25 +00:00
if (!AreAnalysesValid(kAnalysisDominatorAnalysis)) {
ResetDominatorAnalysis();
}
if (dominator_trees_.find(f) == dominator_trees_.end()) {
Remove context() method from opt::Function (#1700) This CL removes the context() method from opt::Function. In the places where the context() was used we can retrieve, or provide, the context in another fashion.
2018-07-12 14:16:15 +00:00
dominator_trees_[f].InitializeTree(*cfg(), f);
Dominator Tree Analysis (#3) Support for dominator and post dominator analysis on ir::Functions. This patch contains a DominatorTree class for building the tree and DominatorAnalysis and DominatorAnalysisPass classes for interfacing and caching the built trees.
2017-11-27 21:21:26 +00:00
}
return &dominator_trees_[f];
}
// Gets the postdominator analysis for function |f|.
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
PostDominatorAnalysis* IRContext::GetPostDominatorAnalysis(const Function* f) {
Add loop descriptors and some required dominator tree extensions. Add post-order tree iterator. Add DominatorTreeNode extensions: - Add begin/end methods to do pre-order and post-order tree traversal from a given DominatorTreeNode Add DominatorTree extensions: - Add begin/end methods to do pre-order and post-order tree traversal - Tree traversal ignore by default the pseudo entry block - Retrieve a DominatorTreeNode from a basic block Add loop descriptor: - Add a LoopDescriptor class to register all loops in a given function. - Add a Loop class to describe a loop: - Loop parent - Nested loops - Loop depth - Loop header, merge, continue and preheader - Basic blocks that belong to the loop Correct a bug that forced dominator tree to be constantly rebuilt.
2017-12-21 14:47:25 +00:00
if (!AreAnalysesValid(kAnalysisDominatorAnalysis)) {
ResetDominatorAnalysis();
}
if (post_dominator_trees_.find(f) == post_dominator_trees_.end()) {
Remove context() method from opt::Function (#1700) This CL removes the context() method from opt::Function. In the places where the context() was used we can retrieve, or provide, the context in another fashion.
2018-07-12 14:16:15 +00:00
post_dominator_trees_[f].InitializeTree(*cfg(), f);
Dominator Tree Analysis (#3) Support for dominator and post dominator analysis on ir::Functions. This patch contains a DominatorTree class for building the tree and DominatorAnalysis and DominatorAnalysisPass classes for interfacing and caching the built trees.
2017-11-27 21:21:26 +00:00
}
return &post_dominator_trees_[f];
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
bool IRContext::CheckCFG() {
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
std::unordered_map<uint32_t, std::vector<uint32_t>> real_preds;
if (!AreAnalysesValid(kAnalysisCFG)) {
return true;
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Function& function : *module()) {
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
for (const auto& bb : function) {
bb.ForEachSuccessorLabel([&bb, &real_preds](const uint32_t lab_id) {
real_preds[lab_id].push_back(bb.id());
});
}
for (auto& bb : function) {
std::vector<uint32_t> preds = cfg()->preds(bb.id());
std::vector<uint32_t> real = real_preds[bb.id()];
std::sort(preds.begin(), preds.end());
std::sort(real.begin(), real.end());
bool same = true;
if (preds.size() != real.size()) {
same = false;
}
for (size_t i = 0; i < real.size() && same; i++) {
if (preds[i] != real[i]) {
same = false;
}
}
if (!same) {
std::cerr << "Predecessors for " << bb.id() << " are different:\n";
std::cerr << "Real:";
for (uint32_t i : real) {
std::cerr << ' ' << i;
}
std::cerr << std::endl;
std::cerr << "Recorded:";
for (uint32_t i : preds) {
std::cerr << ' ' << i;
}
std::cerr << std::endl;
}
if (!same) return false;
}
}
return true;
}
Add IsReachable function to IRContext (#4323) There was a lot of code in the codebase that would get the dominator analysis for a function and then use it to check whether a block is reachable. In the fuzzer, a utility method had been introduced to make this more concise, but it was not being used consistently. This change moves the utility method to IRContext, so that it can be used throughout the codebase, and refactors all existing checks for block reachability to use the utility method.
2021-06-28 19:00:14 +00:00
bool IRContext::IsReachable(const opt::BasicBlock& bb) {
auto enclosing_function = bb.GetParent();
return GetDominatorAnalysis(enclosing_function)
->Dominates(enclosing_function->entry().get(), &bb);
}
Move the ir namespace to opt. (#1680) This CL moves the files in opt/ to consistenly be under the opt:: namespace. This frees up the ir:: namespace so it can be used to make a shared ir represenation.
2018-07-09 15:32:29 +00:00
} // namespace opt
Add the IRContext (part 2): Add def-use manager This change will move the instances of the def-use manager to the IRContext. This allows it to persists across optimization, and does not have to be rebuilt multiple times. Added test to ensure that the IRContext is validating and invalidating the analyses correctly.
2017-11-02 18:25:48 +00:00
} // namespace spvtools
Reference in New Issue Copy Permalink