2018-02-08 15:59:03 +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.
|
|
|
|
|
|
|
|
#include "const_folding_rules.h"
|
|
|
|
|
|
|
|
namespace spvtools {
|
|
|
|
namespace opt {
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
const uint32_t kExtractCompositeIdInIdx = 0;
|
|
|
|
|
2018-02-09 18:37:26 +00:00
|
|
|
// Returns a vector that contains the two 32-bit integers that result from
|
|
|
|
// splitting |a| in two. The first entry in vector are the low order bit if
|
|
|
|
// |a|.
|
|
|
|
inline std::vector<uint32_t> ExtractInts(uint64_t a) {
|
|
|
|
std::vector<uint32_t> result;
|
|
|
|
result.push_back(static_cast<uint32_t>(a));
|
|
|
|
result.push_back(static_cast<uint32_t>(a >> 32));
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Folds an OpcompositeExtract where input is a composite constant.
|
2018-02-08 15:59:03 +00:00
|
|
|
ConstantFoldingRule FoldExtractWithConstants() {
|
|
|
|
return [](ir::Instruction* inst,
|
|
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
|
|
-> const analysis::Constant* {
|
|
|
|
const analysis::Constant* c = constants[kExtractCompositeIdInIdx];
|
|
|
|
if (c == nullptr) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (uint32_t i = 1; i < inst->NumInOperands(); ++i) {
|
|
|
|
uint32_t element_index = inst->GetSingleWordInOperand(i);
|
|
|
|
if (c->AsNullConstant()) {
|
|
|
|
// Return Null for the return type.
|
|
|
|
ir::IRContext* context = inst->context();
|
|
|
|
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
|
|
|
|
analysis::TypeManager* type_mgr = context->get_type_mgr();
|
2018-02-09 18:37:26 +00:00
|
|
|
return const_mgr->GetConstant(type_mgr->GetType(inst->type_id()), {});
|
2018-02-08 15:59:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
auto cc = c->AsCompositeConstant();
|
|
|
|
assert(cc != nullptr);
|
|
|
|
auto components = cc->GetComponents();
|
|
|
|
c = components[element_index];
|
|
|
|
}
|
|
|
|
return c;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
ConstantFoldingRule FoldCompositeWithConstants() {
|
|
|
|
// Folds an OpCompositeConstruct where all of the inputs are constants to a
|
|
|
|
// constant. A new constant is created if necessary.
|
|
|
|
return [](ir::Instruction* inst,
|
|
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
|
|
-> const analysis::Constant* {
|
|
|
|
ir::IRContext* context = inst->context();
|
|
|
|
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
|
|
|
|
analysis::TypeManager* type_mgr = context->get_type_mgr();
|
|
|
|
const analysis::Type* new_type = type_mgr->GetType(inst->type_id());
|
|
|
|
|
|
|
|
std::vector<uint32_t> ids;
|
|
|
|
for (const analysis::Constant* element_const : constants) {
|
|
|
|
if (element_const == nullptr) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
uint32_t element_id = const_mgr->FindDeclaredConstant(element_const);
|
|
|
|
if (element_id == 0) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
ids.push_back(element_id);
|
|
|
|
}
|
|
|
|
return const_mgr->GetConstant(new_type, ids);
|
|
|
|
};
|
|
|
|
}
|
2018-02-09 18:37:26 +00:00
|
|
|
|
|
|
|
// The interface for a function that returns the result of applying a scalar
|
|
|
|
// floating-point binary operation on |a| and |b|. The type of the return value
|
|
|
|
// will be |type|. The input constants must also be of type |type|.
|
2018-02-15 06:13:25 +00:00
|
|
|
using FloatScalarFoldingRule = std::function<const analysis::Constant*(
|
|
|
|
const analysis::Type* result_type, const analysis::Constant* a,
|
2018-02-09 18:37:26 +00:00
|
|
|
const analysis::Constant* b, analysis::ConstantManager*)>;
|
|
|
|
|
|
|
|
// Returns an std::vector containing the elements of |constant|. The type of
|
|
|
|
// |constant| must be |Vector|.
|
|
|
|
std::vector<const analysis::Constant*> GetVectorComponents(
|
|
|
|
const analysis::Constant* constant, analysis::ConstantManager* const_mgr) {
|
|
|
|
std::vector<const analysis::Constant*> components;
|
|
|
|
const analysis::VectorConstant* a = constant->AsVectorConstant();
|
|
|
|
const analysis::Vector* vector_type = constant->type()->AsVector();
|
|
|
|
assert(vector_type != nullptr);
|
|
|
|
if (a != nullptr) {
|
|
|
|
for (uint32_t i = 0; i < vector_type->element_count(); ++i) {
|
|
|
|
components.push_back(a->GetComponents()[i]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const analysis::Type* element_type = vector_type->element_type();
|
|
|
|
const analysis::Constant* element_null_const =
|
|
|
|
const_mgr->GetConstant(element_type, {});
|
|
|
|
for (uint32_t i = 0; i < vector_type->element_count(); ++i) {
|
|
|
|
components.push_back(element_null_const);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return components;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns a |ConstantFoldingRule| that folds floating point scalars using
|
|
|
|
// |scalar_rule| and vectors of floating point by applying |scalar_rule| to the
|
|
|
|
// elements of the vector. The |ConstantFoldingRule| that is returned assumes
|
|
|
|
// that |constants| contains 2 entries. If they are not |nullptr|, then their
|
|
|
|
// type is either |Float| or a |Vector| whose element type is |Float|.
|
|
|
|
ConstantFoldingRule FoldFloatingPointOp(FloatScalarFoldingRule scalar_rule) {
|
|
|
|
return [scalar_rule](ir::Instruction* inst,
|
|
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
|
|
-> const analysis::Constant* {
|
|
|
|
ir::IRContext* context = inst->context();
|
|
|
|
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
|
|
|
|
analysis::TypeManager* type_mgr = context->get_type_mgr();
|
|
|
|
const analysis::Type* result_type = type_mgr->GetType(inst->type_id());
|
|
|
|
const analysis::Vector* vector_type = result_type->AsVector();
|
|
|
|
|
2018-02-17 19:55:54 +00:00
|
|
|
if (!inst->IsFloatingPointFoldingAllowed()) {
|
2018-02-09 18:37:26 +00:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (constants[0] == nullptr || constants[1] == nullptr) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vector_type != nullptr) {
|
2018-02-15 06:13:25 +00:00
|
|
|
std::vector<const analysis::Constant*> a_components;
|
|
|
|
std::vector<const analysis::Constant*> b_components;
|
|
|
|
std::vector<const analysis::Constant*> results_components;
|
2018-02-09 18:37:26 +00:00
|
|
|
|
2018-02-15 06:13:25 +00:00
|
|
|
a_components = GetVectorComponents(constants[0], const_mgr);
|
|
|
|
b_components = GetVectorComponents(constants[1], const_mgr);
|
2018-02-09 18:37:26 +00:00
|
|
|
|
|
|
|
// Fold each component of the vector.
|
2018-02-15 06:13:25 +00:00
|
|
|
for (uint32_t i = 0; i < a_components.size(); ++i) {
|
|
|
|
results_components.push_back(scalar_rule(vector_type->element_type(),
|
|
|
|
a_components[i],
|
|
|
|
b_components[i], const_mgr));
|
|
|
|
if (results_components[i] == nullptr) {
|
2018-02-09 18:37:26 +00:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build the constant object and return it.
|
|
|
|
std::vector<uint32_t> ids;
|
2018-02-15 06:13:25 +00:00
|
|
|
for (const analysis::Constant* member : results_components) {
|
2018-02-09 18:37:26 +00:00
|
|
|
ids.push_back(const_mgr->GetDefiningInstruction(member)->result_id());
|
|
|
|
}
|
|
|
|
return const_mgr->GetConstant(vector_type, ids);
|
|
|
|
} else {
|
2018-02-15 06:13:25 +00:00
|
|
|
return scalar_rule(result_type, constants[0], constants[1], const_mgr);
|
2018-02-09 18:37:26 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the floating point value of |c|. The constant |c| must have type
|
|
|
|
// |Float|, and width |32|.
|
|
|
|
float GetFloatFromConst(const analysis::Constant* c) {
|
|
|
|
assert(c->type()->AsFloat() != nullptr &&
|
|
|
|
c->type()->AsFloat()->width() == 32);
|
|
|
|
const analysis::FloatConstant* fc = c->AsFloatConstant();
|
|
|
|
if (fc) {
|
|
|
|
return fc->GetFloatValue();
|
|
|
|
} else {
|
|
|
|
assert(c->AsNullConstant() && "c must be a float point constant.");
|
|
|
|
return 0.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the double value of |c|. The constant |c| must have type
|
|
|
|
// |Float|, and width |64|.
|
|
|
|
double GetDoubleFromConst(const analysis::Constant* c) {
|
|
|
|
assert(c->type()->AsFloat() != nullptr &&
|
|
|
|
c->type()->AsFloat()->width() == 64);
|
|
|
|
const analysis::FloatConstant* fc = c->AsFloatConstant();
|
|
|
|
if (fc) {
|
|
|
|
return fc->GetDoubleValue();
|
|
|
|
} else {
|
|
|
|
assert(c->AsNullConstant() && "c must be a float point constant.");
|
|
|
|
return 0.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// This macro defines a |FloatScalarFoldingRule| that applies |op|. The
|
|
|
|
// operator |op| must work for both float and double, and use syntax "f1 op f2".
|
2018-02-15 06:13:25 +00:00
|
|
|
#define FOLD_FPARITH_OP(op) \
|
|
|
|
[](const analysis::Type* result_type, const analysis::Constant* a, \
|
|
|
|
const analysis::Constant* b, \
|
|
|
|
analysis::ConstantManager* const_mgr) -> const analysis::Constant* { \
|
|
|
|
assert(result_type != nullptr && a != nullptr && b != nullptr); \
|
|
|
|
assert(result_type == a->type() && result_type == b->type()); \
|
|
|
|
const analysis::Float* float_type = result_type->AsFloat(); \
|
|
|
|
assert(float_type != nullptr); \
|
|
|
|
if (float_type->width() == 32) { \
|
|
|
|
float fa = GetFloatFromConst(a); \
|
|
|
|
float fb = GetFloatFromConst(b); \
|
|
|
|
spvutils::FloatProxy<float> result(fa op fb); \
|
|
|
|
std::vector<uint32_t> words = {result.data()}; \
|
|
|
|
return const_mgr->GetConstant(result_type, words); \
|
|
|
|
} else if (float_type->width() == 64) { \
|
|
|
|
double fa = GetDoubleFromConst(a); \
|
|
|
|
double fb = GetDoubleFromConst(b); \
|
|
|
|
spvutils::FloatProxy<double> result(fa op fb); \
|
|
|
|
std::vector<uint32_t> words(ExtractInts(result.data())); \
|
|
|
|
return const_mgr->GetConstant(result_type, words); \
|
|
|
|
} \
|
|
|
|
return nullptr; \
|
2018-02-09 18:37:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Define the folding rules for subtraction, addition, multiplication, and
|
|
|
|
// division for floating point values.
|
2018-02-15 06:13:25 +00:00
|
|
|
ConstantFoldingRule FoldFSub() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPARITH_OP(-));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFAdd() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPARITH_OP(+));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFMul() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPARITH_OP(*));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFDiv() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPARITH_OP(/));
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CompareFloatingPoint(bool op_result, bool op_unordered,
|
|
|
|
bool need_ordered) {
|
|
|
|
if (need_ordered) {
|
|
|
|
// operands are ordered and Operand 1 is |op| Operand 2
|
|
|
|
return !op_unordered && op_result;
|
|
|
|
} else {
|
|
|
|
// operands are unordered or Operand 1 is |op| Operand 2
|
|
|
|
return op_unordered || op_result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// This macro defines a |FloatScalarFoldingRule| that applies |op|. The
|
|
|
|
// operator |op| must work for both float and double, and use syntax "f1 op f2".
|
|
|
|
#define FOLD_FPCMP_OP(op, ord) \
|
|
|
|
[](const analysis::Type* result_type, const analysis::Constant* a, \
|
|
|
|
const analysis::Constant* b, \
|
|
|
|
analysis::ConstantManager* const_mgr) -> const analysis::Constant* { \
|
|
|
|
assert(result_type != nullptr && a != nullptr && b != nullptr); \
|
|
|
|
assert(result_type->AsBool()); \
|
|
|
|
assert(a->type() == b->type()); \
|
|
|
|
const analysis::Float* float_type = a->type()->AsFloat(); \
|
|
|
|
assert(float_type != nullptr); \
|
|
|
|
if (float_type->width() == 32) { \
|
|
|
|
float fa = GetFloatFromConst(a); \
|
|
|
|
float fb = GetFloatFromConst(b); \
|
|
|
|
bool result = CompareFloatingPoint( \
|
|
|
|
fa op fb, std::isnan(fa) || std::isnan(fb), ord); \
|
|
|
|
std::vector<uint32_t> words = {uint32_t(result)}; \
|
|
|
|
return const_mgr->GetConstant(result_type, words); \
|
|
|
|
} else if (float_type->width() == 64) { \
|
|
|
|
double fa = GetDoubleFromConst(a); \
|
|
|
|
double fb = GetDoubleFromConst(b); \
|
|
|
|
bool result = CompareFloatingPoint( \
|
|
|
|
fa op fb, std::isnan(fa) || std::isnan(fb), ord); \
|
|
|
|
std::vector<uint32_t> words = {uint32_t(result)}; \
|
|
|
|
return const_mgr->GetConstant(result_type, words); \
|
|
|
|
} \
|
|
|
|
return nullptr; \
|
|
|
|
}
|
|
|
|
|
|
|
|
// Define the folding rules for ordered and unordered comparison for floating
|
|
|
|
// point values.
|
|
|
|
ConstantFoldingRule FoldFOrdEqual() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(==, true));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFUnordEqual() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(==, false));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFOrdNotEqual() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(!=, true));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFUnordNotEqual() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(!=, false));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFOrdLessThan() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(<, true));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFUnordLessThan() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(<, false));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFOrdGreaterThan() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(>, true));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFUnordGreaterThan() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(>, false));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFOrdLessThanEqual() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(<=, true));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFUnordLessThanEqual() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(<=, false));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFOrdGreaterThanEqual() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(>=, true));
|
|
|
|
}
|
|
|
|
ConstantFoldingRule FoldFUnordGreaterThanEqual() {
|
|
|
|
return FoldFloatingPointOp(FOLD_FPCMP_OP(>=, false));
|
|
|
|
}
|
2018-02-08 15:59:03 +00:00
|
|
|
} // namespace
|
|
|
|
|
|
|
|
spvtools::opt::ConstantFoldingRules::ConstantFoldingRules() {
|
|
|
|
// Add all folding rules to the list for the opcodes to which they apply.
|
|
|
|
// Note that the order in which rules are added to the list matters. If a rule
|
|
|
|
// applies to the instruction, the rest of the rules will not be attempted.
|
|
|
|
// Take that into consideration.
|
|
|
|
|
|
|
|
rules_[SpvOpCompositeConstruct].push_back(FoldCompositeWithConstants());
|
2018-02-09 18:37:26 +00:00
|
|
|
|
2018-02-08 15:59:03 +00:00
|
|
|
rules_[SpvOpCompositeExtract].push_back(FoldExtractWithConstants());
|
2018-02-09 18:37:26 +00:00
|
|
|
|
|
|
|
rules_[SpvOpFAdd].push_back(FoldFAdd());
|
|
|
|
rules_[SpvOpFDiv].push_back(FoldFDiv());
|
|
|
|
rules_[SpvOpFMul].push_back(FoldFMul());
|
|
|
|
rules_[SpvOpFSub].push_back(FoldFSub());
|
2018-02-15 06:13:25 +00:00
|
|
|
|
|
|
|
rules_[SpvOpFOrdEqual].push_back(FoldFOrdEqual());
|
|
|
|
rules_[SpvOpFUnordEqual].push_back(FoldFUnordEqual());
|
|
|
|
rules_[SpvOpFOrdNotEqual].push_back(FoldFOrdNotEqual());
|
|
|
|
rules_[SpvOpFUnordNotEqual].push_back(FoldFUnordNotEqual());
|
|
|
|
rules_[SpvOpFOrdLessThan].push_back(FoldFOrdLessThan());
|
|
|
|
rules_[SpvOpFUnordLessThan].push_back(FoldFUnordLessThan());
|
|
|
|
rules_[SpvOpFOrdGreaterThan].push_back(FoldFOrdGreaterThan());
|
|
|
|
rules_[SpvOpFUnordGreaterThan].push_back(FoldFUnordGreaterThan());
|
|
|
|
rules_[SpvOpFOrdLessThanEqual].push_back(FoldFOrdLessThanEqual());
|
|
|
|
rules_[SpvOpFUnordLessThanEqual].push_back(FoldFUnordLessThanEqual());
|
|
|
|
rules_[SpvOpFOrdGreaterThanEqual].push_back(FoldFOrdGreaterThanEqual());
|
|
|
|
rules_[SpvOpFUnordGreaterThanEqual].push_back(FoldFUnordGreaterThanEqual());
|
2018-02-08 15:59:03 +00:00
|
|
|
}
|
|
|
|
} // namespace opt
|
|
|
|
} // namespace spvtools
|