233 lines
8.3 KiB
C++
233 lines
8.3 KiB
C++
// Copyright 2025 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include <array>
|
|
#include <iostream>
|
|
|
|
#include "gmock/gmock.h"
|
|
#include "source/spirv_target_env.h"
|
|
#include "source/table2.h"
|
|
#include "test/unit_spirv.h"
|
|
|
|
using ::testing::ContainerEq;
|
|
using ::testing::ValuesIn;
|
|
|
|
namespace spvtools {
|
|
namespace {
|
|
|
|
struct OpcodeLookupCase {
|
|
std::string name;
|
|
uint32_t opcode;
|
|
bool expect_pass = true;
|
|
};
|
|
|
|
std::ostream& operator<<(std::ostream& os, const OpcodeLookupCase& olc) {
|
|
os << "OLC('" << olc.name << "', " << olc.opcode << ", expect pass? "
|
|
<< olc.expect_pass << ")";
|
|
return os;
|
|
}
|
|
|
|
using OpcodeLookupTest = ::testing::TestWithParam<OpcodeLookupCase>;
|
|
|
|
TEST_P(OpcodeLookupTest, OpcodeLookup_ByName) {
|
|
const InstructionDesc* desc = nullptr;
|
|
auto status = LookupOpcode(GetParam().name.data(), &desc);
|
|
if (GetParam().expect_pass) {
|
|
EXPECT_EQ(status, SPV_SUCCESS);
|
|
ASSERT_NE(desc, nullptr);
|
|
EXPECT_EQ(static_cast<uint32_t>(desc->opcode), GetParam().opcode);
|
|
} else {
|
|
EXPECT_NE(status, SPV_SUCCESS);
|
|
EXPECT_EQ(desc, nullptr);
|
|
}
|
|
}
|
|
|
|
TEST_P(OpcodeLookupTest, OpcodeLookup_ByOpcode_Success) {
|
|
const InstructionDesc* desc = nullptr;
|
|
if (GetParam().expect_pass) {
|
|
spv::Op opcode = static_cast<spv::Op>(GetParam().opcode);
|
|
auto status = LookupOpcode(opcode, &desc);
|
|
EXPECT_EQ(status, SPV_SUCCESS);
|
|
ASSERT_NE(desc, nullptr);
|
|
EXPECT_EQ(desc->opcode, opcode);
|
|
}
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Samples, OpcodeLookupTest,
|
|
ValuesIn(std::vector<OpcodeLookupCase>{
|
|
{"Nop", 0},
|
|
{"WritePipe", 275},
|
|
{"TypeAccelerationStructureKHR", 5341},
|
|
{"TypeAccelerationStructureNV", 5341},
|
|
{"does not exist", 0, false},
|
|
{"CopyLogical", 400},
|
|
{"FPGARegINTEL", 5949},
|
|
{"SubgroupMatrixMultiplyAccumulateINTEL", 6237},
|
|
}));
|
|
|
|
TEST(OpcodeLookupSingleTest, OpcodeLookup_ByOpcode_Fails) {
|
|
// This list may need adjusting over time.
|
|
std::array<uint32_t, 3> bad_opcodes = {{99999, 37737, 110101}};
|
|
for (auto bad_opcode : bad_opcodes) {
|
|
const InstructionDesc* desc = nullptr;
|
|
spv::Op opcode = static_cast<spv::Op>(bad_opcode);
|
|
auto status = LookupOpcode(opcode, &desc);
|
|
EXPECT_NE(status, SPV_SUCCESS);
|
|
ASSERT_EQ(desc, nullptr);
|
|
}
|
|
}
|
|
|
|
struct OpcodeLookupEnvCase {
|
|
std::string name;
|
|
uint32_t opcode;
|
|
spv_target_env env = SPV_ENV_UNIVERSAL_1_0;
|
|
bool expect_pass = true;
|
|
};
|
|
|
|
std::ostream& operator<<(std::ostream& os, const OpcodeLookupEnvCase& olec) {
|
|
os << "OLC('" << olec.name << "', " << olec.opcode << ", env "
|
|
<< spvTargetEnvDescription(olec.env) << ", expect pass? "
|
|
<< olec.expect_pass << ")";
|
|
return os;
|
|
}
|
|
|
|
using OpcodeLookupEnvTest = ::testing::TestWithParam<OpcodeLookupEnvCase>;
|
|
|
|
TEST_P(OpcodeLookupEnvTest, OpcodeLookupForEnv_ByName) {
|
|
const InstructionDesc* desc = nullptr;
|
|
auto status =
|
|
LookupOpcodeForEnv(GetParam().env, GetParam().name.data(), &desc);
|
|
if (GetParam().expect_pass) {
|
|
EXPECT_EQ(status, SPV_SUCCESS);
|
|
ASSERT_NE(desc, nullptr);
|
|
EXPECT_EQ(static_cast<uint32_t>(desc->opcode), GetParam().opcode);
|
|
} else {
|
|
EXPECT_NE(status, SPV_SUCCESS);
|
|
EXPECT_EQ(desc, nullptr);
|
|
}
|
|
}
|
|
|
|
TEST_P(OpcodeLookupEnvTest, OpcodeLookupForEnv_ByOpcode) {
|
|
const InstructionDesc* desc = nullptr;
|
|
spv::Op opcode = static_cast<spv::Op>(GetParam().opcode);
|
|
auto status = LookupOpcodeForEnv(GetParam().env, opcode, &desc);
|
|
if (GetParam().expect_pass) {
|
|
EXPECT_EQ(status, SPV_SUCCESS);
|
|
ASSERT_NE(desc, nullptr);
|
|
EXPECT_EQ(desc->opcode, opcode);
|
|
} else {
|
|
// Skip nonsense cases created for the lookup-by-name case.
|
|
if (GetParam().name != "does not exist") {
|
|
EXPECT_NE(status, SPV_SUCCESS);
|
|
EXPECT_EQ(desc, nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Samples, OpcodeLookupEnvTest,
|
|
ValuesIn(std::vector<OpcodeLookupEnvCase>{
|
|
{"Nop", 0},
|
|
{"WritePipe", 275},
|
|
{"TypeAccelerationStructureKHR", 5341},
|
|
{"TypeAccelerationStructureNV", 5341},
|
|
{"does not exist", 0, SPV_ENV_UNIVERSAL_1_0,
|
|
false},
|
|
{"CopyLogical", 400, SPV_ENV_UNIVERSAL_1_0, false},
|
|
{"CopyLogical", 400, SPV_ENV_UNIVERSAL_1_3, false},
|
|
{"CopyLogical", 400, SPV_ENV_UNIVERSAL_1_4, true},
|
|
{"FPGARegINTEL", 5949},
|
|
{"SubgroupMatrixMultiplyAccumulateINTEL", 6237},
|
|
}));
|
|
|
|
TEST(OpcodeLookupExtInstTest, Operands) {
|
|
// The SPIR-V spec grammar has a single rule for OpExtInst, where the last
|
|
// item is "sequence of Ids". SPIRV-Tools handles it differently. It drops
|
|
// that last item, and instead specifies those operands as operands of the
|
|
// extended instruction enum, such as 'cos'.
|
|
// See https://github.com/KhronosGroup/SPIRV-Tools/issues/233
|
|
// Test the exact sequence of operand types extracted for OpExtInst.
|
|
const InstructionDesc* desc = nullptr;
|
|
auto status = LookupOpcode("ExtInst", &desc);
|
|
EXPECT_EQ(status, SPV_SUCCESS);
|
|
ASSERT_NE(desc, nullptr);
|
|
|
|
EXPECT_EQ(desc->operands_range.count(), 4u);
|
|
|
|
auto operands = desc->operands();
|
|
using vtype = std::vector<spv_operand_type_t>;
|
|
|
|
EXPECT_THAT(
|
|
vtype(operands.begin(), operands.end()),
|
|
ContainerEq(vtype{SPV_OPERAND_TYPE_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID,
|
|
SPV_OPERAND_TYPE_ID,
|
|
SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER}));
|
|
}
|
|
|
|
// Test printingClass
|
|
|
|
struct OpcodePrintingClassCase {
|
|
std::string name;
|
|
PrintingClass expected;
|
|
};
|
|
|
|
std::ostream& operator<<(std::ostream& os,
|
|
const OpcodePrintingClassCase& opcc) {
|
|
os << "OPCC('" << opcc.name << "', " << static_cast<int>(opcc.expected)
|
|
<< ")";
|
|
return os;
|
|
}
|
|
|
|
using OpcodePrintingClassTest =
|
|
::testing::TestWithParam<OpcodePrintingClassCase>;
|
|
|
|
TEST_P(OpcodePrintingClassTest, OpcodeLookup_ByName) {
|
|
const InstructionDesc* desc = nullptr;
|
|
auto status = LookupOpcode(GetParam().name.data(), &desc);
|
|
EXPECT_EQ(status, SPV_SUCCESS);
|
|
ASSERT_NE(desc, nullptr);
|
|
EXPECT_EQ(desc->printingClass, GetParam().expected);
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
Samples, OpcodePrintingClassTest,
|
|
ValuesIn(std::vector<OpcodePrintingClassCase>{
|
|
{"ConstantFunctionPointerINTEL", PrintingClass::k_exclude},
|
|
{"Nop", PrintingClass::kMiscellaneous},
|
|
{"SourceContinued", PrintingClass::kDebug},
|
|
{"Decorate", PrintingClass::kAnnotation},
|
|
{"Extension", PrintingClass::kExtension},
|
|
{"MemoryModel", PrintingClass::kMode_Setting},
|
|
{"Variable", PrintingClass::kMemory},
|
|
{"CooperativeMatrixPerElementOpNV", PrintingClass::kFunction},
|
|
{"SampledImage", PrintingClass::kImage},
|
|
{"ConvertFToU", PrintingClass::kConversion},
|
|
{"VectorExtractDynamic", PrintingClass::kComposite},
|
|
{"IAdd", PrintingClass::kArithmetic},
|
|
{"ShiftRightLogical", PrintingClass::kBit},
|
|
{"Any", PrintingClass::kRelational_and_Logical},
|
|
{"DPdx", PrintingClass::kDerivative},
|
|
{"Branch", PrintingClass::kControl_Flow},
|
|
{"AtomicLoad", PrintingClass::kAtomic},
|
|
{"ControlBarrier", PrintingClass::kBarrier},
|
|
{"GroupAll", PrintingClass::kGroup},
|
|
{"EnqueueMarker", PrintingClass::kDevice_Side_Enqueue},
|
|
{"ReadPipe", PrintingClass::kPipe},
|
|
{"GroupNonUniformElect", PrintingClass::kNon_Uniform},
|
|
// Skipping "Reserved" because it's probably an
|
|
// unstable class.
|
|
}));
|
|
|
|
} // namespace
|
|
} // namespace spvtools
|