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/test/val/val_cfg_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'test/val/val_cfg_test.cpp')
-rw-r--r--test/val/val_cfg_test.cpp408
1 files changed, 205 insertions, 203 deletions
diff --git a/test/val/val_cfg_test.cpp b/test/val/val_cfg_test.cpp
index c8dd4a2fd..d2edec1d5 100644
--- a/test/val/val_cfg_test.cpp
+++ b/test/val/val_cfg_test.cpp
@@ -37,7 +37,7 @@ namespace {
using ::testing::HasSubstr;
using ::testing::MatchesRegex;
-using ValidateCFG = spvtest::ValidateBase<SpvCapability>;
+using ValidateCFG = spvtest::ValidateBase<spv::Capability>;
using spvtest::ScopedContext;
std::string nameOps() { return ""; }
@@ -58,7 +58,7 @@ std::string nameOps(std::string head, Args... names) {
class Block {
std::string label_;
std::string body_;
- SpvOp type_;
+ spv::Op type_;
std::vector<Block> successors_;
public:
@@ -66,7 +66,7 @@ class Block {
///
/// @param[in]: label the label id of the block
/// @param[in]: type the branch instruction that ends the block
- explicit Block(std::string label, SpvOp type = SpvOpBranch)
+ explicit Block(std::string label, spv::Op type = spv::Op::OpBranch)
: label_(label), body_(), type_(type), successors_() {}
/// Sets the instructions which will appear in the body of the block
@@ -89,13 +89,13 @@ class Block {
}
switch (type_) {
- case SpvOpBranchConditional:
+ case spv::Op::OpBranchConditional:
out << "OpBranchConditional %cond ";
for (Block& b : successors_) {
out << "%" + b.label_ + " ";
}
break;
- case SpvOpSwitch: {
+ case spv::Op::OpSwitch: {
out << "OpSwitch %one %" + successors_.front().label_;
std::stringstream ss;
for (size_t i = 1; i < successors_.size(); i++) {
@@ -103,25 +103,25 @@ class Block {
}
out << ss.str();
} break;
- case SpvOpLoopMerge: {
+ case spv::Op::OpLoopMerge: {
assert(successors_.size() == 2);
out << "OpLoopMerge %" + successors_[0].label_ + " %" +
successors_[0].label_ + "None";
} break;
- case SpvOpReturn:
+ case spv::Op::OpReturn:
assert(successors_.size() == 0);
out << "OpReturn\n";
break;
- case SpvOpUnreachable:
+ case spv::Op::OpUnreachable:
assert(successors_.size() == 0);
out << "OpUnreachable\n";
break;
- case SpvOpBranch:
+ case spv::Op::OpBranch:
assert(successors_.size() == 1);
out << "OpBranch %" + successors_.front().label_;
break;
- case SpvOpKill:
+ case spv::Op::OpKill:
assert(successors_.size() == 0);
out << "OpKill\n";
break;
@@ -138,9 +138,9 @@ class Block {
/// Assigns the successors for the Block on the lhs
Block& operator>>(Block& lhs, std::vector<Block> successors) {
- if (lhs.type_ == SpvOpBranchConditional) {
+ if (lhs.type_ == spv::Op::OpBranchConditional) {
assert(successors.size() == 2);
- } else if (lhs.type_ == SpvOpSwitch) {
+ } else if (lhs.type_ == spv::Op::OpSwitch) {
assert(successors.size() > 1);
}
lhs.successors_ = successors;
@@ -149,12 +149,12 @@ Block& operator>>(Block& lhs, std::vector<Block> successors) {
/// Assigns the successor for the Block on the lhs
Block& operator>>(Block& lhs, Block& successor) {
- assert(lhs.type_ == SpvOpBranch);
+ assert(lhs.type_ == spv::Op::OpBranch);
lhs.successors_.push_back(successor);
return lhs;
}
-const std::string& GetDefaultHeader(SpvCapability cap) {
+const std::string& GetDefaultHeader(spv::Capability cap) {
static const std::string shader_header =
"OpCapability Shader\n"
"OpCapability Linkage\n"
@@ -165,7 +165,7 @@ const std::string& GetDefaultHeader(SpvCapability cap) {
"OpCapability Linkage\n"
"OpMemoryModel Logical OpenCL\n";
- return (cap == SpvCapabilityShader) ? shader_header : kernel_header;
+ return (cap == spv::Capability::Shader) ? shader_header : kernel_header;
}
const std::string& types_consts() {
@@ -181,8 +181,8 @@ const std::string& types_consts() {
}
INSTANTIATE_TEST_SUITE_P(StructuredControlFlow, ValidateCFG,
- ::testing::Values(SpvCapabilityShader,
- SpvCapabilityKernel));
+ ::testing::Values(spv::Capability::Shader,
+ spv::Capability::Kernel));
TEST_P(ValidateCFG, LoopReachableFromEntryButNeverLeadingToReturn) {
// In this case, the loop is reachable from a node without a predecessor,
@@ -268,11 +268,11 @@ TEST_P(ValidateCFG, LoopUnreachableFromEntryButLeadingToReturn) {
}
TEST_P(ValidateCFG, Simple) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop("loop", SpvOpBranchConditional);
+ Block loop("loop", spv::Op::OpBranchConditional);
Block cont("cont");
- Block merge("merge", SpvOpReturn);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) {
@@ -298,7 +298,7 @@ TEST_P(ValidateCFG, Simple) {
TEST_P(ValidateCFG, Variable) {
Block entry("entry");
Block cont("cont");
- Block exit("exit", SpvOpReturn);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%var = OpVariable %ptrt Function\n");
@@ -317,7 +317,7 @@ TEST_P(ValidateCFG, Variable) {
TEST_P(ValidateCFG, VariableNotInFirstBlockBad) {
Block entry("entry");
Block cont("cont");
- Block exit("exit", SpvOpReturn);
+ Block exit("exit", spv::Op::OpReturn);
// This operation should only be performed in the entry block
cont.SetBody("%var = OpVariable %ptrt Function\n");
@@ -339,10 +339,10 @@ TEST_P(ValidateCFG, VariableNotInFirstBlockBad) {
}
TEST_P(ValidateCFG, BlockSelfLoopIsOk) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop("loop", SpvOpBranchConditional);
- Block merge("merge", SpvOpReturn);
+ Block loop("loop", spv::Op::OpBranchConditional);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) loop.SetBody("OpLoopMerge %merge %loop None\n");
@@ -363,11 +363,11 @@ TEST_P(ValidateCFG, BlockSelfLoopIsOk) {
}
TEST_P(ValidateCFG, BlockAppearsBeforeDominatorBad) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
Block cont("cont");
- Block branch("branch", SpvOpBranchConditional);
- Block merge("merge", SpvOpReturn);
+ Block branch("branch", spv::Op::OpBranchConditional);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) branch.SetBody("OpSelectionMerge %merge None\n");
@@ -392,11 +392,11 @@ TEST_P(ValidateCFG, BlockAppearsBeforeDominatorBad) {
}
TEST_P(ValidateCFG, MergeBlockTargetedByMultipleHeaderBlocksBad) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
Block loop("loop");
- Block selection("selection", SpvOpBranchConditional);
- Block merge("merge", SpvOpReturn);
+ Block selection("selection", spv::Op::OpBranchConditional);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) loop.SetBody(" OpLoopMerge %merge %loop None\n");
@@ -428,11 +428,11 @@ TEST_P(ValidateCFG, MergeBlockTargetedByMultipleHeaderBlocksBad) {
}
TEST_P(ValidateCFG, MergeBlockTargetedByMultipleHeaderBlocksSelectionBad) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop("loop", SpvOpBranchConditional);
- Block selection("selection", SpvOpBranchConditional);
- Block merge("merge", SpvOpReturn);
+ Block loop("loop", spv::Op::OpBranchConditional);
+ Block selection("selection", spv::Op::OpBranchConditional);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) selection.SetBody(" OpSelectionMerge %merge None\n");
@@ -466,7 +466,7 @@ TEST_P(ValidateCFG, MergeBlockTargetedByMultipleHeaderBlocksSelectionBad) {
TEST_P(ValidateCFG, BranchTargetFirstBlockBadSinceEntryBlock) {
Block entry("entry");
Block bad("bad");
- Block end("end", SpvOpReturn);
+ Block end("end", spv::Op::OpReturn);
std::string str = GetDefaultHeader(GetParam()) +
nameOps("entry", "bad", std::make_pair("func", "Main")) +
types_consts() +
@@ -489,7 +489,7 @@ TEST_P(ValidateCFG, BranchTargetFirstBlockBadSinceValue) {
Block entry("entry");
entry.SetBody("%undef = OpUndef %boolt\n");
Block bad("bad");
- Block end("end", SpvOpReturn);
+ Block end("end", spv::Op::OpReturn);
Block badvalue("undef"); // This references the OpUndef.
std::string str = GetDefaultHeader(GetParam()) +
nameOps("entry", "bad", std::make_pair("func", "Main")) +
@@ -511,8 +511,8 @@ TEST_P(ValidateCFG, BranchTargetFirstBlockBadSinceValue) {
TEST_P(ValidateCFG, BranchConditionalTrueTargetFirstBlockBad) {
Block entry("entry");
- Block bad("bad", SpvOpBranchConditional);
- Block exit("exit", SpvOpReturn);
+ Block bad("bad", spv::Op::OpBranchConditional);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
bad.SetBody(" OpLoopMerge %entry %exit None\n");
@@ -538,10 +538,10 @@ TEST_P(ValidateCFG, BranchConditionalTrueTargetFirstBlockBad) {
TEST_P(ValidateCFG, BranchConditionalFalseTargetFirstBlockBad) {
Block entry("entry");
- Block bad("bad", SpvOpBranchConditional);
+ Block bad("bad", spv::Op::OpBranchConditional);
Block t("t");
Block merge("merge");
- Block end("end", SpvOpReturn);
+ Block end("end", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
bad.SetBody("OpLoopMerge %merge %cont None\n");
@@ -568,13 +568,13 @@ TEST_P(ValidateCFG, BranchConditionalFalseTargetFirstBlockBad) {
TEST_P(ValidateCFG, SwitchTargetFirstBlockBad) {
Block entry("entry");
- Block bad("bad", SpvOpSwitch);
+ Block bad("bad", spv::Op::OpSwitch);
Block block1("block1");
Block block2("block2");
Block block3("block3");
Block def("def"); // default block
Block merge("merge");
- Block end("end", SpvOpReturn);
+ Block end("end", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
bad.SetBody("OpSelectionMerge %merge None\n");
@@ -605,15 +605,15 @@ TEST_P(ValidateCFG, SwitchTargetFirstBlockBad) {
TEST_P(ValidateCFG, BranchToBlockInOtherFunctionBad) {
Block entry("entry");
- Block middle("middle", SpvOpBranchConditional);
- Block end("end", SpvOpReturn);
+ Block middle("middle", spv::Op::OpBranchConditional);
+ Block end("end", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
middle.SetBody("OpSelectionMerge %end None\n");
Block entry2("entry2");
Block middle2("middle2");
- Block end2("end2", SpvOpReturn);
+ Block end2("end2", spv::Op::OpReturn);
std::string str = GetDefaultHeader(GetParam()) +
nameOps("middle2", std::make_pair("func", "Main")) +
@@ -643,9 +643,9 @@ TEST_P(ValidateCFG, BranchToBlockInOtherFunctionBad) {
TEST_P(ValidateCFG, HeaderDoesntStrictlyDominateMergeBad) {
// If a merge block is reachable, then it must be strictly dominated by
// its header block.
- bool is_shader = GetParam() == SpvCapabilityShader;
- Block head("head", SpvOpBranchConditional);
- Block exit("exit", SpvOpReturn);
+ bool is_shader = GetParam() == spv::Capability::Shader;
+ Block head("head", spv::Op::OpBranchConditional);
+ Block exit("exit", spv::Op::OpReturn);
head.SetBody("%cond = OpSLessThan %boolt %one %two\n");
@@ -675,16 +675,16 @@ TEST_P(ValidateCFG, HeaderDoesntStrictlyDominateMergeBad) {
}
}
-std::string GetUnreachableMergeNoMergeInst(SpvCapability cap) {
+std::string GetUnreachableMergeNoMergeInst(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranchConditional);
- Block t("t", SpvOpReturn);
- Block f("f", SpvOpReturn);
- Block merge("merge", SpvOpReturn);
+ Block branch("branch", spv::Op::OpBranchConditional);
+ Block t("t", spv::Op::OpReturn);
+ Block f("f", spv::Op::OpReturn);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
branch.AppendBody("OpSelectionMerge %merge None\n");
std::string str = header;
@@ -705,18 +705,18 @@ TEST_P(ValidateCFG, UnreachableMergeNoMergeInst) {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableMergeTerminatedBy(SpvCapability cap, SpvOp op) {
+std::string GetUnreachableMergeTerminatedBy(spv::Capability cap, spv::Op op) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranchConditional);
- Block t("t", SpvOpReturn);
- Block f("f", SpvOpReturn);
+ Block branch("branch", spv::Op::OpBranchConditional);
+ Block t("t", spv::Op::OpReturn);
+ Block f("f", spv::Op::OpReturn);
Block merge("merge", op);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
std::string str = header;
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
branch.AppendBody("OpSelectionMerge %merge None\n");
str += nameOps("branch", "merge", std::make_pair("func", "Main"));
@@ -734,33 +734,35 @@ std::string GetUnreachableMergeTerminatedBy(SpvCapability cap, SpvOp op) {
TEST_P(ValidateCFG, UnreachableMergeTerminatedByOpUnreachable) {
CompileSuccessfully(
- GetUnreachableMergeTerminatedBy(GetParam(), SpvOpUnreachable));
+ GetUnreachableMergeTerminatedBy(GetParam(), spv::Op::OpUnreachable));
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateCFG, UnreachableMergeTerminatedByOpKill) {
- CompileSuccessfully(
- GetUnreachableMergeTerminatedBy(SpvCapabilityShader, SpvOpKill));
+ CompileSuccessfully(GetUnreachableMergeTerminatedBy(spv::Capability::Shader,
+ spv::Op::OpKill));
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_P(ValidateCFG, UnreachableMergeTerminatedByOpReturn) {
- CompileSuccessfully(GetUnreachableMergeTerminatedBy(GetParam(), SpvOpReturn));
+ CompileSuccessfully(
+ GetUnreachableMergeTerminatedBy(GetParam(), spv::Op::OpReturn));
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableContinueTerminatedBy(SpvCapability cap, SpvOp op) {
+std::string GetUnreachableContinueTerminatedBy(spv::Capability cap,
+ spv::Op op) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranch);
- Block merge("merge", SpvOpReturn);
+ Block branch("branch", spv::Op::OpBranch);
+ Block merge("merge", spv::Op::OpReturn);
Block target("target", op);
- if (op == SpvOpBranch) target >> branch;
+ if (op == spv::Op::OpBranch) target >> branch;
std::string str = header;
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
branch.AppendBody("OpLoopMerge %merge %target None\n");
str += nameOps("branch", "merge", "target", std::make_pair("func", "Main"));
@@ -775,10 +777,10 @@ std::string GetUnreachableContinueTerminatedBy(SpvCapability cap, SpvOp op) {
return str;
}
-TEST_P(ValidateCFG, UnreachableContinueTerminatedBySpvOpUnreachable) {
+TEST_P(ValidateCFG, UnreachableContinueTerminatedByOpUnreachable) {
CompileSuccessfully(
- GetUnreachableContinueTerminatedBy(GetParam(), SpvOpUnreachable));
- if (GetParam() == SpvCapabilityShader) {
+ GetUnreachableContinueTerminatedBy(GetParam(), spv::Op::OpUnreachable));
+ if (GetParam() == spv::Capability::Shader) {
ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("targeted by 0 back-edge blocks"));
@@ -787,18 +789,18 @@ TEST_P(ValidateCFG, UnreachableContinueTerminatedBySpvOpUnreachable) {
}
}
-TEST_F(ValidateCFG, UnreachableContinueTerminatedBySpvOpKill) {
- CompileSuccessfully(
- GetUnreachableContinueTerminatedBy(SpvCapabilityShader, SpvOpKill));
+TEST_F(ValidateCFG, UnreachableContinueTerminatedByOpKill) {
+ CompileSuccessfully(GetUnreachableContinueTerminatedBy(
+ spv::Capability::Shader, spv::Op::OpKill));
ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("targeted by 0 back-edge blocks"));
}
-TEST_P(ValidateCFG, UnreachableContinueTerminatedBySpvOpReturn) {
+TEST_P(ValidateCFG, UnreachableContinueTerminatedByOpReturn) {
CompileSuccessfully(
- GetUnreachableContinueTerminatedBy(GetParam(), SpvOpReturn));
- if (GetParam() == SpvCapabilityShader) {
+ GetUnreachableContinueTerminatedBy(GetParam(), spv::Op::OpReturn));
+ if (GetParam() == spv::Capability::Shader) {
ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("targeted by 0 back-edge blocks"));
@@ -807,25 +809,25 @@ TEST_P(ValidateCFG, UnreachableContinueTerminatedBySpvOpReturn) {
}
}
-TEST_P(ValidateCFG, UnreachableContinueTerminatedBySpvOpBranch) {
+TEST_P(ValidateCFG, UnreachableContinueTerminatedByOpBranch) {
CompileSuccessfully(
- GetUnreachableContinueTerminatedBy(GetParam(), SpvOpBranch));
+ GetUnreachableContinueTerminatedBy(GetParam(), spv::Op::OpBranch));
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableMergeUnreachableMergeInst(SpvCapability cap) {
+std::string GetUnreachableMergeUnreachableMergeInst(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
- Block body("body", SpvOpReturn);
+ Block body("body", spv::Op::OpReturn);
Block entry("entry");
- Block branch("branch", SpvOpBranchConditional);
- Block t("t", SpvOpReturn);
- Block f("f", SpvOpReturn);
- Block merge("merge", SpvOpUnreachable);
+ Block branch("branch", spv::Op::OpBranchConditional);
+ Block t("t", spv::Op::OpReturn);
+ Block f("f", spv::Op::OpReturn);
+ Block merge("merge", spv::Op::OpUnreachable);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
std::string str = header;
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
branch.AppendBody("OpSelectionMerge %merge None\n");
str += nameOps("branch", "merge", std::make_pair("func", "Main"));
@@ -847,19 +849,19 @@ TEST_P(ValidateCFG, UnreachableMergeUnreachableMergeInst) {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableContinueUnreachableLoopInst(SpvCapability cap) {
+std::string GetUnreachableContinueUnreachableLoopInst(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
- Block body("body", SpvOpReturn);
+ Block body("body", spv::Op::OpReturn);
Block entry("entry");
- Block branch("branch", SpvOpBranch);
- Block merge("merge", SpvOpReturn);
- Block target("target", SpvOpBranch);
+ Block branch("branch", spv::Op::OpBranch);
+ Block merge("merge", spv::Op::OpReturn);
+ Block target("target", spv::Op::OpBranch);
target >> branch;
std::string str = header;
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
branch.AppendBody("OpLoopMerge %merge %target None\n");
str += nameOps("branch", "merge", "target", std::make_pair("func", "Main"));
@@ -880,21 +882,21 @@ TEST_P(ValidateCFG, UnreachableContinueUnreachableLoopInst) {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableMergeWithComplexBody(SpvCapability cap) {
+std::string GetUnreachableMergeWithComplexBody(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranchConditional);
- Block t("t", SpvOpReturn);
- Block f("f", SpvOpReturn);
- Block merge("merge", SpvOpUnreachable);
+ Block branch("branch", spv::Op::OpBranchConditional);
+ Block t("t", spv::Op::OpReturn);
+ Block f("f", spv::Op::OpReturn);
+ Block merge("merge", spv::Op::OpUnreachable);
entry.AppendBody("%placeholder = OpVariable %intptrt Function\n");
entry.AppendBody("%cond = OpSLessThan %boolt %one %two\n");
merge.AppendBody("OpStore %placeholder %one\n");
std::string str = header;
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
branch.AppendBody("OpSelectionMerge %merge None\n");
str += nameOps("branch", "merge", std::make_pair("func", "Main"));
@@ -916,13 +918,13 @@ TEST_P(ValidateCFG, UnreachableMergeWithComplexBody) {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableContinueWithComplexBody(SpvCapability cap) {
+std::string GetUnreachableContinueWithComplexBody(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranch);
- Block merge("merge", SpvOpReturn);
- Block target("target", SpvOpBranch);
+ Block branch("branch", spv::Op::OpBranch);
+ Block merge("merge", spv::Op::OpReturn);
+ Block target("target", spv::Op::OpBranch);
target >> branch;
@@ -930,7 +932,7 @@ std::string GetUnreachableContinueWithComplexBody(SpvCapability cap) {
target.AppendBody("OpStore %placeholder %one\n");
std::string str = header;
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
branch.AppendBody("OpLoopMerge %merge %target None\n");
str += nameOps("branch", "merge", "target", std::make_pair("func", "Main"));
@@ -951,19 +953,19 @@ TEST_P(ValidateCFG, UnreachableContinueWithComplexBody) {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableMergeWithBranchUse(SpvCapability cap) {
+std::string GetUnreachableMergeWithBranchUse(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranchConditional);
- Block t("t", SpvOpBranch);
- Block f("f", SpvOpReturn);
- Block merge("merge", SpvOpUnreachable);
+ Block branch("branch", spv::Op::OpBranchConditional);
+ Block t("t", spv::Op::OpBranch);
+ Block f("f", spv::Op::OpReturn);
+ Block merge("merge", spv::Op::OpUnreachable);
entry.AppendBody("%cond = OpSLessThan %boolt %one %two\n");
std::string str = header;
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
branch.AppendBody("OpSelectionMerge %merge None\n");
str += nameOps("branch", "merge", std::make_pair("func", "Main"));
@@ -984,20 +986,20 @@ TEST_P(ValidateCFG, UnreachableMergeWithBranchUse) {
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableMergeWithMultipleUses(SpvCapability cap) {
+std::string GetUnreachableMergeWithMultipleUses(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranchConditional);
- Block t("t", SpvOpReturn);
- Block f("f", SpvOpReturn);
- Block merge("merge", SpvOpUnreachable);
- Block duplicate("duplicate", SpvOpBranchConditional);
+ Block branch("branch", spv::Op::OpBranchConditional);
+ Block t("t", spv::Op::OpReturn);
+ Block f("f", spv::Op::OpReturn);
+ Block merge("merge", spv::Op::OpUnreachable);
+ Block duplicate("duplicate", spv::Op::OpBranchConditional);
entry.AppendBody("%cond = OpSLessThan %boolt %one %two\n");
std::string str = header;
- if (cap == SpvCapabilityShader) {
+ if (cap == spv::Capability::Shader) {
branch.AppendBody("OpSelectionMerge %merge None\n");
duplicate.AppendBody("OpSelectionMerge %merge None\n");
}
@@ -1018,7 +1020,7 @@ std::string GetUnreachableMergeWithMultipleUses(SpvCapability cap) {
TEST_P(ValidateCFG, UnreachableMergeWithMultipleUses) {
CompileSuccessfully(GetUnreachableMergeWithMultipleUses(GetParam()));
- if (GetParam() == SpvCapabilityShader) {
+ if (GetParam() == spv::Capability::Shader) {
ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("is already a merge block for another header"));
@@ -1027,20 +1029,20 @@ TEST_P(ValidateCFG, UnreachableMergeWithMultipleUses) {
}
}
-std::string GetUnreachableContinueWithBranchUse(SpvCapability cap) {
+std::string GetUnreachableContinueWithBranchUse(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranch);
- Block merge("merge", SpvOpReturn);
- Block target("target", SpvOpBranch);
+ Block branch("branch", spv::Op::OpBranch);
+ Block merge("merge", spv::Op::OpReturn);
+ Block target("target", spv::Op::OpBranch);
target >> branch;
entry.AppendBody("%placeholder = OpVariable %intptrt Function\n");
std::string str = header;
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
branch.AppendBody("OpLoopMerge %merge %target None\n");
str += nameOps("branch", "merge", "target", std::make_pair("func", "Main"));
@@ -1061,16 +1063,16 @@ TEST_P(ValidateCFG, UnreachableContinueWithBranchUse) {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetReachableMergeAndContinue(SpvCapability cap) {
+std::string GetReachableMergeAndContinue(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranch);
- Block merge("merge", SpvOpReturn);
- Block target("target", SpvOpBranch);
- Block body("body", SpvOpBranchConditional);
- Block t("t", SpvOpBranch);
- Block f("f", SpvOpBranch);
+ Block branch("branch", spv::Op::OpBranch);
+ Block merge("merge", spv::Op::OpReturn);
+ Block target("target", spv::Op::OpBranch);
+ Block body("body", spv::Op::OpBranchConditional);
+ Block t("t", spv::Op::OpBranch);
+ Block f("f", spv::Op::OpBranch);
target >> branch;
body.SetBody("%cond = OpSLessThan %boolt %one %two\n");
@@ -1078,7 +1080,7 @@ std::string GetReachableMergeAndContinue(SpvCapability cap) {
f >> target;
std::string str = header;
- if (cap == SpvCapabilityShader) {
+ if (cap == spv::Capability::Shader) {
branch.AppendBody("OpLoopMerge %merge %target None\n");
body.AppendBody("OpSelectionMerge %f None\n");
}
@@ -1104,23 +1106,23 @@ TEST_P(ValidateCFG, ReachableMergeAndContinue) {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableMergeAndContinue(SpvCapability cap) {
+std::string GetUnreachableMergeAndContinue(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block branch("branch", SpvOpBranch);
- Block merge("merge", SpvOpReturn);
- Block target("target", SpvOpBranch);
- Block body("body", SpvOpBranchConditional);
- Block t("t", SpvOpReturn);
- Block f("f", SpvOpReturn);
- Block pre_target("pre_target", SpvOpBranch);
+ Block branch("branch", spv::Op::OpBranch);
+ Block merge("merge", spv::Op::OpReturn);
+ Block target("target", spv::Op::OpBranch);
+ Block body("body", spv::Op::OpBranchConditional);
+ Block t("t", spv::Op::OpReturn);
+ Block f("f", spv::Op::OpReturn);
+ Block pre_target("pre_target", spv::Op::OpBranch);
target >> branch;
body.SetBody("%cond = OpSLessThan %boolt %one %two\n");
std::string str = header;
- if (cap == SpvCapabilityShader) {
+ if (cap == spv::Capability::Shader) {
branch.AppendBody("OpLoopMerge %merge %target None\n");
body.AppendBody("OpSelectionMerge %pre_target None\n");
}
@@ -1147,12 +1149,12 @@ TEST_P(ValidateCFG, UnreachableMergeAndContinue) {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableBlock(SpvCapability cap) {
+std::string GetUnreachableBlock(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
Block unreachable("unreachable");
- Block exit("exit", SpvOpReturn);
+ Block exit("exit", spv::Op::OpReturn);
std::string str = header;
str += nameOps("unreachable", "exit", std::make_pair("func", "Main"));
@@ -1171,18 +1173,18 @@ TEST_P(ValidateCFG, UnreachableBlock) {
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
}
-std::string GetUnreachableBranch(SpvCapability cap) {
+std::string GetUnreachableBranch(spv::Capability cap) {
std::string header = GetDefaultHeader(cap);
Block entry("entry");
- Block unreachable("unreachable", SpvOpBranchConditional);
+ Block unreachable("unreachable", spv::Op::OpBranchConditional);
Block unreachablechildt("unreachablechildt");
Block unreachablechildf("unreachablechildf");
Block merge("merge");
- Block exit("exit", SpvOpReturn);
+ Block exit("exit", spv::Op::OpReturn);
unreachable.SetBody("%cond = OpSLessThan %boolt %one %two\n");
- if (cap == SpvCapabilityShader)
+ if (cap == spv::Capability::Shader)
unreachable.AppendBody("OpSelectionMerge %merge None\n");
std::string str = header;
@@ -1219,10 +1221,10 @@ TEST_P(ValidateCFG, EmptyFunction) {
}
TEST_P(ValidateCFG, SingleBlockLoop) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop("loop", SpvOpBranchConditional);
- Block exit("exit", SpvOpReturn);
+ Block loop("loop", spv::Op::OpBranchConditional);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) loop.AppendBody("OpLoopMerge %exit %loop None\n");
@@ -1240,15 +1242,15 @@ TEST_P(ValidateCFG, SingleBlockLoop) {
}
TEST_P(ValidateCFG, NestedLoops) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
Block loop1("loop1");
Block loop1_cont_break_block("loop1_cont_break_block",
- SpvOpBranchConditional);
- Block loop2("loop2", SpvOpBranchConditional);
+ spv::Op::OpBranchConditional);
+ Block loop2("loop2", spv::Op::OpBranchConditional);
Block loop2_merge("loop2_merge");
Block loop1_merge("loop1_merge");
- Block exit("exit", SpvOpReturn);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) {
@@ -1275,7 +1277,7 @@ TEST_P(ValidateCFG, NestedLoops) {
}
TEST_P(ValidateCFG, NestedSelection) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
const int N = 256;
std::vector<Block> if_blocks;
@@ -1284,18 +1286,18 @@ TEST_P(ValidateCFG, NestedSelection) {
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
- if_blocks.emplace_back("if0", SpvOpBranchConditional);
+ if_blocks.emplace_back("if0", spv::Op::OpBranchConditional);
if (is_shader) if_blocks[0].SetBody("OpSelectionMerge %if_merge0 None\n");
- merge_blocks.emplace_back("if_merge0", SpvOpReturn);
+ merge_blocks.emplace_back("if_merge0", spv::Op::OpReturn);
for (int i = 1; i < N; i++) {
std::stringstream ss;
ss << i;
- if_blocks.emplace_back("if" + ss.str(), SpvOpBranchConditional);
+ if_blocks.emplace_back("if" + ss.str(), spv::Op::OpBranchConditional);
if (is_shader)
if_blocks[i].SetBody("OpSelectionMerge %if_merge" + ss.str() + " None\n");
- merge_blocks.emplace_back("if_merge" + ss.str(), SpvOpBranch);
+ merge_blocks.emplace_back("if_merge" + ss.str(), spv::Op::OpBranch);
}
std::string str = GetDefaultHeader(GetParam()) + std::string(types_consts()) +
"%func = OpFunction %voidt None %funct\n";
@@ -1318,14 +1320,14 @@ TEST_P(ValidateCFG, NestedSelection) {
}
TEST_P(ValidateCFG, BackEdgeBlockDoesntPostDominateContinueTargetBad) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop1("loop1", SpvOpBranchConditional);
- Block loop2("loop2", SpvOpBranchConditional);
+ Block loop1("loop1", spv::Op::OpBranchConditional);
+ Block loop2("loop2", spv::Op::OpBranchConditional);
Block loop2_merge("loop2_merge");
- Block loop1_cont("loop1_cont", SpvOpBranchConditional);
+ Block loop1_cont("loop1_cont", spv::Op::OpBranchConditional);
Block be_block("be_block");
- Block exit("exit", SpvOpReturn);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) {
@@ -1348,7 +1350,7 @@ TEST_P(ValidateCFG, BackEdgeBlockDoesntPostDominateContinueTargetBad) {
str += "OpFunctionEnd";
CompileSuccessfully(str);
- if (GetParam() == SpvCapabilityShader) {
+ if (GetParam() == spv::Capability::Shader) {
ASSERT_EQ(SPV_ERROR_INVALID_CFG, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
@@ -1363,12 +1365,12 @@ TEST_P(ValidateCFG, BackEdgeBlockDoesntPostDominateContinueTargetBad) {
}
TEST_P(ValidateCFG, BranchingToNonLoopHeaderBlockBad) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block split("split", SpvOpBranchConditional);
+ Block split("split", spv::Op::OpBranchConditional);
Block t("t");
Block f("f");
- Block exit("exit", SpvOpReturn);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) split.SetBody("OpSelectionMerge %exit None\n");
@@ -1398,10 +1400,10 @@ TEST_P(ValidateCFG, BranchingToNonLoopHeaderBlockBad) {
}
TEST_P(ValidateCFG, BranchingToSameNonLoopHeaderBlockBad) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block split("split", SpvOpBranchConditional);
- Block exit("exit", SpvOpReturn);
+ Block split("split", spv::Op::OpBranchConditional);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) split.SetBody("OpSelectionMerge %exit None\n");
@@ -1429,12 +1431,12 @@ TEST_P(ValidateCFG, BranchingToSameNonLoopHeaderBlockBad) {
}
TEST_P(ValidateCFG, MultipleBackEdgeBlocksToLoopHeaderBad) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop("loop", SpvOpBranchConditional);
+ Block loop("loop", spv::Op::OpBranchConditional);
Block back0("back0");
Block back1("back1");
- Block merge("merge", SpvOpReturn);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) loop.SetBody("OpLoopMerge %merge %back0 None\n");
@@ -1465,13 +1467,13 @@ TEST_P(ValidateCFG, MultipleBackEdgeBlocksToLoopHeaderBad) {
}
TEST_P(ValidateCFG, ContinueTargetMustBePostDominatedByBackEdge) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop("loop", SpvOpBranchConditional);
- Block cheader("cheader", SpvOpBranchConditional);
+ Block loop("loop", spv::Op::OpBranchConditional);
+ Block cheader("cheader", spv::Op::OpBranchConditional);
Block be_block("be_block");
- Block merge("merge", SpvOpReturn);
- Block exit("exit", SpvOpReturn);
+ Block merge("merge", spv::Op::OpReturn);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) loop.SetBody("OpLoopMerge %merge %cheader None\n");
@@ -1504,11 +1506,11 @@ TEST_P(ValidateCFG, ContinueTargetMustBePostDominatedByBackEdge) {
}
TEST_P(ValidateCFG, BranchOutOfConstructToMergeBad) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop("loop", SpvOpBranchConditional);
- Block cont("cont", SpvOpBranchConditional);
- Block merge("merge", SpvOpReturn);
+ Block loop("loop", spv::Op::OpBranchConditional);
+ Block cont("cont", spv::Op::OpBranchConditional);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) loop.SetBody("OpLoopMerge %merge %loop None\n");
@@ -1539,12 +1541,12 @@ TEST_P(ValidateCFG, BranchOutOfConstructToMergeBad) {
}
TEST_P(ValidateCFG, BranchOutOfConstructBad) {
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop("loop", SpvOpBranchConditional);
- Block cont("cont", SpvOpBranchConditional);
+ Block loop("loop", spv::Op::OpBranchConditional);
+ Block cont("cont", spv::Op::OpBranchConditional);
Block merge("merge");
- Block exit("exit", SpvOpReturn);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) loop.SetBody("OpLoopMerge %merge %loop None\n");
@@ -1575,12 +1577,12 @@ TEST_P(ValidateCFG, BranchOutOfConstructBad) {
}
TEST_F(ValidateCFG, OpSwitchToUnreachableBlock) {
- Block entry("entry", SpvOpSwitch);
+ Block entry("entry", spv::Op::OpSwitch);
Block case0("case0");
Block case1("case1");
Block case2("case2");
- Block def("default", SpvOpUnreachable);
- Block phi("phi", SpvOpReturn);
+ Block def("default", spv::Op::OpUnreachable);
+ Block phi("phi", spv::Op::OpReturn);
std::string str = R"(
OpCapability Shader
@@ -1687,13 +1689,13 @@ TEST_P(ValidateCFG,
// The nested construct has an unreachable merge block. In the
// augmented CFG that merge block
// we still determine that the
- bool is_shader = GetParam() == SpvCapabilityShader;
- Block entry("entry", SpvOpBranchConditional);
- Block inner_head("inner_head", SpvOpBranchConditional);
- Block inner_true("inner_true", SpvOpReturn);
- Block inner_false("inner_false", SpvOpReturn);
+ bool is_shader = GetParam() == spv::Capability::Shader;
+ Block entry("entry", spv::Op::OpBranchConditional);
+ Block inner_head("inner_head", spv::Op::OpBranchConditional);
+ Block inner_true("inner_true", spv::Op::OpReturn);
+ Block inner_false("inner_false", spv::Op::OpReturn);
Block inner_merge("inner_merge");
- Block exit("exit", SpvOpReturn);
+ Block exit("exit", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) {
@@ -1721,13 +1723,13 @@ TEST_P(ValidateCFG, ContinueTargetCanBeMergeBlockForNestedStructure) {
// The continue construct cannot be the merge target of a nested selection
// because the loop construct must contain "if_merge" because it contains
// "if_head".
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
Block loop("loop");
- Block if_head("if_head", SpvOpBranchConditional);
+ Block if_head("if_head", spv::Op::OpBranchConditional);
Block if_true("if_true");
- Block if_merge("if_merge", SpvOpBranchConditional);
- Block merge("merge", SpvOpReturn);
+ Block if_merge("if_merge", spv::Op::OpBranchConditional);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) {
@@ -1765,11 +1767,11 @@ TEST_P(ValidateCFG, ContinueTargetCanBeMergeBlockForNestedStructure) {
TEST_P(ValidateCFG, SingleLatchBlockMultipleBranchesToLoopHeader) {
// This test case ensures we allow both branches of a loop latch block
// to go back to the loop header. It still counts as a single back edge.
- bool is_shader = GetParam() == SpvCapabilityShader;
+ bool is_shader = GetParam() == spv::Capability::Shader;
Block entry("entry");
- Block loop("loop", SpvOpBranchConditional);
- Block latch("latch", SpvOpBranchConditional);
- Block merge("merge", SpvOpReturn);
+ Block loop("loop", spv::Op::OpBranchConditional);
+ Block latch("latch", spv::Op::OpBranchConditional);
+ Block merge("merge", spv::Op::OpReturn);
entry.SetBody("%cond = OpSLessThan %boolt %one %two\n");
if (is_shader) {
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-29 13:18:23 +0300