mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-12-27 02:10:15 +00:00
0265a9d4de
* Implement constant folding for many transcendentals This change adds support for folding of sin/cos/tan/asin/acos/atan, exp/log/exp2/log2, sqrt, atan2 and pow. The mechanism allows to use any C function to implement folding in the future; for now I limited the actual additions to the most commonly used intrinsics in the shaders. Unary folder had to be tweaked to work with extended instructions - for extended instructions, constants.size() == 2 and constants[0] == nullptr. This adjustment is similar to the one binary folder already performs. Fixes #1390. * Fix Android build On old versions of Android NDK, we don't get std::exp2/std::log2 because of partial C++11 support. We do get ::exp2, but not ::log2 so we need to emulate that.
1278 lines
50 KiB
C++
1278 lines
50 KiB
C++
// 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 "source/opt/const_folding_rules.h"
|
|
|
|
#include "source/opt/ir_context.h"
|
|
|
|
namespace spvtools {
|
|
namespace opt {
|
|
namespace {
|
|
|
|
const uint32_t kExtractCompositeIdInIdx = 0;
|
|
|
|
// Returns true if |type| is Float or a vector of Float.
|
|
bool HasFloatingPoint(const analysis::Type* type) {
|
|
if (type->AsFloat()) {
|
|
return true;
|
|
} else if (const analysis::Vector* vec_type = type->AsVector()) {
|
|
return vec_type->element_type()->AsFloat() != nullptr;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Folds an OpcompositeExtract where input is a composite constant.
|
|
ConstantFoldingRule FoldExtractWithConstants() {
|
|
return [](IRContext* context, 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.
|
|
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
|
|
analysis::TypeManager* type_mgr = context->get_type_mgr();
|
|
return const_mgr->GetConstant(type_mgr->GetType(inst->type_id()), {});
|
|
}
|
|
|
|
auto cc = c->AsCompositeConstant();
|
|
assert(cc != nullptr);
|
|
auto components = cc->GetComponents();
|
|
// Protect against invalid IR. Refuse to fold if the index is out
|
|
// of bounds.
|
|
if (element_index >= components.size()) return nullptr;
|
|
c = components[element_index];
|
|
}
|
|
return c;
|
|
};
|
|
}
|
|
|
|
ConstantFoldingRule FoldVectorShuffleWithConstants() {
|
|
return [](IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
-> const analysis::Constant* {
|
|
assert(inst->opcode() == SpvOpVectorShuffle);
|
|
const analysis::Constant* c1 = constants[0];
|
|
const analysis::Constant* c2 = constants[1];
|
|
if (c1 == nullptr || c2 == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
|
|
const analysis::Type* element_type = c1->type()->AsVector()->element_type();
|
|
|
|
std::vector<const analysis::Constant*> c1_components;
|
|
if (const analysis::VectorConstant* vec_const = c1->AsVectorConstant()) {
|
|
c1_components = vec_const->GetComponents();
|
|
} else {
|
|
assert(c1->AsNullConstant());
|
|
const analysis::Constant* element =
|
|
const_mgr->GetConstant(element_type, {});
|
|
c1_components.resize(c1->type()->AsVector()->element_count(), element);
|
|
}
|
|
std::vector<const analysis::Constant*> c2_components;
|
|
if (const analysis::VectorConstant* vec_const = c2->AsVectorConstant()) {
|
|
c2_components = vec_const->GetComponents();
|
|
} else {
|
|
assert(c2->AsNullConstant());
|
|
const analysis::Constant* element =
|
|
const_mgr->GetConstant(element_type, {});
|
|
c2_components.resize(c2->type()->AsVector()->element_count(), element);
|
|
}
|
|
|
|
std::vector<uint32_t> ids;
|
|
const uint32_t undef_literal_value = 0xffffffff;
|
|
for (uint32_t i = 2; i < inst->NumInOperands(); ++i) {
|
|
uint32_t index = inst->GetSingleWordInOperand(i);
|
|
if (index == undef_literal_value) {
|
|
// Don't fold shuffle with undef literal value.
|
|
return nullptr;
|
|
} else if (index < c1_components.size()) {
|
|
Instruction* member_inst =
|
|
const_mgr->GetDefiningInstruction(c1_components[index]);
|
|
ids.push_back(member_inst->result_id());
|
|
} else {
|
|
Instruction* member_inst = const_mgr->GetDefiningInstruction(
|
|
c2_components[index - c1_components.size()]);
|
|
ids.push_back(member_inst->result_id());
|
|
}
|
|
}
|
|
|
|
analysis::TypeManager* type_mgr = context->get_type_mgr();
|
|
return const_mgr->GetConstant(type_mgr->GetType(inst->type_id()), ids);
|
|
};
|
|
}
|
|
|
|
ConstantFoldingRule FoldVectorTimesScalar() {
|
|
return [](IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
-> const analysis::Constant* {
|
|
assert(inst->opcode() == SpvOpVectorTimesScalar);
|
|
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
|
|
analysis::TypeManager* type_mgr = context->get_type_mgr();
|
|
|
|
if (!inst->IsFloatingPointFoldingAllowed()) {
|
|
if (HasFloatingPoint(type_mgr->GetType(inst->type_id()))) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
const analysis::Constant* c1 = constants[0];
|
|
const analysis::Constant* c2 = constants[1];
|
|
|
|
if (c1 && c1->IsZero()) {
|
|
return c1;
|
|
}
|
|
|
|
if (c2 && c2->IsZero()) {
|
|
// Get or create the NullConstant for this type.
|
|
std::vector<uint32_t> ids;
|
|
return const_mgr->GetConstant(type_mgr->GetType(inst->type_id()), ids);
|
|
}
|
|
|
|
if (c1 == nullptr || c2 == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Check result type.
|
|
const analysis::Type* result_type = type_mgr->GetType(inst->type_id());
|
|
const analysis::Vector* vector_type = result_type->AsVector();
|
|
assert(vector_type != nullptr);
|
|
const analysis::Type* element_type = vector_type->element_type();
|
|
assert(element_type != nullptr);
|
|
const analysis::Float* float_type = element_type->AsFloat();
|
|
assert(float_type != nullptr);
|
|
|
|
// Check types of c1 and c2.
|
|
assert(c1->type()->AsVector() == vector_type);
|
|
assert(c1->type()->AsVector()->element_type() == element_type &&
|
|
c2->type() == element_type);
|
|
|
|
// Get a float vector that is the result of vector-times-scalar.
|
|
std::vector<const analysis::Constant*> c1_components =
|
|
c1->GetVectorComponents(const_mgr);
|
|
std::vector<uint32_t> ids;
|
|
if (float_type->width() == 32) {
|
|
float scalar = c2->GetFloat();
|
|
for (uint32_t i = 0; i < c1_components.size(); ++i) {
|
|
utils::FloatProxy<float> result(c1_components[i]->GetFloat() * scalar);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
const analysis::Constant* new_elem =
|
|
const_mgr->GetConstant(float_type, words);
|
|
ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id());
|
|
}
|
|
return const_mgr->GetConstant(vector_type, ids);
|
|
} else if (float_type->width() == 64) {
|
|
double scalar = c2->GetDouble();
|
|
for (uint32_t i = 0; i < c1_components.size(); ++i) {
|
|
utils::FloatProxy<double> result(c1_components[i]->GetDouble() *
|
|
scalar);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
const analysis::Constant* new_elem =
|
|
const_mgr->GetConstant(float_type, words);
|
|
ids.push_back(const_mgr->GetDefiningInstruction(new_elem)->result_id());
|
|
}
|
|
return const_mgr->GetConstant(vector_type, ids);
|
|
}
|
|
return nullptr;
|
|
};
|
|
}
|
|
|
|
ConstantFoldingRule FoldCompositeWithConstants() {
|
|
// Folds an OpCompositeConstruct where all of the inputs are constants to a
|
|
// constant. A new constant is created if necessary.
|
|
return [](IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
-> const analysis::Constant* {
|
|
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());
|
|
Instruction* type_inst =
|
|
context->get_def_use_mgr()->GetDef(inst->type_id());
|
|
|
|
std::vector<uint32_t> ids;
|
|
for (uint32_t i = 0; i < constants.size(); ++i) {
|
|
const analysis::Constant* element_const = constants[i];
|
|
if (element_const == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t component_type_id = 0;
|
|
if (type_inst->opcode() == SpvOpTypeStruct) {
|
|
component_type_id = type_inst->GetSingleWordInOperand(i);
|
|
} else if (type_inst->opcode() == SpvOpTypeArray) {
|
|
component_type_id = type_inst->GetSingleWordInOperand(0);
|
|
}
|
|
|
|
uint32_t element_id =
|
|
const_mgr->FindDeclaredConstant(element_const, component_type_id);
|
|
if (element_id == 0) {
|
|
return nullptr;
|
|
}
|
|
ids.push_back(element_id);
|
|
}
|
|
return const_mgr->GetConstant(new_type, ids);
|
|
};
|
|
}
|
|
|
|
// 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|.
|
|
using UnaryScalarFoldingRule = std::function<const analysis::Constant*(
|
|
const analysis::Type* result_type, const analysis::Constant* a,
|
|
analysis::ConstantManager*)>;
|
|
|
|
// 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|.
|
|
using BinaryScalarFoldingRule = std::function<const analysis::Constant*(
|
|
const analysis::Type* result_type, const analysis::Constant* a,
|
|
const analysis::Constant* b, analysis::ConstantManager*)>;
|
|
|
|
// Returns a |ConstantFoldingRule| that folds unary floating point scalar ops
|
|
// using |scalar_rule| and unary float point vectors ops by applying
|
|
// |scalar_rule| to the elements of the vector. The |ConstantFoldingRule|
|
|
// that is returned assumes that |constants| contains 1 entry. If they are
|
|
// not |nullptr|, then their type is either |Float| or |Integer| or a |Vector|
|
|
// whose element type is |Float| or |Integer|.
|
|
ConstantFoldingRule FoldFPUnaryOp(UnaryScalarFoldingRule scalar_rule) {
|
|
return [scalar_rule](IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
-> const analysis::Constant* {
|
|
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();
|
|
|
|
if (!inst->IsFloatingPointFoldingAllowed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
const analysis::Constant* arg =
|
|
(inst->opcode() == SpvOpExtInst) ? constants[1] : constants[0];
|
|
|
|
if (arg == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (vector_type != nullptr) {
|
|
std::vector<const analysis::Constant*> a_components;
|
|
std::vector<const analysis::Constant*> results_components;
|
|
|
|
a_components = arg->GetVectorComponents(const_mgr);
|
|
|
|
// Fold each component of the vector.
|
|
for (uint32_t i = 0; i < a_components.size(); ++i) {
|
|
results_components.push_back(scalar_rule(vector_type->element_type(),
|
|
a_components[i], const_mgr));
|
|
if (results_components[i] == nullptr) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
// Build the constant object and return it.
|
|
std::vector<uint32_t> ids;
|
|
for (const analysis::Constant* member : results_components) {
|
|
ids.push_back(const_mgr->GetDefiningInstruction(member)->result_id());
|
|
}
|
|
return const_mgr->GetConstant(vector_type, ids);
|
|
} else {
|
|
return scalar_rule(result_type, arg, const_mgr);
|
|
}
|
|
};
|
|
}
|
|
|
|
// Returns the result of folding the constants in |constants| according the
|
|
// |scalar_rule|. If |result_type| is a vector, then |scalar_rule| is applied
|
|
// per component.
|
|
const analysis::Constant* FoldFPBinaryOp(
|
|
BinaryScalarFoldingRule scalar_rule, uint32_t result_type_id,
|
|
const std::vector<const analysis::Constant*>& constants,
|
|
IRContext* 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(result_type_id);
|
|
const analysis::Vector* vector_type = result_type->AsVector();
|
|
|
|
if (constants[0] == nullptr || constants[1] == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (vector_type != nullptr) {
|
|
std::vector<const analysis::Constant*> a_components;
|
|
std::vector<const analysis::Constant*> b_components;
|
|
std::vector<const analysis::Constant*> results_components;
|
|
|
|
a_components = constants[0]->GetVectorComponents(const_mgr);
|
|
b_components = constants[1]->GetVectorComponents(const_mgr);
|
|
|
|
// Fold each component of the vector.
|
|
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) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
// Build the constant object and return it.
|
|
std::vector<uint32_t> ids;
|
|
for (const analysis::Constant* member : results_components) {
|
|
ids.push_back(const_mgr->GetDefiningInstruction(member)->result_id());
|
|
}
|
|
return const_mgr->GetConstant(vector_type, ids);
|
|
} else {
|
|
return scalar_rule(result_type, constants[0], constants[1], const_mgr);
|
|
}
|
|
}
|
|
|
|
// 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 FoldFPBinaryOp(BinaryScalarFoldingRule scalar_rule) {
|
|
return [scalar_rule](IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
-> const analysis::Constant* {
|
|
if (!inst->IsFloatingPointFoldingAllowed()) {
|
|
return nullptr;
|
|
}
|
|
if (inst->opcode() == SpvOpExtInst) {
|
|
return FoldFPBinaryOp(scalar_rule, inst->type_id(),
|
|
{constants[1], constants[2]}, context);
|
|
}
|
|
return FoldFPBinaryOp(scalar_rule, inst->type_id(), constants, context);
|
|
};
|
|
}
|
|
|
|
// This macro defines a |UnaryScalarFoldingRule| that performs float to
|
|
// integer conversion.
|
|
// TODO(greg-lunarg): Support for 64-bit integer types.
|
|
UnaryScalarFoldingRule FoldFToIOp() {
|
|
return [](const analysis::Type* result_type, const analysis::Constant* a,
|
|
analysis::ConstantManager* const_mgr) -> const analysis::Constant* {
|
|
assert(result_type != nullptr && a != nullptr);
|
|
const analysis::Integer* integer_type = result_type->AsInteger();
|
|
const analysis::Float* float_type = a->type()->AsFloat();
|
|
assert(float_type != nullptr);
|
|
assert(integer_type != nullptr);
|
|
if (integer_type->width() != 32) return nullptr;
|
|
if (float_type->width() == 32) {
|
|
float fa = a->GetFloat();
|
|
uint32_t result = integer_type->IsSigned()
|
|
? static_cast<uint32_t>(static_cast<int32_t>(fa))
|
|
: static_cast<uint32_t>(fa);
|
|
std::vector<uint32_t> words = {result};
|
|
return const_mgr->GetConstant(result_type, words);
|
|
} else if (float_type->width() == 64) {
|
|
double fa = a->GetDouble();
|
|
uint32_t result = integer_type->IsSigned()
|
|
? static_cast<uint32_t>(static_cast<int32_t>(fa))
|
|
: static_cast<uint32_t>(fa);
|
|
std::vector<uint32_t> words = {result};
|
|
return const_mgr->GetConstant(result_type, words);
|
|
}
|
|
return nullptr;
|
|
};
|
|
}
|
|
|
|
// This function defines a |UnaryScalarFoldingRule| that performs integer to
|
|
// float conversion.
|
|
// TODO(greg-lunarg): Support for 64-bit integer types.
|
|
UnaryScalarFoldingRule FoldIToFOp() {
|
|
return [](const analysis::Type* result_type, const analysis::Constant* a,
|
|
analysis::ConstantManager* const_mgr) -> const analysis::Constant* {
|
|
assert(result_type != nullptr && a != nullptr);
|
|
const analysis::Integer* integer_type = a->type()->AsInteger();
|
|
const analysis::Float* float_type = result_type->AsFloat();
|
|
assert(float_type != nullptr);
|
|
assert(integer_type != nullptr);
|
|
if (integer_type->width() != 32) return nullptr;
|
|
uint32_t ua = a->GetU32();
|
|
if (float_type->width() == 32) {
|
|
float result_val = integer_type->IsSigned()
|
|
? static_cast<float>(static_cast<int32_t>(ua))
|
|
: static_cast<float>(ua);
|
|
utils::FloatProxy<float> result(result_val);
|
|
std::vector<uint32_t> words = {result.data()};
|
|
return const_mgr->GetConstant(result_type, words);
|
|
} else if (float_type->width() == 64) {
|
|
double result_val = integer_type->IsSigned()
|
|
? static_cast<double>(static_cast<int32_t>(ua))
|
|
: static_cast<double>(ua);
|
|
utils::FloatProxy<double> result(result_val);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
return const_mgr->GetConstant(result_type, words);
|
|
}
|
|
return nullptr;
|
|
};
|
|
}
|
|
|
|
// This defines a |UnaryScalarFoldingRule| that performs |OpQuantizeToF16|.
|
|
UnaryScalarFoldingRule FoldQuantizeToF16Scalar() {
|
|
return [](const analysis::Type* result_type, const analysis::Constant* a,
|
|
analysis::ConstantManager* const_mgr) -> const analysis::Constant* {
|
|
assert(result_type != nullptr && a != nullptr);
|
|
const analysis::Float* float_type = a->type()->AsFloat();
|
|
assert(float_type != nullptr);
|
|
if (float_type->width() != 32) {
|
|
return nullptr;
|
|
}
|
|
|
|
float fa = a->GetFloat();
|
|
utils::HexFloat<utils::FloatProxy<float>> orignal(fa);
|
|
utils::HexFloat<utils::FloatProxy<utils::Float16>> quantized(0);
|
|
utils::HexFloat<utils::FloatProxy<float>> result(0.0f);
|
|
orignal.castTo(quantized, utils::round_direction::kToZero);
|
|
quantized.castTo(result, utils::round_direction::kToZero);
|
|
std::vector<uint32_t> words = {result.getBits()};
|
|
return const_mgr->GetConstant(result_type, words);
|
|
};
|
|
}
|
|
|
|
// This macro defines a |BinaryScalarFoldingRule| that applies |op|. The
|
|
// operator |op| must work for both float and double, and use syntax "f1 op f2".
|
|
#define FOLD_FPARITH_OP(op) \
|
|
[](const analysis::Type* result_type_in_macro, const analysis::Constant* a, \
|
|
const analysis::Constant* b, \
|
|
analysis::ConstantManager* const_mgr_in_macro) \
|
|
-> const analysis::Constant* { \
|
|
assert(result_type_in_macro != nullptr && a != nullptr && b != nullptr); \
|
|
assert(result_type_in_macro == a->type() && \
|
|
result_type_in_macro == b->type()); \
|
|
const analysis::Float* float_type_in_macro = \
|
|
result_type_in_macro->AsFloat(); \
|
|
assert(float_type_in_macro != nullptr); \
|
|
if (float_type_in_macro->width() == 32) { \
|
|
float fa = a->GetFloat(); \
|
|
float fb = b->GetFloat(); \
|
|
utils::FloatProxy<float> result_in_macro(fa op fb); \
|
|
std::vector<uint32_t> words_in_macro = result_in_macro.GetWords(); \
|
|
return const_mgr_in_macro->GetConstant(result_type_in_macro, \
|
|
words_in_macro); \
|
|
} else if (float_type_in_macro->width() == 64) { \
|
|
double fa = a->GetDouble(); \
|
|
double fb = b->GetDouble(); \
|
|
utils::FloatProxy<double> result_in_macro(fa op fb); \
|
|
std::vector<uint32_t> words_in_macro = result_in_macro.GetWords(); \
|
|
return const_mgr_in_macro->GetConstant(result_type_in_macro, \
|
|
words_in_macro); \
|
|
} \
|
|
return nullptr; \
|
|
}
|
|
|
|
// Define the folding rule for conversion between floating point and integer
|
|
ConstantFoldingRule FoldFToI() { return FoldFPUnaryOp(FoldFToIOp()); }
|
|
ConstantFoldingRule FoldIToF() { return FoldFPUnaryOp(FoldIToFOp()); }
|
|
ConstantFoldingRule FoldQuantizeToF16() {
|
|
return FoldFPUnaryOp(FoldQuantizeToF16Scalar());
|
|
}
|
|
|
|
// Define the folding rules for subtraction, addition, multiplication, and
|
|
// division for floating point values.
|
|
ConstantFoldingRule FoldFSub() { return FoldFPBinaryOp(FOLD_FPARITH_OP(-)); }
|
|
ConstantFoldingRule FoldFAdd() { return FoldFPBinaryOp(FOLD_FPARITH_OP(+)); }
|
|
ConstantFoldingRule FoldFMul() { return FoldFPBinaryOp(FOLD_FPARITH_OP(*)); }
|
|
ConstantFoldingRule FoldFDiv() { return FoldFPBinaryOp(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 |BinaryScalarFoldingRule| 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 = a->GetFloat(); \
|
|
float fb = b->GetFloat(); \
|
|
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 = a->GetDouble(); \
|
|
double fb = b->GetDouble(); \
|
|
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 FoldFPBinaryOp(FOLD_FPCMP_OP(==, true));
|
|
}
|
|
ConstantFoldingRule FoldFUnordEqual() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(==, false));
|
|
}
|
|
ConstantFoldingRule FoldFOrdNotEqual() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(!=, true));
|
|
}
|
|
ConstantFoldingRule FoldFUnordNotEqual() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(!=, false));
|
|
}
|
|
ConstantFoldingRule FoldFOrdLessThan() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(<, true));
|
|
}
|
|
ConstantFoldingRule FoldFUnordLessThan() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(<, false));
|
|
}
|
|
ConstantFoldingRule FoldFOrdGreaterThan() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(>, true));
|
|
}
|
|
ConstantFoldingRule FoldFUnordGreaterThan() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(>, false));
|
|
}
|
|
ConstantFoldingRule FoldFOrdLessThanEqual() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(<=, true));
|
|
}
|
|
ConstantFoldingRule FoldFUnordLessThanEqual() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(<=, false));
|
|
}
|
|
ConstantFoldingRule FoldFOrdGreaterThanEqual() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(>=, true));
|
|
}
|
|
ConstantFoldingRule FoldFUnordGreaterThanEqual() {
|
|
return FoldFPBinaryOp(FOLD_FPCMP_OP(>=, false));
|
|
}
|
|
|
|
// Folds an OpDot where all of the inputs are constants to a
|
|
// constant. A new constant is created if necessary.
|
|
ConstantFoldingRule FoldOpDotWithConstants() {
|
|
return [](IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
-> const analysis::Constant* {
|
|
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());
|
|
assert(new_type->AsFloat() && "OpDot should have a float return type.");
|
|
const analysis::Float* float_type = new_type->AsFloat();
|
|
|
|
if (!inst->IsFloatingPointFoldingAllowed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
// If one of the operands is 0, then the result is 0.
|
|
bool has_zero_operand = false;
|
|
|
|
for (int i = 0; i < 2; ++i) {
|
|
if (constants[i]) {
|
|
if (constants[i]->AsNullConstant() ||
|
|
constants[i]->AsVectorConstant()->IsZero()) {
|
|
has_zero_operand = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (has_zero_operand) {
|
|
if (float_type->width() == 32) {
|
|
utils::FloatProxy<float> result(0.0f);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
return const_mgr->GetConstant(float_type, words);
|
|
}
|
|
if (float_type->width() == 64) {
|
|
utils::FloatProxy<double> result(0.0);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
return const_mgr->GetConstant(float_type, words);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
if (constants[0] == nullptr || constants[1] == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
std::vector<const analysis::Constant*> a_components;
|
|
std::vector<const analysis::Constant*> b_components;
|
|
|
|
a_components = constants[0]->GetVectorComponents(const_mgr);
|
|
b_components = constants[1]->GetVectorComponents(const_mgr);
|
|
|
|
utils::FloatProxy<double> result(0.0);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
const analysis::Constant* result_const =
|
|
const_mgr->GetConstant(float_type, words);
|
|
for (uint32_t i = 0; i < a_components.size() && result_const != nullptr;
|
|
++i) {
|
|
if (a_components[i] == nullptr || b_components[i] == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
const analysis::Constant* component = FOLD_FPARITH_OP(*)(
|
|
new_type, a_components[i], b_components[i], const_mgr);
|
|
if (component == nullptr) {
|
|
return nullptr;
|
|
}
|
|
result_const =
|
|
FOLD_FPARITH_OP(+)(new_type, result_const, component, const_mgr);
|
|
}
|
|
return result_const;
|
|
};
|
|
}
|
|
|
|
// This function defines a |UnaryScalarFoldingRule| that subtracts the constant
|
|
// from zero.
|
|
UnaryScalarFoldingRule FoldFNegateOp() {
|
|
return [](const analysis::Type* result_type, const analysis::Constant* a,
|
|
analysis::ConstantManager* const_mgr) -> const analysis::Constant* {
|
|
assert(result_type != nullptr && a != nullptr);
|
|
assert(result_type == a->type());
|
|
const analysis::Float* float_type = result_type->AsFloat();
|
|
assert(float_type != nullptr);
|
|
if (float_type->width() == 32) {
|
|
float fa = a->GetFloat();
|
|
utils::FloatProxy<float> result(-fa);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
return const_mgr->GetConstant(result_type, words);
|
|
} else if (float_type->width() == 64) {
|
|
double da = a->GetDouble();
|
|
utils::FloatProxy<double> result(-da);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
return const_mgr->GetConstant(result_type, words);
|
|
}
|
|
return nullptr;
|
|
};
|
|
}
|
|
|
|
ConstantFoldingRule FoldFNegate() { return FoldFPUnaryOp(FoldFNegateOp()); }
|
|
|
|
ConstantFoldingRule FoldFClampFeedingCompare(uint32_t cmp_opcode) {
|
|
return [cmp_opcode](IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
-> const analysis::Constant* {
|
|
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
|
|
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
|
|
|
|
if (!inst->IsFloatingPointFoldingAllowed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t non_const_idx = (constants[0] ? 1 : 0);
|
|
uint32_t operand_id = inst->GetSingleWordInOperand(non_const_idx);
|
|
Instruction* operand_inst = def_use_mgr->GetDef(operand_id);
|
|
|
|
analysis::TypeManager* type_mgr = context->get_type_mgr();
|
|
const analysis::Type* operand_type =
|
|
type_mgr->GetType(operand_inst->type_id());
|
|
|
|
if (!operand_type->AsFloat()) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (operand_type->AsFloat()->width() != 32 &&
|
|
operand_type->AsFloat()->width() != 64) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (operand_inst->opcode() != SpvOpExtInst) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (operand_inst->GetSingleWordInOperand(1) != GLSLstd450FClamp) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (constants[1] == nullptr && constants[0] == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t max_id = operand_inst->GetSingleWordInOperand(4);
|
|
const analysis::Constant* max_const =
|
|
const_mgr->FindDeclaredConstant(max_id);
|
|
|
|
uint32_t min_id = operand_inst->GetSingleWordInOperand(3);
|
|
const analysis::Constant* min_const =
|
|
const_mgr->FindDeclaredConstant(min_id);
|
|
|
|
bool found_result = false;
|
|
bool result = false;
|
|
|
|
switch (cmp_opcode) {
|
|
case SpvOpFOrdLessThan:
|
|
case SpvOpFUnordLessThan:
|
|
case SpvOpFOrdGreaterThanEqual:
|
|
case SpvOpFUnordGreaterThanEqual:
|
|
if (constants[0]) {
|
|
if (min_const) {
|
|
if (constants[0]->GetValueAsDouble() <
|
|
min_const->GetValueAsDouble()) {
|
|
found_result = true;
|
|
result = (cmp_opcode == SpvOpFOrdLessThan ||
|
|
cmp_opcode == SpvOpFUnordLessThan);
|
|
}
|
|
}
|
|
if (max_const) {
|
|
if (constants[0]->GetValueAsDouble() >=
|
|
max_const->GetValueAsDouble()) {
|
|
found_result = true;
|
|
result = !(cmp_opcode == SpvOpFOrdLessThan ||
|
|
cmp_opcode == SpvOpFUnordLessThan);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (constants[1]) {
|
|
if (max_const) {
|
|
if (max_const->GetValueAsDouble() <
|
|
constants[1]->GetValueAsDouble()) {
|
|
found_result = true;
|
|
result = (cmp_opcode == SpvOpFOrdLessThan ||
|
|
cmp_opcode == SpvOpFUnordLessThan);
|
|
}
|
|
}
|
|
|
|
if (min_const) {
|
|
if (min_const->GetValueAsDouble() >=
|
|
constants[1]->GetValueAsDouble()) {
|
|
found_result = true;
|
|
result = !(cmp_opcode == SpvOpFOrdLessThan ||
|
|
cmp_opcode == SpvOpFUnordLessThan);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case SpvOpFOrdGreaterThan:
|
|
case SpvOpFUnordGreaterThan:
|
|
case SpvOpFOrdLessThanEqual:
|
|
case SpvOpFUnordLessThanEqual:
|
|
if (constants[0]) {
|
|
if (min_const) {
|
|
if (constants[0]->GetValueAsDouble() <=
|
|
min_const->GetValueAsDouble()) {
|
|
found_result = true;
|
|
result = (cmp_opcode == SpvOpFOrdLessThanEqual ||
|
|
cmp_opcode == SpvOpFUnordLessThanEqual);
|
|
}
|
|
}
|
|
if (max_const) {
|
|
if (constants[0]->GetValueAsDouble() >
|
|
max_const->GetValueAsDouble()) {
|
|
found_result = true;
|
|
result = !(cmp_opcode == SpvOpFOrdLessThanEqual ||
|
|
cmp_opcode == SpvOpFUnordLessThanEqual);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (constants[1]) {
|
|
if (max_const) {
|
|
if (max_const->GetValueAsDouble() <=
|
|
constants[1]->GetValueAsDouble()) {
|
|
found_result = true;
|
|
result = (cmp_opcode == SpvOpFOrdLessThanEqual ||
|
|
cmp_opcode == SpvOpFUnordLessThanEqual);
|
|
}
|
|
}
|
|
|
|
if (min_const) {
|
|
if (min_const->GetValueAsDouble() >
|
|
constants[1]->GetValueAsDouble()) {
|
|
found_result = true;
|
|
result = !(cmp_opcode == SpvOpFOrdLessThanEqual ||
|
|
cmp_opcode == SpvOpFUnordLessThanEqual);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
return nullptr;
|
|
}
|
|
|
|
if (!found_result) {
|
|
return nullptr;
|
|
}
|
|
|
|
const analysis::Type* bool_type =
|
|
context->get_type_mgr()->GetType(inst->type_id());
|
|
const analysis::Constant* result_const =
|
|
const_mgr->GetConstant(bool_type, {static_cast<uint32_t>(result)});
|
|
assert(result_const);
|
|
return result_const;
|
|
};
|
|
}
|
|
|
|
ConstantFoldingRule FoldFMix() {
|
|
return [](IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants)
|
|
-> const analysis::Constant* {
|
|
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
|
|
assert(inst->opcode() == SpvOpExtInst &&
|
|
"Expecting an extended instruction.");
|
|
assert(inst->GetSingleWordInOperand(0) ==
|
|
context->get_feature_mgr()->GetExtInstImportId_GLSLstd450() &&
|
|
"Expecting a GLSLstd450 extended instruction.");
|
|
assert(inst->GetSingleWordInOperand(1) == GLSLstd450FMix &&
|
|
"Expecting and FMix instruction.");
|
|
|
|
if (!inst->IsFloatingPointFoldingAllowed()) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Make sure all FMix operands are constants.
|
|
for (uint32_t i = 1; i < 4; i++) {
|
|
if (constants[i] == nullptr) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
const analysis::Constant* one;
|
|
bool is_vector = false;
|
|
const analysis::Type* result_type = constants[1]->type();
|
|
const analysis::Type* base_type = result_type;
|
|
if (base_type->AsVector()) {
|
|
is_vector = true;
|
|
base_type = base_type->AsVector()->element_type();
|
|
}
|
|
assert(base_type->AsFloat() != nullptr &&
|
|
"FMix is suppose to act on floats or vectors of floats.");
|
|
|
|
if (base_type->AsFloat()->width() == 32) {
|
|
one = const_mgr->GetConstant(base_type,
|
|
utils::FloatProxy<float>(1.0f).GetWords());
|
|
} else {
|
|
one = const_mgr->GetConstant(base_type,
|
|
utils::FloatProxy<double>(1.0).GetWords());
|
|
}
|
|
|
|
if (is_vector) {
|
|
uint32_t one_id = const_mgr->GetDefiningInstruction(one)->result_id();
|
|
one =
|
|
const_mgr->GetConstant(result_type, std::vector<uint32_t>(4, one_id));
|
|
}
|
|
|
|
const analysis::Constant* temp1 = FoldFPBinaryOp(
|
|
FOLD_FPARITH_OP(-), inst->type_id(), {one, constants[3]}, context);
|
|
if (temp1 == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
const analysis::Constant* temp2 = FoldFPBinaryOp(
|
|
FOLD_FPARITH_OP(*), inst->type_id(), {constants[1], temp1}, context);
|
|
if (temp2 == nullptr) {
|
|
return nullptr;
|
|
}
|
|
const analysis::Constant* temp3 =
|
|
FoldFPBinaryOp(FOLD_FPARITH_OP(*), inst->type_id(),
|
|
{constants[2], constants[3]}, context);
|
|
if (temp3 == nullptr) {
|
|
return nullptr;
|
|
}
|
|
return FoldFPBinaryOp(FOLD_FPARITH_OP(+), inst->type_id(), {temp2, temp3},
|
|
context);
|
|
};
|
|
}
|
|
|
|
template <class IntType>
|
|
IntType FoldIClamp(IntType x, IntType min_val, IntType max_val) {
|
|
if (x < min_val) {
|
|
x = min_val;
|
|
}
|
|
if (x > max_val) {
|
|
x = max_val;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
const analysis::Constant* FoldMin(const analysis::Type* result_type,
|
|
const analysis::Constant* a,
|
|
const analysis::Constant* b,
|
|
analysis::ConstantManager*) {
|
|
if (const analysis::Integer* int_type = result_type->AsInteger()) {
|
|
if (int_type->width() == 32) {
|
|
if (int_type->IsSigned()) {
|
|
int32_t va = a->GetS32();
|
|
int32_t vb = b->GetS32();
|
|
return (va < vb ? a : b);
|
|
} else {
|
|
uint32_t va = a->GetU32();
|
|
uint32_t vb = b->GetU32();
|
|
return (va < vb ? a : b);
|
|
}
|
|
} else if (int_type->width() == 64) {
|
|
if (int_type->IsSigned()) {
|
|
int64_t va = a->GetS64();
|
|
int64_t vb = b->GetS64();
|
|
return (va < vb ? a : b);
|
|
} else {
|
|
uint64_t va = a->GetU64();
|
|
uint64_t vb = b->GetU64();
|
|
return (va < vb ? a : b);
|
|
}
|
|
}
|
|
} else if (const analysis::Float* float_type = result_type->AsFloat()) {
|
|
if (float_type->width() == 32) {
|
|
float va = a->GetFloat();
|
|
float vb = b->GetFloat();
|
|
return (va < vb ? a : b);
|
|
} else if (float_type->width() == 64) {
|
|
double va = a->GetDouble();
|
|
double vb = b->GetDouble();
|
|
return (va < vb ? a : b);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const analysis::Constant* FoldMax(const analysis::Type* result_type,
|
|
const analysis::Constant* a,
|
|
const analysis::Constant* b,
|
|
analysis::ConstantManager*) {
|
|
if (const analysis::Integer* int_type = result_type->AsInteger()) {
|
|
if (int_type->width() == 32) {
|
|
if (int_type->IsSigned()) {
|
|
int32_t va = a->GetS32();
|
|
int32_t vb = b->GetS32();
|
|
return (va > vb ? a : b);
|
|
} else {
|
|
uint32_t va = a->GetU32();
|
|
uint32_t vb = b->GetU32();
|
|
return (va > vb ? a : b);
|
|
}
|
|
} else if (int_type->width() == 64) {
|
|
if (int_type->IsSigned()) {
|
|
int64_t va = a->GetS64();
|
|
int64_t vb = b->GetS64();
|
|
return (va > vb ? a : b);
|
|
} else {
|
|
uint64_t va = a->GetU64();
|
|
uint64_t vb = b->GetU64();
|
|
return (va > vb ? a : b);
|
|
}
|
|
}
|
|
} else if (const analysis::Float* float_type = result_type->AsFloat()) {
|
|
if (float_type->width() == 32) {
|
|
float va = a->GetFloat();
|
|
float vb = b->GetFloat();
|
|
return (va > vb ? a : b);
|
|
} else if (float_type->width() == 64) {
|
|
double va = a->GetDouble();
|
|
double vb = b->GetDouble();
|
|
return (va > vb ? a : b);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// Fold an clamp instruction when all three operands are constant.
|
|
const analysis::Constant* FoldClamp1(
|
|
IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants) {
|
|
assert(inst->opcode() == SpvOpExtInst &&
|
|
"Expecting an extended instruction.");
|
|
assert(inst->GetSingleWordInOperand(0) ==
|
|
context->get_feature_mgr()->GetExtInstImportId_GLSLstd450() &&
|
|
"Expecting a GLSLstd450 extended instruction.");
|
|
|
|
// Make sure all Clamp operands are constants.
|
|
for (uint32_t i = 1; i < 3; i++) {
|
|
if (constants[i] == nullptr) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
const analysis::Constant* temp = FoldFPBinaryOp(
|
|
FoldMax, inst->type_id(), {constants[1], constants[2]}, context);
|
|
if (temp == nullptr) {
|
|
return nullptr;
|
|
}
|
|
return FoldFPBinaryOp(FoldMin, inst->type_id(), {temp, constants[3]},
|
|
context);
|
|
}
|
|
|
|
// Fold a clamp instruction when |x >= min_val|.
|
|
const analysis::Constant* FoldClamp2(
|
|
IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants) {
|
|
assert(inst->opcode() == SpvOpExtInst &&
|
|
"Expecting an extended instruction.");
|
|
assert(inst->GetSingleWordInOperand(0) ==
|
|
context->get_feature_mgr()->GetExtInstImportId_GLSLstd450() &&
|
|
"Expecting a GLSLstd450 extended instruction.");
|
|
|
|
const analysis::Constant* x = constants[1];
|
|
const analysis::Constant* min_val = constants[2];
|
|
|
|
if (x == nullptr || min_val == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
const analysis::Constant* temp =
|
|
FoldFPBinaryOp(FoldMax, inst->type_id(), {x, min_val}, context);
|
|
if (temp == min_val) {
|
|
// We can assume that |min_val| is less than |max_val|. Therefore, if the
|
|
// result of the max operation is |min_val|, we know the result of the min
|
|
// operation, even if |max_val| is not a constant.
|
|
return min_val;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
// Fold a clamp instruction when |x >= max_val|.
|
|
const analysis::Constant* FoldClamp3(
|
|
IRContext* context, Instruction* inst,
|
|
const std::vector<const analysis::Constant*>& constants) {
|
|
assert(inst->opcode() == SpvOpExtInst &&
|
|
"Expecting an extended instruction.");
|
|
assert(inst->GetSingleWordInOperand(0) ==
|
|
context->get_feature_mgr()->GetExtInstImportId_GLSLstd450() &&
|
|
"Expecting a GLSLstd450 extended instruction.");
|
|
|
|
const analysis::Constant* x = constants[1];
|
|
const analysis::Constant* max_val = constants[3];
|
|
|
|
if (x == nullptr || max_val == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
const analysis::Constant* temp =
|
|
FoldFPBinaryOp(FoldMin, inst->type_id(), {x, max_val}, context);
|
|
if (temp == max_val) {
|
|
// We can assume that |min_val| is less than |max_val|. Therefore, if the
|
|
// result of the max operation is |min_val|, we know the result of the min
|
|
// operation, even if |max_val| is not a constant.
|
|
return max_val;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
UnaryScalarFoldingRule FoldFTranscendentalUnary(double (*fp)(double)) {
|
|
return
|
|
[fp](const analysis::Type* result_type, const analysis::Constant* a,
|
|
analysis::ConstantManager* const_mgr) -> const analysis::Constant* {
|
|
assert(result_type != nullptr && a != nullptr);
|
|
const analysis::Float* float_type = a->type()->AsFloat();
|
|
assert(float_type != nullptr);
|
|
assert(float_type == result_type->AsFloat());
|
|
if (float_type->width() == 32) {
|
|
float fa = a->GetFloat();
|
|
float res = static_cast<float>(fp(fa));
|
|
utils::FloatProxy<float> result(res);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
return const_mgr->GetConstant(result_type, words);
|
|
} else if (float_type->width() == 64) {
|
|
double fa = a->GetDouble();
|
|
double res = fp(fa);
|
|
utils::FloatProxy<double> result(res);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
return const_mgr->GetConstant(result_type, words);
|
|
}
|
|
return nullptr;
|
|
};
|
|
}
|
|
|
|
BinaryScalarFoldingRule FoldFTranscendentalBinary(double (*fp)(double,
|
|
double)) {
|
|
return
|
|
[fp](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);
|
|
const analysis::Float* float_type = a->type()->AsFloat();
|
|
assert(float_type != nullptr);
|
|
assert(float_type == result_type->AsFloat());
|
|
assert(float_type == b->type()->AsFloat());
|
|
if (float_type->width() == 32) {
|
|
float fa = a->GetFloat();
|
|
float fb = b->GetFloat();
|
|
float res = static_cast<float>(fp(fa, fb));
|
|
utils::FloatProxy<float> result(res);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
return const_mgr->GetConstant(result_type, words);
|
|
} else if (float_type->width() == 64) {
|
|
double fa = a->GetDouble();
|
|
double fb = b->GetDouble();
|
|
double res = fp(fa, fb);
|
|
utils::FloatProxy<double> result(res);
|
|
std::vector<uint32_t> words = result.GetWords();
|
|
return const_mgr->GetConstant(result_type, words);
|
|
}
|
|
return nullptr;
|
|
};
|
|
}
|
|
} // namespace
|
|
|
|
void ConstantFoldingRules::AddFoldingRules() {
|
|
// 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());
|
|
|
|
rules_[SpvOpCompositeExtract].push_back(FoldExtractWithConstants());
|
|
|
|
rules_[SpvOpConvertFToS].push_back(FoldFToI());
|
|
rules_[SpvOpConvertFToU].push_back(FoldFToI());
|
|
rules_[SpvOpConvertSToF].push_back(FoldIToF());
|
|
rules_[SpvOpConvertUToF].push_back(FoldIToF());
|
|
|
|
rules_[SpvOpDot].push_back(FoldOpDotWithConstants());
|
|
rules_[SpvOpFAdd].push_back(FoldFAdd());
|
|
rules_[SpvOpFDiv].push_back(FoldFDiv());
|
|
rules_[SpvOpFMul].push_back(FoldFMul());
|
|
rules_[SpvOpFSub].push_back(FoldFSub());
|
|
|
|
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_[SpvOpFOrdLessThan].push_back(
|
|
FoldFClampFeedingCompare(SpvOpFOrdLessThan));
|
|
|
|
rules_[SpvOpFUnordLessThan].push_back(FoldFUnordLessThan());
|
|
rules_[SpvOpFUnordLessThan].push_back(
|
|
FoldFClampFeedingCompare(SpvOpFUnordLessThan));
|
|
|
|
rules_[SpvOpFOrdGreaterThan].push_back(FoldFOrdGreaterThan());
|
|
rules_[SpvOpFOrdGreaterThan].push_back(
|
|
FoldFClampFeedingCompare(SpvOpFOrdGreaterThan));
|
|
|
|
rules_[SpvOpFUnordGreaterThan].push_back(FoldFUnordGreaterThan());
|
|
rules_[SpvOpFUnordGreaterThan].push_back(
|
|
FoldFClampFeedingCompare(SpvOpFUnordGreaterThan));
|
|
|
|
rules_[SpvOpFOrdLessThanEqual].push_back(FoldFOrdLessThanEqual());
|
|
rules_[SpvOpFOrdLessThanEqual].push_back(
|
|
FoldFClampFeedingCompare(SpvOpFOrdLessThanEqual));
|
|
|
|
rules_[SpvOpFUnordLessThanEqual].push_back(FoldFUnordLessThanEqual());
|
|
rules_[SpvOpFUnordLessThanEqual].push_back(
|
|
FoldFClampFeedingCompare(SpvOpFUnordLessThanEqual));
|
|
|
|
rules_[SpvOpFOrdGreaterThanEqual].push_back(FoldFOrdGreaterThanEqual());
|
|
rules_[SpvOpFOrdGreaterThanEqual].push_back(
|
|
FoldFClampFeedingCompare(SpvOpFOrdGreaterThanEqual));
|
|
|
|
rules_[SpvOpFUnordGreaterThanEqual].push_back(FoldFUnordGreaterThanEqual());
|
|
rules_[SpvOpFUnordGreaterThanEqual].push_back(
|
|
FoldFClampFeedingCompare(SpvOpFUnordGreaterThanEqual));
|
|
|
|
rules_[SpvOpVectorShuffle].push_back(FoldVectorShuffleWithConstants());
|
|
rules_[SpvOpVectorTimesScalar].push_back(FoldVectorTimesScalar());
|
|
|
|
rules_[SpvOpFNegate].push_back(FoldFNegate());
|
|
rules_[SpvOpQuantizeToF16].push_back(FoldQuantizeToF16());
|
|
|
|
// Add rules for GLSLstd450
|
|
FeatureManager* feature_manager = context_->get_feature_mgr();
|
|
uint32_t ext_inst_glslstd450_id =
|
|
feature_manager->GetExtInstImportId_GLSLstd450();
|
|
if (ext_inst_glslstd450_id != 0) {
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FMix}].push_back(FoldFMix());
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SMin}].push_back(
|
|
FoldFPBinaryOp(FoldMin));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UMin}].push_back(
|
|
FoldFPBinaryOp(FoldMin));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FMin}].push_back(
|
|
FoldFPBinaryOp(FoldMin));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SMax}].push_back(
|
|
FoldFPBinaryOp(FoldMax));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UMax}].push_back(
|
|
FoldFPBinaryOp(FoldMax));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FMax}].push_back(
|
|
FoldFPBinaryOp(FoldMax));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UClamp}].push_back(
|
|
FoldClamp1);
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UClamp}].push_back(
|
|
FoldClamp2);
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450UClamp}].push_back(
|
|
FoldClamp3);
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SClamp}].push_back(
|
|
FoldClamp1);
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SClamp}].push_back(
|
|
FoldClamp2);
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450SClamp}].push_back(
|
|
FoldClamp3);
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FClamp}].push_back(
|
|
FoldClamp1);
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FClamp}].push_back(
|
|
FoldClamp2);
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450FClamp}].push_back(
|
|
FoldClamp3);
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Sin}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::sin)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Cos}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::cos)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Tan}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::tan)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Asin}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::asin)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Acos}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::acos)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Atan}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::atan)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Exp}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::exp)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Log}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::log)));
|
|
|
|
#ifdef __ANDROID__
|
|
// Android NDK r15c tageting ABI 15 doesn't have full support for C++11
|
|
// (no std::exp2/log2). ::exp2 is available from C99 but ::log2 isn't
|
|
// available up until ABI 18 so we use a shim
|
|
auto log2_shim = [](double v) -> double { return log(v) / log(2.0); };
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Exp2}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(::exp2)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Log2}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(log2_shim)));
|
|
#else
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Exp2}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::exp2)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Log2}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::log2)));
|
|
#endif
|
|
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Sqrt}].push_back(
|
|
FoldFPUnaryOp(FoldFTranscendentalUnary(std::sqrt)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Atan2}].push_back(
|
|
FoldFPBinaryOp(FoldFTranscendentalBinary(std::atan2)));
|
|
ext_rules_[{ext_inst_glslstd450_id, GLSLstd450Pow}].push_back(
|
|
FoldFPBinaryOp(FoldFTranscendentalBinary(std::pow)));
|
|
}
|
|
}
|
|
} // namespace opt
|
|
} // namespace spvtools
|