| // 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 { |
| constexpr uint32_t kExtractCompositeIdInIdx = 0; |
| |
| // Returns a constants with the value NaN of the given type. Only works for |
| // 32-bit and 64-bit float point types. Returns |nullptr| if an error occurs. |
| const analysis::Constant* GetNan(const analysis::Type* type, |
| analysis::ConstantManager* const_mgr) { |
| const analysis::Float* float_type = type->AsFloat(); |
| if (float_type == nullptr) { |
| return nullptr; |
| } |
| |
| switch (float_type->width()) { |
| case 32: |
| return const_mgr->GetFloatConst(std::numeric_limits<float>::quiet_NaN()); |
| case 64: |
| return const_mgr->GetDoubleConst( |
| std::numeric_limits<double>::quiet_NaN()); |
| default: |
| return nullptr; |
| } |
| } |
| |
| // Returns a constants with the value INF of the given type. Only works for |
| // 32-bit and 64-bit float point types. Returns |nullptr| if an error occurs. |
| const analysis::Constant* GetInf(const analysis::Type* type, |
| analysis::ConstantManager* const_mgr) { |
| const analysis::Float* float_type = type->AsFloat(); |
| if (float_type == nullptr) { |
| return nullptr; |
| } |
| |
| switch (float_type->width()) { |
| case 32: |
| return const_mgr->GetFloatConst(std::numeric_limits<float>::infinity()); |
| case 64: |
| return const_mgr->GetDoubleConst(std::numeric_limits<double>::infinity()); |
| default: |
| return nullptr; |
| } |
| } |
| |
| // 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; |
| } |
| |
| // Returns a constants with the value |-val| of the given type. Only works for |
| // 32-bit and 64-bit float point types. Returns |nullptr| if an error occurs. |
| const analysis::Constant* NegateFPConst(const analysis::Type* result_type, |
| const analysis::Constant* val, |
| analysis::ConstantManager* const_mgr) { |
| const analysis::Float* float_type = result_type->AsFloat(); |
| assert(float_type != nullptr); |
| if (float_type->width() == 32) { |
| float fa = val->GetFloat(); |
| return const_mgr->GetFloatConst(-fa); |
| } else if (float_type->width() == 64) { |
| double da = val->GetDouble(); |
| return const_mgr->GetDoubleConst(-da); |
| } |
| return nullptr; |
| } |
| |
| // 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; |
| }; |
| } |
| |
| // Folds an OpcompositeInsert where input is a composite constant. |
| ConstantFoldingRule FoldInsertWithConstants() { |
| return [](IRContext* context, Instruction* inst, |
| const std::vector<const analysis::Constant*>& constants) |
| -> const analysis::Constant* { |
| analysis::ConstantManager* const_mgr = context->get_constant_mgr(); |
| const analysis::Constant* object = constants[0]; |
| const analysis::Constant* composite = constants[1]; |
| if (object == nullptr || composite == nullptr) { |
| return nullptr; |
| } |
| |
| // If there is more than 1 index, then each additional constant used by the |
| // index will need to be recreated to use the inserted object. |
| std::vector<const analysis::Constant*> chain; |
| std::vector<const analysis::Constant*> components; |
| const analysis::Type* type = nullptr; |
| const uint32_t final_index = (inst->NumInOperands() - 1); |
| |
| // Work down hierarchy of all indexes |
| for (uint32_t i = 2; i < inst->NumInOperands(); ++i) { |
| type = composite->type(); |
| |
| if (composite->AsNullConstant()) { |
| // Make new composite so it can be inserted in the index with the |
| // non-null value |
| if (const auto new_composite = |
| const_mgr->GetNullCompositeConstant(type)) { |
| // Keep track of any indexes along the way to last index |
| if (i != final_index) { |
| chain.push_back(new_composite); |
| } |
| components = new_composite->AsCompositeConstant()->GetComponents(); |
| } else { |
| // Unsupported input type (such as structs) |
| return nullptr; |
| } |
| } else { |
| // Keep track of any indexes along the way to last index |
| if (i != final_index) { |
| chain.push_back(composite); |
| } |
| components = composite->AsCompositeConstant()->GetComponents(); |
| } |
| const uint32_t index = inst->GetSingleWordInOperand(i); |
| composite = components[index]; |
| } |
| |
| // Final index in hierarchy is inserted with new object. |
| const uint32_t final_operand = inst->GetSingleWordInOperand(final_index); |
| std::vector<uint32_t> ids; |
| for (size_t i = 0; i < components.size(); i++) { |
| const analysis::Constant* constant = |
| (i == final_operand) ? object : components[i]; |
| Instruction* member_inst = const_mgr->GetDefiningInstruction(constant); |
| ids.push_back(member_inst->result_id()); |
| } |
| const analysis::Constant* new_constant = const_mgr->GetConstant(type, ids); |
| |
| // Work backwards up the chain and replace each index with new constant. |
| for (size_t i = chain.size(); i > 0; i--) { |
| // Need to insert any previous instruction into the module first. |
| // Can't just insert in types_values_begin() because it will move above |
| // where the types are declared. |
| // Can't compare with location of inst because not all new added |
| // instructions are added to types_values_ |
| auto iter = context->types_values_end(); |
| Module::inst_iterator* pos = &iter; |
| const_mgr->BuildInstructionAndAddToModule(new_constant, pos); |
| |
| composite = chain[i - 1]; |
| components = composite->AsCompositeConstant()->GetComponents(); |
| type = composite->type(); |
| ids.clear(); |
| for (size_t k = 0; k < components.size(); k++) { |
| const uint32_t index = |
| inst->GetSingleWordInOperand(1 + static_cast<uint32_t>(i)); |
| const analysis::Constant* constant = |
| (k == index) ? new_constant : components[k]; |
| const uint32_t constant_id = |
| const_mgr->FindDeclaredConstant(constant, 0); |
| ids.push_back(constant_id); |
| } |
| new_constant = const_mgr->GetConstant(type, ids); |
| } |
| |
| // If multiple constants were created, only need to return the top index. |
| return new_constant; |
| }; |
| } |
| |
| ConstantFoldingRule FoldVectorShuffleWithConstants() { |
| return [](IRContext* context, Instruction* inst, |
| const std::vector<const analysis::Constant*>& constants) |
| -> const analysis::Constant* { |
| assert(inst->opcode() == spv::Op::OpVectorShuffle); |
| 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() == spv::Op::OpVectorTimesScalar); |
| 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 FoldVectorTimesMatrix() { |
| return [](IRContext* context, Instruction* inst, |
| const std::vector<const analysis::Constant*>& constants) |
| -> const analysis::Constant* { |
| assert(inst->opcode() == spv::Op::OpVectorTimesMatrix); |
| 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 == 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()->AsMatrix()->element_type() == vector_type); |
| |
| // Get a float vector that is the result of vector-times-matrix. |
| std::vector<const analysis::Constant*> c1_components = |
| c1->GetVectorComponents(const_mgr); |
| std::vector<const analysis::Constant*> c2_components = |
| c2->AsMatrixConstant()->GetComponents(); |
| uint32_t resultVectorSize = result_type->AsVector()->element_count(); |
| |
| std::vector<uint32_t> ids; |
| |
| if ((c1 && c1->IsZero()) || (c2 && c2->IsZero())) { |
| std::vector<uint32_t> words(float_type->width() / 32, 0); |
| for (uint32_t i = 0; i < resultVectorSize; ++i) { |
| 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); |
| } |
| |
| if (float_type->width() == 32) { |
| for (uint32_t i = 0; i < resultVectorSize; ++i) { |
| float result_scalar = 0.0f; |
| if (!c2_components[i]->AsNullConstant()) { |
| const analysis::VectorConstant* c2_vec = |
| c2_components[i]->AsVectorConstant(); |
| for (uint32_t j = 0; j < c2_vec->GetComponents().size(); ++j) { |
| float c1_scalar = c1_components[j]->GetFloat(); |
| float c2_scalar = c2_vec->GetComponents()[j]->GetFloat(); |
| result_scalar += c1_scalar * c2_scalar; |
| } |
| } |
| utils::FloatProxy<float> result(result_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) { |
| for (uint32_t i = 0; i < c2_components.size(); ++i) { |
| double result_scalar = 0.0; |
| if (!c2_components[i]->AsNullConstant()) { |
| const analysis::VectorConstant* c2_vec = |
| c2_components[i]->AsVectorConstant(); |
| for (uint32_t j = 0; j < c2_vec->GetComponents().size(); ++j) { |
| double c1_scalar = c1_components[j]->GetDouble(); |
| double c2_scalar = c2_vec->GetComponents()[j]->GetDouble(); |
| result_scalar += c1_scalar * c2_scalar; |
| } |
| } |
| utils::FloatProxy<double> result(result_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 FoldMatrixTimesVector() { |
| return [](IRContext* context, Instruction* inst, |
| const std::vector<const analysis::Constant*>& constants) |
| -> const analysis::Constant* { |
| assert(inst->opcode() == spv::Op::OpMatrixTimesVector); |
| 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 == 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()->AsMatrix()->element_type() == vector_type); |
| assert(c2->type()->AsVector()->element_type() == element_type); |
| |
| // Get a float vector that is the result of matrix-times-vector. |
| std::vector<const analysis::Constant*> c1_components = |
| c1->AsMatrixConstant()->GetComponents(); |
| std::vector<const analysis::Constant*> c2_components = |
| c2->GetVectorComponents(const_mgr); |
| uint32_t resultVectorSize = result_type->AsVector()->element_count(); |
| |
| std::vector<uint32_t> ids; |
| |
| if ((c1 && c1->IsZero()) || (c2 && c2->IsZero())) { |
| std::vector<uint32_t> words(float_type->width() / 32, 0); |
| for (uint32_t i = 0; i < resultVectorSize; ++i) { |
| 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); |
| } |
| |
| if (float_type->width() == 32) { |
| for (uint32_t i = 0; i < resultVectorSize; ++i) { |
| float result_scalar = 0.0f; |
| for (uint32_t j = 0; j < c1_components.size(); ++j) { |
| if (!c1_components[j]->AsNullConstant()) { |
| float c1_scalar = c1_components[j] |
| ->AsVectorConstant() |
| ->GetComponents()[i] |
| ->GetFloat(); |
| float c2_scalar = c2_components[j]->GetFloat(); |
| result_scalar += c1_scalar * c2_scalar; |
| } |
| } |
| utils::FloatProxy<float> result(result_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) { |
| for (uint32_t i = 0; i < resultVectorSize; ++i) { |
| double result_scalar = 0.0; |
| for (uint32_t j = 0; j < c1_components.size(); ++j) { |
| if (!c1_components[j]->AsNullConstant()) { |
| double c1_scalar = c1_components[j] |
| ->AsVectorConstant() |
| ->GetComponents()[i] |
| ->GetDouble(); |
| double c2_scalar = c2_components[j]->GetDouble(); |
| result_scalar += c1_scalar * c2_scalar; |
| } |
| } |
| utils::FloatProxy<double> result(result_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() == spv::Op::OpTypeStruct) { |
| component_type_id = type_inst->GetSingleWordInOperand(i); |
| } else if (type_inst->opcode() == spv::Op::OpTypeArray) { |
| 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() == spv::Op::OpExtInst) ? 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() == spv::Op::OpExtInst) { |
| 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(*)); } |
| |
| // Returns the constant that results from evaluating |numerator| / 0.0. Returns |
| // |nullptr| if the result could not be evaluated. |
| const analysis::Constant* FoldFPScalarDivideByZero( |
| const analysis::Type* result_type, const analysis::Constant* numerator, |
| analysis::ConstantManager* const_mgr) { |
| if (numerator == nullptr) { |
| return nullptr; |
| } |
| |
| if (numerator->IsZero()) { |
| return GetNan(result_type, const_mgr); |
| } |
| |
| const analysis::Constant* result = GetInf(result_type, const_mgr); |
| if (result == nullptr) { |
| return nullptr; |
| } |
| |
| if (numerator->AsFloatConstant()->GetValueAsDouble() < 0.0) { |
| result = NegateFPConst(result_type, result, const_mgr); |
| } |
| return result; |
| } |
| |
| // Returns the result of folding |numerator| / |denominator|. Returns |nullptr| |
| // if it cannot be folded. |
| const analysis::Constant* FoldScalarFPDivide( |
| const analysis::Type* result_type, const analysis::Constant* numerator, |
| const analysis::Constant* denominator, |
| analysis::ConstantManager* const_mgr) { |
| if (denominator == nullptr) { |
| return nullptr; |
| } |
| |
| if (denominator->IsZero()) { |
| return FoldFPScalarDivideByZero(result_type, numerator, const_mgr); |
| } |
| |
| const analysis::FloatConstant* denominator_float = |
| denominator->AsFloatConstant(); |
| if (denominator_float && denominator->GetValueAsDouble() == -0.0) { |
| const analysis::Constant* result = |
| FoldFPScalarDivideByZero(result_type, numerator, const_mgr); |
| if (result != nullptr) |
| result = NegateFPConst(result_type, result, const_mgr); |
| return result; |
| } else { |
| return FOLD_FPARITH_OP(/)(result_type, numerator, denominator, const_mgr); |
| } |
| } |
| |
| // Returns the constant folding rule to fold |OpFDiv| with two constants. |
| ConstantFoldingRule FoldFDiv() { return FoldFPBinaryOp(FoldScalarFPDivide); } |
| |
| 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()); |
| return NegateFPConst(result_type, a, const_mgr); |
| }; |
| } |
| |
| ConstantFoldingRule FoldFNegate() { return FoldFPUnaryOp(FoldFNegateOp()); } |
| |
| ConstantFoldingRule FoldFClampFeedingCompare(spv::Op 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() != spv::Op::OpExtInst) { |
| 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 spv::Op::OpFOrdLessThan: |
| case spv::Op::OpFUnordLessThan: |
| case spv::Op::OpFOrdGreaterThanEqual: |
| case spv::Op::OpFUnordGreaterThanEqual: |
| if (constants[0]) { |
| if (min_const) { |
| if (constants[0]->GetValueAsDouble() < |
| min_const->GetValueAsDouble()) { |
| found_result = true; |
| result = (cmp_opcode == spv::Op::OpFOrdLessThan || |
| cmp_opcode == spv::Op::OpFUnordLessThan); |
| } |
| } |
| if (max_const) { |
| if (constants[0]->GetValueAsDouble() >= |
| max_const->GetValueAsDouble()) { |
| found_result = true; |
| result = !(cmp_opcode == spv::Op::OpFOrdLessThan || |
| cmp_opcode == spv::Op::OpFUnordLessThan); |
| } |
| } |
| } |
| |
| if (constants[1]) { |
| if (max_const) { |
| if (max_const->GetValueAsDouble() < |
| constants[1]->GetValueAsDouble()) { |
| found_result = true; |
| result = (cmp_opcode == spv::Op::OpFOrdLessThan || |
| cmp_opcode == spv::Op::OpFUnordLessThan); |
| } |
| } |
| |
| if (min_const) { |
| if (min_const->GetValueAsDouble() >= |
| constants[1]->GetValueAsDouble()) { |
| found_result = true; |
| result = !(cmp_opcode == spv::Op::OpFOrdLessThan || |
| cmp_opcode == spv::Op::OpFUnordLessThan); |
| } |
| } |
| } |
| break; |
| case spv::Op::OpFOrdGreaterThan: |
| case spv::Op::OpFUnordGreaterThan: |
| case spv::Op::OpFOrdLessThanEqual: |
| case spv::Op::OpFUnordLessThanEqual: |
| if (constants[0]) { |
| if (min_const) { |
| if (constants[0]->GetValueAsDouble() <= |
| min_const->GetValueAsDouble()) { |
| found_result = true; |
| result = (cmp_opcode == spv::Op::OpFOrdLessThanEqual || |
| cmp_opcode == spv::Op::OpFUnordLessThanEqual); |
| } |
| } |
| if (max_const) { |
| if (constants[0]->GetValueAsDouble() > |
| max_const->GetValueAsDouble()) { |
| found_result = true; |
| result = !(cmp_opcode == spv::Op::OpFOrdLessThanEqual || |
| cmp_opcode == spv::Op::OpFUnordLessThanEqual); |
| } |
| } |
| } |
| |
| if (constants[1]) { |
| if (max_const) { |
| if (max_const->GetValueAsDouble() <= |
| constants[1]->GetValueAsDouble()) { |
| found_result = true; |
| result = (cmp_opcode == spv::Op::OpFOrdLessThanEqual || |
| cmp_opcode == spv::Op::OpFUnordLessThanEqual); |
| } |
| } |
| |
| if (min_const) { |
| if (min_const->GetValueAsDouble() > |
| constants[1]->GetValueAsDouble()) { |
| found_result = true; |
| result = !(cmp_opcode == spv::Op::OpFOrdLessThanEqual || |
| cmp_opcode == spv::Op::OpFUnordLessThanEqual); |
| } |
| } |
| } |
| 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() == spv::Op::OpExtInst && |
| "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); |
| }; |
| } |
| |
| 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() == spv::Op::OpExtInst && |
| "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 < 4; 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() == spv::Op::OpExtInst && |
| "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() == spv::Op::OpExtInst && |
| "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_[spv::Op::OpCompositeConstruct].push_back(FoldCompositeWithConstants()); |
| |
| rules_[spv::Op::OpCompositeExtract].push_back(FoldExtractWithConstants()); |
| rules_[spv::Op::OpCompositeInsert].push_back(FoldInsertWithConstants()); |
| |
| rules_[spv::Op::OpConvertFToS].push_back(FoldFToI()); |
| rules_[spv::Op::OpConvertFToU].push_back(FoldFToI()); |
| rules_[spv::Op::OpConvertSToF].push_back(FoldIToF()); |
| rules_[spv::Op::OpConvertUToF].push_back(FoldIToF()); |
| |
| rules_[spv::Op::OpDot].push_back(FoldOpDotWithConstants()); |
| rules_[spv::Op::OpFAdd].push_back(FoldFAdd()); |
| rules_[spv::Op::OpFDiv].push_back(FoldFDiv()); |
| rules_[spv::Op::OpFMul].push_back(FoldFMul()); |
| rules_[spv::Op::OpFSub].push_back(FoldFSub()); |
| |
| rules_[spv::Op::OpFOrdEqual].push_back(FoldFOrdEqual()); |
| |
| rules_[spv::Op::OpFUnordEqual].push_back(FoldFUnordEqual()); |
| |
| rules_[spv::Op::OpFOrdNotEqual].push_back(FoldFOrdNotEqual()); |
| |
| rules_[spv::Op::OpFUnordNotEqual].push_back(FoldFUnordNotEqual()); |
| |
| rules_[spv::Op::OpFOrdLessThan].push_back(FoldFOrdLessThan()); |
| rules_[spv::Op::OpFOrdLessThan].push_back( |
| FoldFClampFeedingCompare(spv::Op::OpFOrdLessThan)); |
| |
| rules_[spv::Op::OpFUnordLessThan].push_back(FoldFUnordLessThan()); |
| rules_[spv::Op::OpFUnordLessThan].push_back( |
| FoldFClampFeedingCompare(spv::Op::OpFUnordLessThan)); |
| |
| rules_[spv::Op::OpFOrdGreaterThan].push_back(FoldFOrdGreaterThan()); |
| rules_[spv::Op::OpFOrdGreaterThan].push_back( |
| FoldFClampFeedingCompare(spv::Op::OpFOrdGreaterThan)); |
| |
| rules_[spv::Op::OpFUnordGreaterThan].push_back(FoldFUnordGreaterThan()); |
| rules_[spv::Op::OpFUnordGreaterThan].push_back( |
| FoldFClampFeedingCompare(spv::Op::OpFUnordGreaterThan)); |
| |
| rules_[spv::Op::OpFOrdLessThanEqual].push_back(FoldFOrdLessThanEqual()); |
| rules_[spv::Op::OpFOrdLessThanEqual].push_back( |
| FoldFClampFeedingCompare(spv::Op::OpFOrdLessThanEqual)); |
| |
| rules_[spv::Op::OpFUnordLessThanEqual].push_back(FoldFUnordLessThanEqual()); |
| rules_[spv::Op::OpFUnordLessThanEqual].push_back( |
| FoldFClampFeedingCompare(spv::Op::OpFUnordLessThanEqual)); |
| |
| rules_[spv::Op::OpFOrdGreaterThanEqual].push_back(FoldFOrdGreaterThanEqual()); |
| rules_[spv::Op::OpFOrdGreaterThanEqual].push_back( |
| FoldFClampFeedingCompare(spv::Op::OpFOrdGreaterThanEqual)); |
| |
| rules_[spv::Op::OpFUnordGreaterThanEqual].push_back( |
| FoldFUnordGreaterThanEqual()); |
| rules_[spv::Op::OpFUnordGreaterThanEqual].push_back( |
| FoldFClampFeedingCompare(spv::Op::OpFUnordGreaterThanEqual)); |
| |
| rules_[spv::Op::OpVectorShuffle].push_back(FoldVectorShuffleWithConstants()); |
| rules_[spv::Op::OpVectorTimesScalar].push_back(FoldVectorTimesScalar()); |
| rules_[spv::Op::OpVectorTimesMatrix].push_back(FoldVectorTimesMatrix()); |
| rules_[spv::Op::OpMatrixTimesVector].push_back(FoldMatrixTimesVector()); |
| |
| rules_[spv::Op::OpFNegate].push_back(FoldFNegate()); |
| rules_[spv::Op::OpQuantizeToF16].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 targeting 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 |
