AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-26 21:30:07 +00:00
Code Issues Packages Projects Releases Wiki Activity
46ca66e699
SPIRV-Tools/source/opt/simplification_pass.cpp

170 lines
6.1 KiB
C++
Raw Normal View History

Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
// Copyright (c) 2018 Google LLC
//
// 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/simplification_pass.h"
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
#include <set>
#include <unordered_set>
#include <vector>
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/fold.h"
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
namespace spvtools {
namespace opt {
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 SimplificationPass::Process() {
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
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
for (Function& function : *get_module()) {
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
modified |= SimplifyFunction(&function);
}
return (modified ? Status::SuccessWithChange : Status::SuccessWithoutChange);
}
Add two new simplifications. (#2984) Implements the following simplifications: (a - b) + b => a (a * b) + (a * c) => a * (b + c) Also adds logic to simplification to handle rules that create new operations that might need simplification, such as the second rule above. Only perform the second simplification if the multiplies have the add as their only use. Otherwise this is a deoptimization of size and performance.
2019-10-28 15:19:38 +00:00
void SimplificationPass::AddNewOperands(
Instruction* folded_inst, std::unordered_set<Instruction*>* inst_seen,
std::vector<Instruction*>* work_list) {
analysis::DefUseManager* def_use_mgr = get_def_use_mgr();
folded_inst->ForEachInId(
[&inst_seen, &def_use_mgr, &work_list](uint32_t* iid) {
Instruction* iid_inst = def_use_mgr->GetDef(*iid);
if (!inst_seen->insert(iid_inst).second) return;
work_list->push_back(iid_inst);
});
}
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
bool SimplificationPass::SimplifyFunction(Function* function) {
Update passes to handle function declarations (#4599) Spirv-opt has not had to handle module with function declarations. This lead many passes to assume that every function has a body. This is not always true. This commit will modify a number of passes to handle function declarations. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/4443
2021-10-28 15:54:37 +00:00
if (function->IsDeclaration()) {
return false;
}
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
bool modified = false;
// Phase 1: Traverse all instructions in dominance order.
// The second phase will only be on the instructions whose inputs have changed
// after being processed during phase 1. Since OpPhi instructions are the
// only instructions whose inputs do not necessarily dominate the use, we keep
// track of the OpPhi instructions already seen, and add them to the work list
// for phase 2 when needed.
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*> work_list;
std::unordered_set<Instruction*> process_phis;
std::unordered_set<Instruction*> inst_to_kill;
std::unordered_set<Instruction*> in_work_list;
Add two new simplifications. (#2984) Implements the following simplifications: (a - b) + b => a (a * b) + (a * c) => a * (b + c) Also adds logic to simplification to handle rules that create new operations that might need simplification, such as the second rule above. Only perform the second simplification if the multiplies have the add as their only use. Otherwise this is a deoptimization of size and performance.
2019-10-28 15:19:38 +00:00
std::unordered_set<Instruction*> inst_seen;
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 InstructionFolder& folder = context()->get_instruction_folder();
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
cfg()->ForEachBlockInReversePostOrder(
function->entry().get(),
[&modified, &process_phis, &work_list, &in_work_list, &inst_to_kill,
Add two new simplifications. (#2984) Implements the following simplifications: (a - b) + b => a (a * b) + (a * c) => a * (b + c) Also adds logic to simplification to handle rules that create new operations that might need simplification, such as the second rule above. Only perform the second simplification if the multiplies have the add as their only use. Otherwise this is a deoptimization of size and performance.
2019-10-28 15:19:38 +00:00
&folder, &inst_seen, this](BasicBlock* bb) {
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* inst = &*bb->begin(); inst; inst = inst->NextNode()) {
Add two new simplifications. (#2984) Implements the following simplifications: (a - b) + b => a (a * b) + (a * c) => a * (b + c) Also adds logic to simplification to handle rules that create new operations that might need simplification, such as the second rule above. Only perform the second simplification if the multiplies have the add as their only use. Otherwise this is a deoptimization of size and performance.
2019-10-28 15:19:38 +00:00
inst_seen.insert(inst);
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
if (inst->opcode() == spv::Op::OpPhi) {
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
process_phis.insert(inst);
}
Handle decorations better in some optimizations (#2716) There are a couple spots where we are not looking at decorations when we should. 1. Value numbering is suppose to assign a different value number to ids if they have different decorations. However that is not being done for OpCopyObject and OpPhi. 1. Instruction simplification is propagating OpCopyObject instruction without checking for decorations. It should only do that if no decorations are being lost. Add a new function to the decoration manager to check if the decorations of one id are a subset of the decorations of another. Fixes #2715.
2019-07-10 15:37:16 +00:00
bool is_foldable_copy =
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
inst->opcode() == spv::Op::OpCopyObject &&
Handle decorations better in some optimizations (#2716) There are a couple spots where we are not looking at decorations when we should. 1. Value numbering is suppose to assign a different value number to ids if they have different decorations. However that is not being done for OpCopyObject and OpPhi. 1. Instruction simplification is propagating OpCopyObject instruction without checking for decorations. It should only do that if no decorations are being lost. Add a new function to the decoration manager to check if the decorations of one id are a subset of the decorations of another. Fixes #2715.
2019-07-10 15:37:16 +00:00
context()->get_decoration_mgr()->HaveSubsetOfDecorations(
inst->result_id(), inst->GetSingleWordInOperand(0));
if (is_foldable_copy || folder.FoldInstruction(inst)) {
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
modified = true;
context()->AnalyzeUses(inst);
get_def_use_mgr()->ForEachUser(inst, [&work_list, &process_phis,
&in_work_list](
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* use) {
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
if (process_phis.count(use) && in_work_list.insert(use).second) {
work_list.push_back(use);
}
});
Add two new simplifications. (#2984) Implements the following simplifications: (a - b) + b => a (a * b) + (a * c) => a * (b + c) Also adds logic to simplification to handle rules that create new operations that might need simplification, such as the second rule above. Only perform the second simplification if the multiplies have the add as their only use. Otherwise this is a deoptimization of size and performance.
2019-10-28 15:19:38 +00:00
AddNewOperands(inst, &inst_seen, &work_list);
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
if (inst->opcode() == spv::Op::OpCopyObject) {
Don't move debug or decorations when folding (#2772) Fixes #2764 * Don't replace all uses when simplifying instructions, instead only update non-debug, non-decoration uses * added a test * Add a new version of RAUW that takes a predicate to decide whether to replace the use or not * used in simplification pass
2019-07-29 20:20:43 +00:00
context()->ReplaceAllUsesWithPredicate(
inst->result_id(), inst->GetSingleWordInOperand(0),
Correctly replace debug lexical scope of instruction (#3718) When we update OpenCL.DebugInfo.100 lexical scopes e.g., DebugFunction, we have to replace DebugScope of each instruction that uses the lexical scope correctly.
2020-08-31 14:05:38 +00:00
[](Instruction* user) {
Don't move debug or decorations when folding (#2772) Fixes #2764 * Don't replace all uses when simplifying instructions, instead only update non-debug, non-decoration uses * added a test * Add a new version of RAUW that takes a predicate to decide whether to replace the use or not * used in simplification pass
2019-07-29 20:20:43 +00:00
const auto opcode = user->opcode();
if (!spvOpcodeIsDebug(opcode) &&
!spvOpcodeIsDecoration(opcode)) {
return true;
}
return false;
});
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
inst_to_kill.insert(inst);
in_work_list.insert(inst);
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
} else if (inst->opcode() == spv::Op::OpNop) {
Remove stores of undef. When storing an undef, any value is valid, including the one already in that memory location. So we can avoid the store.
2018-06-25 15:35:19 +00:00
inst_to_kill.insert(inst);
in_work_list.insert(inst);
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
}
}
}
});
// Phase 2: process the instructions in the work list until all of the work is
// done. This time we add all users to the work list because phase 1
// has already finished.
for (size_t i = 0; i < work_list.size(); ++i) {
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* inst = work_list[i];
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
in_work_list.erase(inst);
Add two new simplifications. (#2984) Implements the following simplifications: (a - b) + b => a (a * b) + (a * c) => a * (b + c) Also adds logic to simplification to handle rules that create new operations that might need simplification, such as the second rule above. Only perform the second simplification if the multiplies have the add as their only use. Otherwise this is a deoptimization of size and performance.
2019-10-28 15:19:38 +00:00
inst_seen.insert(inst);
Handle decorations better in some optimizations (#2716) There are a couple spots where we are not looking at decorations when we should. 1. Value numbering is suppose to assign a different value number to ids if they have different decorations. However that is not being done for OpCopyObject and OpPhi. 1. Instruction simplification is propagating OpCopyObject instruction without checking for decorations. It should only do that if no decorations are being lost. Add a new function to the decoration manager to check if the decorations of one id are a subset of the decorations of another. Fixes #2715.
2019-07-10 15:37:16 +00:00
bool is_foldable_copy =
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
inst->opcode() == spv::Op::OpCopyObject &&
Handle decorations better in some optimizations (#2716) There are a couple spots where we are not looking at decorations when we should. 1. Value numbering is suppose to assign a different value number to ids if they have different decorations. However that is not being done for OpCopyObject and OpPhi. 1. Instruction simplification is propagating OpCopyObject instruction without checking for decorations. It should only do that if no decorations are being lost. Add a new function to the decoration manager to check if the decorations of one id are a subset of the decorations of another. Fixes #2715.
2019-07-10 15:37:16 +00:00
context()->get_decoration_mgr()->HaveSubsetOfDecorations(
inst->result_id(), inst->GetSingleWordInOperand(0));
if (is_foldable_copy || folder.FoldInstruction(inst)) {
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
modified = true;
context()->AnalyzeUses(inst);
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
inst, [&work_list, &in_work_list](Instruction* use) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
if (!use->IsDecoration() && use->opcode() != spv::Op::OpName &&
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
in_work_list.insert(use).second) {
work_list.push_back(use);
}
});
Add two new simplifications. (#2984) Implements the following simplifications: (a - b) + b => a (a * b) + (a * c) => a * (b + c) Also adds logic to simplification to handle rules that create new operations that might need simplification, such as the second rule above. Only perform the second simplification if the multiplies have the add as their only use. Otherwise this is a deoptimization of size and performance.
2019-10-28 15:19:38 +00:00
AddNewOperands(inst, &inst_seen, &work_list);
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
if (inst->opcode() == spv::Op::OpCopyObject) {
Don't move debug or decorations when folding (#2772) Fixes #2764 * Don't replace all uses when simplifying instructions, instead only update non-debug, non-decoration uses * added a test * Add a new version of RAUW that takes a predicate to decide whether to replace the use or not * used in simplification pass
2019-07-29 20:20:43 +00:00
context()->ReplaceAllUsesWithPredicate(
inst->result_id(), inst->GetSingleWordInOperand(0),
Correctly replace debug lexical scope of instruction (#3718) When we update OpenCL.DebugInfo.100 lexical scopes e.g., DebugFunction, we have to replace DebugScope of each instruction that uses the lexical scope correctly.
2020-08-31 14:05:38 +00:00
[](Instruction* user) {
Don't move debug or decorations when folding (#2772) Fixes #2764 * Don't replace all uses when simplifying instructions, instead only update non-debug, non-decoration uses * added a test * Add a new version of RAUW that takes a predicate to decide whether to replace the use or not * used in simplification pass
2019-07-29 20:20:43 +00:00
const auto opcode = user->opcode();
if (!spvOpcodeIsDebug(opcode) && !spvOpcodeIsDecoration(opcode)) {
return true;
}
return false;
});
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
inst_to_kill.insert(inst);
in_work_list.insert(inst);
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
} else if (inst->opcode() == spv::Op::OpNop) {
Remove stores of undef. When storing an undef, any value is valid, including the one already in that memory location. So we can avoid the store.
2018-06-25 15:35:19 +00:00
inst_to_kill.insert(inst);
in_work_list.insert(inst);
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
}
}
}
// Phase 3: Kill instructions we know are no longer needed.
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
for (Instruction* inst : inst_to_kill) {
Make use of the instruction folder. Implementation of the simplification pass. - Create pass that calls the instruction folder on each instruction and propagate instructions that fold to a copy. This will do copy propagation as well. - Did not use the propagator engine because I want to modify the instruction as we go along. - Change folding to not allocate new instructions, but make changes in place. This change had a big impact on compile time. - Add simplification pass to the legalization passes in place of insert-extract elimination. - Added test cases for new folding rules. - Added tests for the simplification pass - Added a method to the CFG to apply a function to the basic blocks in reverse post order. Contributes to #1164.
2018-02-02 16:55:05 +00:00
context()->KillInst(inst);
}
return modified;
}
} // namespace opt
} // namespace spvtools
Reference in New Issue Copy Permalink