SPIRV-Tools/source/opt/relax_float_ops_pass.cpp
alan-baker d35a78db57
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981)
Fixes #4960

* Switches to using enum classes with an underlying type to avoid
  undefined behaviour
2022-11-04 17:27:10 -04:00

181 lines
6.7 KiB
C++

// Copyright (c) 2019 The Khronos Group Inc.
// 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.
#include "relax_float_ops_pass.h"
#include "source/opt/ir_builder.h"
namespace spvtools {
namespace opt {
bool RelaxFloatOpsPass::IsRelaxable(Instruction* inst) {
return target_ops_core_f_rslt_.count(inst->opcode()) != 0 ||
target_ops_core_f_opnd_.count(inst->opcode()) != 0 ||
sample_ops_.count(inst->opcode()) != 0 ||
(inst->opcode() == spv::Op::OpExtInst &&
inst->GetSingleWordInOperand(0) ==
context()->get_feature_mgr()->GetExtInstImportId_GLSLstd450() &&
target_ops_450_.count(inst->GetSingleWordInOperand(1)) != 0);
}
bool RelaxFloatOpsPass::IsFloat32(Instruction* inst) {
uint32_t ty_id;
if (target_ops_core_f_opnd_.count(inst->opcode()) != 0) {
uint32_t opnd_id = inst->GetSingleWordInOperand(0);
Instruction* opnd_inst = get_def_use_mgr()->GetDef(opnd_id);
ty_id = opnd_inst->type_id();
} else {
ty_id = inst->type_id();
if (ty_id == 0) return false;
}
return IsFloat(ty_id, 32);
}
bool RelaxFloatOpsPass::IsRelaxed(uint32_t r_id) {
for (auto r_inst : get_decoration_mgr()->GetDecorationsFor(r_id, false))
if (r_inst->opcode() == spv::Op::OpDecorate &&
spv::Decoration(r_inst->GetSingleWordInOperand(1)) ==
spv::Decoration::RelaxedPrecision)
return true;
return false;
}
bool RelaxFloatOpsPass::ProcessInst(Instruction* r_inst) {
uint32_t r_id = r_inst->result_id();
if (r_id == 0) return false;
if (!IsFloat32(r_inst)) return false;
if (IsRelaxed(r_id)) return false;
if (!IsRelaxable(r_inst)) return false;
get_decoration_mgr()->AddDecoration(
r_id, uint32_t(spv::Decoration::RelaxedPrecision));
return true;
}
bool RelaxFloatOpsPass::ProcessFunction(Function* func) {
bool modified = false;
cfg()->ForEachBlockInReversePostOrder(
func->entry().get(), [&modified, this](BasicBlock* bb) {
for (auto ii = bb->begin(); ii != bb->end(); ++ii)
modified |= ProcessInst(&*ii);
});
return modified;
}
Pass::Status RelaxFloatOpsPass::ProcessImpl() {
Pass::ProcessFunction pfn = [this](Function* fp) {
return ProcessFunction(fp);
};
bool modified = context()->ProcessReachableCallTree(pfn);
return modified ? Status::SuccessWithChange : Status::SuccessWithoutChange;
}
Pass::Status RelaxFloatOpsPass::Process() {
Initialize();
return ProcessImpl();
}
void RelaxFloatOpsPass::Initialize() {
target_ops_core_f_rslt_ = {
spv::Op::OpLoad,
spv::Op::OpPhi,
spv::Op::OpVectorExtractDynamic,
spv::Op::OpVectorInsertDynamic,
spv::Op::OpVectorShuffle,
spv::Op::OpCompositeExtract,
spv::Op::OpCompositeConstruct,
spv::Op::OpCompositeInsert,
spv::Op::OpCopyObject,
spv::Op::OpTranspose,
spv::Op::OpConvertSToF,
spv::Op::OpConvertUToF,
spv::Op::OpFConvert,
// spv::Op::OpQuantizeToF16,
spv::Op::OpFNegate,
spv::Op::OpFAdd,
spv::Op::OpFSub,
spv::Op::OpFMul,
spv::Op::OpFDiv,
spv::Op::OpFMod,
spv::Op::OpVectorTimesScalar,
spv::Op::OpMatrixTimesScalar,
spv::Op::OpVectorTimesMatrix,
spv::Op::OpMatrixTimesVector,
spv::Op::OpMatrixTimesMatrix,
spv::Op::OpOuterProduct,
spv::Op::OpDot,
spv::Op::OpSelect,
};
target_ops_core_f_opnd_ = {
spv::Op::OpFOrdEqual,
spv::Op::OpFUnordEqual,
spv::Op::OpFOrdNotEqual,
spv::Op::OpFUnordNotEqual,
spv::Op::OpFOrdLessThan,
spv::Op::OpFUnordLessThan,
spv::Op::OpFOrdGreaterThan,
spv::Op::OpFUnordGreaterThan,
spv::Op::OpFOrdLessThanEqual,
spv::Op::OpFUnordLessThanEqual,
spv::Op::OpFOrdGreaterThanEqual,
spv::Op::OpFUnordGreaterThanEqual,
};
target_ops_450_ = {
GLSLstd450Round, GLSLstd450RoundEven, GLSLstd450Trunc, GLSLstd450FAbs,
GLSLstd450FSign, GLSLstd450Floor, GLSLstd450Ceil, GLSLstd450Fract,
GLSLstd450Radians, GLSLstd450Degrees, GLSLstd450Sin, GLSLstd450Cos,
GLSLstd450Tan, GLSLstd450Asin, GLSLstd450Acos, GLSLstd450Atan,
GLSLstd450Sinh, GLSLstd450Cosh, GLSLstd450Tanh, GLSLstd450Asinh,
GLSLstd450Acosh, GLSLstd450Atanh, GLSLstd450Atan2, GLSLstd450Pow,
GLSLstd450Exp, GLSLstd450Log, GLSLstd450Exp2, GLSLstd450Log2,
GLSLstd450Sqrt, GLSLstd450InverseSqrt, GLSLstd450Determinant,
GLSLstd450MatrixInverse,
// TODO(greg-lunarg): GLSLstd450ModfStruct,
GLSLstd450FMin, GLSLstd450FMax, GLSLstd450FClamp, GLSLstd450FMix,
GLSLstd450Step, GLSLstd450SmoothStep, GLSLstd450Fma,
// TODO(greg-lunarg): GLSLstd450FrexpStruct,
GLSLstd450Ldexp, GLSLstd450Length, GLSLstd450Distance, GLSLstd450Cross,
GLSLstd450Normalize, GLSLstd450FaceForward, GLSLstd450Reflect,
GLSLstd450Refract, GLSLstd450NMin, GLSLstd450NMax, GLSLstd450NClamp};
sample_ops_ = {spv::Op::OpImageSampleImplicitLod,
spv::Op::OpImageSampleExplicitLod,
spv::Op::OpImageSampleDrefImplicitLod,
spv::Op::OpImageSampleDrefExplicitLod,
spv::Op::OpImageSampleProjImplicitLod,
spv::Op::OpImageSampleProjExplicitLod,
spv::Op::OpImageSampleProjDrefImplicitLod,
spv::Op::OpImageSampleProjDrefExplicitLod,
spv::Op::OpImageFetch,
spv::Op::OpImageGather,
spv::Op::OpImageDrefGather,
spv::Op::OpImageRead,
spv::Op::OpImageSparseSampleImplicitLod,
spv::Op::OpImageSparseSampleExplicitLod,
spv::Op::OpImageSparseSampleDrefImplicitLod,
spv::Op::OpImageSparseSampleDrefExplicitLod,
spv::Op::OpImageSparseSampleProjImplicitLod,
spv::Op::OpImageSparseSampleProjExplicitLod,
spv::Op::OpImageSparseSampleProjDrefImplicitLod,
spv::Op::OpImageSparseSampleProjDrefExplicitLod,
spv::Op::OpImageSparseFetch,
spv::Op::OpImageSparseGather,
spv::Op::OpImageSparseDrefGather,
spv::Op::OpImageSparseTexelsResident,
spv::Op::OpImageSparseRead};
}
} // namespace opt
} // namespace spvtools