| // Copyright (c) 2019 Valve Corporation |
| // Copyright (c) 2019 LunarG Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #ifndef LIBSPIRV_OPT_RELAX_FLOAT_OPS_PASS_H_ |
| #define LIBSPIRV_OPT_RELAX_FLOAT_OPS_PASS_H_ |
| |
| #include "source/opt/ir_builder.h" |
| #include "source/opt/pass.h" |
| |
| namespace spvtools { |
| namespace opt { |
| |
| class RelaxFloatOpsPass : public Pass { |
| public: |
| RelaxFloatOpsPass() : Pass() {} |
| |
| ~RelaxFloatOpsPass() override = default; |
| |
| IRContext::Analysis GetPreservedAnalyses() override { |
| return IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping; |
| } |
| |
| // See optimizer.hpp for pass user documentation. |
| Status Process() override; |
| |
| const char* name() const override { return "convert-to-half-pass"; } |
| |
| private: |
| // Return true if |inst| can have the RelaxedPrecision decoration applied |
| // to it. |
| bool IsRelaxable(Instruction* inst); |
| |
| // Return true if |inst| returns scalar, vector or matrix type with base |
| // float and width 32 |
| bool IsFloat32(Instruction* inst); |
| |
| // Return true if |r_id| is decorated with RelaxedPrecision |
| bool IsRelaxed(uint32_t r_id); |
| |
| // If |inst| is an instruction of float32-based type and is not decorated |
| // RelaxedPrecision, add such a decoration to the module. |
| bool ProcessInst(Instruction* inst); |
| |
| // Call ProcessInst on every instruction in |func|. |
| bool ProcessFunction(Function* func); |
| |
| Pass::Status ProcessImpl(); |
| |
| // Initialize state for converting to half |
| void Initialize(); |
| |
| struct hasher { |
| size_t operator()(const spv::Op& op) const noexcept { |
| return std::hash<uint32_t>()(uint32_t(op)); |
| } |
| }; |
| |
| // Set of float result core operations to be processed |
| std::unordered_set<spv::Op, hasher> target_ops_core_f_rslt_; |
| |
| // Set of float operand core operations to be processed |
| std::unordered_set<spv::Op, hasher> target_ops_core_f_opnd_; |
| |
| // Set of 450 extension operations to be processed |
| std::unordered_set<uint32_t> target_ops_450_; |
| |
| // Set of sample operations |
| std::unordered_set<spv::Op, hasher> sample_ops_; |
| }; |
| |
| } // namespace opt |
| } // namespace spvtools |
| |
| #endif // LIBSPIRV_OPT_RELAX_FLOAT_OPS_PASS_H_ |