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

814 lines
30 KiB
C++
Raw Normal View History

Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
// Copyright (c) 2017 The Khronos Group Inc.
// Copyright (c) 2017 Valve Corporation
// Copyright (c) 2017 LunarG Inc.
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
// Copyright (c) 2018 Google LLC
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
//
// 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/aggressive_dead_code_elim_pass.h"
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include <memory>
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
#include <stack>
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/cfa.h"
#include "source/latest_version_glsl_std_450_header.h"
#include "source/opt/iterator.h"
#include "source/opt/reflect.h"
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
namespace spvtools {
namespace opt {
namespace {
const uint32_t kTypePointerStorageClassInIdx = 0;
ADCE: Treat privates like locals in entry point with no calls This is needed for ongoing legalization of HLSL. It allows removal of accesses to textures/buffers that are not used.
2017-10-10 20:35:53 +00:00
const uint32_t kEntryPointFunctionIdInIdx = 1;
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
const uint32_t kSelectionMergeMergeBlockIdInIdx = 0;
const uint32_t kLoopMergeMergeBlockIdInIdx = 0;
AggressiveDCE: Add merge and continue branches for live loop. This ensures that an if-break is not eliminated from a loop. This fixes issue #989
2017-11-28 23:18:05 +00:00
const uint32_t kLoopMergeContinueBlockIdInIdx = 1;
Get ADCE to handle OpCopyMemory ADCE does not treat OpCopyMemory as an instruction that references memory. Because of that stores are removed that should not be. This change teaches ADCE that OpCopyMemory and OpCopyMemorySize both loads from and stores to memory. This will keep other stores live when needed, and will allows ADCE to remove OpCopyMemory instructions as well. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1556.
2018-05-16 14:41:40 +00:00
const uint32_t kCopyMemoryTargetAddrInIdx = 0;
const uint32_t kCopyMemorySourceAddrInIdx = 1;
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
// Sorting functor to present annotation instructions in an easy-to-process
// order. The functor orders by opcode first and falls back on unique id
// ordering if both instructions have the same opcode.
//
// Desired priority:
// SpvOpGroupDecorate
// SpvOpGroupMemberDecorate
// SpvOpDecorate
// SpvOpMemberDecorate
// SpvOpDecorateId
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
// SpvOpDecorateStringGOOGLE
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
// SpvOpDecorationGroup
struct DecorationLess {
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 operator()(const Instruction* lhs, const Instruction* rhs) const {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
assert(lhs && rhs);
SpvOp lhsOp = lhs->opcode();
SpvOp rhsOp = rhs->opcode();
if (lhsOp != rhsOp) {
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
#define PRIORITY_CASE(opcode) \
if (lhsOp == opcode && rhsOp != opcode) return true; \
if (rhsOp == opcode && lhsOp != opcode) return false;
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
// OpGroupDecorate and OpGroupMember decorate are highest priority to
// eliminate dead targets early and simplify subsequent checks.
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
PRIORITY_CASE(SpvOpGroupDecorate)
PRIORITY_CASE(SpvOpGroupMemberDecorate)
PRIORITY_CASE(SpvOpDecorate)
PRIORITY_CASE(SpvOpMemberDecorate)
PRIORITY_CASE(SpvOpDecorateId)
PRIORITY_CASE(SpvOpDecorateStringGOOGLE)
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
// OpDecorationGroup is lowest priority to ensure use/def chains remain
// usable for instructions that target this group.
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
PRIORITY_CASE(SpvOpDecorationGroup)
#undef PRIORITY_CASE
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
}
// Fall back to maintain total ordering (compare unique ids).
return *lhs < *rhs;
}
};
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
} // namespace
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
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
bool AggressiveDCEPass::IsVarOfStorage(uint32_t varId, uint32_t storageClass) {
Allow pointers to pointers in logical addressing mode. A few optimizations are updates to handle code that is suppose to be using the logical addressing mode, but still has variables that contain pointers as long as the pointer are to opaque objects. This is called "relaxed logical addressing". |Instruction::GetBaseAddress| will check that pointers that are use meet the relaxed logical addressing rules. Optimization that now handle relaxed logical addressing instead of logical addressing are: - aggressive dead-code elimination - local access chain convert - local store elimination passes.
2017-12-11 18:10:24 +00:00
if (varId == 0) return false;
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
const Instruction* varInst = get_def_use_mgr()->GetDef(varId);
Opt: Have "size" passes process full entry point call tree. Includes code to deal correctly with OpFunctionParameter. This is needed by opaque propagation which may not exhaustively inline entry point functions. Adds ProcessEntryPointCallTree: a method to do work on the functions in the entry point call trees in a deterministic order.
2017-08-10 22:42:16 +00:00
const SpvOp op = varInst->opcode();
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
if (op != SpvOpVariable) return false;
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
const uint32_t varTypeId = varInst->type_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
const Instruction* varTypeInst = get_def_use_mgr()->GetDef(varTypeId);
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
if (varTypeInst->opcode() != SpvOpTypePointer) return false;
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
return varTypeInst->GetSingleWordInOperand(kTypePointerStorageClassInIdx) ==
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
storageClass;
ADCE: Treat privates like locals in entry point with no calls This is needed for ongoing legalization of HLSL. It allows removal of accesses to textures/buffers that are not used.
2017-10-10 20:35:53 +00:00
}
bool AggressiveDCEPass::IsLocalVar(uint32_t varId) {
Remove dead Workgroup variables in ADCE. If there is a shader with a variable in the workgroup storage class that is stored to, but not loadeds, then we know nothing will read those loads. It should be safe to remove them. This is implemented in ADCE by treating workgroup variables the same way that private variables are treated. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1550.
2018-05-08 18:02:03 +00:00
if (IsVarOfStorage(varId, SpvStorageClassFunction)) {
return true;
}
if (!private_like_local_) {
return false;
}
return IsVarOfStorage(varId, SpvStorageClassPrivate) ||
IsVarOfStorage(varId, SpvStorageClassWorkgroup);
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
}
void AggressiveDCEPass::AddStores(uint32_t ptrId) {
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
get_def_use_mgr()->ForEachUser(ptrId, [this, ptrId](Instruction* user) {
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
switch (user->opcode()) {
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
case SpvOpAccessChain:
case SpvOpInBoundsAccessChain:
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
case SpvOpCopyObject:
this->AddStores(user->result_id());
break;
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
case SpvOpLoad:
break;
Get ADCE to handle OpCopyMemory ADCE does not treat OpCopyMemory as an instruction that references memory. Because of that stores are removed that should not be. This change teaches ADCE that OpCopyMemory and OpCopyMemorySize both loads from and stores to memory. This will keep other stores live when needed, and will allows ADCE to remove OpCopyMemory instructions as well. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1556.
2018-05-16 14:41:40 +00:00
case SpvOpCopyMemory:
case SpvOpCopyMemorySized:
if (user->GetSingleWordInOperand(kCopyMemoryTargetAddrInIdx) == ptrId) {
AddToWorklist(user);
}
break;
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 default, assume it stores e.g. frexp, modf, function call
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
case SpvOpStore:
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
default:
Simplifying code for adding instructions to worklist * AddToWorklist can now be called unconditionally * It will only add instructions that have not already been marked as live * Fixes a case where a merge was not added to the worklist because the branch was already marked as live * Added two similar tests that fail without the fix
2018-01-18 19:15:54 +00:00
AddToWorklist(user);
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
break;
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
}
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
});
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
}
Add extension whitelists to size-reduction passes. Currently only SPV_KHR_variable_pointers is disallowed in passes which do pointer analysis. Positive and negative tests of the general extensions mechanism were added to aggressive_dce but cover all passes.
2017-07-19 00:57:26 +00:00
bool AggressiveDCEPass::AllExtensionsSupported() const {
// If any extension not in whitelist, return false
Re-factor Phi insertion code out of LocalMultiStoreElimPass Including a re-factor of common behaviour into class Pass: The following functions are now in class Pass: - IsLoopHeader. - ComputeStructuredOrder - ComputeStructuredSuccessors (annoyingly, I could not re-factor all instances of this function, the copy in common_uniform_elim_pass.cpp is slightly different and fails with the common implementation). - GetPointeeTypeId - TakeNextId - FinalizeNextId - MergeBlockIdIfAny This is a NFC (non-functional change)
2017-10-25 17:26:25 +00:00
for (auto& ei : get_module()->extensions()) {
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
const char* extName =
reinterpret_cast<const char*>(&ei.GetInOperand(0).words[0]);
Add extension whitelists to size-reduction passes. Currently only SPV_KHR_variable_pointers is disallowed in passes which do pointer analysis. Positive and negative tests of the general extensions mechanism were added to aggressive_dce but cover all passes.
2017-07-19 00:57:26 +00:00
if (extensions_whitelist_.find(extName) == extensions_whitelist_.end())
return false;
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
}
Add extension whitelists to size-reduction passes. Currently only SPV_KHR_variable_pointers is disallowed in passes which do pointer analysis. Positive and negative tests of the general extensions mechanism were added to aggressive_dce but cover all passes.
2017-07-19 00:57:26 +00:00
return true;
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
}
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 AggressiveDCEPass::IsDead(Instruction* inst) {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
if (IsLive(inst)) return false;
Fix ADCE to treat OpUnreachable correctly during liveness analysis (#1984) ADCE liveness algorithm should treat OpUnreachable at least like other branch instructions. It was being treated as always live which was preventing useless structured constructs from being eliminated. OpUnreachable is generated by dead branch elimination which is now being required by merge return, so this fix should accompany that change.
2018-10-19 14:16:35 +00:00
if ((inst->IsBranch() || inst->opcode() == SpvOpUnreachable) &&
!IsStructuredHeader(context()->get_instr_block(inst), nullptr, nullptr,
nullptr))
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
return false;
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
bool AggressiveDCEPass::IsTargetDead(Instruction* inst) {
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
const uint32_t tId = inst->GetSingleWordInOperand(0);
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* tInst = get_def_use_mgr()->GetDef(tId);
if (IsAnnotationInst(tInst->opcode())) {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
// This must be a decoration group. We go through annotations in a specific
// order. So if this is not used by any group or group member decorates, it
// is dead.
assert(tInst->opcode() == SpvOpDecorationGroup);
bool dead = 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
get_def_use_mgr()->ForEachUser(tInst, [&dead](Instruction* user) {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
if (user->opcode() == SpvOpGroupDecorate ||
user->opcode() == SpvOpGroupMemberDecorate)
dead = false;
});
return dead;
ADCE: Add support for function calls ADCE will now generate correct code in the presence of function calls. This is needed for opaque type optimization needed by glslang. Currently all function calls are marked as live. TODO: mark calls live only if they write a non-local.
2017-08-04 21:04:37 +00:00
}
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
return IsDead(tInst);
ADCE: Add support for function calls ADCE will now generate correct code in the presence of function calls. This is needed for opaque type optimization needed by glslang. Currently all function calls are marked as live. TODO: mark calls live only if they write a non-local.
2017-08-04 21:04:37 +00:00
}
void AggressiveDCEPass::ProcessLoad(uint32_t varId) {
// Only process locals
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
if (!IsLocalVar(varId)) return;
ADCE: Add support for function calls ADCE will now generate correct code in the presence of function calls. This is needed for opaque type optimization needed by glslang. Currently all function calls are marked as live. TODO: mark calls live only if they write a non-local.
2017-08-04 21:04:37 +00:00
// Return if already processed
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
if (live_local_vars_.find(varId) != live_local_vars_.end()) return;
ADCE: Add support for function calls ADCE will now generate correct code in the presence of function calls. This is needed for opaque type optimization needed by glslang. Currently all function calls are marked as live. TODO: mark calls live only if they write a non-local.
2017-08-04 21:04:37 +00:00
// Mark all stores to varId as live
AddStores(varId);
// Cache varId as processed
live_local_vars_.insert(varId);
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
}
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 AggressiveDCEPass::IsStructuredHeader(BasicBlock* bp,
Instruction** mergeInst,
Instruction** branchInst,
Adding support for switch removal in ADCE * Updated code to handle switches * Enabled disabled test and added a couple new ones
2018-01-15 18:25:45 +00:00
uint32_t* mergeBlockId) {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
if (!bp) return false;
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* mi = bp->GetMergeInst();
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
if (mi == nullptr) return false;
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* bri = &*bp->tail();
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
if (branchInst != nullptr) *branchInst = bri;
if (mergeInst != nullptr) *mergeInst = mi;
if (mergeBlockId != nullptr) *mergeBlockId = mi->GetSingleWordInOperand(0);
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
return true;
}
void AggressiveDCEPass::ComputeBlock2HeaderMaps(
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::list<BasicBlock*>& structuredOrder) {
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
block2headerBranch_.clear();
Fix ADCE liveness to include all enclosing control structures. (#1975) Was removing control structures which didn't have data dependency with enclosed live loop and otherwise did not contain live code. An example is a counting loop around a live loop. Fixes #1967.
2018-10-16 12:00:07 +00:00
header2nextHeaderBranch_.clear();
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
branch2merge_.clear();
Fixes infinite loop in ADCE * Addresses how breaks are indentified to prevent infinite loops when back to back loop share a merge and header * Added test to catch the bug
2018-01-18 20:44:00 +00:00
structured_order_index_.clear();
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::stack<Instruction*> currentHeaderBranch;
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
currentHeaderBranch.push(nullptr);
uint32_t currentMergeBlockId = 0;
Fixes infinite loop in ADCE * Addresses how breaks are indentified to prevent infinite loops when back to back loop share a merge and header * Added test to catch the bug
2018-01-18 20:44:00 +00:00
uint32_t index = 0;
for (auto bi = structuredOrder.begin(); bi != structuredOrder.end();
++bi, ++index) {
structured_order_index_[*bi] = index;
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
// If this block is the merge block of the current control construct,
// we are leaving the current construct so we must update state
if ((*bi)->id() == currentMergeBlockId) {
currentHeaderBranch.pop();
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* chb = currentHeaderBranch.top();
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
if (chb != nullptr)
currentMergeBlockId = branch2merge_[chb]->GetSingleWordInOperand(0);
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33: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
Instruction* mergeInst;
Instruction* branchInst;
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
uint32_t mergeBlockId;
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
bool is_header =
Adding support for switch removal in ADCE * Updated code to handle switches * Enabled disabled test and added a couple new ones
2018-01-15 18:25:45 +00:00
IsStructuredHeader(*bi, &mergeInst, &branchInst, &mergeBlockId);
Fix ADCE liveness to include all enclosing control structures. (#1975) Was removing control structures which didn't have data dependency with enclosed live loop and otherwise did not contain live code. An example is a counting loop around a live loop. Fixes #1967.
2018-10-16 12:00:07 +00:00
// Map header block to next enclosing header.
if (is_header) header2nextHeaderBranch_[*bi] = currentHeaderBranch.top();
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
// If this is a loop header, update state first so the block will map to
Fix ADCE liveness to include all enclosing control structures. (#1975) Was removing control structures which didn't have data dependency with enclosed live loop and otherwise did not contain live code. An example is a counting loop around a live loop. Fixes #1967.
2018-10-16 12:00:07 +00:00
// itself.
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
if (is_header && mergeInst->opcode() == SpvOpLoopMerge) {
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
currentHeaderBranch.push(branchInst);
branch2merge_[branchInst] = mergeInst;
currentMergeBlockId = mergeBlockId;
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
}
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
// Map the block to the current construct.
block2headerBranch_[*bi] = currentHeaderBranch.top();
// If this is an if header, update state so following blocks map to the if.
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
if (is_header && mergeInst->opcode() == SpvOpSelectionMerge) {
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
currentHeaderBranch.push(branchInst);
branch2merge_[branchInst] = mergeInst;
currentMergeBlockId = mergeBlockId;
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33: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
void AggressiveDCEPass::AddBranch(uint32_t labelId, BasicBlock* bp) {
std::unique_ptr<Instruction> newBranch(
new Instruction(context(), SpvOpBranch, 0, 0,
{{spv_operand_type_t::SPV_OPERAND_TYPE_ID, {labelId}}}));
Preserve inst-to-block and def-use in passes. The following passes are updated to preserve the inst-to-block and def-use analysies: private-to-local aggressive dead-code elimination dead branch elimination local-single-block elimination local-single-store elimination reduce load size compact ids (inst-to-block only) merge block dead-insert elimination ccp The one execption is that compact ids still kills the def-use manager. This is because it changes so many ids it is faster to kill and rebuild. Does everything in https://github.com/KhronosGroup/SPIRV-Tools/issues/1593 except for the changes to merge return.
2018-06-01 17:04:46 +00:00
context()->AnalyzeDefUse(&*newBranch);
context()->set_instr_block(&*newBranch, bp);
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
bp->AddInstruction(std::move(newBranch));
}
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
void AggressiveDCEPass::AddBreaksAndContinuesToWorklist(
Handle breaks from structured-ifs in DCE. (#1848) * Handle breaks from structured-ifs in DCE. dead code elimination assumes that are conditional branches except for breaks and continues in loops will have an OpSelectionMerge before them. That is not true when breaking out of a selection construct. The fix is to look for breaks in selection constructs in the same place we look for breaks and continues for loops.
2018-08-21 15:54:44 +00:00
Instruction* mergeInst) {
assert(mergeInst->opcode() == SpvOpSelectionMerge ||
mergeInst->opcode() == SpvOpLoopMerge);
BasicBlock* header = context()->get_instr_block(mergeInst);
Fixes infinite loop in ADCE * Addresses how breaks are indentified to prevent infinite loops when back to back loop share a merge and header * Added test to catch the bug
2018-01-18 20:44:00 +00:00
uint32_t headerIndex = structured_order_index_[header];
Handle breaks from structured-ifs in DCE. (#1848) * Handle breaks from structured-ifs in DCE. dead code elimination assumes that are conditional branches except for breaks and continues in loops will have an OpSelectionMerge before them. That is not true when breaking out of a selection construct. The fix is to look for breaks in selection constructs in the same place we look for breaks and continues for loops.
2018-08-21 15:54:44 +00:00
const uint32_t mergeId = mergeInst->GetSingleWordInOperand(0);
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
BasicBlock* merge = context()->get_instr_block(mergeId);
Fixes infinite loop in ADCE * Addresses how breaks are indentified to prevent infinite loops when back to back loop share a merge and header * Added test to catch the bug
2018-01-18 20:44:00 +00:00
uint32_t mergeIndex = structured_order_index_[merge];
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
get_def_use_mgr()->ForEachUser(
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
mergeId, [headerIndex, mergeIndex, this](Instruction* user) {
Fixing missing early exit from break identification
2018-01-17 19:09:24 +00:00
if (!user->IsBranch()) return;
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
BasicBlock* block = context()->get_instr_block(user);
Fixes infinite loop in ADCE * Addresses how breaks are indentified to prevent infinite loops when back to back loop share a merge and header * Added test to catch the bug
2018-01-18 20:44:00 +00:00
uint32_t index = structured_order_index_[block];
if (headerIndex < index && index < mergeIndex) {
// This is a break from the loop.
AddToWorklist(user);
// Add branch's merge if there is one.
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* userMerge = branch2merge_[user];
Fixes infinite loop in ADCE * Addresses how breaks are indentified to prevent infinite loops when back to back loop share a merge and header * Added test to catch the bug
2018-01-18 20:44:00 +00:00
if (userMerge != nullptr) AddToWorklist(userMerge);
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
}
});
Handle breaks from structured-ifs in DCE. (#1848) * Handle breaks from structured-ifs in DCE. dead code elimination assumes that are conditional branches except for breaks and continues in loops will have an OpSelectionMerge before them. That is not true when breaking out of a selection construct. The fix is to look for breaks in selection constructs in the same place we look for breaks and continues for loops.
2018-08-21 15:54:44 +00:00
if (mergeInst->opcode() != SpvOpLoopMerge) {
return;
}
// For loops we need to find the continues as well.
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
const uint32_t contId =
Handle breaks from structured-ifs in DCE. (#1848) * Handle breaks from structured-ifs in DCE. dead code elimination assumes that are conditional branches except for breaks and continues in loops will have an OpSelectionMerge before them. That is not true when breaking out of a selection construct. The fix is to look for breaks in selection constructs in the same place we look for breaks and continues for loops.
2018-08-21 15:54:44 +00:00
mergeInst->GetSingleWordInOperand(kLoopMergeContinueBlockIdInIdx);
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
get_def_use_mgr()->ForEachUser(contId, [&contId, this](Instruction* user) {
AggressiveDCE: Add merge and continue branches for live loop. This ensures that an if-break is not eliminated from a loop. This fixes issue #989
2017-11-28 23:18:05 +00:00
SpvOp op = user->opcode();
Adding support for switch removal in ADCE * Updated code to handle switches * Enabled disabled test and added a couple new ones
2018-01-15 18:25:45 +00:00
if (op == SpvOpBranchConditional || op == SpvOpSwitch) {
// A conditional branch or switch can only be a continue if it does not
// have a merge instruction or its merge block is not the continue block.
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* hdrMerge = branch2merge_[user];
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
if (hdrMerge != nullptr && hdrMerge->opcode() == SpvOpSelectionMerge) {
uint32_t hdrMergeId =
hdrMerge->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx);
if (hdrMergeId == contId) return;
// Need to mark merge instruction too
Simplifying code for adding instructions to worklist * AddToWorklist can now be called unconditionally * It will only add instructions that have not already been marked as live * Fixes a case where a merge was not added to the worklist because the branch was already marked as live * Added two similar tests that fail without the fix
2018-01-18 19:15:54 +00:00
AddToWorklist(hdrMerge);
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
}
} else if (op == SpvOpBranch) {
// An unconditional branch can only be a continue if it is not
// branching to its own merge block.
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
BasicBlock* blk = context()->get_instr_block(user);
Instruction* hdrBranch = block2headerBranch_[blk];
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
if (hdrBranch == nullptr) return;
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* hdrMerge = branch2merge_[hdrBranch];
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
if (hdrMerge->opcode() == SpvOpLoopMerge) return;
uint32_t hdrMergeId =
hdrMerge->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx);
if (contId == hdrMergeId) return;
} else {
return;
}
Simplifying code for adding instructions to worklist * AddToWorklist can now be called unconditionally * It will only add instructions that have not already been marked as live * Fixes a case where a merge was not added to the worklist because the branch was already marked as live * Added two similar tests that fail without the fix
2018-01-18 19:15:54 +00:00
AddToWorklist(user);
AggressiveDCE: Add merge and continue branches for live loop. This ensures that an if-break is not eliminated from a loop. This fixes issue #989
2017-11-28 23:18:05 +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
bool AggressiveDCEPass::AggressiveDCE(Function* func) {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
// Mark function parameters as live.
AddToWorklist(&func->DefInst());
func->ForEachParam(
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
[this](const Instruction* param) {
AddToWorklist(const_cast<Instruction*>(param));
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
},
false);
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
// Compute map from block to controlling conditional branch
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::list<BasicBlock*> structuredOrder;
Add a new class opt::CFG to represent the CFG for the module. This class moves some of the CFG-related functionality into a new class opt::CFG. There is some other code related to the CFG in the inliner and in opt::LocalSingleStoreElimPass that should also be moved, but that require more changes than this pure restructuring. I will move those bits in a follow-up PR. Currently, the CFG is computed every time a pass is instantiated, but this should be later moved to the new IRContext class that @s-perron is working on. Other re-factoring: - Add BasicBlock::ContinueBlockIdIfAny. Re-factored out of MergeBlockIdIfAny - Rewrite IsLoopHeader in terms of GetLoopMergeInst. - Run clang-format on some files.
2017-10-30 21:42:26 +00:00
cfg()->ComputeStructuredOrder(func, &*func->begin(), &structuredOrder);
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
ComputeBlock2HeaderMaps(structuredOrder);
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
bool modified = false;
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
// Add instructions with external side effects to worklist. Also add branches
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
// EXCEPT those immediately contained in an "if" selection construct or a loop
// or continue construct.
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
// TODO(greg-lunarg): Handle Frexp, Modf more optimally
ADCE: Treat privates like locals in entry point with no calls This is needed for ongoing legalization of HLSL. It allows removal of accesses to textures/buffers that are not used.
2017-10-10 20:35:53 +00:00
call_in_func_ = false;
func_is_entry_point_ = false;
private_stores_.clear();
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
// Stacks to keep track of when we are inside an if- or loop-construct.
ADCE: Only mark true breaks and continues of live loops This fixes issue #1075 - Mark continue when conditional branch with merge block. Only mark if merge block is not continue block. - Handle conditional branch break with preceding merge
2017-12-12 21:27:46 +00:00
// When immediately inside an if- or loop-construct, we do not initially
// mark branches live. All other branches must be marked live.
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
std::stack<bool> assume_branches_live;
std::stack<uint32_t> currentMergeBlockId;
// Push sentinel values on stack for when outside of any control flow.
assume_branches_live.push(true);
currentMergeBlockId.push(0);
for (auto bi = structuredOrder.begin(); bi != structuredOrder.end(); ++bi) {
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
// If exiting if or loop, update stacks
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
if ((*bi)->id() == currentMergeBlockId.top()) {
assume_branches_live.pop();
currentMergeBlockId.pop();
}
for (auto ii = (*bi)->begin(); ii != (*bi)->end(); ++ii) {
SpvOp op = ii->opcode();
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
switch (op) {
case SpvOpStore: {
uint32_t varId;
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)GetPtr(&*ii, &varId);
ADCE: Treat privates like locals in entry point with no calls This is needed for ongoing legalization of HLSL. It allows removal of accesses to textures/buffers that are not used.
2017-10-10 20:35:53 +00:00
// Mark stores as live if their variable is not function scope
// and is not private scope. Remember private stores for possible
Remove dead Workgroup variables in ADCE. If there is a shader with a variable in the workgroup storage class that is stored to, but not loadeds, then we know nothing will read those loads. It should be safe to remove them. This is implemented in ADCE by treating workgroup variables the same way that private variables are treated. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1550.
2018-05-08 18:02:03 +00:00
// later inclusion. We cannot call IsLocalVar at this point because
// private_like_local_ has not been set yet.
if (IsVarOfStorage(varId, SpvStorageClassPrivate) ||
IsVarOfStorage(varId, SpvStorageClassWorkgroup))
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
private_stores_.push_back(&*ii);
ADCE: Treat privates like locals in entry point with no calls This is needed for ongoing legalization of HLSL. It allows removal of accesses to textures/buffers that are not used.
2017-10-10 20:35:53 +00:00
else if (!IsVarOfStorage(varId, SpvStorageClassFunction))
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
AddToWorklist(&*ii);
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
} break;
Get ADCE to handle OpCopyMemory ADCE does not treat OpCopyMemory as an instruction that references memory. Because of that stores are removed that should not be. This change teaches ADCE that OpCopyMemory and OpCopyMemorySize both loads from and stores to memory. This will keep other stores live when needed, and will allows ADCE to remove OpCopyMemory instructions as well. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1556.
2018-05-16 14:41:40 +00:00
case SpvOpCopyMemory:
case SpvOpCopyMemorySized: {
uint32_t varId;
(void)GetPtr(ii->GetSingleWordInOperand(kCopyMemoryTargetAddrInIdx),
&varId);
if (IsVarOfStorage(varId, SpvStorageClassPrivate) ||
IsVarOfStorage(varId, SpvStorageClassWorkgroup))
private_stores_.push_back(&*ii);
else if (!IsVarOfStorage(varId, SpvStorageClassFunction))
AddToWorklist(&*ii);
} break;
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
case SpvOpLoopMerge: {
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
assume_branches_live.push(false);
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
currentMergeBlockId.push(
ii->GetSingleWordInOperand(kLoopMergeMergeBlockIdInIdx));
} break;
case SpvOpSelectionMerge: {
Adding support for switch removal in ADCE * Updated code to handle switches * Enabled disabled test and added a couple new ones
2018-01-15 18:25:45 +00:00
assume_branches_live.push(false);
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
currentMergeBlockId.push(
ii->GetSingleWordInOperand(kSelectionMergeMergeBlockIdInIdx));
} break;
Adding support for switch removal in ADCE * Updated code to handle switches * Enabled disabled test and added a couple new ones
2018-01-15 18:25:45 +00:00
case SpvOpSwitch:
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
case SpvOpBranch:
Fix ADCE to treat OpUnreachable correctly during liveness analysis (#1984) ADCE liveness algorithm should treat OpUnreachable at least like other branch instructions. It was being treated as always live which was preventing useless structured constructs from being eliminated. OpUnreachable is generated by dead branch elimination which is now being required by merge return, so this fix should accompany that change.
2018-10-19 14:16:35 +00:00
case SpvOpBranchConditional:
case SpvOpUnreachable: {
Handle breaks from structured-ifs in DCE. (#1848) * Handle breaks from structured-ifs in DCE. dead code elimination assumes that are conditional branches except for breaks and continues in loops will have an OpSelectionMerge before them. That is not true when breaking out of a selection construct. The fix is to look for breaks in selection constructs in the same place we look for breaks and continues for loops.
2018-08-21 15:54:44 +00:00
if (assume_branches_live.top()) {
AddToWorklist(&*ii);
}
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
} break;
default: {
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
// Function calls, atomics, function params, function returns, etc.
ADCE: Add support for function calls ADCE will now generate correct code in the presence of function calls. This is needed for opaque type optimization needed by glslang. Currently all function calls are marked as live. TODO: mark calls live only if they write a non-local.
2017-08-04 21:04:37 +00:00
// TODO(greg-lunarg): function calls live only if write to non-local
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
if (!ii->IsOpcodeSafeToDelete()) {
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
AddToWorklist(&*ii);
}
ADCE: Treat privates like locals in entry point with no calls This is needed for ongoing legalization of HLSL. It allows removal of accesses to textures/buffers that are not used.
2017-10-10 20:35:53 +00:00
// Remember function calls
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
if (op == SpvOpFunctionCall) call_in_func_ = true;
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
} break;
}
}
}
ADCE: Treat privates like locals in entry point with no calls This is needed for ongoing legalization of HLSL. It allows removal of accesses to textures/buffers that are not used.
2017-10-10 20:35:53 +00:00
// See if current function is an entry point
Re-factor Phi insertion code out of LocalMultiStoreElimPass Including a re-factor of common behaviour into class Pass: The following functions are now in class Pass: - IsLoopHeader. - ComputeStructuredOrder - ComputeStructuredSuccessors (annoyingly, I could not re-factor all instances of this function, the copy in common_uniform_elim_pass.cpp is slightly different and fails with the common implementation). - GetPointeeTypeId - TakeNextId - FinalizeNextId - MergeBlockIdIfAny This is a NFC (non-functional change)
2017-10-25 17:26:25 +00:00
for (auto& ei : get_module()->entry_points()) {
ADCE: Treat privates like locals in entry point with no calls This is needed for ongoing legalization of HLSL. It allows removal of accesses to textures/buffers that are not used.
2017-10-10 20:35:53 +00:00
if (ei.GetSingleWordInOperand(kEntryPointFunctionIdInIdx) ==
func->result_id()) {
func_is_entry_point_ = true;
break;
}
}
// If the current function is an entry point and has no function calls,
// we can optimize private variables as locals
private_like_local_ = func_is_entry_point_ && !call_in_func_;
// If privates are not like local, add their stores to worklist
if (!private_like_local_)
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
for (auto& ps : private_stores_) AddToWorklist(ps);
// Perform closure on live instruction set.
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
while (!worklist_.empty()) {
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* liveInst = worklist_.front();
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
// Add all operand instructions if not already live
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
liveInst->ForEachInId([&liveInst, this](const uint32_t* iid) {
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* inInst = get_def_use_mgr()->GetDef(*iid);
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
// Do not add label if an operand of a branch. This is not needed
// as part of live code discovery and can create false live code,
// for example, the branch to a header of a loop.
if (inInst->opcode() == SpvOpLabel && liveInst->IsBranch()) return;
Simplifying code for adding instructions to worklist * AddToWorklist can now be called unconditionally * It will only add instructions that have not already been marked as live * Fixes a case where a merge was not added to the worklist because the branch was already marked as live * Added two similar tests that fail without the fix
2018-01-18 19:15:54 +00:00
AddToWorklist(inInst);
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
});
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
if (liveInst->type_id() != 0) {
AddToWorklist(get_def_use_mgr()->GetDef(liveInst->type_id()));
}
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
// If in a structured if or loop construct, add the controlling
Fix ADCE liveness to include all enclosing control structures. (#1975) Was removing control structures which didn't have data dependency with enclosed live loop and otherwise did not contain live code. An example is a counting loop around a live loop. Fixes #1967.
2018-10-16 12:00:07 +00:00
// conditional branch and its merge.
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
BasicBlock* blk = context()->get_instr_block(liveInst);
Instruction* branchInst = block2headerBranch_[blk];
Simplifying code for adding instructions to worklist * AddToWorklist can now be called unconditionally * It will only add instructions that have not already been marked as live * Fixes a case where a merge was not added to the worklist because the branch was already marked as live * Added two similar tests that fail without the fix
2018-01-18 19:15:54 +00:00
if (branchInst != nullptr) {
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
AddToWorklist(branchInst);
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* mergeInst = branch2merge_[branchInst];
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
AddToWorklist(mergeInst);
Fix ADCE liveness to include all enclosing control structures. (#1975) Was removing control structures which didn't have data dependency with enclosed live loop and otherwise did not contain live code. An example is a counting loop around a live loop. Fixes #1967.
2018-10-16 12:00:07 +00:00
}
// If the block is a header, add the next outermost controlling
// conditional branch and its merge.
Instruction* nextBranchInst = header2nextHeaderBranch_[blk];
if (nextBranchInst != nullptr) {
AddToWorklist(nextBranchInst);
Instruction* mergeInst = branch2merge_[nextBranchInst];
AddToWorklist(mergeInst);
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
}
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
// If local load, add all variable's stores if variable not already live
Consider atomics that load when analyzing live stores in ADCE (#1956) (#1958) Consider atomics that load when analyzing live stores in ADCE. Previously it asserted that the base of an OpImageTexelPointer should be an image. It is actually a pointer to an image, so IsValidBasePointer should suffice.
2018-10-12 12:46:35 +00:00
if (liveInst->opcode() == SpvOpLoad || liveInst->IsAtomicWithLoad()) {
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
uint32_t varId;
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)GetPtr(liveInst, &varId);
Allow pointers to pointers in logical addressing mode. A few optimizations are updates to handle code that is suppose to be using the logical addressing mode, but still has variables that contain pointers as long as the pointer are to opaque objects. This is called "relaxed logical addressing". |Instruction::GetBaseAddress| will check that pointers that are use meet the relaxed logical addressing rules. Optimization that now handle relaxed logical addressing instead of logical addressing are: - aggressive dead-code elimination - local access chain convert - local store elimination passes.
2017-12-11 18:10:24 +00:00
if (varId != 0) {
ProcessLoad(varId);
}
Fix ADCE liveness to include all enclosing control structures. (#1975) Was removing control structures which didn't have data dependency with enclosed live loop and otherwise did not contain live code. An example is a counting loop around a live loop. Fixes #1967.
2018-10-16 12:00:07 +00:00
// Process memory copies like loads
Get ADCE to handle OpCopyMemory ADCE does not treat OpCopyMemory as an instruction that references memory. Because of that stores are removed that should not be. This change teaches ADCE that OpCopyMemory and OpCopyMemorySize both loads from and stores to memory. This will keep other stores live when needed, and will allows ADCE to remove OpCopyMemory instructions as well. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1556.
2018-05-16 14:41:40 +00:00
} else if (liveInst->opcode() == SpvOpCopyMemory ||
liveInst->opcode() == SpvOpCopyMemorySized) {
uint32_t varId;
(void)GetPtr(liveInst->GetSingleWordInOperand(kCopyMemorySourceAddrInIdx),
&varId);
if (varId != 0) {
ProcessLoad(varId);
}
Fix ADCE to treat OpUnreachable correctly during liveness analysis (#1984) ADCE liveness algorithm should treat OpUnreachable at least like other branch instructions. It was being treated as always live which was preventing useless structured constructs from being eliminated. OpUnreachable is generated by dead branch elimination which is now being required by merge return, so this fix should accompany that change.
2018-10-19 14:16:35 +00:00
// If merge, add other branches that are part of its control structure
Fix ADCE liveness to include all enclosing control structures. (#1975) Was removing control structures which didn't have data dependency with enclosed live loop and otherwise did not contain live code. An example is a counting loop around a live loop. Fixes #1967.
2018-10-16 12:00:07 +00:00
} else if (liveInst->opcode() == SpvOpLoopMerge ||
liveInst->opcode() == SpvOpSelectionMerge) {
AddBreaksAndContinuesToWorklist(liveInst);
Handle breaks from structured-ifs in DCE. (#1848) * Handle breaks from structured-ifs in DCE. dead code elimination assumes that are conditional branches except for breaks and continues in loops will have an OpSelectionMerge before them. That is not true when breaking out of a selection construct. The fix is to look for breaks in selection constructs in the same place we look for breaks and continues for loops.
2018-08-21 15:54:44 +00:00
// If function call, treat as if it loads from all pointer arguments
Cleanup whitespace lint warnings. (#1690) This CL cleans up the whitespace warnings and enables the check when running 'git cl presubmit --all -uf'.
2018-07-10 17:09:46 +00:00
} else if (liveInst->opcode() == SpvOpFunctionCall) {
ADCE: Add support for function calls ADCE will now generate correct code in the presence of function calls. This is needed for opaque type optimization needed by glslang. Currently all function calls are marked as live. TODO: mark calls live only if they write a non-local.
2017-08-04 21:04:37 +00:00
liveInst->ForEachInId([this](const uint32_t* iid) {
// Skip non-ptr args
if (!IsPtr(*iid)) return;
uint32_t varId;
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)GetPtr(*iid, &varId);
ADCE: Add support for function calls ADCE will now generate correct code in the presence of function calls. This is needed for opaque type optimization needed by glslang. Currently all function calls are marked as live. TODO: mark calls live only if they write a non-local.
2017-08-04 21:04:37 +00:00
ProcessLoad(varId);
});
Handle breaks from structured-ifs in DCE. (#1848) * Handle breaks from structured-ifs in DCE. dead code elimination assumes that are conditional branches except for breaks and continues in loops will have an OpSelectionMerge before them. That is not true when breaking out of a selection construct. The fix is to look for breaks in selection constructs in the same place we look for breaks and continues for loops.
2018-08-21 15:54:44 +00:00
// If function parameter, treat as if it's result id is loaded from
Cleanup whitespace lint warnings. (#1690) This CL cleans up the whitespace warnings and enables the check when running 'git cl presubmit --all -uf'.
2018-07-10 17:09:46 +00:00
} else if (liveInst->opcode() == SpvOpFunctionParameter) {
Opt: Have "size" passes process full entry point call tree. Includes code to deal correctly with OpFunctionParameter. This is needed by opaque propagation which may not exhaustively inline entry point functions. Adds ProcessEntryPointCallTree: a method to do work on the functions in the entry point call trees in a deterministic order.
2017-08-10 22:42:16 +00:00
ProcessLoad(liveInst->result_id());
Handle breaks from structured-ifs in DCE. (#1848) * Handle breaks from structured-ifs in DCE. dead code elimination assumes that are conditional branches except for breaks and continues in loops will have an OpSelectionMerge before them. That is not true when breaking out of a selection construct. The fix is to look for breaks in selection constructs in the same place we look for breaks and continues for loops.
2018-08-21 15:54:44 +00:00
// We treat an OpImageTexelPointer as a load of the pointer, and
// that value is manipulated to get the result.
Cleanup whitespace lint warnings. (#1690) This CL cleans up the whitespace warnings and enables the check when running 'git cl presubmit --all -uf'.
2018-07-10 17:09:46 +00:00
} else if (liveInst->opcode() == SpvOpImageTexelPointer) {
Teach ADCE about OpImageTexelPointer Currently OpImageTexelPointer operations are treat like a use of the pointer, but it does not look for the memory being referenced to make sure stores are not removed. This change teaches it so identify the memory being accessed, and treats it as if that memory is loaded. Fixes to #1445.
2018-04-02 17:40:53 +00:00
uint32_t varId;
(void)GetPtr(liveInst, &varId);
if (varId != 0) {
ProcessLoad(varId);
}
}
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
worklist_.pop();
}
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
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
// Kill dead instructions and remember dead blocks
for (auto bi = structuredOrder.begin(); bi != structuredOrder.end();) {
uint32_t mergeBlockId = 0;
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
(*bi)->ForEachInst([this, &modified, &mergeBlockId](Instruction* inst) {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
if (!IsDead(inst)) return;
if (inst->opcode() == SpvOpLabel) return;
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
// If dead instruction is selection merge, remember merge block
// for new branch at end of block
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
if (inst->opcode() == SpvOpSelectionMerge ||
inst->opcode() == SpvOpLoopMerge)
mergeBlockId = inst->GetSingleWordInOperand(0);
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
to_kill_.push_back(inst);
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
modified = true;
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
});
ADCE: Empty Loop Elimination This entirely eliminates loops which do not contain live code.
2017-10-25 00:58:48 +00:00
// If a structured if or loop was deleted, add a branch to its merge
// block, and traverse to the merge block and continue processing there.
// We know the block still exists because the label is not deleted.
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
if (mergeBlockId != 0) {
AddBranch(mergeBlockId, *bi);
for (++bi; (*bi)->id() != mergeBlockId; ++bi) {
}
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
} else {
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
++bi;
}
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
}
ADCE: Dead if elimination Mark structured conditional branches live only if one or more instructions in their associated construct is marked live. After closure, replace dead structured conditional branches with a branch to its merge and remove dead blocks. ADCE: Dead If Elim: Remove duplicate StructuredOrder code Also generalize ComputeStructuredOrder so that the caller can specify the root block for the order. Phi insertion uses pseudo_entry_block and adce and dead branch elim use the first block of the function. ADCE: Dead If Elim: Pull redundant code out of InsertPhiInstructions ADCE: Dead If Elim: Encapsulate CFG Cleanup Initialization ADCE: Dead If Elim: Remove redundant code from ADCE initialization ADCE: Dead If: Use CFGCleanup to eliminate newly dead blocks Moved bulk of CFG Cleanup code into MemPass.
2017-10-17 22:33:43 +00:00
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
return modified;
}
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
void AggressiveDCEPass::InitializeModuleScopeLiveInstructions() {
Fixes #1404. Don't DCE workgroup size Added test.
2018-03-13 17:48:48 +00:00
// Keep all execution modes.
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
for (auto& exec : get_module()->execution_modes()) {
AddToWorklist(&exec);
}
Fixes #1404. Don't DCE workgroup size Added test.
2018-03-13 17:48:48 +00:00
// Keep all entry points.
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
for (auto& entry : get_module()->entry_points()) {
AddToWorklist(&entry);
}
Fixes #1404. Don't DCE workgroup size Added test.
2018-03-13 17:48:48 +00:00
// Keep workgroup size.
for (auto& anno : get_module()->annotations()) {
if (anno.opcode() == SpvOpDecorate) {
if (anno.GetSingleWordInOperand(1u) == SpvDecorationBuiltIn &&
anno.GetSingleWordInOperand(2u) == SpvBuiltInWorkgroupSize) {
AddToWorklist(&anno);
}
}
}
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
}
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
Pass::Status AggressiveDCEPass::ProcessImpl() {
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
// Current functionality assumes shader capability
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
// TODO(greg-lunarg): Handle additional capabilities
Store all enabled capabilities in the feature manger. In order to keep track of all of the implicit capabilities as well as the explicit ones, we will add them all to the feature manager. That is the object that needs to be queried when checking if a capability is enabled. The name of the "HasCapability" function in the module was changed to make it more obvious that it does not check for implied capabilities. Keep an spv_context and AssemblyGrammar in IRContext
2017-12-19 19:18:13 +00:00
if (!context()->get_feature_mgr()->HasCapability(SpvCapabilityShader))
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
return Status::SuccessWithoutChange;
Allow pointers to pointers in logical addressing mode. A few optimizations are updates to handle code that is suppose to be using the logical addressing mode, but still has variables that contain pointers as long as the pointer are to opaque objects. This is called "relaxed logical addressing". |Instruction::GetBaseAddress| will check that pointers that are use meet the relaxed logical addressing rules. Optimization that now handle relaxed logical addressing instead of logical addressing are: - aggressive dead-code elimination - local access chain convert - local store elimination passes.
2017-12-11 18:10:24 +00:00
// Current functionality assumes relaxed logical addressing (see
// instruction.h)
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
// TODO(greg-lunarg): Handle non-logical addressing
Store all enabled capabilities in the feature manger. In order to keep track of all of the implicit capabilities as well as the explicit ones, we will add them all to the feature manager. That is the object that needs to be queried when checking if a capability is enabled. The name of the "HasCapability" function in the module was changed to make it more obvious that it does not check for implied capabilities. Keep an spv_context and AssemblyGrammar in IRContext
2017-12-19 19:18:13 +00:00
if (context()->get_feature_mgr()->HasCapability(SpvCapabilityAddresses))
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
return Status::SuccessWithoutChange;
Minor code review feedback on AggressiveDCE
2017-07-10 15:45:59 +00:00
// If any extensions in the module are not explicitly supported,
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
// return unmodified.
if (!AllExtensionsSupported()) return Status::SuccessWithoutChange;
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
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 the decoration manager is kept live then the context will try to keep it
// up to date. ADCE deals with group decorations by changing the operands in
// |OpGroupDecorate| instruction directly without informing the decoration
// manager. This can put it in an invalid state which will cause an error
// when the context tries to update it. To avoid this problem invalidate
// the decoration manager upfront.
context()->InvalidateAnalyses(IRContext::Analysis::kAnalysisDecorations);
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
// Eliminate Dead functions.
bool modified = EliminateDeadFunctions();
InitializeModuleScopeLiveInstructions();
// Process all entry point functions.
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
ProcessFunction pfn = [this](Function* fp) { return AggressiveDCE(fp); };
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 |= context()->ProcessEntryPointCallTree(pfn);
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
// Process module-level instructions. Now that all live instructions have
// been marked, it is safe to remove dead global values.
modified |= ProcessGlobalValues();
// Kill all dead instructions.
for (auto inst : to_kill_) {
context()->KillInst(inst);
}
// Cleanup all CFG including all unreachable blocks.
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
ProcessFunction cleanup = [this](Function* f) { return CFGCleanup(f); };
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 |= context()->ProcessEntryPointCallTree(cleanup);
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
}
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
bool AggressiveDCEPass::EliminateDeadFunctions() {
// Identify live functions first. Those that are not live
// are dead. ADCE is disabled for non-shaders so we do not check for exported
// functions here.
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_set<const Function*> live_function_set;
ProcessFunction mark_live = [&live_function_set](Function* fp) {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
live_function_set.insert(fp);
return false;
};
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
context()->ProcessEntryPointCallTree(mark_live);
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
bool modified = false;
for (auto funcIter = get_module()->begin();
funcIter != get_module()->end();) {
if (live_function_set.count(&*funcIter) == 0) {
modified = true;
EliminateFunction(&*funcIter);
funcIter = funcIter.Erase();
} else {
++funcIter;
}
}
return modified;
}
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 AggressiveDCEPass::EliminateFunction(Function* func) {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
// Remove all of the instruction in the function body
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
func->ForEachInst([this](Instruction* inst) { context()->KillInst(inst); },
true);
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
}
bool AggressiveDCEPass::ProcessGlobalValues() {
// Remove debug and annotation statements referencing dead instructions.
// This must be done before killing the instructions, otherwise there are
// dead objects in the def/use database.
bool modified = false;
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* instruction = &*get_module()->debug2_begin();
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
while (instruction) {
if (instruction->opcode() != SpvOpName) {
instruction = instruction->NextNode();
continue;
}
if (IsTargetDead(instruction)) {
instruction = context()->KillInst(instruction);
modified = true;
} else {
instruction = instruction->NextNode();
}
}
// This code removes all unnecessary decorations safely (see #1174). It also
// does so in a more efficient manner than deleting them only as the targets
// are deleted.
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*> annotations;
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
for (auto& inst : get_module()->annotations()) annotations.push_back(&inst);
std::sort(annotations.begin(), annotations.end(), DecorationLess());
for (auto annotation : annotations) {
switch (annotation->opcode()) {
case SpvOpDecorate:
case SpvOpMemberDecorate:
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
case SpvOpDecorateStringGOOGLE:
Handle OpMemberDecorateStringGOOGLE in ACDE (#2029) Add missing case to the switch statement for the annotation instructions. See https://github.com/KhronosGroup/glslang/issues/1561.
2018-11-02 17:42:45 +00:00
case SpvOpMemberDecorateStringGOOGLE:
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
if (IsTargetDead(annotation)) {
context()->KillInst(annotation);
modified = true;
}
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
break;
Removing HLSLCounterBuffer decorations when not needed. (#1954) The HlslCounterBufferGOOGLE that was introduced changed the OpDecorateId so that is can now reference an id other than the target. If that other id is used only in the decoration, then the definition of the id will be removed because decoration do not count as real uses. However, if the target of the decoration is still live the decoration will not be removed. This leaves a reference to an id that is not defined. There are two solutions to consider. The first is that is the decoration is kept, then the definition of the id should be kept live. Implementing this change would be involved because the way ADCE handles decorations will have to be reimplemented. The other solution is to remove the decoration the id is otherwise dead. This works for this specific case. Also this is the more desirable behaviour in this case. The id will always be the id of a variable that belongs to a descriptor set. If that variable is not bound and we do not remove it, the driver will complain. I chose to implement the second solution. The first will be left to when a case for it comes up. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1885.
2018-10-05 12:23:09 +00:00
case SpvOpDecorateId:
if (IsTargetDead(annotation)) {
context()->KillInst(annotation);
modified = true;
} else {
if (annotation->GetSingleWordInOperand(1) ==
SpvDecorationHlslCounterBufferGOOGLE) {
// HlslCounterBuffer will reference an id other than the target.
// If that id is dead, then the decoration can be removed as well.
uint32_t counter_buffer_id = annotation->GetSingleWordInOperand(2);
Instruction* counter_buffer_inst =
get_def_use_mgr()->GetDef(counter_buffer_id);
if (IsDead(counter_buffer_inst)) {
context()->KillInst(annotation);
modified = true;
}
}
}
break;
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
case SpvOpGroupDecorate: {
// Go through the targets of this group decorate. Remove each dead
// target. If all targets are dead, remove this decoration.
bool dead = true;
Analyze uses for all instructions. (#1937) * Analyze uses for all instructions. The def-use manager needs to fill in the `inst_to_used_ids_` field for every instruction. This means we have to analyze the uses for every instruction, even if they do not have any uses. This mistake was not found earlier because there was a typo in the equality check for def-use managers. No new tests are needed. While looking into this I found redundant work in block merge. Cleaning that up at the same time. * Fix other transformations Aggressive dead code elimination did not update the OpGroupDecorate and the OpGroupMemberDecorate instructions properly when they are updated. That is fixed. Dead branch elimination did not analyze the OpUnreachable instructions that is would add. That is taken care of.
2018-09-28 18:39:06 +00:00
bool removed_operand = false;
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
for (uint32_t i = 1; i < annotation->NumOperands();) {
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* opInst =
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
get_def_use_mgr()->GetDef(annotation->GetSingleWordOperand(i));
if (IsDead(opInst)) {
// Don't increment |i|.
annotation->RemoveOperand(i);
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
modified = true;
Analyze uses for all instructions. (#1937) * Analyze uses for all instructions. The def-use manager needs to fill in the `inst_to_used_ids_` field for every instruction. This means we have to analyze the uses for every instruction, even if they do not have any uses. This mistake was not found earlier because there was a typo in the equality check for def-use managers. No new tests are needed. While looking into this I found redundant work in block merge. Cleaning that up at the same time. * Fix other transformations Aggressive dead code elimination did not update the OpGroupDecorate and the OpGroupMemberDecorate instructions properly when they are updated. That is fixed. Dead branch elimination did not analyze the OpUnreachable instructions that is would add. That is taken care of.
2018-09-28 18:39:06 +00:00
removed_operand = true;
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
} else {
i++;
dead = false;
}
}
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
if (dead) {
context()->KillInst(annotation);
modified = true;
Analyze uses for all instructions. (#1937) * Analyze uses for all instructions. The def-use manager needs to fill in the `inst_to_used_ids_` field for every instruction. This means we have to analyze the uses for every instruction, even if they do not have any uses. This mistake was not found earlier because there was a typo in the equality check for def-use managers. No new tests are needed. While looking into this I found redundant work in block merge. Cleaning that up at the same time. * Fix other transformations Aggressive dead code elimination did not update the OpGroupDecorate and the OpGroupMemberDecorate instructions properly when they are updated. That is fixed. Dead branch elimination did not analyze the OpUnreachable instructions that is would add. That is taken care of.
2018-09-28 18:39:06 +00:00
} else if (removed_operand) {
context()->UpdateDefUse(annotation);
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
}
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
break;
}
case SpvOpGroupMemberDecorate: {
// Go through the targets of this group member decorate. Remove each
// dead target (and member index). If all targets are dead, remove this
// decoration.
bool dead = true;
Analyze uses for all instructions. (#1937) * Analyze uses for all instructions. The def-use manager needs to fill in the `inst_to_used_ids_` field for every instruction. This means we have to analyze the uses for every instruction, even if they do not have any uses. This mistake was not found earlier because there was a typo in the equality check for def-use managers. No new tests are needed. While looking into this I found redundant work in block merge. Cleaning that up at the same time. * Fix other transformations Aggressive dead code elimination did not update the OpGroupDecorate and the OpGroupMemberDecorate instructions properly when they are updated. That is fixed. Dead branch elimination did not analyze the OpUnreachable instructions that is would add. That is taken care of.
2018-09-28 18:39:06 +00:00
bool removed_operand = false;
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
for (uint32_t i = 1; i < annotation->NumOperands();) {
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* opInst =
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
get_def_use_mgr()->GetDef(annotation->GetSingleWordOperand(i));
if (IsDead(opInst)) {
// Don't increment |i|.
annotation->RemoveOperand(i + 1);
annotation->RemoveOperand(i);
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
modified = true;
Analyze uses for all instructions. (#1937) * Analyze uses for all instructions. The def-use manager needs to fill in the `inst_to_used_ids_` field for every instruction. This means we have to analyze the uses for every instruction, even if they do not have any uses. This mistake was not found earlier because there was a typo in the equality check for def-use managers. No new tests are needed. While looking into this I found redundant work in block merge. Cleaning that up at the same time. * Fix other transformations Aggressive dead code elimination did not update the OpGroupDecorate and the OpGroupMemberDecorate instructions properly when they are updated. That is fixed. Dead branch elimination did not analyze the OpUnreachable instructions that is would add. That is taken care of.
2018-09-28 18:39:06 +00:00
removed_operand = true;
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
} else {
i += 2;
dead = false;
}
}
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
if (dead) {
context()->KillInst(annotation);
modified = true;
Analyze uses for all instructions. (#1937) * Analyze uses for all instructions. The def-use manager needs to fill in the `inst_to_used_ids_` field for every instruction. This means we have to analyze the uses for every instruction, even if they do not have any uses. This mistake was not found earlier because there was a typo in the equality check for def-use managers. No new tests are needed. While looking into this I found redundant work in block merge. Cleaning that up at the same time. * Fix other transformations Aggressive dead code elimination did not update the OpGroupDecorate and the OpGroupMemberDecorate instructions properly when they are updated. That is fixed. Dead branch elimination did not analyze the OpUnreachable instructions that is would add. That is taken care of.
2018-09-28 18:39:06 +00:00
} else if (removed_operand) {
context()->UpdateDefUse(annotation);
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
}
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
break;
}
case SpvOpDecorationGroup:
// By the time we hit decoration groups we've checked everything that
// can target them. So if they have no uses they must be dead.
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
if (get_def_use_mgr()->NumUsers(annotation) == 0) {
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
context()->KillInst(annotation);
ADCE: Remove OpDecorateStringGOOGLE Also fix a few failures to set "modified" status when removing global values. Add OpDecorateStringGOOGLE to decoration ordering Fixes #1492
2018-04-16 15:33:13 +00:00
modified = true;
}
Adding additional functionality to ADCE. Modified ADCE to remove dead globals. * Entry point and execution mode instructions are marked as alive * Reachable functions and their parameters are marked as alive * Instruction deletion now deferred until the end of the pass * Eliminated dead insts set, added IsDead to calculate that value instead * Ported applicable dead variable elimination tests * Ported dead constant elim tests Added dead function elimination to ADCE * ported dead function elim tests Added handling of decoration groups in ADCE * Uses a custom sorter to traverse decorations in a specific order * Simplifies necessary checks Updated -O and -Os pass lists.
2017-12-18 17:13:10 +00:00
break;
default:
assert(false);
break;
}
}
// Since ADCE is disabled for non-shaders, we don't check for export linkage
// attributes here.
for (auto& val : get_module()->types_values()) {
if (IsDead(&val)) {
to_kill_.push_back(&val);
}
}
return modified;
}
use Pass::Run to set the context on each pass. (#1708) Currently the IRContext is passed into the Pass::Process method. It is then up to the individual pass to store the context into the context_ variable. This CL changes the Run method to store the context before calling Process which no-longer receives the context as a parameter.
2018-07-12 13:08:45 +00:00
AggressiveDCEPass::AggressiveDCEPass() = default;
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
use Pass::Run to set the context on each pass. (#1708) Currently the IRContext is passed into the Pass::Process method. It is then up to the individual pass to store the context into the context_ variable. This CL changes the Run method to store the context before calling Process which no-longer receives the context as a parameter.
2018-07-12 13:08:45 +00:00
Pass::Status AggressiveDCEPass::Process() {
// Initialize extensions whitelist
InitExtensions();
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
return ProcessImpl();
}
Add extension whitelists to size-reduction passes. Currently only SPV_KHR_variable_pointers is disallowed in passes which do pointer analysis. Positive and negative tests of the general extensions mechanism were added to aggressive_dce but cover all passes.
2017-07-19 00:57:26 +00:00
void AggressiveDCEPass::InitExtensions() {
extensions_whitelist_.clear();
extensions_whitelist_.insert({
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
"SPV_AMD_shader_explicit_vertex_parameter",
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
"SPV_AMD_shader_trinary_minmax",
"SPV_AMD_gcn_shader",
"SPV_KHR_shader_ballot",
"SPV_AMD_shader_ballot",
"SPV_AMD_gpu_shader_half_float",
"SPV_KHR_shader_draw_parameters",
"SPV_KHR_subgroup_vote",
"SPV_KHR_16bit_storage",
"SPV_KHR_device_group",
"SPV_KHR_multiview",
"SPV_NVX_multiview_per_view_attributes",
"SPV_NV_viewport_array2",
"SPV_NV_stereo_view_rendering",
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
"SPV_NV_sample_mask_override_coverage",
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
"SPV_NV_geometry_shader_passthrough",
"SPV_AMD_texture_gather_bias_lod",
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
"SPV_KHR_storage_buffer_storage_class",
// SPV_KHR_variable_pointers
// Currently do not support extended pointer expressions
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
"SPV_AMD_gpu_shader_int16",
"SPV_KHR_post_depth_coverage",
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
"SPV_KHR_shader_atomic_counter_ops",
Add missing SPV extension strings
2018-03-08 13:54:00 +00:00
"SPV_EXT_shader_stencil_export",
"SPV_EXT_shader_viewport_index_layer",
"SPV_AMD_shader_image_load_store_lod",
"SPV_AMD_shader_fragment_mask",
"SPV_EXT_fragment_fully_covered",
"SPV_AMD_gpu_shader_half_float_fetch",
Add recent Google extensions to optimizer whitelists Optimizations should work in the presence of recent SPV_GOOGLE_decorate_string and SPV_GOOGLE_hlsl_functionality1 SPV_GOOGLE_decorate_string: - Adds operation OpDecorateStringGOOGLE to decorate an object with decorations having string operands. SPV_GOOGLE_hlsl_functionality1: - Adds HlslSemanticGOOGLE, used to decorate an interface variable with an HLSL semantic string. Optimizations already preserve those variables as required because they are interface variables (with uses), independent of whether they have HLSL decorations. - Adds HlslCounterBufferGOOGLE, used to associate a buffer with a counter variable. Fixes #1391
2018-03-08 20:33:28 +00:00
"SPV_GOOGLE_decorate_string",
"SPV_GOOGLE_hlsl_functionality1",
Optimizer: update extension whitelists Add two new extensions: - SPV_NV_shader_subgroup_partitioned - SPV_EXT_descriptor_indexing
2018-04-06 14:18:34 +00:00
"SPV_NV_shader_subgroup_partitioned",
"SPV_EXT_descriptor_indexing",
Add support for Nvidia Turing extensions
2018-09-19 18:53:33 +00:00
"SPV_NV_fragment_shader_barycentric",
"SPV_NV_compute_shader_derivatives",
"SPV_NV_shader_image_footprint",
"SPV_NV_shading_rate",
"SPV_NV_mesh_shader",
Add support for nv-raytracing-final (#2010) Add support for nv-raytracing (non-experimental)
2018-10-25 18:07:46 +00:00
"SPV_NV_ray_tracing",
Add basic support for EXT_fragment_invocation_density (#2100) Whitelisting the extension in optimizations * copying what was done for NV_shading_rate
2018-11-23 15:21:19 +00:00
"SPV_EXT_fragment_invocation_density",
Add extension whitelists to size-reduction passes. Currently only SPV_KHR_variable_pointers is disallowed in passes which do pointer analysis. Positive and negative tests of the general extensions mechanism were added to aggressive_dce but cover all passes.
2017-07-19 00:57:26 +00:00
});
}
Add AggressiveDCEPass Create aggressive dead code elimination pass This pass eliminates unused code from functions. In addition, it detects and eliminates code which may have spurious uses but which do not contribute to the output of the function. The most common cause of such code sequences is summations in loops whose result is no longer used due to dead code elimination. This optimization has additional compile time cost over standard dead code elimination. This pass only processes entry point functions. It also only processes shaders with logical addressing. It currently will not process functions with function calls. It currently only supports the GLSL.std.450 extended instruction set. It currently does not support any extensions. This pass will be made more effective by first running passes that remove dead control flow and inlines function calls. This pass can be especially useful after running Local Access Chain Conversion, which tends to cause cycles of dead code to be left after Store/Load elimination passes are completed. These cycles cannot be eliminated with standard dead code elimination. Additionally: This transform uses a whitelist of instructions that it knows do have side effects, (a.k.a. combinators). It assumes other instructions have side effects: it will not remove them, and assumes they have side effects via their ID operands.
2017-06-08 16:37:21 +00:00
} // namespace opt
} // namespace spvtools
Reference in New Issue Copy Permalink