Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/KhronosGroup/SPIRV-Tools.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/source/opt/folding_rules.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/opt/folding_rules.cpp')
-rw-r--r--source/opt/folding_rules.cpp655
1 files changed, 352 insertions, 303 deletions
diff --git a/source/opt/folding_rules.cpp b/source/opt/folding_rules.cpp
index 3d803addc..1a4fdcc73 100644
--- a/source/opt/folding_rules.cpp
+++ b/source/opt/folding_rules.cpp
@@ -43,33 +43,33 @@ const uint32_t kStoreObjectInIdx = 1;
int32_t ImageOperandsMaskInOperandIndex(Instruction* inst) {
const auto opcode = inst->opcode();
switch (opcode) {
- case SpvOpImageSampleImplicitLod:
- case SpvOpImageSampleExplicitLod:
- case SpvOpImageSampleProjImplicitLod:
- case SpvOpImageSampleProjExplicitLod:
- case SpvOpImageFetch:
- case SpvOpImageRead:
- case SpvOpImageSparseSampleImplicitLod:
- case SpvOpImageSparseSampleExplicitLod:
- case SpvOpImageSparseSampleProjImplicitLod:
- case SpvOpImageSparseSampleProjExplicitLod:
- case SpvOpImageSparseFetch:
- case SpvOpImageSparseRead:
+ case spv::Op::OpImageSampleImplicitLod:
+ case spv::Op::OpImageSampleExplicitLod:
+ case spv::Op::OpImageSampleProjImplicitLod:
+ case spv::Op::OpImageSampleProjExplicitLod:
+ case spv::Op::OpImageFetch:
+ case spv::Op::OpImageRead:
+ case spv::Op::OpImageSparseSampleImplicitLod:
+ case spv::Op::OpImageSparseSampleExplicitLod:
+ case spv::Op::OpImageSparseSampleProjImplicitLod:
+ case spv::Op::OpImageSparseSampleProjExplicitLod:
+ case spv::Op::OpImageSparseFetch:
+ case spv::Op::OpImageSparseRead:
return inst->NumOperands() > 4 ? 2 : -1;
- case SpvOpImageSampleDrefImplicitLod:
- case SpvOpImageSampleDrefExplicitLod:
- case SpvOpImageSampleProjDrefImplicitLod:
- case SpvOpImageSampleProjDrefExplicitLod:
- case SpvOpImageGather:
- case SpvOpImageDrefGather:
- case SpvOpImageSparseSampleDrefImplicitLod:
- case SpvOpImageSparseSampleDrefExplicitLod:
- case SpvOpImageSparseSampleProjDrefImplicitLod:
- case SpvOpImageSparseSampleProjDrefExplicitLod:
- case SpvOpImageSparseGather:
- case SpvOpImageSparseDrefGather:
+ case spv::Op::OpImageSampleDrefImplicitLod:
+ case spv::Op::OpImageSampleDrefExplicitLod:
+ case spv::Op::OpImageSampleProjDrefImplicitLod:
+ case spv::Op::OpImageSampleProjDrefExplicitLod:
+ case spv::Op::OpImageGather:
+ case spv::Op::OpImageDrefGather:
+ case spv::Op::OpImageSparseSampleDrefImplicitLod:
+ case spv::Op::OpImageSparseSampleDrefExplicitLod:
+ case spv::Op::OpImageSparseSampleProjDrefImplicitLod:
+ case spv::Op::OpImageSparseSampleProjDrefExplicitLod:
+ case spv::Op::OpImageSparseGather:
+ case spv::Op::OpImageSparseDrefGather:
return inst->NumOperands() > 5 ? 3 : -1;
- case SpvOpImageWrite:
+ case spv::Op::OpImageWrite:
return inst->NumOperands() > 3 ? 3 : -1;
default:
return -1;
@@ -304,7 +304,7 @@ uint32_t Reciprocal(analysis::ConstantManager* const_mgr,
FoldingRule ReciprocalFDiv() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFDiv);
+ assert(inst->opcode() == spv::Op::OpFDiv);
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
@@ -333,7 +333,7 @@ FoldingRule ReciprocalFDiv() {
// Don't fold a null constant.
return false;
}
- inst->SetOpcode(SpvOpFMul);
+ inst->SetOpcode(spv::Op::OpFMul);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0u)}},
{SPV_OPERAND_TYPE_ID, {id}}});
@@ -348,7 +348,8 @@ FoldingRule ReciprocalFDiv() {
FoldingRule MergeNegateArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFNegate || inst->opcode() == SpvOpSNegate);
+ assert(inst->opcode() == spv::Op::OpFNegate ||
+ inst->opcode() == spv::Op::OpSNegate);
(void)constants;
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
@@ -362,7 +363,7 @@ FoldingRule MergeNegateArithmetic() {
if (op_inst->opcode() == inst->opcode()) {
// Elide negates.
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {op_inst->GetSingleWordInOperand(0u)}}});
return true;
@@ -382,7 +383,8 @@ FoldingRule MergeNegateArithmetic() {
FoldingRule MergeNegateMulDivArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFNegate || inst->opcode() == SpvOpSNegate);
+ assert(inst->opcode() == spv::Op::OpFNegate ||
+ inst->opcode() == spv::Op::OpSNegate);
(void)constants;
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
const analysis::Type* type =
@@ -398,9 +400,10 @@ FoldingRule MergeNegateMulDivArithmetic() {
uint32_t width = ElementWidth(type);
if (width != 32 && width != 64) return false;
- SpvOp opcode = op_inst->opcode();
- if (opcode == SpvOpFMul || opcode == SpvOpFDiv || opcode == SpvOpIMul ||
- opcode == SpvOpSDiv || opcode == SpvOpUDiv) {
+ spv::Op opcode = op_inst->opcode();
+ if (opcode == spv::Op::OpFMul || opcode == spv::Op::OpFDiv ||
+ opcode == spv::Op::OpIMul || opcode == spv::Op::OpSDiv ||
+ opcode == spv::Op::OpUDiv) {
std::vector<const analysis::Constant*> op_constants =
const_mgr->GetOperandConstants(op_inst);
// Merge negate into mul or div if one operand is constant.
@@ -413,7 +416,8 @@ FoldingRule MergeNegateMulDivArithmetic() {
: op_inst->GetSingleWordInOperand(1u);
// Change this instruction to a mul/div.
inst->SetOpcode(op_inst->opcode());
- if (opcode == SpvOpFDiv || opcode == SpvOpUDiv || opcode == SpvOpSDiv) {
+ if (opcode == spv::Op::OpFDiv || opcode == spv::Op::OpUDiv ||
+ opcode == spv::Op::OpSDiv) {
uint32_t op0 = zero_is_variable ? non_const_id : neg_id;
uint32_t op1 = zero_is_variable ? neg_id : non_const_id;
inst->SetInOperands(
@@ -440,7 +444,8 @@ FoldingRule MergeNegateMulDivArithmetic() {
FoldingRule MergeNegateAddSubArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFNegate || inst->opcode() == SpvOpSNegate);
+ assert(inst->opcode() == spv::Op::OpFNegate ||
+ inst->opcode() == spv::Op::OpSNegate);
(void)constants;
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
const analysis::Type* type =
@@ -456,14 +461,16 @@ FoldingRule MergeNegateAddSubArithmetic() {
uint32_t width = ElementWidth(type);
if (width != 32 && width != 64) return false;
- if (op_inst->opcode() == SpvOpFAdd || op_inst->opcode() == SpvOpFSub ||
- op_inst->opcode() == SpvOpIAdd || op_inst->opcode() == SpvOpISub) {
+ if (op_inst->opcode() == spv::Op::OpFAdd ||
+ op_inst->opcode() == spv::Op::OpFSub ||
+ op_inst->opcode() == spv::Op::OpIAdd ||
+ op_inst->opcode() == spv::Op::OpISub) {
std::vector<const analysis::Constant*> op_constants =
const_mgr->GetOperandConstants(op_inst);
if (op_constants[0] || op_constants[1]) {
bool zero_is_variable = op_constants[0] == nullptr;
- bool is_add = (op_inst->opcode() == SpvOpFAdd) ||
- (op_inst->opcode() == SpvOpIAdd);
+ bool is_add = (op_inst->opcode() == spv::Op::OpFAdd) ||
+ (op_inst->opcode() == spv::Op::OpIAdd);
bool swap_operands = !is_add || zero_is_variable;
bool negate_const = is_add;
const analysis::Constant* c = ConstInput(op_constants);
@@ -481,7 +488,8 @@ FoldingRule MergeNegateAddSubArithmetic() {
uint32_t op1 =
zero_is_variable ? const_id : op_inst->GetSingleWordInOperand(1u);
if (swap_operands) std::swap(op0, op1);
- inst->SetOpcode(HasFloatingPoint(type) ? SpvOpFSub : SpvOpISub);
+ inst->SetOpcode(HasFloatingPoint(type) ? spv::Op::OpFSub
+ : spv::Op::OpISub);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {op0}}, {SPV_OPERAND_TYPE_ID, {op1}}});
return true;
@@ -512,7 +520,7 @@ bool HasZero(const analysis::Constant* c) {
// id. Returns 0 if the result is not a valid value. The input types must be
// Float.
uint32_t PerformFloatingPointOperation(analysis::ConstantManager* const_mgr,
- SpvOp opcode,
+ spv::Op opcode,
const analysis::Constant* input1,
const analysis::Constant* input2) {
const analysis::Type* type = input1->type();
@@ -535,17 +543,17 @@ uint32_t PerformFloatingPointOperation(analysis::ConstantManager* const_mgr,
} \
static_assert(true, "require extra semicolon")
switch (opcode) {
- case SpvOpFMul:
+ case spv::Op::OpFMul:
FOLD_OP(*);
break;
- case SpvOpFDiv:
+ case spv::Op::OpFDiv:
if (HasZero(input2)) return 0;
FOLD_OP(/);
break;
- case SpvOpFAdd:
+ case spv::Op::OpFAdd:
FOLD_OP(+);
break;
- case SpvOpFSub:
+ case spv::Op::OpFSub:
FOLD_OP(-);
break;
default:
@@ -561,7 +569,8 @@ uint32_t PerformFloatingPointOperation(analysis::ConstantManager* const_mgr,
// id. Returns 0 if the result is not a valid value. The input types must be
// Integers.
uint32_t PerformIntegerOperation(analysis::ConstantManager* const_mgr,
- SpvOp opcode, const analysis::Constant* input1,
+ spv::Op opcode,
+ const analysis::Constant* input1,
const analysis::Constant* input2) {
assert(input1->type()->AsInteger());
const analysis::Integer* type = input1->type()->AsInteger();
@@ -582,17 +591,17 @@ uint32_t PerformIntegerOperation(analysis::ConstantManager* const_mgr,
} \
static_assert(true, "require extra semicolon")
switch (opcode) {
- case SpvOpIMul:
+ case spv::Op::OpIMul:
FOLD_OP(*);
break;
- case SpvOpSDiv:
- case SpvOpUDiv:
+ case spv::Op::OpSDiv:
+ case spv::Op::OpUDiv:
assert(false && "Should not merge integer division");
break;
- case SpvOpIAdd:
+ case spv::Op::OpIAdd:
FOLD_OP(+);
break;
- case SpvOpISub:
+ case spv::Op::OpISub:
FOLD_OP(-);
break;
default:
@@ -607,7 +616,7 @@ uint32_t PerformIntegerOperation(analysis::ConstantManager* const_mgr,
// Performs |input1| |opcode| |input2| and returns the merged constant result
// id. Returns 0 if the result is not a valid value. The input types must be
// Integers, Floats or Vectors of such.
-uint32_t PerformOperation(analysis::ConstantManager* const_mgr, SpvOp opcode,
+uint32_t PerformOperation(analysis::ConstantManager* const_mgr, spv::Op opcode,
const analysis::Constant* input1,
const analysis::Constant* input2) {
assert(input1 && input2);
@@ -667,7 +676,8 @@ uint32_t PerformOperation(analysis::ConstantManager* const_mgr, SpvOp opcode,
FoldingRule MergeMulMulArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFMul || inst->opcode() == SpvOpIMul);
+ assert(inst->opcode() == spv::Op::OpFMul ||
+ inst->opcode() == spv::Op::OpIMul);
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
@@ -719,7 +729,7 @@ FoldingRule MergeMulMulArithmetic() {
FoldingRule MergeMulDivArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFMul);
+ assert(inst->opcode() == spv::Op::OpFMul);
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
@@ -733,10 +743,10 @@ FoldingRule MergeMulDivArithmetic() {
for (uint32_t i = 0; i < 2; i++) {
uint32_t op_id = inst->GetSingleWordInOperand(i);
Instruction* op_inst = def_use_mgr->GetDef(op_id);
- if (op_inst->opcode() == SpvOpFDiv) {
+ if (op_inst->opcode() == spv::Op::OpFDiv) {
if (op_inst->GetSingleWordInOperand(1) ==
inst->GetSingleWordInOperand(1 - i)) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {op_inst->GetSingleWordInOperand(0)}}});
return true;
@@ -749,7 +759,7 @@ FoldingRule MergeMulDivArithmetic() {
Instruction* other_inst = NonConstInput(context, constants[0], inst);
if (!other_inst->IsFloatingPointFoldingAllowed()) return false;
- if (other_inst->opcode() == SpvOpFDiv) {
+ if (other_inst->opcode() == spv::Op::OpFDiv) {
std::vector<const analysis::Constant*> other_constants =
const_mgr->GetOperandConstants(other_inst);
const analysis::Constant* const_input2 = ConstInput(other_constants);
@@ -793,7 +803,8 @@ FoldingRule MergeMulDivArithmetic() {
FoldingRule MergeMulNegateArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFMul || inst->opcode() == SpvOpIMul);
+ assert(inst->opcode() == spv::Op::OpFMul ||
+ inst->opcode() == spv::Op::OpIMul);
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
@@ -809,8 +820,8 @@ FoldingRule MergeMulNegateArithmetic() {
if (uses_float && !other_inst->IsFloatingPointFoldingAllowed())
return false;
- if (other_inst->opcode() == SpvOpFNegate ||
- other_inst->opcode() == SpvOpSNegate) {
+ if (other_inst->opcode() == spv::Op::OpFNegate ||
+ other_inst->opcode() == spv::Op::OpSNegate) {
uint32_t neg_id = NegateConstant(const_mgr, const_input1);
inst->SetInOperands(
@@ -833,7 +844,7 @@ FoldingRule MergeMulNegateArithmetic() {
FoldingRule MergeDivDivArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFDiv);
+ assert(inst->opcode() == spv::Op::OpFDiv);
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
@@ -856,10 +867,10 @@ FoldingRule MergeDivDivArithmetic() {
bool other_first_is_variable = other_constants[0] == nullptr;
- SpvOp merge_op = inst->opcode();
+ spv::Op merge_op = inst->opcode();
if (other_first_is_variable) {
// Constants magnify.
- merge_op = SpvOpFMul;
+ merge_op = spv::Op::OpFMul;
}
// This is an x / (*) case. Swap the inputs. Doesn't harm multiply
@@ -873,10 +884,10 @@ FoldingRule MergeDivDivArithmetic() {
? other_inst->GetSingleWordInOperand(0u)
: other_inst->GetSingleWordInOperand(1u);
- SpvOp op = inst->opcode();
+ spv::Op op = inst->opcode();
if (!first_is_variable && !other_first_is_variable) {
// Effectively div of 1/x, so change to multiply.
- op = SpvOpFMul;
+ op = spv::Op::OpFMul;
}
uint32_t op1 = merged_id;
@@ -904,7 +915,7 @@ FoldingRule MergeDivDivArithmetic() {
FoldingRule MergeDivMulArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFDiv);
+ assert(inst->opcode() == spv::Op::OpFDiv);
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
@@ -918,11 +929,11 @@ FoldingRule MergeDivMulArithmetic() {
uint32_t op_id = inst->GetSingleWordInOperand(0);
Instruction* op_inst = def_use_mgr->GetDef(op_id);
- if (op_inst->opcode() == SpvOpFMul) {
+ if (op_inst->opcode() == spv::Op::OpFMul) {
for (uint32_t i = 0; i < 2; i++) {
if (op_inst->GetSingleWordInOperand(i) ==
inst->GetSingleWordInOperand(1)) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID,
{op_inst->GetSingleWordInOperand(1 - i)}}});
return true;
@@ -936,7 +947,7 @@ FoldingRule MergeDivMulArithmetic() {
if (!other_inst->IsFloatingPointFoldingAllowed()) return false;
bool first_is_variable = constants[0] == nullptr;
- if (other_inst->opcode() == SpvOpFMul) {
+ if (other_inst->opcode() == spv::Op::OpFMul) {
std::vector<const analysis::Constant*> other_constants =
const_mgr->GetOperandConstants(other_inst);
const analysis::Constant* const_input2 = ConstInput(other_constants);
@@ -976,7 +987,7 @@ FoldingRule MergeDivMulArithmetic() {
FoldingRule MergeDivNegateArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFDiv);
+ assert(inst->opcode() == spv::Op::OpFDiv);
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
if (!inst->IsFloatingPointFoldingAllowed()) return false;
@@ -986,7 +997,7 @@ FoldingRule MergeDivNegateArithmetic() {
if (!other_inst->IsFloatingPointFoldingAllowed()) return false;
bool first_is_variable = constants[0] == nullptr;
- if (other_inst->opcode() == SpvOpFNegate) {
+ if (other_inst->opcode() == spv::Op::OpFNegate) {
uint32_t neg_id = NegateConstant(const_mgr, const_input1);
if (first_is_variable) {
@@ -1012,7 +1023,8 @@ FoldingRule MergeDivNegateArithmetic() {
FoldingRule MergeAddNegateArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFAdd || inst->opcode() == SpvOpIAdd);
+ assert(inst->opcode() == spv::Op::OpFAdd ||
+ inst->opcode() == spv::Op::OpIAdd);
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
bool uses_float = HasFloatingPoint(type);
@@ -1024,9 +1036,10 @@ FoldingRule MergeAddNegateArithmetic() {
if (uses_float && !other_inst->IsFloatingPointFoldingAllowed())
return false;
- if (other_inst->opcode() == SpvOpSNegate ||
- other_inst->opcode() == SpvOpFNegate) {
- inst->SetOpcode(HasFloatingPoint(type) ? SpvOpFSub : SpvOpISub);
+ if (other_inst->opcode() == spv::Op::OpSNegate ||
+ other_inst->opcode() == spv::Op::OpFNegate) {
+ inst->SetOpcode(HasFloatingPoint(type) ? spv::Op::OpFSub
+ : spv::Op::OpISub);
uint32_t const_id = constants[0] ? inst->GetSingleWordInOperand(0u)
: inst->GetSingleWordInOperand(1u);
inst->SetInOperands(
@@ -1045,7 +1058,8 @@ FoldingRule MergeAddNegateArithmetic() {
FoldingRule MergeSubNegateArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFSub || inst->opcode() == SpvOpISub);
+ assert(inst->opcode() == spv::Op::OpFSub ||
+ inst->opcode() == spv::Op::OpISub);
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
@@ -1061,15 +1075,15 @@ FoldingRule MergeSubNegateArithmetic() {
if (uses_float && !other_inst->IsFloatingPointFoldingAllowed())
return false;
- if (other_inst->opcode() == SpvOpSNegate ||
- other_inst->opcode() == SpvOpFNegate) {
+ if (other_inst->opcode() == spv::Op::OpSNegate ||
+ other_inst->opcode() == spv::Op::OpFNegate) {
uint32_t op1 = 0;
uint32_t op2 = 0;
- SpvOp opcode = inst->opcode();
+ spv::Op opcode = inst->opcode();
if (constants[0] != nullptr) {
op1 = other_inst->GetSingleWordInOperand(0u);
op2 = inst->GetSingleWordInOperand(0u);
- opcode = HasFloatingPoint(type) ? SpvOpFAdd : SpvOpIAdd;
+ opcode = HasFloatingPoint(type) ? spv::Op::OpFAdd : spv::Op::OpIAdd;
} else {
op1 = NegateConstant(const_mgr, const_input1);
op2 = other_inst->GetSingleWordInOperand(0u);
@@ -1093,7 +1107,8 @@ FoldingRule MergeSubNegateArithmetic() {
FoldingRule MergeAddAddArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFAdd || inst->opcode() == SpvOpIAdd);
+ assert(inst->opcode() == spv::Op::OpFAdd ||
+ inst->opcode() == spv::Op::OpIAdd);
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
@@ -1109,8 +1124,8 @@ FoldingRule MergeAddAddArithmetic() {
if (uses_float && !other_inst->IsFloatingPointFoldingAllowed())
return false;
- if (other_inst->opcode() == SpvOpFAdd ||
- other_inst->opcode() == SpvOpIAdd) {
+ if (other_inst->opcode() == spv::Op::OpFAdd ||
+ other_inst->opcode() == spv::Op::OpIAdd) {
std::vector<const analysis::Constant*> other_constants =
const_mgr->GetOperandConstants(other_inst);
const analysis::Constant* const_input2 = ConstInput(other_constants);
@@ -1140,7 +1155,8 @@ FoldingRule MergeAddAddArithmetic() {
FoldingRule MergeAddSubArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFAdd || inst->opcode() == SpvOpIAdd);
+ assert(inst->opcode() == spv::Op::OpFAdd ||
+ inst->opcode() == spv::Op::OpIAdd);
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
@@ -1156,15 +1172,15 @@ FoldingRule MergeAddSubArithmetic() {
if (uses_float && !other_inst->IsFloatingPointFoldingAllowed())
return false;
- if (other_inst->opcode() == SpvOpFSub ||
- other_inst->opcode() == SpvOpISub) {
+ if (other_inst->opcode() == spv::Op::OpFSub ||
+ other_inst->opcode() == spv::Op::OpISub) {
std::vector<const analysis::Constant*> other_constants =
const_mgr->GetOperandConstants(other_inst);
const analysis::Constant* const_input2 = ConstInput(other_constants);
if (!const_input2) return false;
bool first_is_variable = other_constants[0] == nullptr;
- SpvOp op = inst->opcode();
+ spv::Op op = inst->opcode();
uint32_t op1 = 0;
uint32_t op2 = 0;
if (first_is_variable) {
@@ -1199,7 +1215,8 @@ FoldingRule MergeAddSubArithmetic() {
FoldingRule MergeSubAddArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFSub || inst->opcode() == SpvOpISub);
+ assert(inst->opcode() == spv::Op::OpFSub ||
+ inst->opcode() == spv::Op::OpISub);
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
@@ -1215,8 +1232,8 @@ FoldingRule MergeSubAddArithmetic() {
if (uses_float && !other_inst->IsFloatingPointFoldingAllowed())
return false;
- if (other_inst->opcode() == SpvOpFAdd ||
- other_inst->opcode() == SpvOpIAdd) {
+ if (other_inst->opcode() == spv::Op::OpFAdd ||
+ other_inst->opcode() == spv::Op::OpIAdd) {
std::vector<const analysis::Constant*> other_constants =
const_mgr->GetOperandConstants(other_inst);
const analysis::Constant* const_input2 = ConstInput(other_constants);
@@ -1231,7 +1248,7 @@ FoldingRule MergeSubAddArithmetic() {
// Subtract the constants.
uint32_t merged_id = PerformOperation(const_mgr, inst->opcode(),
const_input1, const_input2);
- SpvOp op = inst->opcode();
+ spv::Op op = inst->opcode();
uint32_t op1 = 0;
uint32_t op2 = 0;
if (constants[0] == nullptr) {
@@ -1264,7 +1281,8 @@ FoldingRule MergeSubAddArithmetic() {
FoldingRule MergeSubSubArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFSub || inst->opcode() == SpvOpISub);
+ assert(inst->opcode() == spv::Op::OpFSub ||
+ inst->opcode() == spv::Op::OpISub);
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
@@ -1280,8 +1298,8 @@ FoldingRule MergeSubSubArithmetic() {
if (uses_float && !other_inst->IsFloatingPointFoldingAllowed())
return false;
- if (other_inst->opcode() == SpvOpFSub ||
- other_inst->opcode() == SpvOpISub) {
+ if (other_inst->opcode() == spv::Op::OpFSub ||
+ other_inst->opcode() == spv::Op::OpISub) {
std::vector<const analysis::Constant*> other_constants =
const_mgr->GetOperandConstants(other_inst);
const analysis::Constant* const_input2 = ConstInput(other_constants);
@@ -1292,9 +1310,9 @@ FoldingRule MergeSubSubArithmetic() {
// Merge the constants.
uint32_t merged_id = 0;
- SpvOp merge_op = inst->opcode();
+ spv::Op merge_op = inst->opcode();
if (other_constants[0] == nullptr) {
- merge_op = uses_float ? SpvOpFAdd : SpvOpIAdd;
+ merge_op = uses_float ? spv::Op::OpFAdd : spv::Op::OpIAdd;
} else if (constants[0] == nullptr) {
std::swap(const_input1, const_input2);
}
@@ -1302,10 +1320,10 @@ FoldingRule MergeSubSubArithmetic() {
PerformOperation(const_mgr, merge_op, const_input1, const_input2);
if (merged_id == 0) return false;
- SpvOp op = inst->opcode();
+ spv::Op op = inst->opcode();
if (constants[0] != nullptr && other_constants[0] != nullptr) {
// Change the operation.
- op = uses_float ? SpvOpFAdd : SpvOpIAdd;
+ op = uses_float ? spv::Op::OpFAdd : spv::Op::OpIAdd;
}
uint32_t op1 = 0;
@@ -1333,13 +1351,14 @@ bool MergeGenericAddendSub(uint32_t addend, uint32_t sub, Instruction* inst) {
IRContext* context = inst->context();
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
Instruction* sub_inst = def_use_mgr->GetDef(sub);
- if (sub_inst->opcode() != SpvOpFSub && sub_inst->opcode() != SpvOpISub)
+ if (sub_inst->opcode() != spv::Op::OpFSub &&
+ sub_inst->opcode() != spv::Op::OpISub)
return false;
- if (sub_inst->opcode() == SpvOpFSub &&
+ if (sub_inst->opcode() == spv::Op::OpFSub &&
!sub_inst->IsFloatingPointFoldingAllowed())
return false;
if (addend != sub_inst->GetSingleWordInOperand(1)) return false;
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {sub_inst->GetSingleWordInOperand(0)}}});
context->UpdateDefUse(inst);
@@ -1355,7 +1374,8 @@ bool MergeGenericAddendSub(uint32_t addend, uint32_t sub, Instruction* inst) {
FoldingRule MergeGenericAddSubArithmetic() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpFAdd || inst->opcode() == SpvOpIAdd);
+ assert(inst->opcode() == spv::Op::OpFAdd ||
+ inst->opcode() == spv::Op::OpIAdd);
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
bool uses_float = HasFloatingPoint(type);
@@ -1383,7 +1403,8 @@ bool FactorAddMulsOpnds(uint32_t factor0_0, uint32_t factor0_1,
IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping);
Instruction* new_add_inst = ir_builder.AddBinaryOp(
inst->type_id(), inst->opcode(), factor0_1, factor1_1);
- inst->SetOpcode(inst->opcode() == SpvOpFAdd ? SpvOpFMul : SpvOpIMul);
+ inst->SetOpcode(inst->opcode() == spv::Op::OpFAdd ? spv::Op::OpFMul
+ : spv::Op::OpIMul);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {factor0_0}},
{SPV_OPERAND_TYPE_ID, {new_add_inst->result_id()}}});
context->UpdateDefUse(inst);
@@ -1395,7 +1416,8 @@ bool FactorAddMulsOpnds(uint32_t factor0_0, uint32_t factor0_1,
FoldingRule FactorAddMuls() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpFAdd || inst->opcode() == SpvOpIAdd);
+ assert(inst->opcode() == spv::Op::OpFAdd ||
+ inst->opcode() == spv::Op::OpIAdd);
const analysis::Type* type =
context->get_type_mgr()->GetType(inst->type_id());
bool uses_float = HasFloatingPoint(type);
@@ -1404,13 +1426,13 @@ FoldingRule FactorAddMuls() {
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
uint32_t add_op0 = inst->GetSingleWordInOperand(0);
Instruction* add_op0_inst = def_use_mgr->GetDef(add_op0);
- if (add_op0_inst->opcode() != SpvOpFMul &&
- add_op0_inst->opcode() != SpvOpIMul)
+ if (add_op0_inst->opcode() != spv::Op::OpFMul &&
+ add_op0_inst->opcode() != spv::Op::OpIMul)
return false;
uint32_t add_op1 = inst->GetSingleWordInOperand(1);
Instruction* add_op1_inst = def_use_mgr->GetDef(add_op1);
- if (add_op1_inst->opcode() != SpvOpFMul &&
- add_op1_inst->opcode() != SpvOpIMul)
+ if (add_op1_inst->opcode() != spv::Op::OpFMul &&
+ add_op1_inst->opcode() != spv::Op::OpIMul)
return false;
// Only perform this optimization if both of the muls only have one use.
@@ -1418,7 +1440,7 @@ FoldingRule FactorAddMuls() {
if (def_use_mgr->NumUses(add_op0_inst) > 1) return false;
if (def_use_mgr->NumUses(add_op1_inst) > 1) return false;
- if (add_op0_inst->opcode() == SpvOpFMul &&
+ if (add_op0_inst->opcode() == spv::Op::OpFMul &&
(!add_op0_inst->IsFloatingPointFoldingAllowed() ||
!add_op1_inst->IsFloatingPointFoldingAllowed()))
return false;
@@ -1457,7 +1479,7 @@ void ReplaceWithFma(Instruction* inst, uint32_t x, uint32_t y, uint32_t a) {
operands.push_back({SPV_OPERAND_TYPE_ID, {y}});
operands.push_back({SPV_OPERAND_TYPE_ID, {a}});
- inst->SetOpcode(SpvOpExtInst);
+ inst->SetOpcode(spv::Op::OpExtInst);
inst->SetInOperands(std::move(operands));
}
@@ -1468,7 +1490,7 @@ void ReplaceWithFma(Instruction* inst, uint32_t x, uint32_t y, uint32_t a) {
// a + (x * y) = Fma x y a
bool MergeMulAddArithmetic(IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpFAdd);
+ assert(inst->opcode() == spv::Op::OpFAdd);
if (!inst->IsFloatingPointFoldingAllowed()) {
return false;
@@ -1479,7 +1501,7 @@ bool MergeMulAddArithmetic(IRContext* context, Instruction* inst,
uint32_t op_id = inst->GetSingleWordInOperand(i);
Instruction* op_inst = def_use_mgr->GetDef(op_id);
- if (op_inst->opcode() != SpvOpFMul) {
+ if (op_inst->opcode() != spv::Op::OpFMul) {
continue;
}
@@ -1514,7 +1536,7 @@ void ReplaceWithFmaAndNegate(Instruction* sub, uint32_t x, uint32_t y,
sub->context(), sub,
IRContext::kAnalysisDefUse | IRContext::kAnalysisInstrToBlockMapping);
- Instruction* neg = ir_builder.AddUnaryOp(sub->type_id(), SpvOpFNegate,
+ Instruction* neg = ir_builder.AddUnaryOp(sub->type_id(), spv::Op::OpFNegate,
negate_addition ? a : x);
uint32_t neg_op = neg->result_id(); // -a : -x
@@ -1525,7 +1547,7 @@ void ReplaceWithFmaAndNegate(Instruction* sub, uint32_t x, uint32_t y,
operands.push_back({SPV_OPERAND_TYPE_ID, {y}});
operands.push_back({SPV_OPERAND_TYPE_ID, {negate_addition ? neg_op : a}});
- sub->SetOpcode(SpvOpExtInst);
+ sub->SetOpcode(spv::Op::OpExtInst);
sub->SetInOperands(std::move(operands));
}
@@ -1536,7 +1558,7 @@ void ReplaceWithFmaAndNegate(Instruction* sub, uint32_t x, uint32_t y,
// a - (x * y) = Fma -x y a
bool MergeMulSubArithmetic(IRContext* context, Instruction* sub,
const std::vector<const analysis::Constant*>&) {
- assert(sub->opcode() == SpvOpFSub);
+ assert(sub->opcode() == spv::Op::OpFSub);
if (!sub->IsFloatingPointFoldingAllowed()) {
return false;
@@ -1547,7 +1569,7 @@ bool MergeMulSubArithmetic(IRContext* context, Instruction* sub,
uint32_t op_id = sub->GetSingleWordInOperand(i);
Instruction* mul = def_use_mgr->GetDef(op_id);
- if (mul->opcode() != SpvOpFMul) {
+ if (mul->opcode() != spv::Op::OpFMul) {
continue;
}
@@ -1567,7 +1589,8 @@ bool MergeMulSubArithmetic(IRContext* context, Instruction* sub,
FoldingRule IntMultipleBy1() {
return [](IRContext*, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpIMul && "Wrong opcode. Should be OpIMul.");
+ assert(inst->opcode() == spv::Op::OpIMul &&
+ "Wrong opcode. Should be OpIMul.");
for (uint32_t i = 0; i < 2; i++) {
if (constants[i] == nullptr) {
continue;
@@ -1579,7 +1602,7 @@ FoldingRule IntMultipleBy1() {
bool is_one = (width == 32) ? int_constant->GetU32BitValue() == 1u
: int_constant->GetU64BitValue() == 1ull;
if (is_one) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(1 - i)}}});
return true;
@@ -1596,7 +1619,7 @@ FoldingRule IntMultipleBy1() {
uint32_t GetNumOfElementsContributedByOperand(IRContext* context,
const Instruction* inst,
uint32_t index) {
- assert(inst->opcode() == SpvOpCompositeConstruct);
+ assert(inst->opcode() == spv::Op::OpCompositeConstruct);
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
analysis::TypeManager* type_mgr = context->get_type_mgr();
@@ -1627,7 +1650,7 @@ uint32_t GetNumOfElementsContributedByOperand(IRContext* context,
// out-of-bounds. |inst| must be an |OpCompositeConstruct| instruction.
std::vector<Operand> GetExtractOperandsForElementOfCompositeConstruct(
IRContext* context, const Instruction* inst, uint32_t result_index) {
- assert(inst->opcode() == SpvOpCompositeConstruct);
+ assert(inst->opcode() == spv::Op::OpCompositeConstruct);
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
analysis::TypeManager* type_mgr = context->get_type_mgr();
@@ -1666,7 +1689,7 @@ bool CompositeConstructFeedingExtract(
const std::vector<const analysis::Constant*>&) {
// If the input to an OpCompositeExtract is an OpCompositeConstruct,
// then we can simply use the appropriate element in the construction.
- assert(inst->opcode() == SpvOpCompositeExtract &&
+ assert(inst->opcode() == spv::Op::OpCompositeExtract &&
"Wrong opcode. Should be OpCompositeExtract.");
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
@@ -1678,7 +1701,7 @@ bool CompositeConstructFeedingExtract(
uint32_t cid = inst->GetSingleWordInOperand(kExtractCompositeIdInIdx);
Instruction* cinst = def_use_mgr->GetDef(cid);
- if (cinst->opcode() != SpvOpCompositeConstruct) {
+ if (cinst->opcode() != spv::Op::OpCompositeConstruct) {
return false;
}
@@ -1700,7 +1723,7 @@ bool CompositeConstructFeedingExtract(
if (operands.size() == 1) {
// If there were no extra indices, then we have the final object. No need
// to extract any more.
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
}
inst->SetInOperands(std::move(operands));
@@ -1738,8 +1761,8 @@ const analysis::Type* GetElementType(uint32_t type_id,
bool HaveSameIndexesExceptForLast(Instruction* inst_1, Instruction* inst_2) {
assert(inst_1->opcode() == inst_2->opcode() &&
"Expecting the opcodes to be the same.");
- assert((inst_1->opcode() == SpvOpCompositeInsert ||
- inst_1->opcode() == SpvOpCompositeExtract) &&
+ assert((inst_1->opcode() == spv::Op::OpCompositeInsert ||
+ inst_1->opcode() == spv::Op::OpCompositeExtract) &&
"Instructions must be OpCompositeInsert or OpCompositeExtract.");
if (inst_1->NumInOperands() != inst_2->NumInOperands()) {
@@ -1747,7 +1770,7 @@ bool HaveSameIndexesExceptForLast(Instruction* inst_1, Instruction* inst_2) {
}
uint32_t first_index_position =
- (inst_1->opcode() == SpvOpCompositeInsert ? 2 : 1);
+ (inst_1->opcode() == spv::Op::OpCompositeInsert ? 2 : 1);
for (uint32_t i = first_index_position; i < inst_1->NumInOperands() - 1;
i++) {
if (inst_1->GetSingleWordInOperand(i) !=
@@ -1766,7 +1789,7 @@ bool HaveSameIndexesExceptForLast(Instruction* inst_1, Instruction* inst_2) {
bool CompositeExtractFeedingConstruct(
IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpCompositeConstruct &&
+ assert(inst->opcode() == spv::Op::OpCompositeConstruct &&
"Wrong opcode. Should be OpCompositeConstruct.");
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
uint32_t original_id = 0;
@@ -1788,7 +1811,7 @@ bool CompositeExtractFeedingConstruct(
first_element_inst = element_inst;
}
- if (element_inst->opcode() != SpvOpCompositeExtract) {
+ if (element_inst->opcode() != spv::Op::OpCompositeExtract) {
return false;
}
@@ -1828,14 +1851,14 @@ bool CompositeExtractFeedingConstruct(
if (first_element_inst->NumInOperands() == 2) {
// Simplify by using the original object.
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {original_id}}});
return true;
}
// Copies the original id and all indexes except for the last to the new
// extract instruction.
- inst->SetOpcode(SpvOpCompositeExtract);
+ inst->SetOpcode(spv::Op::OpCompositeExtract);
inst->SetInOperands(std::vector<Operand>(first_element_inst->begin() + 2,
first_element_inst->end() - 1));
return true;
@@ -1844,13 +1867,13 @@ bool CompositeExtractFeedingConstruct(
FoldingRule InsertFeedingExtract() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpCompositeExtract &&
+ assert(inst->opcode() == spv::Op::OpCompositeExtract &&
"Wrong opcode. Should be OpCompositeExtract.");
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
uint32_t cid = inst->GetSingleWordInOperand(kExtractCompositeIdInIdx);
Instruction* cinst = def_use_mgr->GetDef(cid);
- if (cinst->opcode() != SpvOpCompositeInsert) {
+ if (cinst->opcode() != spv::Op::OpCompositeInsert) {
return false;
}
@@ -1870,7 +1893,7 @@ FoldingRule InsertFeedingExtract() {
// We are extracting the element that was inserted.
if (i == inst->NumInOperands() && i + 1 == cinst->NumInOperands()) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID,
{cinst->GetSingleWordInOperand(kInsertObjectIdInIdx)}}});
@@ -1919,14 +1942,14 @@ FoldingRule InsertFeedingExtract() {
FoldingRule VectorShuffleFeedingExtract() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpCompositeExtract &&
+ assert(inst->opcode() == spv::Op::OpCompositeExtract &&
"Wrong opcode. Should be OpCompositeExtract.");
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
analysis::TypeManager* type_mgr = context->get_type_mgr();
uint32_t cid = inst->GetSingleWordInOperand(kExtractCompositeIdInIdx);
Instruction* cinst = def_use_mgr->GetDef(cid);
- if (cinst->opcode() != SpvOpVectorShuffle) {
+ if (cinst->opcode() != spv::Op::OpVectorShuffle) {
return false;
}
@@ -1947,7 +1970,7 @@ FoldingRule VectorShuffleFeedingExtract() {
// Extracting an undefined value so fold this extract into an undef.
const uint32_t undef_literal_value = 0xffffffff;
if (new_index == undef_literal_value) {
- inst->SetOpcode(SpvOpUndef);
+ inst->SetOpcode(spv::Op::OpUndef);
inst->SetInOperands({});
return true;
}
@@ -1975,7 +1998,7 @@ FoldingRule VectorShuffleFeedingExtract() {
FoldingRule FMixFeedingExtract() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpCompositeExtract &&
+ assert(inst->opcode() == spv::Op::OpCompositeExtract &&
"Wrong opcode. Should be OpCompositeExtract.");
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
@@ -1984,7 +2007,7 @@ FoldingRule FMixFeedingExtract() {
inst->GetSingleWordInOperand(kExtractCompositeIdInIdx);
Instruction* composite_inst = def_use_mgr->GetDef(composite_id);
- if (composite_inst->opcode() != SpvOpExtInst) {
+ if (composite_inst->opcode() != spv::Op::OpExtInst) {
return false;
}
@@ -2004,7 +2027,7 @@ FoldingRule FMixFeedingExtract() {
a->SetInOperand(kExtractCompositeIdInIdx, {a_id});
context->get_instruction_folder().FoldInstruction(a.get());
- if (a->opcode() != SpvOpCopyObject) {
+ if (a->opcode() != spv::Op::OpCopyObject) {
return false;
}
@@ -2066,7 +2089,7 @@ std::map<uint32_t, uint32_t> GetInsertedValues(Instruction* inst) {
analysis::DefUseManager* def_use_mgr = inst->context()->get_def_use_mgr();
std::map<uint32_t, uint32_t> values_inserted;
Instruction* current_inst = inst;
- while (current_inst->opcode() == SpvOpCompositeInsert) {
+ while (current_inst->opcode() == spv::Op::OpCompositeInsert) {
if (current_inst->NumInOperands() > inst->NumInOperands()) {
// This is the catch the case
// %2 = OpCompositeInsert %m2x2int %v2int_1_0 %m2x2int_undef 0
@@ -2108,7 +2131,7 @@ bool DoInsertedValuesCoverEntireObject(
// Returns the type of the element that immediately contains the element being
// inserted by the OpCompositeInsert instruction |inst|.
const analysis::Type* GetContainerType(Instruction* inst) {
- assert(inst->opcode() == SpvOpCompositeInsert);
+ assert(inst->opcode() == spv::Op::OpCompositeInsert);
analysis::TypeManager* type_mgr = inst->context()->get_type_mgr();
return GetElementType(inst->type_id(), inst->begin() + 4, inst->end() - 1,
type_mgr);
@@ -2140,7 +2163,7 @@ Instruction* BuildCompositeConstruct(
// instruction is replaced with an OpCopyObject instead.
void InsertConstructedObject(Instruction* inst, const Instruction* construct) {
if (inst->NumInOperands() == 3) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {construct->result_id()}}});
} else {
inst->SetInOperand(kInsertObjectIdInIdx, {construct->result_id()});
@@ -2153,7 +2176,7 @@ void InsertConstructedObject(Instruction* inst, const Instruction* construct) {
bool CompositeInsertToCompositeConstruct(
IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpCompositeInsert &&
+ assert(inst->opcode() == spv::Op::OpCompositeInsert &&
"Wrong opcode. Should be OpCompositeInsert.");
if (inst->NumInOperands() < 3) return false;
@@ -2179,7 +2202,8 @@ FoldingRule RedundantPhi() {
// itself, can be replaced by the value itself.
return [](IRContext*, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpPhi && "Wrong opcode. Should be OpPhi.");
+ assert(inst->opcode() == spv::Op::OpPhi &&
+ "Wrong opcode. Should be OpPhi.");
uint32_t incoming_value = 0;
@@ -2203,7 +2227,7 @@ FoldingRule RedundantPhi() {
}
// We have a single incoming value. Simplify using that value.
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {incoming_value}}});
return true;
};
@@ -2212,7 +2236,7 @@ FoldingRule RedundantPhi() {
FoldingRule BitCastScalarOrVector() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpBitcast && constants.size() == 1);
+ assert(inst->opcode() == spv::Op::OpBitcast && constants.size() == 1);
if (constants[0] == nullptr) return false;
const analysis::Type* type =
@@ -2232,7 +2256,7 @@ FoldingRule BitCastScalarOrVector() {
auto new_feeder_id =
const_mgr->GetDefiningInstruction(bitcasted_constant, inst->type_id())
->result_id();
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {new_feeder_id}}});
return true;
};
@@ -2243,7 +2267,7 @@ FoldingRule RedundantSelect() {
// constant can be replaced by one of the values
return [](IRContext*, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpSelect &&
+ assert(inst->opcode() == spv::Op::OpSelect &&
"Wrong opcode. Should be OpSelect.");
assert(inst->NumInOperands() == 3);
assert(constants.size() == 3);
@@ -2253,14 +2277,14 @@ FoldingRule RedundantSelect() {
if (true_id == false_id) {
// Both results are the same, condition doesn't matter
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {true_id}}});
return true;
} else if (constants[0]) {
const analysis::Type* type = constants[0]->type();
if (type->AsBool()) {
// Scalar constant value, select the corresponding value.
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
if (constants[0]->AsNullConstant() ||
!constants[0]->AsBoolConstant()->value()) {
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {false_id}}});
@@ -2272,7 +2296,7 @@ FoldingRule RedundantSelect() {
assert(type->AsVector());
if (constants[0]->AsNullConstant()) {
// All values come from false id.
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {false_id}}});
return true;
} else {
@@ -2299,7 +2323,7 @@ FoldingRule RedundantSelect() {
}
}
- inst->SetOpcode(SpvOpVectorShuffle);
+ inst->SetOpcode(spv::Op::OpVectorShuffle);
inst->SetInOperands(std::move(ops));
return true;
}
@@ -2359,7 +2383,8 @@ FloatConstantKind getFloatConstantKind(const analysis::Constant* constant) {
FoldingRule RedundantFAdd() {
return [](IRContext*, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFAdd && "Wrong opcode. Should be OpFAdd.");
+ assert(inst->opcode() == spv::Op::OpFAdd &&
+ "Wrong opcode. Should be OpFAdd.");
assert(constants.size() == 2);
if (!inst->IsFloatingPointFoldingAllowed()) {
@@ -2370,7 +2395,7 @@ FoldingRule RedundantFAdd() {
FloatConstantKind kind1 = getFloatConstantKind(constants[1]);
if (kind0 == FloatConstantKind::Zero || kind1 == FloatConstantKind::Zero) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID,
{inst->GetSingleWordInOperand(
kind0 == FloatConstantKind::Zero ? 1 : 0)}}});
@@ -2384,7 +2409,8 @@ FoldingRule RedundantFAdd() {
FoldingRule RedundantFSub() {
return [](IRContext*, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFSub && "Wrong opcode. Should be OpFSub.");
+ assert(inst->opcode() == spv::Op::OpFSub &&
+ "Wrong opcode. Should be OpFSub.");
assert(constants.size() == 2);
if (!inst->IsFloatingPointFoldingAllowed()) {
@@ -2395,14 +2421,14 @@ FoldingRule RedundantFSub() {
FloatConstantKind kind1 = getFloatConstantKind(constants[1]);
if (kind0 == FloatConstantKind::Zero) {
- inst->SetOpcode(SpvOpFNegate);
+ inst->SetOpcode(spv::Op::OpFNegate);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(1)}}});
return true;
}
if (kind1 == FloatConstantKind::Zero) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0)}}});
return true;
@@ -2415,7 +2441,8 @@ FoldingRule RedundantFSub() {
FoldingRule RedundantFMul() {
return [](IRContext*, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFMul && "Wrong opcode. Should be OpFMul.");
+ assert(inst->opcode() == spv::Op::OpFMul &&
+ "Wrong opcode. Should be OpFMul.");
assert(constants.size() == 2);
if (!inst->IsFloatingPointFoldingAllowed()) {
@@ -2426,7 +2453,7 @@ FoldingRule RedundantFMul() {
FloatConstantKind kind1 = getFloatConstantKind(constants[1]);
if (kind0 == FloatConstantKind::Zero || kind1 == FloatConstantKind::Zero) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID,
{inst->GetSingleWordInOperand(
kind0 == FloatConstantKind::Zero ? 0 : 1)}}});
@@ -2434,7 +2461,7 @@ FoldingRule RedundantFMul() {
}
if (kind0 == FloatConstantKind::One || kind1 == FloatConstantKind::One) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands({{SPV_OPERAND_TYPE_ID,
{inst->GetSingleWordInOperand(
kind0 == FloatConstantKind::One ? 1 : 0)}}});
@@ -2448,7 +2475,8 @@ FoldingRule RedundantFMul() {
FoldingRule RedundantFDiv() {
return [](IRContext*, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpFDiv && "Wrong opcode. Should be OpFDiv.");
+ assert(inst->opcode() == spv::Op::OpFDiv &&
+ "Wrong opcode. Should be OpFDiv.");
assert(constants.size() == 2);
if (!inst->IsFloatingPointFoldingAllowed()) {
@@ -2459,14 +2487,14 @@ FoldingRule RedundantFDiv() {
FloatConstantKind kind1 = getFloatConstantKind(constants[1]);
if (kind0 == FloatConstantKind::Zero) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0)}}});
return true;
}
if (kind1 == FloatConstantKind::One) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID, {inst->GetSingleWordInOperand(0)}}});
return true;
@@ -2479,7 +2507,7 @@ FoldingRule RedundantFDiv() {
FoldingRule RedundantFMix() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpExtInst &&
+ assert(inst->opcode() == spv::Op::OpExtInst &&
"Wrong opcode. Should be OpExtInst.");
if (!inst->IsFloatingPointFoldingAllowed()) {
@@ -2497,7 +2525,7 @@ FoldingRule RedundantFMix() {
FloatConstantKind kind4 = getFloatConstantKind(constants[4]);
if (kind4 == FloatConstantKind::Zero || kind4 == FloatConstantKind::One) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
inst->SetInOperands(
{{SPV_OPERAND_TYPE_ID,
{inst->GetSingleWordInOperand(kind4 == FloatConstantKind::Zero
@@ -2515,7 +2543,8 @@ FoldingRule RedundantFMix() {
FoldingRule RedundantIAdd() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpIAdd && "Wrong opcode. Should be OpIAdd.");
+ assert(inst->opcode() == spv::Op::OpIAdd &&
+ "Wrong opcode. Should be OpIAdd.");
uint32_t operand = std::numeric_limits<uint32_t>::max();
const analysis::Type* operand_type = nullptr;
@@ -2531,9 +2560,9 @@ FoldingRule RedundantIAdd() {
const analysis::Type* inst_type =
context->get_type_mgr()->GetType(inst->type_id());
if (inst_type->IsSame(operand_type)) {
- inst->SetOpcode(SpvOpCopyObject);
+ inst->SetOpcode(spv::Op::OpCopyObject);
} else {
- inst->SetOpcode(SpvOpBitcast);
+ inst->SetOpcode(spv::Op::OpBitcast);
}
inst->SetInOperands({{SPV_OPERAND_TYPE_ID, {operand}}});
return true;
@@ -2547,7 +2576,8 @@ FoldingRule RedundantIAdd() {
FoldingRule DotProductDoingExtract() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>& constants) {
- assert(inst->opcode() == SpvOpDot && "Wrong opcode. Should be OpDot.");
+ assert(inst->opcode() == spv::Op::OpDot &&
+ "Wrong opcode. Should be OpDot.");
analysis::ConstantManager* const_mgr = context->get_constant_mgr();
@@ -2606,7 +2636,7 @@ FoldingRule DotProductDoingExtract() {
operands.push_back(
{SPV_OPERAND_TYPE_LITERAL_INTEGER, {component_with_one}});
- inst->SetOpcode(SpvOpCompositeExtract);
+ inst->SetOpcode(spv::Op::OpCompositeExtract);
inst->SetInOperands(std::move(operands));
return true;
}
@@ -2621,20 +2651,22 @@ FoldingRule DotProductDoingExtract() {
FoldingRule StoringUndef() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpStore && "Wrong opcode. Should be OpStore.");
+ assert(inst->opcode() == spv::Op::OpStore &&
+ "Wrong opcode. Should be OpStore.");
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
// If this is a volatile store, the store cannot be removed.
if (inst->NumInOperands() == 3) {
- if (inst->GetSingleWordInOperand(2) & SpvMemoryAccessVolatileMask) {
+ if (inst->GetSingleWordInOperand(2) &
+ uint32_t(spv::MemoryAccessMask::Volatile)) {
return false;
}
}
uint32_t object_id = inst->GetSingleWordInOperand(kStoreObjectInIdx);
Instruction* object_inst = def_use_mgr->GetDef(object_id);
- if (object_inst->opcode() == SpvOpUndef) {
+ if (object_inst->opcode() == spv::Op::OpUndef) {
inst->ToNop();
return true;
}
@@ -2645,7 +2677,7 @@ FoldingRule StoringUndef() {
FoldingRule VectorShuffleFeedingShuffle() {
return [](IRContext* context, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpVectorShuffle &&
+ assert(inst->opcode() == spv::Op::OpVectorShuffle &&
"Wrong opcode. Should be OpVectorShuffle.");
analysis::DefUseManager* def_use_mgr = context->get_def_use_mgr();
@@ -2658,13 +2690,13 @@ FoldingRule VectorShuffleFeedingShuffle() {
uint32_t op0_length = op0_type->element_count();
bool feeder_is_op0 = true;
- if (feeding_shuffle_inst->opcode() != SpvOpVectorShuffle) {
+ if (feeding_shuffle_inst->opcode() != spv::Op::OpVectorShuffle) {
feeding_shuffle_inst =
def_use_mgr->GetDef(inst->GetSingleWordInOperand(1));
feeder_is_op0 = false;
}
- if (feeding_shuffle_inst->opcode() != SpvOpVectorShuffle) {
+ if (feeding_shuffle_inst->opcode() != spv::Op::OpVectorShuffle) {
return false;
}
@@ -2775,7 +2807,7 @@ FoldingRule VectorShuffleFeedingShuffle() {
FoldingRule RemoveRedundantOperands() {
return [](IRContext*, Instruction* inst,
const std::vector<const analysis::Constant*>&) {
- assert(inst->opcode() == SpvOpEntryPoint &&
+ assert(inst->opcode() == spv::Op::OpEntryPoint &&
"Wrong opcode. Should be OpEntryPoint.");
bool has_redundant_operand = false;
std::unordered_set<uint32_t> seen_operands;
@@ -2808,46 +2840,52 @@ FoldingRule UpdateImageOperands() {
const std::vector<const analysis::Constant*>& constants) {
const auto opcode = inst->opcode();
(void)opcode;
- assert((opcode == SpvOpImageSampleImplicitLod ||
- opcode == SpvOpImageSampleExplicitLod ||
- opcode == SpvOpImageSampleDrefImplicitLod ||
- opcode == SpvOpImageSampleDrefExplicitLod ||
- opcode == SpvOpImageSampleProjImplicitLod ||
- opcode == SpvOpImageSampleProjExplicitLod ||
- opcode == SpvOpImageSampleProjDrefImplicitLod ||
- opcode == SpvOpImageSampleProjDrefExplicitLod ||
- opcode == SpvOpImageFetch || opcode == SpvOpImageGather ||
- opcode == SpvOpImageDrefGather || opcode == SpvOpImageRead ||
- opcode == SpvOpImageWrite ||
- opcode == SpvOpImageSparseSampleImplicitLod ||
- opcode == SpvOpImageSparseSampleExplicitLod ||
- opcode == SpvOpImageSparseSampleDrefImplicitLod ||
- opcode == SpvOpImageSparseSampleDrefExplicitLod ||
- opcode == SpvOpImageSparseSampleProjImplicitLod ||
- opcode == SpvOpImageSparseSampleProjExplicitLod ||
- opcode == SpvOpImageSparseSampleProjDrefImplicitLod ||
- opcode == SpvOpImageSparseSampleProjDrefExplicitLod ||
- opcode == SpvOpImageSparseFetch ||
- opcode == SpvOpImageSparseGather ||
- opcode == SpvOpImageSparseDrefGather ||
- opcode == SpvOpImageSparseRead) &&
+ assert((opcode == spv::Op::OpImageSampleImplicitLod ||
+ opcode == spv::Op::OpImageSampleExplicitLod ||
+ opcode == spv::Op::OpImageSampleDrefImplicitLod ||
+ opcode == spv::Op::OpImageSampleDrefExplicitLod ||
+ opcode == spv::Op::OpImageSampleProjImplicitLod ||
+ opcode == spv::Op::OpImageSampleProjExplicitLod ||
+ opcode == spv::Op::OpImageSampleProjDrefImplicitLod ||
+ opcode == spv::Op::OpImageSampleProjDrefExplicitLod ||
+ opcode == spv::Op::OpImageFetch ||
+ opcode == spv::Op::OpImageGather ||
+ opcode == spv::Op::OpImageDrefGather ||
+ opcode == spv::Op::OpImageRead || opcode == spv::Op::OpImageWrite ||
+ opcode == spv::Op::OpImageSparseSampleImplicitLod ||
+ opcode == spv::Op::OpImageSparseSampleExplicitLod ||
+ opcode == spv::Op::OpImageSparseSampleDrefImplicitLod ||
+ opcode == spv::Op::OpImageSparseSampleDrefExplicitLod ||
+ opcode == spv::Op::OpImageSparseSampleProjImplicitLod ||
+ opcode == spv::Op::OpImageSparseSampleProjExplicitLod ||
+ opcode == spv::Op::OpImageSparseSampleProjDrefImplicitLod ||
+ opcode == spv::Op::OpImageSparseSampleProjDrefExplicitLod ||
+ opcode == spv::Op::OpImageSparseFetch ||
+ opcode == spv::Op::OpImageSparseGather ||
+ opcode == spv::Op::OpImageSparseDrefGather ||
+ opcode == spv::Op::OpImageSparseRead) &&
"Wrong opcode. Should be an image instruction.");
int32_t operand_index = ImageOperandsMaskInOperandIndex(inst);
if (operand_index >= 0) {
auto image_operands = inst->GetSingleWordInOperand(operand_index);
- if (image_operands & SpvImageOperandsOffsetMask) {
+ if (image_operands & uint32_t(spv::ImageOperandsMask::Offset)) {
uint32_t offset_operand_index = operand_index + 1;
- if (image_operands & SpvImageOperandsBiasMask) offset_operand_index++;
- if (image_operands & SpvImageOperandsLodMask) offset_operand_index++;
- if (image_operands & SpvImageOperandsGradMask)
+ if (image_operands & uint32_t(spv::ImageOperandsMask::Bias))
+ offset_operand_index++;
+ if (image_operands & uint32_t(spv::ImageOperandsMask::Lod))
+ offset_operand_index++;
+ if (image_operands & uint32_t(spv::ImageOperandsMask::Grad))
offset_operand_index += 2;
- assert(((image_operands & SpvImageOperandsConstOffsetMask) == 0) &&
+ assert(((image_operands &
+ uint32_t(spv::ImageOperandsMask::ConstOffset)) == 0) &&
"Offset and ConstOffset may not be used together");
if (offset_operand_index < inst->NumOperands()) {
if (constants[offset_operand_index]) {
- image_operands = image_operands | SpvImageOperandsConstOffsetMask;
- image_operands = image_operands & ~SpvImageOperandsOffsetMask;
+ image_operands =
+ image_operands | uint32_t(spv::ImageOperandsMask::ConstOffset);
+ image_operands =
+ image_operands & ~uint32_t(spv::ImageOperandsMask::Offset);
inst->SetInOperand(operand_index, {image_operands});
return true;
}
@@ -2866,108 +2904,119 @@ void FoldingRules::AddFoldingRules() {
// 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_[SpvOpBitcast].push_back(BitCastScalarOrVector());
-
- rules_[SpvOpCompositeConstruct].push_back(CompositeExtractFeedingConstruct);
-
- rules_[SpvOpCompositeExtract].push_back(InsertFeedingExtract());
- rules_[SpvOpCompositeExtract].push_back(CompositeConstructFeedingExtract);
- rules_[SpvOpCompositeExtract].push_back(VectorShuffleFeedingExtract());
- rules_[SpvOpCompositeExtract].push_back(FMixFeedingExtract());
-
- rules_[SpvOpCompositeInsert].push_back(CompositeInsertToCompositeConstruct);
-
- rules_[SpvOpDot].push_back(DotProductDoingExtract());
-
- rules_[SpvOpEntryPoint].push_back(RemoveRedundantOperands());
-
- rules_[SpvOpFAdd].push_back(RedundantFAdd());
- rules_[SpvOpFAdd].push_back(MergeAddNegateArithmetic());
- rules_[SpvOpFAdd].push_back(MergeAddAddArithmetic());
- rules_[SpvOpFAdd].push_back(MergeAddSubArithmetic());
- rules_[SpvOpFAdd].push_back(MergeGenericAddSubArithmetic());
- rules_[SpvOpFAdd].push_back(FactorAddMuls());
- rules_[SpvOpFAdd].push_back(MergeMulAddArithmetic);
-
- rules_[SpvOpFDiv].push_back(RedundantFDiv());
- rules_[SpvOpFDiv].push_back(ReciprocalFDiv());
- rules_[SpvOpFDiv].push_back(MergeDivDivArithmetic());
- rules_[SpvOpFDiv].push_back(MergeDivMulArithmetic());
- rules_[SpvOpFDiv].push_back(MergeDivNegateArithmetic());
-
- rules_[SpvOpFMul].push_back(RedundantFMul());
- rules_[SpvOpFMul].push_back(MergeMulMulArithmetic());
- rules_[SpvOpFMul].push_back(MergeMulDivArithmetic());
- rules_[SpvOpFMul].push_back(MergeMulNegateArithmetic());
-
- rules_[SpvOpFNegate].push_back(MergeNegateArithmetic());
- rules_[SpvOpFNegate].push_back(MergeNegateAddSubArithmetic());
- rules_[SpvOpFNegate].push_back(MergeNegateMulDivArithmetic());
-
- rules_[SpvOpFSub].push_back(RedundantFSub());
- rules_[SpvOpFSub].push_back(MergeSubNegateArithmetic());
- rules_[SpvOpFSub].push_back(MergeSubAddArithmetic());
- rules_[SpvOpFSub].push_back(MergeSubSubArithmetic());
- rules_[SpvOpFSub].push_back(MergeMulSubArithmetic);
-
- rules_[SpvOpIAdd].push_back(RedundantIAdd());
- rules_[SpvOpIAdd].push_back(MergeAddNegateArithmetic());
- rules_[SpvOpIAdd].push_back(MergeAddAddArithmetic());
- rules_[SpvOpIAdd].push_back(MergeAddSubArithmetic());
- rules_[SpvOpIAdd].push_back(MergeGenericAddSubArithmetic());
- rules_[SpvOpIAdd].push_back(FactorAddMuls());
-
- rules_[SpvOpIMul].push_back(IntMultipleBy1());
- rules_[SpvOpIMul].push_back(MergeMulMulArithmetic());
- rules_[SpvOpIMul].push_back(MergeMulNegateArithmetic());
-
- rules_[SpvOpISub].push_back(MergeSubNegateArithmetic());
- rules_[SpvOpISub].push_back(MergeSubAddArithmetic());
- rules_[SpvOpISub].push_back(MergeSubSubArithmetic());
-
- rules_[SpvOpPhi].push_back(RedundantPhi());
-
- rules_[SpvOpSNegate].push_back(MergeNegateArithmetic());
- rules_[SpvOpSNegate].push_back(MergeNegateMulDivArithmetic());
- rules_[SpvOpSNegate].push_back(MergeNegateAddSubArithmetic());
-
- rules_[SpvOpSelect].push_back(RedundantSelect());
-
- rules_[SpvOpStore].push_back(StoringUndef());
-
- rules_[SpvOpVectorShuffle].push_back(VectorShuffleFeedingShuffle());
-
- rules_[SpvOpImageSampleImplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageSampleExplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageSampleDrefImplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageSampleDrefExplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageSampleProjImplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageSampleProjExplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageSampleProjDrefImplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageSampleProjDrefExplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageFetch].push_back(UpdateImageOperands());
- rules_[SpvOpImageGather].push_back(UpdateImageOperands());
- rules_[SpvOpImageDrefGather].push_back(UpdateImageOperands());
- rules_[SpvOpImageRead].push_back(UpdateImageOperands());
- rules_[SpvOpImageWrite].push_back(UpdateImageOperands());
- rules_[SpvOpImageSparseSampleImplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageSparseSampleExplicitLod].push_back(UpdateImageOperands());
- rules_[SpvOpImageSparseSampleDrefImplicitLod].push_back(
+ rules_[spv::Op::OpBitcast].push_back(BitCastScalarOrVector());
+
+ rules_[spv::Op::OpCompositeConstruct].push_back(
+ CompositeExtractFeedingConstruct);
+
+ rules_[spv::Op::OpCompositeExtract].push_back(InsertFeedingExtract());
+ rules_[spv::Op::OpCompositeExtract].push_back(
+ CompositeConstructFeedingExtract);
+ rules_[spv::Op::OpCompositeExtract].push_back(VectorShuffleFeedingExtract());
+ rules_[spv::Op::OpCompositeExtract].push_back(FMixFeedingExtract());
+
+ rules_[spv::Op::OpCompositeInsert].push_back(
+ CompositeInsertToCompositeConstruct);
+
+ rules_[spv::Op::OpDot].push_back(DotProductDoingExtract());
+
+ rules_[spv::Op::OpEntryPoint].push_back(RemoveRedundantOperands());
+
+ rules_[spv::Op::OpFAdd].push_back(RedundantFAdd());
+ rules_[spv::Op::OpFAdd].push_back(MergeAddNegateArithmetic());
+ rules_[spv::Op::OpFAdd].push_back(MergeAddAddArithmetic());
+ rules_[spv::Op::OpFAdd].push_back(MergeAddSubArithmetic());
+ rules_[spv::Op::OpFAdd].push_back(MergeGenericAddSubArithmetic());
+ rules_[spv::Op::OpFAdd].push_back(FactorAddMuls());
+ rules_[spv::Op::OpFAdd].push_back(MergeMulAddArithmetic);
+
+ rules_[spv::Op::OpFDiv].push_back(RedundantFDiv());
+ rules_[spv::Op::OpFDiv].push_back(ReciprocalFDiv());
+ rules_[spv::Op::OpFDiv].push_back(MergeDivDivArithmetic());
+ rules_[spv::Op::OpFDiv].push_back(MergeDivMulArithmetic());
+ rules_[spv::Op::OpFDiv].push_back(MergeDivNegateArithmetic());
+
+ rules_[spv::Op::OpFMul].push_back(RedundantFMul());
+ rules_[spv::Op::OpFMul].push_back(MergeMulMulArithmetic());
+ rules_[spv::Op::OpFMul].push_back(MergeMulDivArithmetic());
+ rules_[spv::Op::OpFMul].push_back(MergeMulNegateArithmetic());
+
+ rules_[spv::Op::OpFNegate].push_back(MergeNegateArithmetic());
+ rules_[spv::Op::OpFNegate].push_back(MergeNegateAddSubArithmetic());
+ rules_[spv::Op::OpFNegate].push_back(MergeNegateMulDivArithmetic());
+
+ rules_[spv::Op::OpFSub].push_back(RedundantFSub());
+ rules_[spv::Op::OpFSub].push_back(MergeSubNegateArithmetic());
+ rules_[spv::Op::OpFSub].push_back(MergeSubAddArithmetic());
+ rules_[spv::Op::OpFSub].push_back(MergeSubSubArithmetic());
+ rules_[spv::Op::OpFSub].push_back(MergeMulSubArithmetic);
+
+ rules_[spv::Op::OpIAdd].push_back(RedundantIAdd());
+ rules_[spv::Op::OpIAdd].push_back(MergeAddNegateArithmetic());
+ rules_[spv::Op::OpIAdd].push_back(MergeAddAddArithmetic());
+ rules_[spv::Op::OpIAdd].push_back(MergeAddSubArithmetic());
+ rules_[spv::Op::OpIAdd].push_back(MergeGenericAddSubArithmetic());
+ rules_[spv::Op::OpIAdd].push_back(FactorAddMuls());
+
+ rules_[spv::Op::OpIMul].push_back(IntMultipleBy1());
+ rules_[spv::Op::OpIMul].push_back(MergeMulMulArithmetic());
+ rules_[spv::Op::OpIMul].push_back(MergeMulNegateArithmetic());
+
+ rules_[spv::Op::OpISub].push_back(MergeSubNegateArithmetic());
+ rules_[spv::Op::OpISub].push_back(MergeSubAddArithmetic());
+ rules_[spv::Op::OpISub].push_back(MergeSubSubArithmetic());
+
+ rules_[spv::Op::OpPhi].push_back(RedundantPhi());
+
+ rules_[spv::Op::OpSNegate].push_back(MergeNegateArithmetic());
+ rules_[spv::Op::OpSNegate].push_back(MergeNegateMulDivArithmetic());
+ rules_[spv::Op::OpSNegate].push_back(MergeNegateAddSubArithmetic());
+
+ rules_[spv::Op::OpSelect].push_back(RedundantSelect());
+
+ rules_[spv::Op::OpStore].push_back(StoringUndef());
+
+ rules_[spv::Op::OpVectorShuffle].push_back(VectorShuffleFeedingShuffle());
+
+ rules_[spv::Op::OpImageSampleImplicitLod].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageSampleExplicitLod].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageSampleDrefImplicitLod].push_back(
+ UpdateImageOperands());
+ rules_[spv::Op::OpImageSampleDrefExplicitLod].push_back(
+ UpdateImageOperands());
+ rules_[spv::Op::OpImageSampleProjImplicitLod].push_back(
+ UpdateImageOperands());
+ rules_[spv::Op::OpImageSampleProjExplicitLod].push_back(
+ UpdateImageOperands());
+ rules_[spv::Op::OpImageSampleProjDrefImplicitLod].push_back(
+ UpdateImageOperands());
+ rules_[spv::Op::OpImageSampleProjDrefExplicitLod].push_back(
+ UpdateImageOperands());
+ rules_[spv::Op::OpImageFetch].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageGather].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageDrefGather].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageRead].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageWrite].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageSparseSampleImplicitLod].push_back(
+ UpdateImageOperands());
+ rules_[spv::Op::OpImageSparseSampleExplicitLod].push_back(
+ UpdateImageOperands());
+ rules_[spv::Op::OpImageSparseSampleDrefImplicitLod].push_back(
UpdateImageOperands());
- rules_[SpvOpImageSparseSampleDrefExplicitLod].push_back(
+ rules_[spv::Op::OpImageSparseSampleDrefExplicitLod].push_back(
UpdateImageOperands());
- rules_[SpvOpImageSparseSampleProjImplicitLod].push_back(
+ rules_[spv::Op::OpImageSparseSampleProjImplicitLod].push_back(
UpdateImageOperands());
- rules_[SpvOpImageSparseSampleProjExplicitLod].push_back(
+ rules_[spv::Op::OpImageSparseSampleProjExplicitLod].push_back(
UpdateImageOperands());
- rules_[SpvOpImageSparseSampleProjDrefImplicitLod].push_back(
+ rules_[spv::Op::OpImageSparseSampleProjDrefImplicitLod].push_back(
UpdateImageOperands());
- rules_[SpvOpImageSparseSampleProjDrefExplicitLod].push_back(
+ rules_[spv::Op::OpImageSparseSampleProjDrefExplicitLod].push_back(
UpdateImageOperands());
- rules_[SpvOpImageSparseFetch].push_back(UpdateImageOperands());
- rules_[SpvOpImageSparseGather].push_back(UpdateImageOperands());
- rules_[SpvOpImageSparseDrefGather].push_back(UpdateImageOperands());
- rules_[SpvOpImageSparseRead].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageSparseFetch].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageSparseGather].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageSparseDrefGather].push_back(UpdateImageOperands());
+ rules_[spv::Op::OpImageSparseRead].push_back(UpdateImageOperands());
FeatureManager* feature_manager = context_->get_feature_mgr();
// Add rules for GLSLstd450
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-29 12:51:28 +0300