AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-23 04:00:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
69e1deabc1
SPIRV-Tools/source/opt/fold.cpp

712 lines
22 KiB
C++
Raw Normal View History

Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
// Copyright (c) 2017 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include "source/opt/fold.h"
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
Add folding of OpCompositeExtract and OpConstantComposite constant instructions. Create files for constant folding rules. Add the rules for OpConstantComposite and OpCompositeExtract.
2018-02-08 15:59:03 +00:00
#include <cassert>
#include <cstdint>
#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/const_folding_rules.h"
#include "source/opt/def_use_manager.h"
#include "source/opt/folding_rules.h"
#include "source/opt/ir_builder.h"
#include "source/opt/ir_context.h"
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
namespace spvtools {
namespace opt {
namespace {
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
#ifndef INT32_MIN
#define INT32_MIN (-2147483648)
#endif
#ifndef INT32_MAX
#define INT32_MAX 2147483647
#endif
#ifndef UINT32_MAX
#define UINT32_MAX 0xffffffff /* 4294967295U */
#endif
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
} // namespace
uint32_t InstructionFolder::UnaryOperate(SpvOp opcode, uint32_t operand) const {
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
switch (opcode) {
// Arthimetics
Fix overflow when negating INT_MIN. (#2293) When doing (-INT_MIN) is considered overflow, so we cannot fold it by actually performing the negation. Fixes https://crbug.com/917991
2019-01-17 22:01:55 +00:00
case SpvOp::SpvOpSNegate: {
int32_t s_operand = static_cast<int32_t>(operand);
if (s_operand == std::numeric_limits<int32_t>::min()) {
return s_operand;
}
return -s_operand;
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
case SpvOp::SpvOpNot:
return ~operand;
case SpvOp::SpvOpLogicalNot:
return !static_cast<bool>(operand);
Support constant-folding UConvert and SConvert (#2960)
2019-10-16 20:29:55 +00:00
case SpvOp::SpvOpUConvert:
return operand;
case SpvOp::SpvOpSConvert:
return operand;
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
default:
assert(false &&
"Unsupported unary operation for OpSpecConstantOp instruction");
return 0u;
}
}
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
uint32_t InstructionFolder::BinaryOperate(SpvOp opcode, uint32_t a,
uint32_t b) const {
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
switch (opcode) {
// Arthimetics
case SpvOp::SpvOpIAdd:
return a + b;
case SpvOp::SpvOpISub:
return a - b;
case SpvOp::SpvOpIMul:
return a * b;
case SpvOp::SpvOpUDiv:
Fold divisions by 0. (#1963) The current implementation in the folder when seeing a division by zero is to assert. In the release build, the compiler will attempt to compute the value, which causes its own problems. The solution I will go with is to fold the division, and just give it the value of 0. The same goes for remainder and mod operations. Fixes #1961.
2018-10-10 15:17:26 +00:00
if (b != 0) {
return a / b;
} else {
// Dividing by 0 is undefined, so we will just pick 0.
return 0;
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
case SpvOp::SpvOpSDiv:
Fold divisions by 0. (#1963) The current implementation in the folder when seeing a division by zero is to assert. In the release build, the compiler will attempt to compute the value, which causes its own problems. The solution I will go with is to fold the division, and just give it the value of 0. The same goes for remainder and mod operations. Fixes #1961.
2018-10-10 15:17:26 +00:00
if (b != 0u) {
return (static_cast<int32_t>(a)) / (static_cast<int32_t>(b));
} else {
// Dividing by 0 is undefined, so we will just pick 0.
return 0;
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
case SpvOp::SpvOpSRem: {
// The sign of non-zero result comes from the first operand: a. This is
// guaranteed by C++11 rules for integer division operator. The division
// result is rounded toward zero, so the result of '%' has the sign of
// the first operand.
Fold divisions by 0. (#1963) The current implementation in the folder when seeing a division by zero is to assert. In the release build, the compiler will attempt to compute the value, which causes its own problems. The solution I will go with is to fold the division, and just give it the value of 0. The same goes for remainder and mod operations. Fixes #1961.
2018-10-10 15:17:26 +00:00
if (b != 0u) {
return static_cast<int32_t>(a) % static_cast<int32_t>(b);
} else {
// Remainder when dividing with 0 is undefined, so we will just pick 0.
return 0;
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
}
case SpvOp::SpvOpSMod: {
// The sign of non-zero result comes from the second operand: b
Fold divisions by 0. (#1963) The current implementation in the folder when seeing a division by zero is to assert. In the release build, the compiler will attempt to compute the value, which causes its own problems. The solution I will go with is to fold the division, and just give it the value of 0. The same goes for remainder and mod operations. Fixes #1961.
2018-10-10 15:17:26 +00:00
if (b != 0u) {
int32_t rem = BinaryOperate(SpvOp::SpvOpSRem, a, b);
int32_t b_prim = static_cast<int32_t>(b);
return (rem + b_prim) % b_prim;
} else {
// Mod with 0 is undefined, so we will just pick 0.
return 0;
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
}
case SpvOp::SpvOpUMod:
Fold divisions by 0. (#1963) The current implementation in the folder when seeing a division by zero is to assert. In the release build, the compiler will attempt to compute the value, which causes its own problems. The solution I will go with is to fold the division, and just give it the value of 0. The same goes for remainder and mod operations. Fixes #1961.
2018-10-10 15:17:26 +00:00
if (b != 0u) {
return (a % b);
} else {
// Mod with 0 is undefined, so we will just pick 0.
return 0;
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
// Shifting
Remove undefined behaviour when folding shifts. (#2157) We currently simulate all shift operations when the two operand are constants. The problem is that if the shift amount is larger than 32, the result is undefined. I'm changing the folder to return 0 if the shift value is too high. That way, we will have defined behaviour. https://crbug.com/910937.
2018-12-04 15:04:02 +00:00
case SpvOp::SpvOpShiftRightLogical:
Fix up bit shifts by 32. (#2292) In C++, a bit shift of the same size as the type is undefined, but it is defined in spir-v. When folding those cases, we have to be careful. We cannot simply do the shift in C++. Fixes https://crbug.com/917697.
2019-01-16 20:52:23 +00:00
if (b >= 32) {
// This is undefined behaviour when |b| > 32. Choose 0 for consistency.
// When |b| == 32, doing the shift in C++ in undefined, but the result
// will be 0, so just return that value.
Remove undefined behaviour when folding shifts. (#2157) We currently simulate all shift operations when the two operand are constants. The problem is that if the shift amount is larger than 32, the result is undefined. I'm changing the folder to return 0 if the shift value is too high. That way, we will have defined behaviour. https://crbug.com/910937.
2018-12-04 15:04:02 +00:00
return 0;
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
return a >> b;
case SpvOp::SpvOpShiftRightArithmetic:
Remove undefined behaviour when folding shifts. (#2157) We currently simulate all shift operations when the two operand are constants. The problem is that if the shift amount is larger than 32, the result is undefined. I'm changing the folder to return 0 if the shift value is too high. That way, we will have defined behaviour. https://crbug.com/910937.
2018-12-04 15:04:02 +00:00
if (b > 32) {
// This is undefined behaviour. Choose 0 for consistency.
return 0;
}
Fix up bit shifts by 32. (#2292) In C++, a bit shift of the same size as the type is undefined, but it is defined in spir-v. When folding those cases, we have to be careful. We cannot simply do the shift in C++. Fixes https://crbug.com/917697.
2019-01-16 20:52:23 +00:00
if (b == 32) {
// Doing the shift in C++ is undefined, but the result is defined in the
// spir-v spec. Find that value another way.
if (static_cast<int32_t>(a) >= 0) {
return 0;
} else {
return static_cast<uint32_t>(-1);
}
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
return (static_cast<int32_t>(a)) >> b;
case SpvOp::SpvOpShiftLeftLogical:
Fix up bit shifts by 32. (#2292) In C++, a bit shift of the same size as the type is undefined, but it is defined in spir-v. When folding those cases, we have to be careful. We cannot simply do the shift in C++. Fixes https://crbug.com/917697.
2019-01-16 20:52:23 +00:00
if (b >= 32) {
// This is undefined behaviour when |b| > 32. Choose 0 for consistency.
// When |b| == 32, doing the shift in C++ in undefined, but the result
// will be 0, so just return that value.
Remove undefined behaviour when folding shifts. (#2157) We currently simulate all shift operations when the two operand are constants. The problem is that if the shift amount is larger than 32, the result is undefined. I'm changing the folder to return 0 if the shift value is too high. That way, we will have defined behaviour. https://crbug.com/910937.
2018-12-04 15:04:02 +00:00
return 0;
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
return a << b;
// Bitwise operations
case SpvOp::SpvOpBitwiseOr:
return a | b;
case SpvOp::SpvOpBitwiseAnd:
return a & b;
case SpvOp::SpvOpBitwiseXor:
return a ^ b;
// Logical
case SpvOp::SpvOpLogicalEqual:
return (static_cast<bool>(a)) == (static_cast<bool>(b));
case SpvOp::SpvOpLogicalNotEqual:
return (static_cast<bool>(a)) != (static_cast<bool>(b));
case SpvOp::SpvOpLogicalOr:
return (static_cast<bool>(a)) || (static_cast<bool>(b));
case SpvOp::SpvOpLogicalAnd:
return (static_cast<bool>(a)) && (static_cast<bool>(b));
// Comparison
case SpvOp::SpvOpIEqual:
return a == b;
case SpvOp::SpvOpINotEqual:
return a != b;
case SpvOp::SpvOpULessThan:
return a < b;
case SpvOp::SpvOpSLessThan:
return (static_cast<int32_t>(a)) < (static_cast<int32_t>(b));
case SpvOp::SpvOpUGreaterThan:
return a > b;
case SpvOp::SpvOpSGreaterThan:
return (static_cast<int32_t>(a)) > (static_cast<int32_t>(b));
case SpvOp::SpvOpULessThanEqual:
return a <= b;
case SpvOp::SpvOpSLessThanEqual:
return (static_cast<int32_t>(a)) <= (static_cast<int32_t>(b));
case SpvOp::SpvOpUGreaterThanEqual:
return a >= b;
case SpvOp::SpvOpSGreaterThanEqual:
return (static_cast<int32_t>(a)) >= (static_cast<int32_t>(b));
default:
assert(false &&
"Unsupported binary operation for OpSpecConstantOp instruction");
return 0u;
}
}
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
uint32_t InstructionFolder::TernaryOperate(SpvOp opcode, uint32_t a, uint32_t b,
uint32_t c) const {
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
switch (opcode) {
case SpvOp::SpvOpSelect:
return (static_cast<bool>(a)) ? b : c;
default:
assert(false &&
"Unsupported ternary operation for OpSpecConstantOp instruction");
return 0u;
}
}
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
uint32_t InstructionFolder::OperateWords(
SpvOp opcode, const std::vector<uint32_t>& operand_words) const {
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
switch (operand_words.size()) {
case 1:
return UnaryOperate(opcode, operand_words.front());
case 2:
return BinaryOperate(opcode, operand_words.front(), operand_words.back());
case 3:
return TernaryOperate(opcode, operand_words[0], operand_words[1],
operand_words[2]);
default:
assert(false && "Invalid number of operands");
return 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
bool InstructionFolder::FoldInstructionInternal(Instruction* inst) const {
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
auto identity_map = [](uint32_t id) { return id; };
Cleanup extraneous namespace qualifies in source/opt. (#1716) This CL follows up on the opt namespacing CLs by removing the unnecessary opt:: and opt::analysis:: namespace prefixes.
2018-07-12 19:14:43 +00:00
Instruction* folded_inst = FoldInstructionToConstant(inst, identity_map);
Add general folding infrastructure. Create the folding engine that will 1) attempt to fold an instruction. 2) iterates on the folding so small folding rules can be easily combined. 3) insert new instructions when needed. I've added the minimum number of rules needed to test the features above.
2018-01-24 18:26:33 +00:00
if (folded_inst != nullptr) {
inst->SetOpcode(SpvOpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {folded_inst->result_id()}}});
return true;
}
Pass the IRContext into the folding rules. (#1709) This CL updates the folding rules to receive the IRContext as a paramter instead of retrieving off of the Instruction. Issue #1703
2018-07-12 13:12:23 +00:00
analysis::ConstantManager* const_manager = context_->get_constant_mgr();
Merge arithmetic with non-trivial constant operands Adding basis of arithmetic merging * Refactored constant collection in ConstantManager * New rules: * consecutive negates * negate of arithmetic op with a constant * consecutive muls * reciprocal of div * Removed IRContext::CanFoldFloatingPoint * replaced by Instruction::IsFloatingPointFoldingAllowed * Fixed some bad tests * added some header comments Added PerformIntegerOperation * minor fixes to constants and tests * fixed IntMultiplyBy1 to work with 64 bit ints * added tests for integer mul merging Adding test for vector integer multiply merging Adding support for merging integer add and sub through negate * Added tests Adding rules to merge mult with preceding divide * Has a couple tests, but needs more * Added more comments Fixed bug in integer division folding * Will no longer merge through integer division if there would be a remainder in the division * Added a bunch more tests Adding rules to merge divide and multiply through divide * Improved comments * Added tests Adding rules to handle mul or div of a negation * Added tests Changes for review * Early exit if no constants are involved in more functions * fixed some comments * removed unused declaration * clarified some logic Adding new rules for add and subtract * Fold adds of adds, subtracts or negates * Fold subtracts of adds, subtracts or negates * Added tests
2018-02-16 21:07:33 +00:00
std::vector<const analysis::Constant*> constants =
const_manager->GetOperandConstants(inst);
Add general folding infrastructure. Create the folding engine that will 1) attempt to fold an instruction. 2) iterates on the folding so small folding rules can be easily combined. 3) insert new instructions when needed. I've added the minimum number of rules needed to test the features above.
2018-01-24 18:26:33 +00:00
Refactor instruction folders (#2815) * Refactor instruction folders We want to refactor the instruction folder to allow different sets of rules to be added to the instruction folder. We might want different sets of rules in different circumstances. We also need a way to add rules for extended instructions. Changes are made to the FoldingRules class and ConstFoldingRules class to enable that. We added tests to check that we can fold extended instructions using the new framework. At the same time, I noticed that there were two tests that did not tests what they were suppose to. They could not be easily salvaged. #2813 was opened to track adding the new tests.
2019-08-26 22:54:11 +00:00
for (const FoldingRule& rule :
GetFoldingRules().GetRulesForInstruction(inst)) {
Pass the IRContext into the folding rules. (#1709) This CL updates the folding rules to receive the IRContext as a paramter instead of retrieving off of the Instruction. Issue #1703
2018-07-12 13:12:23 +00:00
if (rule(context_, inst, constants)) {
Add general folding infrastructure. Create the folding engine that will 1) attempt to fold an instruction. 2) iterates on the folding so small folding rules can be easily combined. 3) insert new instructions when needed. I've added the minimum number of rules needed to test the features above.
2018-01-24 18:26:33 +00:00
return true;
}
}
return false;
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
// Returns the result of performing an operation on scalar constant operands.
// This function extracts the operand values as 32 bit words and returns the
// result in 32 bit word. Scalar constants with longer than 32-bit width are
// not accepted in this function.
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
uint32_t InstructionFolder::FoldScalars(
SpvOp opcode,
const std::vector<const analysis::Constant*>& operands) const {
Fix https://github.com/KhronosGroup/SPIRV-Tools/issues/1130 This addresses review feedback for the CCP implementation (which fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/889). This adds more protection around the folding of instructions that would not be supported by the folder.
2017-12-22 17:38:02 +00:00
assert(IsFoldableOpcode(opcode) &&
"Unhandled instruction opcode in FoldScalars");
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
std::vector<uint32_t> operand_values_in_raw_words;
Implement SSA CCP (SSA Conditional Constant Propagation). This implements the conditional constant propagation pass proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The main logic resides in CCPPass::VisitInstruction. Instruction that may produce a constant value are evaluated with the constant folder. If they produce a new constant, the instruction is considered interesting. Otherwise, it's considered varying (for unfoldable instructions) or just not interesting (when not enough operands have a constant value). The other main piece of logic is in CCPPass::VisitBranch. This evaluates the selector of the branch. When it's found to be a known value, it computes the destination basic block and sets it. This tells the propagator which branches to follow. The patch required extensions to the constant manager as well. Instead of hashing the Constant pointers, this patch changes the constant pool to hash the contents of the Constant. This allows the lookups to be done using the actual values of the Constant, preventing duplicate definitions.
2017-12-05 16:39:25 +00:00
for (const auto& operand : operands) {
if (const analysis::ScalarConstant* scalar = operand->AsScalarConstant()) {
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
const auto& scalar_words = scalar->words();
assert(scalar_words.size() == 1 &&
"Scalar constants with longer than 32-bit width are not allowed "
"in FoldScalars()");
operand_values_in_raw_words.push_back(scalar_words.front());
} else if (operand->AsNullConstant()) {
operand_values_in_raw_words.push_back(0u);
} else {
assert(false &&
"FoldScalars() only accepts ScalarConst or NullConst type of "
"constant");
}
}
return OperateWords(opcode, operand_values_in_raw_words);
}
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
bool InstructionFolder::FoldBinaryIntegerOpToConstant(
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, const std::function<uint32_t(uint32_t)>& id_map,
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
uint32_t* result) const {
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
SpvOp opcode = inst->opcode();
Pass the IRContext into the folding rules. (#1709) This CL updates the folding rules to receive the IRContext as a paramter instead of retrieving off of the Instruction. Issue #1703
2018-07-12 13:12:23 +00:00
analysis::ConstantManager* const_manger = context_->get_constant_mgr();
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
uint32_t ids[2];
const analysis::IntConstant* constants[2];
for (uint32_t i = 0; i < 2; 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
const Operand* operand = &inst->GetInOperand(i);
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
if (operand->type != SPV_OPERAND_TYPE_ID) {
return false;
}
Use id_map in Fold*ToConstant The folding routines are suppose to use the id_map provided to map the ids in the instruction. The ones I just added are missing it.
2018-01-22 19:48:43 +00:00
ids[i] = id_map(operand->words[0]);
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
const analysis::Constant* constant =
const_manger->FindDeclaredConstant(ids[i]);
constants[i] = (constant != nullptr ? constant->AsIntConstant() : nullptr);
}
switch (opcode) {
// Arthimetics
case SpvOp::SpvOpIMul:
for (uint32_t i = 0; i < 2; i++) {
if (constants[i] != nullptr && constants[i]->IsZero()) {
*result = 0;
return true;
}
}
break;
case SpvOp::SpvOpUDiv:
case SpvOp::SpvOpSDiv:
case SpvOp::SpvOpSRem:
case SpvOp::SpvOpSMod:
case SpvOp::SpvOpUMod:
// This changes undefined behaviour (ie divide by 0) into a 0.
for (uint32_t i = 0; i < 2; i++) {
if (constants[i] != nullptr && constants[i]->IsZero()) {
*result = 0;
return true;
}
}
break;
// Shifting
case SpvOp::SpvOpShiftRightLogical:
case SpvOp::SpvOpShiftLeftLogical:
if (constants[1] != nullptr) {
// When shifting by a value larger than the size of the result, the
// result is undefined. We are setting the undefined behaviour to a
Fix up bit shifts by 32. (#2292) In C++, a bit shift of the same size as the type is undefined, but it is defined in spir-v. When folding those cases, we have to be careful. We cannot simply do the shift in C++. Fixes https://crbug.com/917697.
2019-01-16 20:52:23 +00:00
// result of 0. If the shift amount is the same as the size of the
// result, then the result is defined, and it 0.
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
uint32_t shift_amount = constants[1]->GetU32BitValue();
if (shift_amount >= 32) {
*result = 0;
return true;
}
}
break;
// Bitwise operations
case SpvOp::SpvOpBitwiseOr:
for (uint32_t i = 0; i < 2; i++) {
if (constants[i] != nullptr) {
// TODO: Change the mask against a value based on the bit width of the
// instruction result type. This way we can handle say 16-bit values
// as well.
uint32_t mask = constants[i]->GetU32BitValue();
if (mask == 0xFFFFFFFF) {
*result = 0xFFFFFFFF;
return true;
}
}
}
break;
case SpvOp::SpvOpBitwiseAnd:
for (uint32_t i = 0; i < 2; i++) {
if (constants[i] != nullptr) {
if (constants[i]->IsZero()) {
*result = 0;
return true;
}
}
}
break;
// Comparison
case SpvOp::SpvOpULessThan:
if (constants[0] != nullptr &&
constants[0]->GetU32BitValue() == UINT32_MAX) {
*result = false;
return true;
}
if (constants[1] != nullptr && constants[1]->GetU32BitValue() == 0) {
*result = false;
return true;
}
break;
case SpvOp::SpvOpSLessThan:
if (constants[0] != nullptr &&
constants[0]->GetS32BitValue() == INT32_MAX) {
*result = false;
return true;
}
if (constants[1] != nullptr &&
constants[1]->GetS32BitValue() == INT32_MIN) {
*result = false;
return true;
}
break;
case SpvOp::SpvOpUGreaterThan:
if (constants[0] != nullptr && constants[0]->IsZero()) {
*result = false;
return true;
}
if (constants[1] != nullptr &&
constants[1]->GetU32BitValue() == UINT32_MAX) {
*result = false;
return true;
}
break;
case SpvOp::SpvOpSGreaterThan:
if (constants[0] != nullptr &&
constants[0]->GetS32BitValue() == INT32_MIN) {
*result = false;
return true;
}
if (constants[1] != nullptr &&
constants[1]->GetS32BitValue() == INT32_MAX) {
*result = false;
return true;
}
break;
case SpvOp::SpvOpULessThanEqual:
if (constants[0] != nullptr && constants[0]->IsZero()) {
*result = true;
return true;
}
if (constants[1] != nullptr &&
constants[1]->GetU32BitValue() == UINT32_MAX) {
*result = true;
return true;
}
break;
case SpvOp::SpvOpSLessThanEqual:
if (constants[0] != nullptr &&
constants[0]->GetS32BitValue() == INT32_MIN) {
*result = true;
return true;
}
if (constants[1] != nullptr &&
constants[1]->GetS32BitValue() == INT32_MAX) {
*result = true;
return true;
}
break;
case SpvOp::SpvOpUGreaterThanEqual:
if (constants[0] != nullptr &&
constants[0]->GetU32BitValue() == UINT32_MAX) {
*result = true;
return true;
}
if (constants[1] != nullptr && constants[1]->GetU32BitValue() == 0) {
*result = true;
return true;
}
break;
case SpvOp::SpvOpSGreaterThanEqual:
if (constants[0] != nullptr &&
constants[0]->GetS32BitValue() == INT32_MAX) {
*result = true;
return true;
}
if (constants[1] != nullptr &&
constants[1]->GetS32BitValue() == INT32_MIN) {
*result = true;
return true;
}
break;
default:
break;
}
return false;
}
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
bool InstructionFolder::FoldBinaryBooleanOpToConstant(
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, const std::function<uint32_t(uint32_t)>& id_map,
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
uint32_t* result) const {
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
SpvOp opcode = inst->opcode();
Pass the IRContext into the folding rules. (#1709) This CL updates the folding rules to receive the IRContext as a paramter instead of retrieving off of the Instruction. Issue #1703
2018-07-12 13:12:23 +00:00
analysis::ConstantManager* const_manger = context_->get_constant_mgr();
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
uint32_t ids[2];
const analysis::BoolConstant* constants[2];
for (uint32_t i = 0; i < 2; 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
const Operand* operand = &inst->GetInOperand(i);
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
if (operand->type != SPV_OPERAND_TYPE_ID) {
return false;
}
Use id_map in Fold*ToConstant The folding routines are suppose to use the id_map provided to map the ids in the instruction. The ones I just added are missing it.
2018-01-22 19:48:43 +00:00
ids[i] = id_map(operand->words[0]);
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
const analysis::Constant* constant =
const_manger->FindDeclaredConstant(ids[i]);
constants[i] = (constant != nullptr ? constant->AsBoolConstant() : nullptr);
}
switch (opcode) {
Merge arithmetic with non-trivial constant operands Adding basis of arithmetic merging * Refactored constant collection in ConstantManager * New rules: * consecutive negates * negate of arithmetic op with a constant * consecutive muls * reciprocal of div * Removed IRContext::CanFoldFloatingPoint * replaced by Instruction::IsFloatingPointFoldingAllowed * Fixed some bad tests * added some header comments Added PerformIntegerOperation * minor fixes to constants and tests * fixed IntMultiplyBy1 to work with 64 bit ints * added tests for integer mul merging Adding test for vector integer multiply merging Adding support for merging integer add and sub through negate * Added tests Adding rules to merge mult with preceding divide * Has a couple tests, but needs more * Added more comments Fixed bug in integer division folding * Will no longer merge through integer division if there would be a remainder in the division * Added a bunch more tests Adding rules to merge divide and multiply through divide * Improved comments * Added tests Adding rules to handle mul or div of a negation * Added tests Changes for review * Early exit if no constants are involved in more functions * fixed some comments * removed unused declaration * clarified some logic Adding new rules for add and subtract * Fold adds of adds, subtracts or negates * Fold subtracts of adds, subtracts or negates * Added tests
2018-02-16 21:07:33 +00:00
// Logical
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
case SpvOp::SpvOpLogicalOr:
for (uint32_t i = 0; i < 2; i++) {
if (constants[i] != nullptr) {
if (constants[i]->value()) {
*result = true;
return true;
}
}
}
break;
case SpvOp::SpvOpLogicalAnd:
for (uint32_t i = 0; i < 2; i++) {
if (constants[i] != nullptr) {
if (!constants[i]->value()) {
*result = false;
return true;
}
}
}
break;
default:
break;
}
return false;
}
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
bool InstructionFolder::FoldIntegerOpToConstant(
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, const std::function<uint32_t(uint32_t)>& id_map,
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
uint32_t* result) const {
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
assert(IsFoldableOpcode(inst->opcode()) &&
"Unhandled instruction opcode in FoldScalars");
switch (inst->NumInOperands()) {
case 2:
Use id_map in Fold*ToConstant The folding routines are suppose to use the id_map provided to map the ids in the instruction. The ones I just added are missing it.
2018-01-22 19:48:43 +00:00
return FoldBinaryIntegerOpToConstant(inst, id_map, result) ||
FoldBinaryBooleanOpToConstant(inst, id_map, result);
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
default:
return false;
}
}
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
std::vector<uint32_t> InstructionFolder::FoldVectors(
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
SpvOp opcode, uint32_t num_dims,
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
const std::vector<const analysis::Constant*>& operands) const {
Fix https://github.com/KhronosGroup/SPIRV-Tools/issues/1130 This addresses review feedback for the CCP implementation (which fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/889). This adds more protection around the folding of instructions that would not be supported by the folder.
2017-12-22 17:38:02 +00:00
assert(IsFoldableOpcode(opcode) &&
"Unhandled instruction opcode in FoldVectors");
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
std::vector<uint32_t> result;
for (uint32_t d = 0; d < num_dims; d++) {
std::vector<uint32_t> operand_values_for_one_dimension;
Implement SSA CCP (SSA Conditional Constant Propagation). This implements the conditional constant propagation pass proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The main logic resides in CCPPass::VisitInstruction. Instruction that may produce a constant value are evaluated with the constant folder. If they produce a new constant, the instruction is considered interesting. Otherwise, it's considered varying (for unfoldable instructions) or just not interesting (when not enough operands have a constant value). The other main piece of logic is in CCPPass::VisitBranch. This evaluates the selector of the branch. When it's found to be a known value, it computes the destination basic block and sets it. This tells the propagator which branches to follow. The patch required extensions to the constant manager as well. Instead of hashing the Constant pointers, this patch changes the constant pool to hash the contents of the Constant. This allows the lookups to be done using the actual values of the Constant, preventing duplicate definitions.
2017-12-05 16:39:25 +00:00
for (const auto& operand : operands) {
if (const analysis::VectorConstant* vector_operand =
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
operand->AsVectorConstant()) {
// Extract the raw value of the scalar component constants
// in 32-bit words here. The reason of not using FoldScalars() here
// is that we do not create temporary null constants as components
// when the vector operand is a NullConstant because Constant creation
Fix various source comment (doxygen) typos (#4680) Found via `codespell -q 3 -L fo,lod,parm
2022-01-26 20:13:08 +00:00
// may need extra checks for the validity and that is not managed in
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
// here.
if (const analysis::ScalarConstant* scalar_component =
vector_operand->GetComponents().at(d)->AsScalarConstant()) {
const auto& scalar_words = scalar_component->words();
assert(
scalar_words.size() == 1 &&
"Vector components with longer than 32-bit width are not allowed "
"in FoldVectors()");
operand_values_for_one_dimension.push_back(scalar_words.front());
} else if (operand->AsNullConstant()) {
operand_values_for_one_dimension.push_back(0u);
} else {
assert(false &&
"VectorConst should only has ScalarConst or NullConst as "
"components");
}
} else if (operand->AsNullConstant()) {
operand_values_for_one_dimension.push_back(0u);
} else {
assert(false &&
"FoldVectors() only accepts VectorConst or NullConst type of "
"constant");
}
}
result.push_back(OperateWords(opcode, operand_values_for_one_dimension));
}
return result;
}
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
bool InstructionFolder::IsFoldableOpcode(SpvOp opcode) const {
Implement SSA CCP (SSA Conditional Constant Propagation). This implements the conditional constant propagation pass proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The main logic resides in CCPPass::VisitInstruction. Instruction that may produce a constant value are evaluated with the constant folder. If they produce a new constant, the instruction is considered interesting. Otherwise, it's considered varying (for unfoldable instructions) or just not interesting (when not enough operands have a constant value). The other main piece of logic is in CCPPass::VisitBranch. This evaluates the selector of the branch. When it's found to be a known value, it computes the destination basic block and sets it. This tells the propagator which branches to follow. The patch required extensions to the constant manager as well. Instead of hashing the Constant pointers, this patch changes the constant pool to hash the contents of the Constant. This allows the lookups to be done using the actual values of the Constant, preventing duplicate definitions.
2017-12-05 16:39:25 +00:00
// NOTE: Extend to more opcodes as new cases are handled in the folder
// functions.
switch (opcode) {
case SpvOp::SpvOpBitwiseAnd:
case SpvOp::SpvOpBitwiseOr:
case SpvOp::SpvOpBitwiseXor:
case SpvOp::SpvOpIAdd:
case SpvOp::SpvOpIEqual:
case SpvOp::SpvOpIMul:
case SpvOp::SpvOpINotEqual:
case SpvOp::SpvOpISub:
case SpvOp::SpvOpLogicalAnd:
case SpvOp::SpvOpLogicalEqual:
case SpvOp::SpvOpLogicalNot:
case SpvOp::SpvOpLogicalNotEqual:
case SpvOp::SpvOpLogicalOr:
case SpvOp::SpvOpNot:
case SpvOp::SpvOpSDiv:
case SpvOp::SpvOpSelect:
case SpvOp::SpvOpSGreaterThan:
case SpvOp::SpvOpSGreaterThanEqual:
case SpvOp::SpvOpShiftLeftLogical:
case SpvOp::SpvOpShiftRightArithmetic:
case SpvOp::SpvOpShiftRightLogical:
case SpvOp::SpvOpSLessThan:
case SpvOp::SpvOpSLessThanEqual:
case SpvOp::SpvOpSMod:
case SpvOp::SpvOpSNegate:
case SpvOp::SpvOpSRem:
Support constant-folding UConvert and SConvert (#2960)
2019-10-16 20:29:55 +00:00
case SpvOp::SpvOpSConvert:
case SpvOp::SpvOpUConvert:
Implement SSA CCP (SSA Conditional Constant Propagation). This implements the conditional constant propagation pass proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The main logic resides in CCPPass::VisitInstruction. Instruction that may produce a constant value are evaluated with the constant folder. If they produce a new constant, the instruction is considered interesting. Otherwise, it's considered varying (for unfoldable instructions) or just not interesting (when not enough operands have a constant value). The other main piece of logic is in CCPPass::VisitBranch. This evaluates the selector of the branch. When it's found to be a known value, it computes the destination basic block and sets it. This tells the propagator which branches to follow. The patch required extensions to the constant manager as well. Instead of hashing the Constant pointers, this patch changes the constant pool to hash the contents of the Constant. This allows the lookups to be done using the actual values of the Constant, preventing duplicate definitions.
2017-12-05 16:39:25 +00:00
case SpvOp::SpvOpUDiv:
case SpvOp::SpvOpUGreaterThan:
case SpvOp::SpvOpUGreaterThanEqual:
case SpvOp::SpvOpULessThan:
case SpvOp::SpvOpULessThanEqual:
case SpvOp::SpvOpUMod:
return true;
default:
return false;
}
}
Move folding routines into a class The folding routines are currently global functions. They also rely on data in an std::map that holds the folding rules for each opcode. This causes that map to not have a clear owner, and therefore never gets deleted. There has been a request to delete this map. To implement this, we will create a InstructionFolder class that owns the maps. The IRContext will own the InstructionFolder instance. Then the global functions will become public memeber functions of the InstructionFolder. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/1659.
2018-07-05 18:19:50 +00:00
bool InstructionFolder::IsFoldableConstant(
const analysis::Constant* cst) const {
Fix https://github.com/KhronosGroup/SPIRV-Tools/issues/1130 This addresses review feedback for the CCP implementation (which fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/889). This adds more protection around the folding of instructions that would not be supported by the folder.
2017-12-22 17:38:02 +00:00
// Currently supported constants are 32-bit values or null constants.
if (const analysis::ScalarConstant* scalar = cst->AsScalarConstant())
return scalar->words().size() == 1;
else
return cst->AsNullConstant() != nullptr;
}
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* InstructionFolder::FoldInstructionToConstant(
Instruction* inst, std::function<uint32_t(uint32_t)> id_map) const {
Pass the IRContext into the folding rules. (#1709) This CL updates the folding rules to receive the IRContext as a paramter instead of retrieving off of the Instruction. Issue #1703
2018-07-12 13:12:23 +00:00
analysis::ConstantManager* const_mgr = context_->get_constant_mgr();
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
Get CCP to use the constant floating point rules. Fixes #1311
2018-02-15 15:41:01 +00:00
if (!inst->IsFoldableByFoldScalar() &&
Refactor instruction folders (#2815) * Refactor instruction folders We want to refactor the instruction folder to allow different sets of rules to be added to the instruction folder. We might want different sets of rules in different circumstances. We also need a way to add rules for extended instructions. Changes are made to the FoldingRules class and ConstFoldingRules class to enable that. We added tests to check that we can fold extended instructions using the new framework. At the same time, I noticed that there were two tests that did not tests what they were suppose to. They could not be easily salvaged. #2813 was opened to track adding the new tests.
2019-08-26 22:54:11 +00:00
!GetConstantFoldingRules().HasFoldingRule(inst)) {
Fold binary floating point operators. Adds the floating rules for FAdd, FDiv, FMul, and FSub. Contributes to #1164.
2018-02-09 18:37:26 +00:00
return nullptr;
}
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
// Collect the values of the constant parameters.
std::vector<const analysis::Constant*> constants;
bool missing_constants = false;
inst->ForEachInId([&constants, &missing_constants, const_mgr,
&id_map](uint32_t* op_id) {
uint32_t id = id_map(*op_id);
const analysis::Constant* const_op = const_mgr->FindDeclaredConstant(id);
Add folding of OpCompositeExtract and OpConstantComposite constant instructions. Create files for constant folding rules. Add the rules for OpConstantComposite and OpCompositeExtract.
2018-02-08 15:59:03 +00:00
if (!const_op) {
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
constants.push_back(nullptr);
missing_constants = true;
Fold binary floating point operators. Adds the floating rules for FAdd, FDiv, FMul, and FSub. Contributes to #1164.
2018-02-09 18:37:26 +00:00
} else {
constants.push_back(const_op);
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
}
});
Refactor instruction folders (#2815) * Refactor instruction folders We want to refactor the instruction folder to allow different sets of rules to be added to the instruction folder. We might want different sets of rules in different circumstances. We also need a way to add rules for extended instructions. Changes are made to the FoldingRules class and ConstFoldingRules class to enable that. We added tests to check that we can fold extended instructions using the new framework. At the same time, I noticed that there were two tests that did not tests what they were suppose to. They could not be easily salvaged. #2813 was opened to track adding the new tests.
2019-08-26 22:54:11 +00:00
const analysis::Constant* folded_const = nullptr;
for (auto rule : GetConstantFoldingRules().GetRulesForInstruction(inst)) {
folded_const = rule(context_, inst, constants);
if (folded_const != nullptr) {
Instruction* const_inst =
const_mgr->GetDefiningInstruction(folded_const, inst->type_id());
Handle id overflow in the constant manager. (#2844) Fixes crbug.com/997246
2019-09-09 19:12:26 +00:00
if (const_inst == nullptr) {
return nullptr;
}
Refactor instruction folders (#2815) * Refactor instruction folders We want to refactor the instruction folder to allow different sets of rules to be added to the instruction folder. We might want different sets of rules in different circumstances. We also need a way to add rules for extended instructions. Changes are made to the FoldingRules class and ConstFoldingRules class to enable that. We added tests to check that we can fold extended instructions using the new framework. At the same time, I noticed that there were two tests that did not tests what they were suppose to. They could not be easily salvaged. #2813 was opened to track adding the new tests.
2019-08-26 22:54:11 +00:00
assert(const_inst->type_id() == inst->type_id());
// May be a new instruction that needs to be analysed.
context_->UpdateDefUse(const_inst);
return const_inst;
Add folding of OpCompositeExtract and OpConstantComposite constant instructions. Create files for constant folding rules. Add the rules for OpConstantComposite and OpCompositeExtract.
2018-02-08 15:59:03 +00:00
}
}
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
uint32_t result_val = 0;
bool successful = false;
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
// If all parameters are constant, fold the instruction to a constant.
Get CCP to use the constant floating point rules. Fixes #1311
2018-02-15 15:41:01 +00:00
if (!missing_constants && inst->IsFoldableByFoldScalar()) {
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
result_val = FoldScalars(inst->opcode(), constants);
successful = true;
}
Get CCP to use the constant floating point rules. Fixes #1311
2018-02-15 15:41:01 +00:00
if (!successful && inst->IsFoldableByFoldScalar()) {
Use id_map in Fold*ToConstant The folding routines are suppose to use the id_map provided to map the ids in the instruction. The ones I just added are missing it.
2018-01-22 19:48:43 +00:00
successful = FoldIntegerOpToConstant(inst, id_map, &result_val);
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +00:00
}
if (successful) {
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
const analysis::Constant* result_const =
const_mgr->GetConstant(const_mgr->GetType(inst), {result_val});
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* folded_inst =
Make sure the constant folder get the correct type. There are a few locations where we need to handle duplicate types. We cannot merge them because they may be needed for reflection. When this happens we need do some extra lookups in the type manager. The specific fixes are: 1) When generating a constant through `GetDefiningInstruction` accept and use an id for the desired type of the constant. This will make sure you get the type that is needed. 2) In Private-to-local, make sure we to update the def-use chains when a new pointer type is created. 3) In the type manager, make sure that `FindPointerToType` returns a pointer that points to the given type and not a duplicate type. 4) In scalar replacment, make sure the null constants that are created are the correct type.
2018-07-04 17:17:30 +00:00
const_mgr->GetDefiningInstruction(result_const, inst->type_id());
return folded_inst;
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
}
return nullptr;
}
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 InstructionFolder::IsFoldableType(Instruction* type_inst) const {
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
// Support 32-bit integers.
if (type_inst->opcode() == SpvOpTypeInt) {
return type_inst->GetSingleWordInOperand(0) == 32;
}
// Support booleans.
if (type_inst->opcode() == SpvOpTypeBool) {
return true;
}
// Nothing else yet.
return false;
}
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before. It seems like andriod has a problem with INT32_MAX and the like. I'll explicitly define those if the are not already defined.
2018-01-09 17:45:46 +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 InstructionFolder::FoldInstruction(Instruction* inst) const {
Add general folding infrastructure. Create the folding engine that will 1) attempt to fold an instruction. 2) iterates on the folding so small folding rules can be easily combined. 3) insert new instructions when needed. I've added the minimum number of rules needed to test the features above.
2018-01-24 18:26:33 +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
Instruction* folded_inst(inst);
Fold binary floating point operators. Adds the floating rules for FAdd, FDiv, FMul, and FSub. Contributes to #1164.
2018-02-09 18:37:26 +00:00
while (folded_inst->opcode() != SpvOpCopyObject &&
FoldInstructionInternal(&*folded_inst)) {
Add general folding infrastructure. Create the folding engine that will 1) attempt to fold an instruction. 2) iterates on the folding so small folding rules can be easily combined. 3) insert new instructions when needed. I've added the minimum number of rules needed to test the features above.
2018-01-24 18:26:33 +00:00
modified = true;
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
}
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
return modified;
Add generic folding function and use in CCP The current folding routines have a very cumbersome interface, make them harder to use, and not a obvious how to extend. This change is to create a new interface for the folding routines, and show how it can be used by calling it from CCP. This does not make a significant change to the behaviour of CCP. In general it should produce the same code as before; however it is possible that an instruction that takes 32-bit integers as inputs and the result is not a 32-bit integer or bool will not be folded as before.
2018-01-09 17:45:46 +00:00
}
Re-factor generic constant folding code out of FoldSpecConstantOpAndCompositePass There are no functional changes in this patch. The generic folding routines in FoldSpecConstantOpAndCompositePass are now inside opt/fold.{cpp,h}. This code will be used by the upcoming constant propagation pass. In time, we'll add more expression folding and simplification into these two files.
2017-10-17 23:41:37 +00:00
} // namespace opt
} // namespace spvtools
Reference in New Issue Copy Permalink