| // Copyright (c) 2015-2016 The Khronos Group Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // Assembler tests for instructions in the "Image Instructions" section of |
| // the SPIR-V spec. |
| |
| #include <string> |
| #include <vector> |
| |
| #include "gmock/gmock.h" |
| #include "test/test_fixture.h" |
| #include "test/unit_spirv.h" |
| |
| namespace spvtools { |
| namespace { |
| |
| using spvtest::MakeInstruction; |
| using spvtest::TextToBinaryTest; |
| using ::testing::Eq; |
| |
| // An example case for a mask value with operands. |
| struct ImageOperandsCase { |
| std::string image_operands; |
| // The expected mask, followed by its operands. |
| std::vector<uint32_t> expected_mask_and_operands; |
| }; |
| |
| // Test all kinds of image operands. |
| |
| using ImageOperandsTest = |
| spvtest::TextToBinaryTestBase<::testing::TestWithParam<ImageOperandsCase>>; |
| |
| TEST_P(ImageOperandsTest, Sample) { |
| const std::string input = |
| "%2 = OpImageFetch %1 %3 %4" + GetParam().image_operands + "\n"; |
| EXPECT_THAT(CompiledInstructions(input), |
| Eq(MakeInstruction(spv::Op::OpImageFetch, {1, 2, 3, 4}, |
| GetParam().expected_mask_and_operands))); |
| } |
| |
| #define MASK(NAME) uint32_t(spv::ImageOperandsMask::NAME) |
| INSTANTIATE_TEST_SUITE_P( |
| TextToBinaryImageOperandsAny, ImageOperandsTest, |
| ::testing::ValuesIn(std::vector<ImageOperandsCase>{ |
| // TODO(dneto): Rev32 adds many more values, and rearranges their |
| // values. |
| // Image operands are optional. |
| {"", {}}, |
| // Test each kind, alone. |
| {" Bias %5", {MASK(Bias), 5}}, |
| {" Lod %5", {MASK(Lod), 5}}, |
| {" Grad %5 %6", {MASK(Grad), 5, 6}}, |
| {" ConstOffset %5", {MASK(ConstOffset), 5}}, |
| {" Offset %5", {MASK(Offset), 5}}, |
| {" ConstOffsets %5", {MASK(ConstOffsets), 5}}, |
| {" Sample %5", {MASK(Sample), 5}}, |
| {" MinLod %5", {MASK(MinLod), 5}}, |
| })); |
| #undef MASK |
| #define MASK(NAME) static_cast<uint32_t>(spv::ImageOperandsMask::NAME) |
| INSTANTIATE_TEST_SUITE_P( |
| TextToBinaryImageOperandsCombination, ImageOperandsTest, |
| ::testing::ValuesIn(std::vector<ImageOperandsCase>{ |
| // TODO(dneto): Rev32 adds many more values, and rearranges their |
| // values. |
| // Test adjacent pairs, so we can easily debug the values when it fails. |
| {" Bias|Lod %5 %6", {MASK(Bias) | MASK(Lod), 5, 6}}, |
| {" Lod|Grad %5 %6 %7", {MASK(Lod) | MASK(Grad), 5, 6, 7}}, |
| {" Grad|ConstOffset %5 %6 %7", |
| {MASK(Grad) | MASK(ConstOffset), 5, 6, 7}}, |
| {" ConstOffset|Offset %5 %6", {MASK(ConstOffset) | MASK(Offset), 5, 6}}, |
| {" Offset|ConstOffsets %5 %6", |
| {MASK(Offset) | MASK(ConstOffsets), 5, 6}}, |
| {" ConstOffsets|Sample %5 %6", |
| {MASK(ConstOffsets) | MASK(Sample), 5, 6}}, |
| // Test all masks together. |
| {" Bias|Lod|Grad|ConstOffset|Offset|ConstOffsets|Sample" |
| " %5 %6 %7 %8 %9 %10 %11 %12", |
| {MASK(Bias) | MASK(Lod) | MASK(Grad) | MASK(ConstOffset) | |
| MASK(Offset) | MASK(ConstOffsets) | MASK(Sample), |
| 5, 6, 7, 8, 9, 10, 11, 12}}, |
| // The same, but with mask value names reversed. |
| {" Sample|ConstOffsets|Offset|ConstOffset|Grad|Lod|Bias" |
| " %5 %6 %7 %8 %9 %10 %11 %12", |
| {MASK(Bias) | MASK(Lod) | MASK(Grad) | MASK(ConstOffset) | |
| MASK(Offset) | MASK(ConstOffsets) | MASK(Sample), |
| 5, 6, 7, 8, 9, 10, 11, 12}}})); |
| #undef MASK |
| |
| TEST_F(ImageOperandsTest, WrongOperand) { |
| EXPECT_THAT(CompileFailure("%r = OpImageFetch %t %i %c xxyyzz"), |
| Eq("Invalid image operand 'xxyyzz'.")); |
| } |
| |
| // Test OpImage |
| |
| using OpImageTest = TextToBinaryTest; |
| |
| TEST_F(OpImageTest, Valid) { |
| const std::string input = "%2 = OpImage %1 %3\n"; |
| EXPECT_THAT(CompiledInstructions(input), |
| Eq(MakeInstruction(spv::Op::OpImage, {1, 2, 3}))); |
| |
| // Test the disassembler. |
| EXPECT_THAT(EncodeAndDecodeSuccessfully(input), input); |
| } |
| |
| TEST_F(OpImageTest, InvalidTypeOperand) { |
| EXPECT_THAT(CompileFailure("%2 = OpImage 42"), |
| Eq("Expected id to start with %.")); |
| } |
| |
| TEST_F(OpImageTest, MissingSampledImageOperand) { |
| EXPECT_THAT(CompileFailure("%2 = OpImage %1"), |
| Eq("Expected operand for OpImage instruction, but found the end " |
| "of the stream.")); |
| } |
| |
| TEST_F(OpImageTest, InvalidSampledImageOperand) { |
| EXPECT_THAT(CompileFailure("%2 = OpImage %1 1000"), |
| Eq("Expected id to start with %.")); |
| } |
| |
| TEST_F(OpImageTest, TooManyOperands) { |
| // We should improve this message, to say what instruction we're trying to |
| // parse. |
| EXPECT_THAT(CompileFailure("%2 = OpImage %1 %3 %4"), // an Id |
| Eq("Expected '=', found end of stream.")); |
| |
| EXPECT_THAT(CompileFailure("%2 = OpImage %1 %3 99"), // a number |
| Eq("Expected <opcode> or <result-id> at the beginning of an " |
| "instruction, found '99'.")); |
| EXPECT_THAT(CompileFailure("%2 = OpImage %1 %3 \"abc\""), // a string |
| Eq("Expected <opcode> or <result-id> at the beginning of an " |
| "instruction, found '\"abc\"'.")); |
| } |
| |
| // Test OpImageSparseRead |
| |
| using OpImageSparseReadTest = TextToBinaryTest; |
| |
| TEST_F(OpImageSparseReadTest, OnlyRequiredOperands) { |
| const std::string input = "%2 = OpImageSparseRead %1 %3 %4\n"; |
| EXPECT_THAT(CompiledInstructions(input), |
| Eq(MakeInstruction(spv::Op::OpImageSparseRead, {1, 2, 3, 4}))); |
| // Test the disassembler. |
| EXPECT_THAT(EncodeAndDecodeSuccessfully(input), input); |
| } |
| |
| // Test all kinds of image operands on OpImageSparseRead |
| |
| using ImageSparseReadImageOperandsTest = |
| spvtest::TextToBinaryTestBase<::testing::TestWithParam<ImageOperandsCase>>; |
| |
| TEST_P(ImageSparseReadImageOperandsTest, Sample) { |
| const std::string input = |
| "%2 = OpImageSparseRead %1 %3 %4" + GetParam().image_operands + "\n"; |
| EXPECT_THAT(CompiledInstructions(input), |
| Eq(MakeInstruction(spv::Op::OpImageSparseRead, {1, 2, 3, 4}, |
| GetParam().expected_mask_and_operands))); |
| // Test the disassembler. |
| EXPECT_THAT(EncodeAndDecodeSuccessfully(input), input); |
| } |
| |
| #define MASK(NAME) uint32_t(spv::ImageOperandsMask::NAME) |
| INSTANTIATE_TEST_SUITE_P(ImageSparseReadImageOperandsAny, |
| ImageSparseReadImageOperandsTest, |
| ::testing::ValuesIn(std::vector<ImageOperandsCase>{ |
| // Image operands are optional. |
| {"", {}}, |
| // Test each kind, alone. |
| {" Bias %5", {MASK(Bias), 5}}, |
| {" Lod %5", {MASK(Lod), 5}}, |
| {" Grad %5 %6", {MASK(Grad), 5, 6}}, |
| {" ConstOffset %5", {MASK(ConstOffset), 5}}, |
| {" Offset %5", {MASK(Offset), 5}}, |
| {" ConstOffsets %5", {MASK(ConstOffsets), 5}}, |
| {" Sample %5", {MASK(Sample), 5}}, |
| {" MinLod %5", {MASK(MinLod), 5}}, |
| })); |
| #undef MASK |
| #define MASK(NAME) static_cast<uint32_t>(spv::ImageOperandsMask::NAME) |
| INSTANTIATE_TEST_SUITE_P( |
| ImageSparseReadImageOperandsCombination, ImageSparseReadImageOperandsTest, |
| ::testing::ValuesIn(std::vector<ImageOperandsCase>{ |
| // values. |
| // Test adjacent pairs, so we can easily debug the values when it fails. |
| {" Bias|Lod %5 %6", {MASK(Bias) | MASK(Lod), 5, 6}}, |
| {" Lod|Grad %5 %6 %7", {MASK(Lod) | MASK(Grad), 5, 6, 7}}, |
| {" Grad|ConstOffset %5 %6 %7", |
| {MASK(Grad) | MASK(ConstOffset), 5, 6, 7}}, |
| {" ConstOffset|Offset %5 %6", {MASK(ConstOffset) | MASK(Offset), 5, 6}}, |
| {" Offset|ConstOffsets %5 %6", |
| {MASK(Offset) | MASK(ConstOffsets), 5, 6}}, |
| {" ConstOffsets|Sample %5 %6", |
| {MASK(ConstOffsets) | MASK(Sample), 5, 6}}, |
| // Test all masks together. |
| {" Bias|Lod|Grad|ConstOffset|Offset|ConstOffsets|Sample" |
| " %5 %6 %7 %8 %9 %10 %11 %12", |
| {MASK(Bias) | MASK(Lod) | MASK(Grad) | MASK(ConstOffset) | |
| MASK(Offset) | MASK(ConstOffsets) | MASK(Sample), |
| 5, 6, 7, 8, 9, 10, 11, 12}}, |
| // Don't try the masks reversed, since this is a round trip test, |
| // and the disassembler will sort them. |
| })); |
| #undef MASK |
| |
| TEST_F(OpImageSparseReadTest, InvalidTypeOperand) { |
| EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead 42"), |
| Eq("Expected id to start with %.")); |
| } |
| |
| TEST_F(OpImageSparseReadTest, MissingImageOperand) { |
| EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead %1"), |
| Eq("Expected operand for OpImageSparseRead instruction, but " |
| "found the end of the stream.")); |
| } |
| |
| TEST_F(OpImageSparseReadTest, InvalidImageOperand) { |
| EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead %1 1000"), |
| Eq("Expected id to start with %.")); |
| } |
| |
| TEST_F(OpImageSparseReadTest, MissingCoordinateOperand) { |
| EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead %1 %2"), |
| Eq("Expected operand for OpImageSparseRead instruction, but " |
| "found the end of the stream.")); |
| } |
| |
| TEST_F(OpImageSparseReadTest, InvalidCoordinateOperand) { |
| EXPECT_THAT(CompileFailure("%2 = OpImageSparseRead %1 %2 1000"), |
| Eq("Expected id to start with %.")); |
| } |
| |
| // TODO(dneto): OpSampledImage |
| // TODO(dneto): OpImageSampleImplicitLod |
| // TODO(dneto): OpImageSampleExplicitLod |
| // TODO(dneto): OpImageSampleDrefImplicitLod |
| // TODO(dneto): OpImageSampleDrefExplicitLod |
| // TODO(dneto): OpImageSampleProjImplicitLod |
| // TODO(dneto): OpImageSampleProjExplicitLod |
| // TODO(dneto): OpImageSampleProjDrefImplicitLod |
| // TODO(dneto): OpImageSampleProjDrefExplicitLod |
| // TODO(dneto): OpImageGather |
| // TODO(dneto): OpImageDrefGather |
| // TODO(dneto): OpImageRead |
| // TODO(dneto): OpImageWrite |
| // TODO(dneto): OpImageQueryFormat |
| // TODO(dneto): OpImageQueryOrder |
| // TODO(dneto): OpImageQuerySizeLod |
| // TODO(dneto): OpImageQuerySize |
| // TODO(dneto): OpImageQueryLod |
| // TODO(dneto): OpImageQueryLevels |
| // TODO(dneto): OpImageQuerySamples |
| // TODO(dneto): OpImageSparseSampleImplicitLod |
| // TODO(dneto): OpImageSparseSampleExplicitLod |
| // TODO(dneto): OpImageSparseSampleDrefImplicitLod |
| // TODO(dneto): OpImageSparseSampleDrefExplicitLod |
| // TODO(dneto): OpImageSparseSampleProjImplicitLod |
| // TODO(dneto): OpImageSparseSampleProjExplicitLod |
| // TODO(dneto): OpImageSparseSampleProjDrefImplicitLod |
| // TODO(dneto): OpImageSparseSampleProjDrefExplicitLod |
| // TODO(dneto): OpImageSparseFetch |
| // TODO(dneto): OpImageSparseDrefGather |
| // TODO(dneto): OpImageSparseTexelsResident |
| |
| } // namespace |
| } // namespace spvtools |
