AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-30 06:50:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
e4aebf99fa
SPIRV-Tools/test/val/val_id_test.cpp

6589 lines
213 KiB
C++
Raw Normal View History

Extend copyright to 2016.
2016-01-07 18:44:22 +00:00
// Copyright (c) 2015-2016 The Khronos Group Inc.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
//
Relicense SPIRV-Tools under Apache 2.0 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
2016-09-01 19:33:59 +00:00
// 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
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
//
Relicense SPIRV-Tools under Apache 2.0 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
2016-09-01 19:33:59 +00:00
// http://www.apache.org/licenses/LICENSE-2.0
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
//
Relicense SPIRV-Tools under Apache 2.0 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
2016-09-01 19:33:59 +00:00
// 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.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Fix validation of array length.
2016-04-04 19:55:05 +00:00
#include <sstream>
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
#include <string>
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include <vector>
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
#include "gmock/gmock.h"
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include "test/test_fixture.h"
#include "test/unit_spirv.h"
#include "test/val/val_fixtures.h"
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// NOTE: The tests in this file are ONLY testing ID usage, there for the input
// SPIR-V does not follow the logical layout rules from the spec in all cases in
// order to makes the tests smaller. Validation of the whole module is handled
// in stages, ID validation is only one of these stages. All validation stages
// are stand alone.
Move tests into namespaces (#1689) This CL moves the test into namespaces based on their directories.
2018-07-11 13:24:49 +00:00
namespace spvtools {
namespace val {
Put test classes in anonymous namespace. Put TestFixture.h classes in a namespace. Remove unused #includes.
2015-08-31 19:24:32 +00:00
namespace {
Validate all type ids. (#1868) * Validate all type ids. The validator does not check if the type of an instruction is actually a type unless the OpCode has a specific requirement. For example, OpFAdd is checked, but OpUndef is not. The commit add a generic check that if there is a type id then the id defines a type. http://crbug.com/876694 * Merge other checks for type into new one. There are a couple check that the type id is a type for specific opcodes. Those have been mereged into 1. Small changes to other test cases to make them valid enough for the purpose of the test.
2018-08-28 03:45:32 +00:00
using spvtest::ScopedContext;
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
using ::testing::HasSubstr;
using ::testing::ValuesIn;
Fix validation of array length.
2016-04-04 19:55:05 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
using ValidateIdWithMessage = spvtest::ValidateBase<bool>;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Add tests coverage for OpTypeVector column count validation (#2087) Add tests coverage for OpTypeVector column count validation Fixes #2064 Fixes #2086
2018-11-21 16:13:28 +00:00
std::string kOpCapabilitySetupWithoutVector16 = R"(
OpCapability Shader
OpCapability Linkage
OpCapability Addresses
OpCapability Int8
OpCapability Int16
OpCapability Int64
OpCapability Float64
OpCapability LiteralSampler
OpCapability Pipes
OpCapability DeviceEnqueue
)";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string kOpCapabilitySetup = R"(
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpCapability Shader
Validation of OpEntryPoint usage. According to the SPIRV Spec (2.16.1): * There is at least one OpEntryPoint instruction, unless the Linkage capability is being used. * No function can be targeted by both an OpEntryPoint instruction and an OpFunctionCall instruction. Also updated unit tests to includ OpEntryPoint.
2017-01-09 16:10:52 +00:00
OpCapability Linkage
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpCapability Addresses
Adding validation code for more data rules. These rules are under "Data Rules" in 2.16.1 (Universal Validation Rules) part of the SPIR-V 1.1 Specification document: * Scalar floating-point types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Scalar integer types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Vector types can only be parameterized with numerical types or the OpTypeBool type. * Matrix types can only be parameterized with floating-point types. * Matrix types can only be parameterized as having only 2, 3, or 4 columns. * Specialization constants (see Specialization) are limited to integers, Booleans, floating-point numbers, and vectors of these.
2016-11-10 20:12:26 +00:00
OpCapability Int8
OpCapability Int16
OpCapability Int64
OpCapability Float64
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
OpCapability LiteralSampler
OpCapability Pipes
OpCapability DeviceEnqueue
OpCapability Vector16
Validate that only a single OpMemoryModel is provided. This CL adds validation that only a single OpMemoryModel is provided in the SPIR-V binary. Fixes #1574
2018-05-22 17:13:14 +00:00
)";
Checks for variable pointers (#1976) In logical addressing mode, we are not allowed to generate variables pointers. There is already a check for OpSelect. However, OpPhi and OpPtrAccessChain are not checked to make sure it does not generate an variable pointer. I've added those checks. Fixes #1957.
2018-10-16 18:57:55 +00:00
std::string kOpVariablePtrSetUp = R"(
OpCapability VariablePointers
OpExtension "SPV_KHR_variable_pointers"
)";
std::string kGLSL450MemoryModel =
kOpCapabilitySetup + kOpVariablePtrSetUp + R"(
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpMemoryModel Logical GLSL450
)";
Add tests coverage for OpTypeVector column count validation (#2087) Add tests coverage for OpTypeVector column count validation Fixes #2064 Fixes #2086
2018-11-21 16:13:28 +00:00
std::string kGLSL450MemoryModelWithoutVector16 =
kOpCapabilitySetupWithoutVector16 + kOpVariablePtrSetUp + R"(
OpMemoryModel Logical GLSL450
)";
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
std::string kNoKernelGLSL450MemoryModel = R"(
OpCapability Shader
OpCapability Linkage
OpCapability Addresses
OpCapability Int8
OpCapability Int16
OpCapability Int64
OpCapability Float64
OpMemoryModel Logical GLSL450
)";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string kOpenCLMemoryModel32 = R"(
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
OpCapability Addresses
OpCapability Linkage
OpCapability Kernel
%1 = OpExtInstImport "OpenCL.std"
OpMemoryModel Physical32 OpenCL
)";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string kOpenCLMemoryModel64 = R"(
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
OpCapability Addresses
OpCapability Linkage
OpCapability Kernel
OpCapability Int64
%1 = OpExtInstImport "OpenCL.std"
OpMemoryModel Physical64 OpenCL
)";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string sampledImageSetup = R"(
Validation for OpSampledImage instruction. This change implements the validation for usages of OpSampledImage instruction as described in the Data Rules section of the Universal Validation Rules of the SPIR-V Spec.
2016-11-22 23:06:55 +00:00
%void = OpTypeVoid
%typeFuncVoid = OpTypeFunction %void
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%image_type = OpTypeImage %float 2D 0 0 0 1 Unknown
%_ptr_UniformConstant_img = OpTypePointer UniformConstant %image_type
%tex = OpVariable %_ptr_UniformConstant_img UniformConstant
%sampler_type = OpTypeSampler
%_ptr_UniformConstant_sam = OpTypePointer UniformConstant %sampler_type
%s = OpVariable %_ptr_UniformConstant_sam UniformConstant
%sampled_image_type = OpTypeSampledImage %image_type
%v2float = OpTypeVector %float 2
%float_1 = OpConstant %float 1
%float_2 = OpConstant %float 2
%const_vec_1_1 = OpConstantComposite %v2float %float_1 %float_1
%const_vec_2_2 = OpConstantComposite %v2float %float_2 %float_2
%bool_type = OpTypeBool
%spec_true = OpSpecConstantTrue %bool_type
%main = OpFunction %void None %typeFuncVoid
%label_1 = OpLabel
%image_inst = OpLoad %image_type %tex
%sampler_inst = OpLoad %sampler_type %s
)";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string BranchConditionalSetup = R"(
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
OpExecutionMode %main OriginUpperLeft
OpSource GLSL 140
OpName %main "main"
; type definitions
%bool = OpTypeBool
%uint = OpTypeInt 32 0
%int = OpTypeInt 32 1
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
; constants
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
%true = OpConstantTrue %bool
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
%i0 = OpConstant %int 0
%i1 = OpConstant %int 1
%f0 = OpConstant %float 0
%f1 = OpConstant %float 1
; main function header
%void = OpTypeVoid
%voidfunc = OpTypeFunction %void
%main = OpFunction %void None %voidfunc
%lmain = OpLabel
)";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string BranchConditionalTail = R"(
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
%target_t = OpLabel
OpNop
OpBranch %end
%target_f = OpLabel
OpNop
OpBranch %end
%end = OpLabel
OpReturn
OpFunctionEnd
)";
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: OpUndef
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpName) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpName %2 "name"
%1 = OpTypeInt 32 0
%2 = OpTypePointer UniformConstant %1
%3 = OpVariable %2 UniformConstant)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberNameGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpMemberName %2 0 "foo"
%1 = OpTypeInt 32 0
%2 = OpTypeStruct %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberNameTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpMemberName %1 0 "foo"
%1 = OpTypeInt 32 0)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Output id names along with numbers in validate_id (#1601) This CL updates the validate_id code to output the name of the object along with the id number. There were a few instances which already output the name, this just extends to all of them. Now, the output should say 123[obj] instead of just 123. Issue #1581
2018-06-07 02:08:27 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpMemberName Type <id> '1[%uint]' is not a struct type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberNameMemberBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Change Ids in tests to avoid confusion The assembler assigns ID numbers sequentially, so it's confusing to have a %1 in the source assembly when it isn't the first mentioned ID. Rewrite the ID names to avoid this situation in a few cases.
2017-03-07 14:49:43 +00:00
OpMemberName %1 1 "foo"
%2 = OpTypeInt 32 0
%1 = OpTypeStruct %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Output id names along with numbers in validate_id (#1601) This CL updates the validate_id code to output the name of the object along with the id number. There were a few instances which already output the name, this just extends to all of them. Now, the output should say 123[obj] instead of just 123. Issue #1581
2018-06-07 02:08:27 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpMemberName Member <id> '1[%_struct_1]' index is larger "
"than Type <id> '1[%_struct_1]'s member count."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLineGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpString "/path/to/source.file"
Update core instruction syntax to Rev32 Many instructions added and a few changed structure. Workarounds: - Some operands can be enabled by either one of two capabilities. The spv_operand_desc_t does not handle that now. For now just select the first one. Fixes to tests: - OpLoopMerge now takes a mandatory continue target. - OpTypePipe drops the type argument. Pipes are opaque. - OpLine no longer takes a target ID argument. The ID validator was fixed the OpLine and OpTypePipe changes. Those were the only ID validator tests affected. The patch to the spec doc generator was updated so it handles the two-capability case, even if in an hacky way.
2015-09-24 19:45:59 +00:00
OpLine %1 0 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%3 = OpTypePointer Input %2
%4 = OpVariable %3 Input)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Change Ids in tests to avoid confusion The assembler assigns ID numbers sequentially, so it's confusing to have a %1 in the source assembly when it isn't the first mentioned ID. Rewrite the ID names to avoid this situation in a few cases.
2017-03-07 14:49:43 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLineFileBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
%1 = OpTypeInt 32 0
OpLine %1 0 0
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpLine Target <id> '1[%uint]' is not an OpString."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpDecorateGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpDecorate %2 GLSLShared
%1 = OpTypeInt 64 0
%2 = OpTypeStruct %1 %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpDecorateBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpDecorate %1 GLSLShared)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("forward referenced IDs have not been defined"));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberDecorateGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate Uniform decoration (#2181)
2018-12-07 14:32:57 +00:00
OpMemberDecorate %2 0 RelaxedPrecision
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeStruct %1 %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberDecorateBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate Uniform decoration (#2181)
2018-12-07 14:32:57 +00:00
OpMemberDecorate %1 0 RelaxedPrecision
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpMemberDecorate Structure type <id> '1[%uint]' is "
"not a struct type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpMemberDecorateMemberBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate Uniform decoration (#2181)
2018-12-07 14:32:57 +00:00
OpMemberDecorate %1 3 RelaxedPrecision
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
%int = OpTypeInt 32 0
%1 = OpTypeStruct %int %int)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Index 3 provided in OpMemberDecorate for struct <id> "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"1[%_struct_1] is out of bounds. The structure has 2 "
"members. Largest valid index is 1."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpGroupDecorateGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpDecorationGroup
Validate Uniform decoration (#2181)
2018-12-07 14:32:57 +00:00
OpDecorate %1 RelaxedPrecision
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpDecorate %1 GLSLShared
OpGroupDecorate %1 %3 %4
%2 = OpTypeInt 32 0
%3 = OpConstant %2 42
%4 = OpConstant %2 23)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
restrict opcodes targeting OpDecorationGroup
2017-10-21 16:39:32 +00:00
TEST_F(ValidateIdWithMessage, OpDecorationGroupBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
restrict opcodes targeting OpDecorationGroup
2017-10-21 16:39:32 +00:00
%1 = OpDecorationGroup
Validate Uniform decoration (#2181)
2018-12-07 14:32:57 +00:00
OpDecorate %1 RelaxedPrecision
restrict opcodes targeting OpDecorationGroup
2017-10-21 16:39:32 +00:00
OpDecorate %1 GLSLShared
OpMemberDecorate %1 0 Constant
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Result id of OpDecorationGroup can only "
"be targeted by OpName, OpGroupDecorate, "
Process OpDecorateId in ADCE (#2761) * Process OpDecorateId in ADCE When there is an OpDecorateId instruction that is live, the ids that is references must be kept live. This change adds them to the worklist. I've also updated a validator check to allow OpDecorateId to be able to apply to decoration groups. Fixes #1759. * Remove dead code.
2019-07-24 18:43:49 +00:00
"OpDecorate, OpDecorateId, and OpGroupMemberDecorate"));
restrict opcodes targeting OpDecorationGroup
2017-10-21 16:39:32 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpGroupDecorateDecorationGroupBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = R"(
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
OpCapability Shader
OpCapability Linkage
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpGroupDecorate %1 %2 %3
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeInt 32 0
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
%3 = OpConstant %2 42)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpGroupDecorate Decoration group <id> '1[%1]' is not "
"a decoration group."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpGroupDecorateTargetBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpDecorationGroup
Validate Uniform decoration (#2181)
2018-12-07 14:32:57 +00:00
OpDecorate %1 RelaxedPrecision
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpDecorate %1 GLSLShared
OpGroupDecorate %1 %3
%2 = OpTypeInt 32 0)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("forward referenced IDs have not been defined"));
}
TEST_F(ValidateIdWithMessage, OpGroupMemberDecorateDecorationGroupBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = R"(
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
OpCapability Shader
OpCapability Linkage
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpGroupMemberDecorate %1 %2 0
%2 = OpTypeInt 32 0)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpGroupMemberDecorate Decoration group <id> '1[%1]' "
"is not a decoration group."));
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
}
TEST_F(ValidateIdWithMessage, OpGroupMemberDecorateIdNotStructBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
%1 = OpDecorationGroup
OpGroupMemberDecorate %1 %2 0
%2 = OpTypeInt 32 0)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpGroupMemberDecorate Structure type <id> '2[%uint]' "
"is not a struct type."));
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
}
TEST_F(ValidateIdWithMessage, OpGroupMemberDecorateIndexOutOfBoundBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
OpDecorate %1 Offset 0
%1 = OpDecorationGroup
OpGroupMemberDecorate %1 %struct 3
%float = OpTypeFloat 32
%struct = OpTypeStruct %float %float %float
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Index 3 provided in OpGroupMemberDecorate for struct "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"<id> 2[%_struct_2] is out of bounds. The structure "
"has 3 members. Largest valid index is 2."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
// TODO: OpExtInst
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %3 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointFunctionBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %1 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpEntryPoint Entry Point <id> '1[%void]' is not a "
"function."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointParameterCountBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %3 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeFunction %1 %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpEntryPoint Entry Point <id> '1[%1]'s function "
"parameter count is not zero"));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointReturnTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %3 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
Validator checks OpReturn called from void func Added check into validate_cfg which checks that OpReturn is not called from functions which are supposed to return a value.
2017-10-11 22:13:21 +00:00
%ret = OpConstant %1 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
Validator checks OpReturn called from void func Added check into validate_cfg which checks that OpReturn is not called from functions which are supposed to return a value.
2017-10-11 22:13:21 +00:00
OpReturnValue %ret
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpEntryPoint Entry Point <id> '1[%1]'s function "
"return type is not void."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Check BuiltIn Decoration rules. When applied to a structure-type member, all members of that structure type must also be decorated with BuiltIn. (No allowed mixing of built-in variables and non-built-in variables within a single structure.) When applied to a structure-type member, that structure type cannot be contained as a member of another structure type. There is at most one object per Storage Class that can contain a structure type containing members decorated with BuiltIn, consumed per entry-point.
2017-01-16 17:54:15 +00:00
TEST_F(ValidateIdWithMessage, OpEntryPointInterfaceIsNotVariableTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = R"(
Check BuiltIn Decoration rules. When applied to a structure-type member, all members of that structure type must also be decorated with BuiltIn. (No allowed mixing of built-in variables and non-built-in variables within a single structure.) When applied to a structure-type member, that structure type cannot be contained as a member of another structure type. There is at most one object per Storage Class that can contain a structure type containing members decorated with BuiltIn, consumed per entry-point.
2017-01-16 17:54:15 +00:00
OpCapability Shader
OpCapability Geometry
OpMemoryModel Logical GLSL450
OpEntryPoint Geometry %main "main" %ptr_builtin_1
Add validation for execution modes * Check rules from Execution Mode tables, 2.16.2 and the Vulkan environment spec * Allows MeshNV execution model with the following execution modes * LocalSize, LocalSizeId, OutputPoints and OutputVertices * Done to not break their validation
2018-09-28 20:41:56 +00:00
OpExecutionMode %main InputPoints
OpExecutionMode %main OutputPoints
Check BuiltIn Decoration rules. When applied to a structure-type member, all members of that structure type must also be decorated with BuiltIn. (No allowed mixing of built-in variables and non-built-in variables within a single structure.) When applied to a structure-type member, that structure type cannot be contained as a member of another structure type. There is at most one object per Storage Class that can contain a structure type containing members decorated with BuiltIn, consumed per entry-point.
2017-01-16 17:54:15 +00:00
OpMemberDecorate %struct_1 0 BuiltIn InvocationId
%int = OpTypeInt 32 1
%void = OpTypeVoid
%func = OpTypeFunction %void
%struct_1 = OpTypeStruct %int
%ptr_builtin_1 = OpTypePointer Input %struct_1
%main = OpFunction %void None %func
%5 = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Interfaces passed to OpEntryPoint must be of type "
"OpTypeVariable. Found OpTypePointer."));
}
TEST_F(ValidateIdWithMessage, OpEntryPointInterfaceStorageClassBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = R"(
Check BuiltIn Decoration rules. When applied to a structure-type member, all members of that structure type must also be decorated with BuiltIn. (No allowed mixing of built-in variables and non-built-in variables within a single structure.) When applied to a structure-type member, that structure type cannot be contained as a member of another structure type. There is at most one object per Storage Class that can contain a structure type containing members decorated with BuiltIn, consumed per entry-point.
2017-01-16 17:54:15 +00:00
OpCapability Shader
OpCapability Geometry
OpMemoryModel Logical GLSL450
OpEntryPoint Geometry %main "main" %in_1
Add validation for execution modes * Check rules from Execution Mode tables, 2.16.2 and the Vulkan environment spec * Allows MeshNV execution model with the following execution modes * LocalSize, LocalSizeId, OutputPoints and OutputVertices * Done to not break their validation
2018-09-28 20:41:56 +00:00
OpExecutionMode %main InputPoints
OpExecutionMode %main OutputPoints
Check BuiltIn Decoration rules. When applied to a structure-type member, all members of that structure type must also be decorated with BuiltIn. (No allowed mixing of built-in variables and non-built-in variables within a single structure.) When applied to a structure-type member, that structure type cannot be contained as a member of another structure type. There is at most one object per Storage Class that can contain a structure type containing members decorated with BuiltIn, consumed per entry-point.
2017-01-16 17:54:15 +00:00
OpMemberDecorate %struct_1 0 BuiltIn InvocationId
%int = OpTypeInt 32 1
%void = OpTypeVoid
%func = OpTypeFunction %void
%struct_1 = OpTypeStruct %int
%ptr_builtin_1 = OpTypePointer Uniform %struct_1
%in_1 = OpVariable %ptr_builtin_1 Uniform
%main = OpFunction %void None %func
%5 = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpEntryPoint interfaces must be OpVariables with "
"Storage Class of Input(1) or Output(3). Found Storage "
"Class 2 for Entry Point id 1."));
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpExecutionModeGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
OpEntryPoint GLCompute %3 ""
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpExecutionMode %3 LocalSize 1 1 1
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpExecutionModeEntryPointMissing) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpExecutionMode %3 LocalSize 1 1 1
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpExecutionMode Entry Point <id> '1[%1]' is not the "
"Entry Point operand of an OpEntryPoint."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpExecutionModeEntryPointBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
OpEntryPoint GLCompute %3 "" %a
OpExecutionMode %a LocalSize 1 1 1
%void = OpTypeVoid
%ptr = OpTypePointer Input %void
%a = OpVariable %ptr Input
%2 = OpTypeFunction %void
%3 = OpFunction %void None %2
%4 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpExecutionMode Entry Point <id> '2[%2]' is not the "
"Entry Point operand of an OpEntryPoint."));
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorFloat) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorInt) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
%2 = OpTypeVector %1 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorUInt) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
%1 = OpTypeInt 64 0
%2 = OpTypeVector %1 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorBool) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
%1 = OpTypeBool
%2 = OpTypeVector %1 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorComponentTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypePointer UniformConstant %1
%3 = OpTypeVector %2 4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpTypeVector Component Type <id> "
"'2[%_ptr_UniformConstant_float]' is not a scalar type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Add tests coverage for OpTypeVector column count validation (#2087) Add tests coverage for OpTypeVector column count validation Fixes #2064 Fixes #2086
2018-11-21 16:13:28 +00:00
TEST_F(ValidateIdWithMessage, OpTypeVectorColumnCountLessThanTwoBad) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 1)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Illegal number of components (1) for TypeVector\n %v1float = "
"OpTypeVector %float 1\n"));
}
TEST_F(ValidateIdWithMessage, OpTypeVectorColumnCountGreaterThanFourBad) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Illegal number of components (5) for TypeVector\n %v5float = "
"OpTypeVector %float 5\n"));
}
TEST_F(ValidateIdWithMessage, OpTypeVectorColumnCountEightWithoutVector16Bad) {
std::string spirv = kGLSL450MemoryModelWithoutVector16 + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 8)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Having 8 components for TypeVector requires the Vector16 "
"capability\n %v8float = OpTypeVector %float 8\n"));
}
TEST_F(ValidateIdWithMessage,
OpTypeVectorColumnCountSixteenWithoutVector16Bad) {
std::string spirv = kGLSL450MemoryModelWithoutVector16 + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 16)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Having 16 components for TypeVector requires the Vector16 "
"capability\n %v16float = OpTypeVector %float 16\n"));
}
TEST_F(ValidateIdWithMessage, OpTypeVectorColumnCountOfEightWithVector16Good) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 8)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateIdWithMessage,
OpTypeVectorColumnCountOfSixteenWithVector16Good) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 16)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeMatrixGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation code for more data rules. These rules are under "Data Rules" in 2.16.1 (Universal Validation Rules) part of the SPIR-V 1.1 Specification document: * Scalar floating-point types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Scalar integer types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Vector types can only be parameterized with numerical types or the OpTypeBool type. * Matrix types can only be parameterized with floating-point types. * Matrix types can only be parameterized as having only 2, 3, or 4 columns. * Specialization constants (see Specialization) are limited to integers, Booleans, floating-point numbers, and vectors of these.
2016-11-10 20:12:26 +00:00
%1 = OpTypeFloat 32
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeVector %1 2
%3 = OpTypeMatrix %2 3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Add tests for matrix type data rule validation (#2082) Add tests for matrix type data rule validation This covers the data rules for matrix types specified in the SPIR-V spec, section 2.16.1, and the WebGPU SPIR-V Execution Environment spec. Fixes #2065 Fixes #2080
2018-11-19 22:04:03 +00:00
TEST_F(ValidateIdWithMessage, OpTypeMatrixColumnTypeNonVectorBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Add tests for matrix type data rule validation (#2082) Add tests for matrix type data rule validation This covers the data rules for matrix types specified in the SPIR-V spec, section 2.16.1, and the WebGPU SPIR-V Execution Environment spec. Fixes #2065 Fixes #2080
2018-11-19 22:04:03 +00:00
%1 = OpTypeFloat 32
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeMatrix %1 3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Add tests for matrix type data rule validation (#2082) Add tests for matrix type data rule validation This covers the data rules for matrix types specified in the SPIR-V spec, section 2.16.1, and the WebGPU SPIR-V Execution Environment spec. Fixes #2065 Fixes #2080
2018-11-19 22:04:03 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("olumns in a matrix must be of type vector.\n %mat3float = "
"OpTypeMatrix %float 3\n"));
}
TEST_F(ValidateIdWithMessage, OpTypeMatrixVectorTypeNonFloatBad) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 16 0
%2 = OpTypeVector %1 2
%3 = OpTypeMatrix %2 2)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Matrix types can only be parameterized with floating-point "
"types.\n %mat2v2ushort = OpTypeMatrix %v2ushort 2\n"));
}
TEST_F(ValidateIdWithMessage, OpTypeMatrixColumnCountLessThanTwoBad) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 2
%3 = OpTypeMatrix %2 1)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Matrix types can only be parameterized as having only 2, 3, "
"or 4 columns.\n %mat1v2float = OpTypeMatrix %v2float 1\n"));
}
TEST_F(ValidateIdWithMessage, OpTypeMatrixColumnCountGreaterThanFourBad) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 2
%3 = OpTypeMatrix %2 8)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Matrix types can only be parameterized as having only 2, 3, "
"or 4 columns.\n %mat8v2float = OpTypeMatrix %v2float 8\n"));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeSamplerGood) {
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
// In Rev31, OpTypeSampler takes no arguments.
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
%s = OpTypeSampler)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpTypeArray %1 %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validation of array length.
2016-04-04 19:55:05 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayElementTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpTypeArray %2 %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpTypeArray Element Type <id> '2[%uint_1]' is not a "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validation of array length.
2016-04-04 19:55:05 +00:00
// Signed or unsigned.
enum Signed { kSigned, kUnsigned };
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
// Creates an assembly module declaring OpTypeArray with the given length.
std::string MakeArrayLength(const std::string& len, Signed isSigned, int width,
int max_int_width = 64,
bool use_vulkan_memory_model = false) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::ostringstream ss;
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
ss << R"(
OpCapability Shader
)";
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
if (use_vulkan_memory_model) {
ss << " OpCapability VulkanMemoryModel\n";
}
if (width == 16) {
ss << " OpCapability Int16\n";
}
if (max_int_width > 32) {
ss << "\n OpCapability Int64\n";
}
if (use_vulkan_memory_model) {
ss << " OpExtension \"SPV_KHR_vulkan_memory_model\"\n";
ss << "OpMemoryModel Logical Vulkan\n";
} else {
ss << "OpMemoryModel Logical GLSL450\n";
}
ss << "OpEntryPoint GLCompute %main \"main\"\n";
ss << "OpExecutionMode %main LocalSize 1 1 1\n";
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
ss << " %t = OpTypeInt " << width << (isSigned == kSigned ? " 1" : " 0");
ss << " %l = OpConstant %t " << len;
ss << " %a = OpTypeArray %t %l";
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
ss << " %void = OpTypeVoid \n"
" %voidfn = OpTypeFunction %void \n"
" %main = OpFunction %void None %voidfn \n"
" %entry = OpLabel\n"
" OpReturn\n"
" OpFunctionEnd\n";
Fix validation of array length.
2016-04-04 19:55:05 +00:00
return ss.str();
}
// Tests OpTypeArray. Parameter is the width (in bits) of the array-length's
// type.
class OpTypeArrayLengthTest
: public spvtest::TextToBinaryTestBase<::testing::TestWithParam<int>> {
protected:
OpTypeArrayLengthTest()
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
: env_(SPV_ENV_UNIVERSAL_1_0),
position_(spv_position_t{0, 0, 0}),
Fix MSVC error C2797.
2016-04-04 20:05:31 +00:00
diagnostic_(spvDiagnosticCreate(&position_, "")) {}
Fix validation of array length.
2016-04-04 19:55:05 +00:00
~OpTypeArrayLengthTest() { spvDiagnosticDestroy(diagnostic_); }
// Runs spvValidate() on v, printing any errors via spvDiagnosticPrint().
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
spv_result_t Val(const SpirvVector& v, const std::string& expected_err = "") {
Fix validation of array length.
2016-04-04 19:55:05 +00:00
spv_const_binary_t cbinary{v.data(), v.size()};
Fix leaks in tests (#2295) Generally, a test fixture in a method that can generate a binary should release any previously cached binary. Similarly for diagnostics.
2019-01-16 21:53:10 +00:00
spvDiagnosticDestroy(diagnostic_);
diagnostic_ = nullptr;
First tests for SPIR-V v1.1. Add test for named-barrier instructions and capability. Add spv_target_env as an optional argument to CompileSuccessfully() and CompileFailure(). Currently defaults to UNIVERSAL_1_0, though that could change in the future. Make spv_context a local variable in test methods instead of a TextToBinaryTestBase member. Introduce ScopedContext to make temp contexts easier.
2016-04-19 02:25:35 +00:00
const auto status =
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
spvValidate(ScopedContext(env_).context, &cbinary, &diagnostic_);
Fix validation of array length.
2016-04-04 19:55:05 +00:00
if (status != SPV_SUCCESS) {
spvDiagnosticPrint(diagnostic_);
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(std::string(diagnostic_->error),
testing::ContainsRegex(expected_err));
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
return status;
}
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
protected:
spv_target_env env_;
Fix validation of array length.
2016-04-04 19:55:05 +00:00
private:
spv_position_t position_; // For creating diagnostic_.
spv_diagnostic diagnostic_;
};
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
TEST_P(OpTypeArrayLengthTest, LengthPositiveSmall) {
Fix validation of array length.
2016-04-04 19:55:05 +00:00
const int width = GetParam();
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("1", kSigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("1", kUnsigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("2", kSigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("2", kUnsigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("55", kSigned, width))));
EXPECT_EQ(SPV_SUCCESS,
Val(CompileSuccessfully(MakeArrayLength("55", kUnsigned, width))));
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
const std::string fpad(width / 4 - 1, 'F');
Fix validation of array length.
2016-04-04 19:55:05 +00:00
EXPECT_EQ(
SPV_SUCCESS,
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
Val(CompileSuccessfully(MakeArrayLength("0x7" + fpad, kSigned, width))))
<< MakeArrayLength("0x7" + fpad, kSigned, width);
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
TEST_P(OpTypeArrayLengthTest, LengthZero) {
const int width = GetParam();
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_EQ(SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("0", kSigned, width)),
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
"OpTypeArray Length <id> '3\\[%.*\\]' default value must be at "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"least 1."));
EXPECT_EQ(SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("0", kUnsigned, width)),
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
"OpTypeArray Length <id> '3\\[%.*\\]' default value must be at "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"least 1."));
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
TEST_P(OpTypeArrayLengthTest, LengthNegative) {
const int width = GetParam();
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_EQ(SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("-1", kSigned, width)),
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
"OpTypeArray Length <id> '3\\[%.*\\]' default value must be at "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"least 1."));
EXPECT_EQ(SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("-2", kSigned, width)),
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
"OpTypeArray Length <id> '3\\[%.*\\]' default value must be at "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"least 1."));
EXPECT_EQ(SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength("-123", kSigned, width)),
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
"OpTypeArray Length <id> '3\\[%.*\\]' default value must be at "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"least 1."));
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
const std::string neg_max = "0x8" + std::string(width / 4 - 1, '0');
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_EQ(SPV_ERROR_INVALID_ID,
Val(CompileSuccessfully(MakeArrayLength(neg_max, kSigned, width)),
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
"OpTypeArray Length <id> '3\\[%.*\\]' default value must be at "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"least 1."));
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
WebGPU: Array size at most max signed int + 1 (#3077) This makes it easier to clamp indices for robust-buffer-access behaviour. See https://github.com/gpuweb/spirv-execution-env/issues/47
2019-12-03 16:55:28 +00:00
// Returns the string form of an integer of the form 0x80....0 of the
// given bit width.
std::string big_num_ending_0(int bit_width) {
return "0x8" + std::string(bit_width / 4 - 1, '0');
}
// Returns the string form of an integer of the form 0x80..001 of the
// given bit width.
std::string big_num_ending_1(int bit_width) {
return "0x8" + std::string(bit_width / 4 - 2, '0') + "1";
}
TEST_P(OpTypeArrayLengthTest, LengthPositiveHugeEnding0InVulkan) {
env_ = SPV_ENV_VULKAN_1_0;
const int width = GetParam();
for (int max_int_width : {32, 64}) {
if (width > max_int_width) {
// Not valid to even make the OpConstant in this case.
continue;
}
const auto module = CompileSuccessfully(MakeArrayLength(
big_num_ending_0(width), kUnsigned, width, max_int_width));
EXPECT_EQ(SPV_SUCCESS, Val(module));
}
}
TEST_P(OpTypeArrayLengthTest, LengthPositiveHugeEnding1InVulkan) {
env_ = SPV_ENV_VULKAN_1_0;
const int width = GetParam();
for (int max_int_width : {32, 64}) {
if (width > max_int_width) {
// Not valid to even make the OpConstant in this case.
continue;
}
const auto module = CompileSuccessfully(MakeArrayLength(
big_num_ending_1(width), kUnsigned, width, max_int_width));
EXPECT_EQ(SPV_SUCCESS, Val(module));
}
}
TEST_P(OpTypeArrayLengthTest, LengthPositiveHugeEnding0InWebGPU) {
env_ = SPV_ENV_WEBGPU_0;
const int width = GetParam();
// WebGPU only has 32 bit integers.
if (width != 32) return;
const int max_int_width = 32;
const auto module = CompileSuccessfully(MakeArrayLength(
big_num_ending_0(width), kUnsigned, width, max_int_width, true));
EXPECT_EQ(SPV_SUCCESS, Val(module));
}
TEST_P(OpTypeArrayLengthTest, LengthPositiveHugeEnding1InWebGPU) {
env_ = SPV_ENV_WEBGPU_0;
const int width = GetParam();
// WebGPU only has 32 bit integers.
if (width != 32) return;
const int max_int_width = 32;
const auto module = CompileSuccessfully(MakeArrayLength(
big_num_ending_1(width), kUnsigned, width, max_int_width, true));
EXPECT_EQ(SPV_ERROR_INVALID_ID,
Val(module,
"OpTypeArray Length <id> '3\\[%.*\\]' size exceeds max value "
"2147483648 permitted by WebGPU: got 2147483649"));
}
Adding validation code for more data rules. These rules are under "Data Rules" in 2.16.1 (Universal Validation Rules) part of the SPIR-V 1.1 Specification document: * Scalar floating-point types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Scalar integer types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Vector types can only be parameterized with numerical types or the OpTypeBool type. * Matrix types can only be parameterized with floating-point types. * Matrix types can only be parameterized as having only 2, 3, or 4 columns. * Specialization constants (see Specialization) are limited to integers, Booleans, floating-point numbers, and vectors of these.
2016-11-10 20:12:26 +00:00
// The only valid widths for integers are 8, 16, 32, and 64.
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
// Since the Int8 capability requires the Kernel capability, and the Kernel
// capability prohibits usage of signed integers, we can skip 8-bit integers
// here since the purpose of these tests is to check the validity of
// OpTypeArray, not OpTypeInt.
Remove use of deprecated googletest macro (#2286) * Remove use of deprecated googletest macro INSTANTIATE_TEST_CASE_P has been deprecated. We need to use INSTANTIATE_TEST_SUITE_P instead. * Remove extra commas from test suites.
2019-01-29 23:56:52 +00:00
INSTANTIATE_TEST_SUITE_P(Widths, OpTypeArrayLengthTest,
ValuesIn(std::vector<int>{16, 32, 64}));
Fix validation of array length.
2016-04-04 19:55:05 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayLengthNull) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%i32 = OpTypeInt 32 0
Fix validation of array length.
2016-04-04 19:55:05 +00:00
%len = OpConstantNull %i32
%ary = OpTypeArray %i32 %len)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"OpTypeArray Length <id> '2[%2]' default value must be at least 1."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayLengthSpecConst) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%i32 = OpTypeInt 32 0
Fix validation of array length.
2016-04-04 19:55:05 +00:00
%len = OpSpecConstant %i32 2
%ary = OpTypeArray %i32 %len)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeArrayLengthSpecConstOp) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%i32 = OpTypeInt 32 0
Fix validation of array length.
2016-04-04 19:55:05 +00:00
%c1 = OpConstant %i32 1
%c2 = OpConstant %i32 2
%len = OpSpecConstantOp %i32 IAdd %c1 %c2
%ary = OpTypeArray %i32 %len)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validation of array length.
2016-04-04 19:55:05 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeRuntimeArrayGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeRuntimeArray %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeRuntimeArrayBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 0
%3 = OpTypeRuntimeArray %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpTypeRuntimeArray Element Type <id> '2[%uint_0]' is not a "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
// TODO: Object of this type can only be created with OpVariable using the
// Unifrom Storage Class
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeStructGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeFloat 64
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%3 = OpTypePointer Input %1
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpTypeStruct %1 %2 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeStructMemberTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeFloat 64
%3 = OpConstant %2 0.0
%4 = OpTypeStruct %1 %2 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpTypeStruct Member Type <id> '3[%double_0]' is not "
"a type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
For Vulkan, disallow structures containing opaque types (#2546)
2019-07-16 20:16:19 +00:00
TEST_F(ValidateIdWithMessage, OpTypeStructOpaqueTypeBad) {
std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %main "main"
%1 = OpTypeSampler
%2 = OpTypeStruct %1
%void = OpTypeVoid
%3 = OpTypeFunction %void
%main = OpFunction %void None %3
%5 = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str(), SPV_ENV_VULKAN_1_0);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpTypeStruct must not contain an opaque type"));
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypePointerGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpTypePointer Input %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypePointerBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%3 = OpTypePointer Input %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpTypePointer Type <id> '2[%uint_0]' is not a "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeFunctionGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeFunction %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeFunctionReturnTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 0
%3 = OpTypeFunction %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpTypeFunction Return Type <id> '2[%uint_0]' is not "
"a type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypeFunctionParameterBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpConstant %2 0
%4 = OpTypeFunction %1 %2 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpTypeFunction Parameter Type <id> '3[%uint_0]' is not a "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Ensure that function parameter's type is not void (#2118) Fixes #2094
2018-11-27 14:40:19 +00:00
TEST_F(ValidateIdWithMessage, OpTypeFunctionParameterTypeVoidBad) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%4 = OpTypeFunction %1 %2 %1)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpTypeFunction Parameter Type <id> '1[%void]' cannot "
"be OpTypeVoid."));
Ensure that function parameter's type is not void (#2118) Fixes #2094
2018-11-27 14:40:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpTypePipeGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 16
Update core instruction syntax to Rev32 Many instructions added and a few changed structure. Workarounds: - Some operands can be enabled by either one of two capabilities. The spv_operand_desc_t does not handle that now. For now just select the first one. Fixes to tests: - OpLoopMerge now takes a mandatory continue target. - OpTypePipe drops the type argument. Pipes are opaque. - OpLine no longer takes a target ID argument. The ID validator was fixed the OpLine and OpTypePipe changes. Those were the only ID validator tests affected. The patch to the spec doc generator was updated so it handles the two-capability case, even if in an hacky way.
2015-09-24 19:45:59 +00:00
%3 = OpTypePipe ReadOnly)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantTrueGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeBool
%2 = OpConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantTrueBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantTrue Result Type <id> '1[%void]' is not a boolean "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantFalseGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Add an API parameter to choose assembly syntax format for assembler. Added a new enum for supported assembly syntax formats: Canonical Assembly Format (CAF) and Assignment Assembly Format (AAF). Updated assembler interface functions to support choice of assembly syntax format.
2015-09-10 18:00:00 +00:00
%1 = OpTypeBool
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantFalseBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpConstantFalse %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantFalse Result Type <id> '1[%void]' is not a boolean "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
Added tracking to types and validated certain instructions. We need to know how to generate correct SPIRV for cases like OpConstant %int64 42 since the current parser will encode the 42 as a 32-bit value incorrectly. This change is the first of a pair. This one tracks types, and makes sure that OpConstant and OpSpecConstant are only ever called with Integer or Float types, and OpSwitch is only called with integer generating values.
2015-09-29 15:28:34 +00:00
%2 = OpConstant !1 !0)";
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
// The expected failure code is implementation dependent (currently
// INVALID_BINARY because the binary parser catches these cases) and may
// change over time, but this must always fail.
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeVectorGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpConstant %1 3.14
%4 = OpConstantComposite %2 %3 %3 %3 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeVectorWithUndefGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpConstant %1 3.14
%9 = OpUndef %1
%4 = OpConstantComposite %2 %3 %3 %3 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeVectorResultTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpConstant %1 3.14
%4 = OpConstantComposite %1 %3 %3 %3 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Result Type <id> '1[%float]' is not a "
"composite type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeVectorConstituentTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%4 = OpTypeInt 32 0
%3 = OpConstant %1 3.14
%5 = OpConstant %4 42 ; bad type for constant value
%6 = OpConstantComposite %2 %3 %5 %3 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Constituent <id> '5[%uint_42]'s type "
"does not match Result Type <id> '2[%v4float]'s vector "
"element type."));
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage,
OpConstantCompositeVectorConstituentUndefTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%4 = OpTypeInt 32 0
%3 = OpConstant %1 3.14
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%5 = OpUndef %4 ; bad type for undef value
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpConstantComposite %2 %3 %5 %3 %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Constituent <id> '5[%5]'s type does not "
"match Result Type <id> '2[%v4float]'s vector element type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeMatrixGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
String literals must be quoted.
2015-08-24 20:27:02 +00:00
%5 = OpConstant %1 0.0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpConstantComposite %2 %4 %5 %5 %5
%7 = OpConstantComposite %2 %5 %4 %5 %5
%8 = OpConstantComposite %2 %5 %5 %4 %5
%9 = OpConstantComposite %2 %5 %5 %5 %4
%10 = OpConstantComposite %3 %6 %7 %8 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeMatrixUndefGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpConstant %1 0.0
%6 = OpConstantComposite %2 %4 %5 %5 %5
%7 = OpConstantComposite %2 %5 %4 %5 %5
%8 = OpConstantComposite %2 %5 %5 %4 %5
%9 = OpUndef %2
%10 = OpConstantComposite %3 %6 %7 %8 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeMatrixConstituentTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%11 = OpTypeVector %1 3
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpConstant %1 0.0
%6 = OpConstantComposite %2 %4 %5 %5 %5
%7 = OpConstantComposite %2 %5 %4 %5 %5
%8 = OpConstantComposite %2 %5 %5 %4 %5
%9 = OpConstantComposite %11 %5 %5 %5
%10 = OpConstantComposite %3 %6 %7 %8 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Constituent <id> '10[%10]' vector "
"component count does not match Result Type <id> "
"'4[%mat4v4float]'s vector component count."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage,
OpConstantCompositeMatrixConstituentUndefTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%11 = OpTypeVector %1 3
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpConstant %1 0.0
%6 = OpConstantComposite %2 %4 %5 %5 %5
%7 = OpConstantComposite %2 %5 %4 %5 %5
%8 = OpConstantComposite %2 %5 %5 %4 %5
%9 = OpUndef %11
%10 = OpConstantComposite %3 %6 %7 %8 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Constituent <id> '10[%10]' vector "
"component count does not match Result Type <id> "
"'4[%mat4v4float]'s vector component count."));
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%4 = OpConstantComposite %3 %2 %2 %2 %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayWithUndefGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%9 = OpUndef %1
%3 = OpTypeArray %1 %2
%4 = OpConstantComposite %3 %2 %2 %2 %9)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayConstConstituentTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
Adding validation for vector data rule. Number of components in a vector can be 2 or 3 or 4. If Vector16 capability is used, 8 and 16 components are also allowed. Also added unit tests for vector data rule.
2016-11-04 22:31:21 +00:00
%4 = OpConstantComposite %3 %2 %2 %2 %1)"; // Uses a type as operand
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 1[%uint] cannot be a "
"type"));
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
}
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayConstConstituentBad) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%4 = OpTypePointer Uniform %1
%5 = OpVariable %4 Uniform
%6 = OpConstantComposite %3 %2 %2 %2 %5)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Constituent <id> '5[%5]' is not a "
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
"constant or undef."));
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayConstituentTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%5 = OpTypeFloat 32
%6 = OpConstant %5 3.14 ; bad type for const value
%4 = OpConstantComposite %3 %2 %2 %2 %6)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Constituent <id> "
"'5[%float_3_1400001]'s type does not match Result "
"Type <id> '3[%_arr_uint_uint_4]'s array element "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeArrayConstituentUndefTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%5 = OpTypeFloat 32
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%6 = OpUndef %5 ; bad type for undef
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpConstantComposite %3 %2 %2 %2 %6)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Constituent <id> "
"'5[%5]'s type does not match Result "
"Type <id> '3[%_arr_uint_uint_4]'s array element "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeStructGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpConstant %2 4300000000
%6 = OpConstantComposite %3 %4 %4 %5)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeStructUndefGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpUndef %2
%6 = OpConstantComposite %3 %4 %4 %5)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeStructMemberTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpConstant %2 4300000000
%6 = OpConstantComposite %3 %4 %5 %4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Constituent <id> "
"'5[%ulong_4300000000]' type does not match the "
"Result Type <id> '3[%_struct_3]'s member type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantCompositeStructMemberUndefTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpUndef %2
%6 = OpConstantComposite %3 %4 %5 %4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantComposite Constituent <id> '5[%5]' type "
"does not match the Result Type <id> '3[%_struct_3]'s "
"member type."));
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantSamplerGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
%float = OpTypeFloat 32
%samplerType = OpTypeSampler
%3 = OpConstantSampler %samplerType ClampToEdge 0 Nearest)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantSamplerResultTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpConstantSampler %1 Clamp 0 Nearest)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"OpConstantSampler Result Type <id> '1[%float]' is not a sampler "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeBool
%2 = OpConstantNull %1
%3 = OpTypeInt 32 0
%4 = OpConstantNull %3
%5 = OpTypeFloat 32
%6 = OpConstantNull %5
%7 = OpTypePointer UniformConstant %3
%8 = OpConstantNull %7
%9 = OpTypeEvent
%10 = OpConstantNull %9
%11 = OpTypeDeviceEvent
%12 = OpConstantNull %11
%13 = OpTypeReserveId
%14 = OpConstantNull %13
%15 = OpTypeQueue
%16 = OpConstantNull %15
Adding validation code for more data rules. These rules are under "Data Rules" in 2.16.1 (Universal Validation Rules) part of the SPIR-V 1.1 Specification document: * Scalar floating-point types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Scalar integer types can be parameterized only as 32 bit, plus any additional sizes enabled by capabilities. * Vector types can only be parameterized with numerical types or the OpTypeBool type. * Matrix types can only be parameterized with floating-point types. * Matrix types can only be parameterized as having only 2, 3, or 4 columns. * Specialization constants (see Specialization) are limited to integers, Booleans, floating-point numbers, and vectors of these.
2016-11-10 20:12:26 +00:00
%17 = OpTypeVector %5 2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%18 = OpConstantNull %17
%19 = OpTypeMatrix %17 2
%20 = OpConstantNull %19
%25 = OpConstant %3 8
%21 = OpTypeArray %3 %25
%22 = OpConstantNull %21
%23 = OpTypeStruct %3 %5 %1
%24 = OpConstantNull %23
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
%26 = OpTypeArray %17 %25
%27 = OpConstantNull %26
%28 = OpTypeStruct %7 %26 %26 %1
%29 = OpConstantNull %28
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullBasicBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpConstantNull %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpConstantNull Result Type <id> '1[%void]' cannot have a null "
"value."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullArrayBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%2 = OpTypeInt 32 0
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
%3 = OpTypeSampler
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpConstant %2 4
%5 = OpTypeArray %3 %4
%6 = OpConstantNull %5)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"OpConstantNull Result Type <id> '4[%_arr_2_uint_4]' cannot have a "
"null value."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullStructBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
%2 = OpTypeSampler
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypeStruct %2 %2
%4 = OpConstantNull %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpConstantNull Result Type <id> '2[%_struct_2]' "
"cannot have a null value."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpConstantNullRuntimeArrayBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
%bool = OpTypeBool
%array = OpTypeRuntimeArray %bool
%null = OpConstantNull %array)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"OpConstantNull Result Type <id> '2[%_runtimearr_bool]' cannot have "
"a null value."));
Make IsTypeNullable a transitive check.
2016-02-03 22:16:27 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantTrueGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeBool
%2 = OpSpecConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantTrueBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpSpecConstantTrue %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
Remove validate_datarules.cpp (#2911) * Checks moved into individual opcode validation * removes duplicated checks * Add check that forward pointer points to struct
2019-09-24 21:55:12 +00:00
HasSubstr("OpSpecConstantTrue Result Type <id> '1[%void]' is not "
"a boolean type"));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantFalseGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeBool
%2 = OpSpecConstantFalse %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantFalseBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpSpecConstantFalse %1)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Remove validate_datarules.cpp (#2911) * Checks moved into individual opcode validation * removes duplicated checks * Add check that forward pointer points to struct
2019-09-24 21:55:12 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpSpecConstantFalse Result Type <id> '1[%void]' is not "
"a boolean type"));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeFloat 32
%2 = OpSpecConstant %1 42)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpSpecConstantBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
Added tracking to types and validated certain instructions. We need to know how to generate correct SPIRV for cases like OpConstant %int64 42 since the current parser will encode the 42 as a 32-bit value incorrectly. This change is the first of a pair. This one tracks types, and makes sure that OpConstant and OpSpecConstant are only ever called with Integer or Float types, and OpSwitch is only called with integer generating values.
2015-09-29 15:28:34 +00:00
%2 = OpSpecConstant !1 !4)";
Fix spvOpcodeIsScalarType() to include Boolean. Remove redundant validations of OpConstant and OpConstantComposite. Binary parser already performs these checks, so the validations can never be triggered. Enable bad-constant tests.
2016-01-21 20:55:43 +00:00
// The expected failure code is implementation dependent (currently
// INVALID_BINARY because the binary parser catches these cases) and may
// change over time, but this must always fail.
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_BINARY, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Type Id 1 is not a scalar numeric type"));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Valid: SpecConstantComposite specializes to a vector.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpSpecConstant %1 3.14
%4 = OpConstant %1 3.14
%5 = OpSpecConstantComposite %2 %3 %3 %4 %4)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Valid: Vector of floats and Undefs.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorWithUndefGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpSpecConstant %1 3.14
%5 = OpConstant %1 3.14
%9 = OpUndef %1
%4 = OpSpecConstantComposite %2 %3 %5 %3 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: result type is float.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorResultTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpSpecConstant %1 3.14
%4 = OpSpecConstantComposite %1 %3 %3 %3 %3)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(), HasSubstr("is not a composite type"));
}
// Invalid: Vector contains a mix of Int and Float.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorConstituentTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%4 = OpTypeInt 32 0
%3 = OpSpecConstant %1 3.14
%5 = OpConstant %4 42 ; bad type for constant value
%6 = OpSpecConstantComposite %2 %3 %5 %3 %3)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> "
"'5[%uint_42]'s type does not match Result Type <id> "
"'2[%v4float]'s vector element type."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Constituent is not a constant
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeVectorConstituentNotConstantBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeInt 32 0
%4 = OpSpecConstant %1 3.14
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
%5 = OpTypePointer Uniform %1
%6 = OpVariable %5 Uniform
%7 = OpSpecConstantComposite %2 %6 %4 %4 %4)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '6[%6]' is "
"not a constant or undef."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Vector contains a mix of Undef-int and Float.
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeVectorConstituentUndefTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%4 = OpTypeInt 32 0
%3 = OpSpecConstant %1 3.14
%5 = OpUndef %4 ; bad type for undef value
%6 = OpSpecConstantComposite %2 %3 %5 %3 %3)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '5[%5]'s "
"type does not match Result Type <id> '2[%v4float]'s "
"vector element type."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Vector expects 3 components, but 4 specified.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeVectorNumComponentsBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 3
%3 = OpConstant %1 3.14
%5 = OpSpecConstant %1 4.0
%6 = OpSpecConstantComposite %2 %3 %5 %3 %3)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> count does "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"not match Result Type <id> '2[%v3float]'s vector "
"component count."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Valid: 4x4 matrix of floats
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpSpecConstant %1 0.0
%6 = OpSpecConstantComposite %2 %4 %5 %5 %5
%7 = OpSpecConstantComposite %2 %5 %4 %5 %5
%8 = OpSpecConstantComposite %2 %5 %5 %4 %5
%9 = OpSpecConstantComposite %2 %5 %5 %5 %4
%10 = OpSpecConstantComposite %3 %6 %7 %8 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Valid: Matrix in which one column is Undef
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixUndefGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpConstant %1 1.0
%5 = OpSpecConstant %1 0.0
%6 = OpSpecConstantComposite %2 %4 %5 %5 %5
%7 = OpSpecConstantComposite %2 %5 %4 %5 %5
%8 = OpSpecConstantComposite %2 %5 %5 %4 %5
%9 = OpUndef %2
%10 = OpSpecConstantComposite %3 %6 %7 %8 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Matrix in which the sizes of column vectors are not equal.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixConstituentTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeVector %1 3
%4 = OpTypeMatrix %2 4
%5 = OpSpecConstant %1 1.0
%6 = OpConstant %1 0.0
%7 = OpSpecConstantComposite %2 %5 %6 %6 %6
%8 = OpSpecConstantComposite %2 %6 %5 %6 %6
%9 = OpSpecConstantComposite %2 %6 %6 %5 %6
%10 = OpSpecConstantComposite %3 %6 %6 %6
%11 = OpSpecConstantComposite %4 %7 %8 %9 %10)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '10[%10]' "
"vector component count does not match Result Type "
"<id> '4[%mat4v4float]'s vector component count."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Matrix type expects 4 columns but only 3 specified.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixNumColsBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeMatrix %2 4
%4 = OpSpecConstant %1 1.0
%5 = OpConstant %1 0.0
%6 = OpSpecConstantComposite %2 %4 %5 %5 %5
%7 = OpSpecConstantComposite %2 %5 %4 %5 %5
%8 = OpSpecConstantComposite %2 %5 %5 %4 %5
%10 = OpSpecConstantComposite %3 %6 %7 %8)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent <id> count does "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"not match Result Type <id> '3[%mat4v4float]'s matrix column "
"count."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Composite contains a non-const/undef component
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeMatrixConstituentNotConstBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpConstant %1 0.0
%3 = OpTypeVector %1 4
%4 = OpTypeMatrix %3 4
%5 = OpSpecConstantComposite %3 %2 %2 %2 %2
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
%6 = OpTypePointer Uniform %1
%7 = OpVariable %6 Uniform
%8 = OpSpecConstantComposite %4 %5 %5 %5 %7)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '7[%7]' is "
Fix validation of constant matrices (#2794) Fixes #2793 * Don't special case matrix validation compared to other composites * just check the constituents are constants or undefs * later checking validates the column type * new test
2019-08-14 15:26:41 +00:00
"not a constant or undef."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Composite contains a column that is *not* a vector (it's an array)
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixColTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeInt 32 0
%3 = OpSpecConstant %2 4
%4 = OpConstant %1 0.0
%5 = OpTypeVector %1 4
%6 = OpTypeArray %2 %3
%7 = OpTypeMatrix %5 4
%8 = OpSpecConstantComposite %6 %3 %3 %3 %3
%9 = OpSpecConstantComposite %5 %4 %4 %4 %4
%10 = OpSpecConstantComposite %7 %9 %9 %9 %8)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '8[%8]' type "
"does not match Result Type <id> '7[%mat4v4float]'s "
"matrix column type."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Matrix with an Undef column of the wrong size.
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeMatrixConstituentUndefTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeFloat 32
%2 = OpTypeVector %1 4
%3 = OpTypeVector %1 3
%4 = OpTypeMatrix %2 4
%5 = OpSpecConstant %1 1.0
%6 = OpSpecConstant %1 0.0
%7 = OpSpecConstantComposite %2 %5 %6 %6 %6
%8 = OpSpecConstantComposite %2 %6 %5 %6 %6
%9 = OpSpecConstantComposite %2 %6 %6 %5 %6
%10 = OpUndef %3
%11 = OpSpecConstantComposite %4 %7 %8 %9 %10)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '10[%10]' "
"vector component count does not match Result Type "
"<id> '4[%mat4v4float]'s vector component count."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Matrix in which some columns are Int and some are Float.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeMatrixColumnTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeFloat 32
%3 = OpTypeVector %1 2
%4 = OpTypeVector %2 2
%5 = OpTypeMatrix %4 2
%6 = OpSpecConstant %1 42
%7 = OpConstant %2 3.14
%8 = OpSpecConstantComposite %3 %6 %6
%9 = OpSpecConstantComposite %4 %7 %7
%10 = OpSpecConstantComposite %5 %8 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '8[%8]' "
"component type does not match Result Type <id> "
"'5[%mat2v2float]'s matrix column component type."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Valid: Array of integers
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
%2 = OpSpecConstant %1 4
%5 = OpConstant %1 5
%3 = OpTypeArray %1 %2
%6 = OpTypeArray %1 %5
%4 = OpSpecConstantComposite %3 %2 %2 %2 %2
%7 = OpSpecConstantComposite %3 %5 %5 %5 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Expecting an array of 4 components, but 3 specified.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayNumComponentsBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
Moving constant opcode validation into a new file * Split constant opcode validation out of idUsage and into validate_constants.cpp * minor style fixes * reduced duplication * fixed an issue with array sizing
2018-08-17 15:20:55 +00:00
%2 = OpConstant %1 4
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeArray %1 %2
%4 = OpSpecConstantComposite %3 %2 %2 %2)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpSpecConstantComposite Constituent count does not "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"match Result Type <id> '3[%_arr_uint_uint_4]'s array "
"length."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Valid: Array of Integers and Undef-int
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayWithUndefGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
%2 = OpSpecConstant %1 4
%9 = OpUndef %1
%3 = OpTypeArray %1 %2
%4 = OpSpecConstantComposite %3 %2 %2 %2 %9)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Array uses a type as operand.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayConstConstituentBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
%4 = OpTypePointer Uniform %1
%5 = OpVariable %4 Uniform
%6 = OpSpecConstantComposite %3 %2 %2 %2 %5)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '5[%5]' is "
"not a constant or undef."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Array has a mix of Int and Float components.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeArrayConstituentTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
%2 = OpConstant %1 4
%3 = OpTypeArray %1 %2
%4 = OpTypeFloat 32
%5 = OpSpecConstant %4 3.14 ; bad type for const value
%6 = OpSpecConstantComposite %3 %2 %2 %2 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '5[%5]'s "
"type does not match Result Type <id> "
"'3[%_arr_uint_uint_4]'s array element type."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Array has a mix of Int and Undef-float.
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeArrayConstituentUndefTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
%2 = OpSpecConstant %1 4
%3 = OpTypeArray %1 %2
%5 = OpTypeFloat 32
%6 = OpUndef %5 ; bad type for undef
%4 = OpSpecConstantComposite %3 %2 %2 %2 %6)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '5[%5]'s "
"type does not match Result Type <id> "
"'3[%_arr_uint_2]'s array element type."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Valid: Struct of {Int32,Int32,Int64}.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpSpecConstant %2 4300000000
%6 = OpSpecConstantComposite %3 %4 %4 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: missing one int32 struct member.
TEST_F(ValidateIdWithMessage,
OpSpecConstantCompositeStructMissingComponentBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
%3 = OpTypeStruct %1 %1 %1
%4 = OpConstant %1 42
%5 = OpSpecConstant %1 430
%6 = OpSpecConstantComposite %3 %4 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> "
"'2[%_struct_2]' count does not match Result Type "
"<id> '2[%_struct_2]'s struct member count."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Valid: Struct uses Undef-int64.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructUndefGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpSpecConstant %1 42
%5 = OpUndef %2
%6 = OpSpecConstantComposite %3 %4 %4 %5)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Composite contains non-const/undef component.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructNonConstBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpSpecConstant %1 42
%5 = OpUndef %2
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
%6 = OpTypePointer Uniform %1
%7 = OpVariable %6 Uniform
%8 = OpSpecConstantComposite %3 %4 %7 %5)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '7[%7]' is "
"not a constant or undef."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Struct component type does not match expected specialization type.
// Second component was expected to be Int32, but got Int64.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructMemberTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpConstant %1 42
%5 = OpSpecConstant %2 4300000000
%6 = OpSpecConstantComposite %3 %4 %5 %4)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '5[%5]' type "
"does not match the Result Type <id> '3[%_struct_3]'s "
"member type."));
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
}
// Invalid: Undef-int64 used when Int32 was expected.
TEST_F(ValidateIdWithMessage, OpSpecConstantCompositeStructMemberUndefTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%1 = OpTypeInt 32 0
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 64 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
%3 = OpTypeStruct %1 %1 %2
%4 = OpSpecConstant %1 42
%5 = OpUndef %2
%6 = OpSpecConstantComposite %3 %4 %5 %4)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpSpecConstantComposite Constituent <id> '5[%5]' type "
"does not match the Result Type <id> '3[%_struct_3]'s "
"member type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
// TODO: OpSpecConstantOp
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpVariableGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpTypePointer Input %1
%3 = OpVariable %2 Input)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
TEST_F(ValidateIdWithMessage, OpVariableInitializerConstantGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpTypePointer Input %1
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpConstant %1 42
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%4 = OpVariable %2 Input %3)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
TEST_F(ValidateIdWithMessage, OpVariableInitializerGlobalVariableGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
%2 = OpTypePointer Uniform %1
%3 = OpVariable %2 Uniform
Validate pointer variables (#2111) Fixes #2104 * Checks the rules for logical addressing and variable pointers * Has an out for relaxed logical pointers * Updated PassFixture to expose validator options * enabled relaxed logical pointers for some tests * New validator tests
2018-11-27 21:47:10 +00:00
%4 = OpTypePointer Private %2 ; pointer to pointer
%5 = OpVariable %4 Private %3
)";
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: Positive test OpVariable with OpConstantNull of OpTypePointer
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpVariableResultTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpVariable %1 Input)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpVariable Result Type <id> '1[%uint]' is not a pointer "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
TEST_F(ValidateIdWithMessage, OpVariableInitializerIsTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%1 = OpTypeInt 32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%2 = OpTypePointer Input %1
%3 = OpVariable %2 Input %2)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 2[%_ptr_Input_uint] "
"cannot be a type"));
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
}
TEST_F(ValidateIdWithMessage, OpVariableInitializerIsFunctionVarBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%int = OpTypeInt 32 0
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
%ptrint = OpTypePointer Function %int
%ptrptrint = OpTypePointer Function %ptrint
%void = OpTypeVoid
%fnty = OpTypeFunction %void
%main = OpFunction %void None %fnty
%entry = OpLabel
%var = OpVariable %ptrint Function
%varinit = OpVariable %ptrptrint Function %var ; Can't initialize function variable.
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpVariable Initializer <id> '8[%8]' is not a constant "
"or module-scope variable"));
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
}
TEST_F(ValidateIdWithMessage, OpVariableInitializerIsModuleVarGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%int = OpTypeInt 32 0
An OpVariable initializer can be a module-scope variable Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/482
2016-12-07 15:33:27 +00:00
%ptrint = OpTypePointer Uniform %int
%mvar = OpVariable %ptrint Uniform
%ptrptrint = OpTypePointer Function %ptrint
%void = OpTypeVoid
%fnty = OpTypeFunction %void
%main = OpFunction %void None %fnty
%entry = OpLabel
%goodvar = OpVariable %ptrptrint Function %mvar ; This is ok
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Validator: check OpTypeBool inside Blocks (#1405) OpTypeBool can only be used with non-externally visible shader Storage Classes: Workgroup, CrossWorkgroup, Private, and Function.
2018-08-30 13:01:37 +00:00
TEST_F(ValidateIdWithMessage, OpVariableContainsBoolBad) {
std::string spirv = kGLSL450MemoryModel + R"(
%bool = OpTypeBool
%int = OpTypeInt 32 0
%block = OpTypeStruct %bool %int
%_ptr_Uniform_block = OpTypePointer Uniform %block
%var = OpVariable %_ptr_Uniform_block Uniform
%void = OpTypeVoid
%fnty = OpTypeFunction %void
%main = OpFunction %void None %fnty
%entry = OpLabel
%load = OpLoad %block %var
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("If OpTypeBool is stored in conjunction with OpVariable"
", it can only be used with non-externally visible "
"shader Storage Classes: Workgroup, CrossWorkgroup, "
"Private, and Function"));
}
TEST_F(ValidateIdWithMessage, OpVariableContainsBoolPointerGood) {
std::string spirv = kGLSL450MemoryModel + R"(
%bool = OpTypeBool
%boolptr = OpTypePointer Uniform %bool
%int = OpTypeInt 32 0
%block = OpTypeStruct %boolptr %int
%_ptr_Uniform_block = OpTypePointer Uniform %block
%var = OpVariable %_ptr_Uniform_block Uniform
%void = OpTypeVoid
%fnty = OpTypeFunction %void
%main = OpFunction %void None %fnty
%entry = OpLabel
%load = OpLoad %block %var
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateIdWithMessage, OpVariableContainsBuiltinBoolGood) {
std::string spirv = kGLSL450MemoryModel + R"(
OpMemberDecorate %input 0 BuiltIn FrontFacing
%bool = OpTypeBool
%input = OpTypeStruct %bool
%_ptr_input = OpTypePointer Input %input
%var = OpVariable %_ptr_input Input
%void = OpTypeVoid
%fnty = OpTypeFunction %void
%main = OpFunction %void None %fnty
%entry = OpLabel
%load = OpLoad %input %var
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Added NVIDIA ray tracing storage classes in ValidateVariable. (#2254) * Added additional changes for the new AccelerationStructureNV type. * Added NVIDIA ray tracing storage classes for checking in ValidateVariable. * For NVIDIA ray tracing storage classes added test to load bool type (allowed) in new storage class.
2018-12-27 20:08:11 +00:00
TEST_F(ValidateIdWithMessage, OpVariableContainsRayPayloadBoolGood) {
std::string spirv = R"(
OpCapability RayTracingNV
OpCapability Shader
OpCapability Linkage
OpExtension "SPV_NV_ray_tracing"
OpMemoryModel Logical GLSL450
%bool = OpTypeBool
%PerRayData = OpTypeStruct %bool
%_ptr_PerRayData = OpTypePointer RayPayloadNV %PerRayData
%var = OpVariable %_ptr_PerRayData RayPayloadNV
%void = OpTypeVoid
%fnty = OpTypeFunction %void
%main = OpFunction %void None %fnty
%entry = OpLabel
%load = OpLoad %PerRayData %var
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Validate pointer variables (#2111) Fixes #2104 * Checks the rules for logical addressing and variable pointers * Has an out for relaxed logical pointers * Updated PassFixture to expose validator options * enabled relaxed logical pointers for some tests * New validator tests
2018-11-27 21:47:10 +00:00
TEST_F(ValidateIdWithMessage, OpVariablePointerNoVariablePointersBad) {
const std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
%void = OpTypeVoid
%int = OpTypeInt 32 0
%_ptr_workgroup_int = OpTypePointer Workgroup %int
%_ptr_function_ptr = OpTypePointer Function %_ptr_workgroup_int
%voidfn = OpTypeFunction %void
%func = OpFunction %void None %voidfn
%entry = OpLabel
%var = OpVariable %_ptr_function_ptr Function
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"In Logical addressing, variables may not allocate a pointer type"));
}
TEST_F(ValidateIdWithMessage,
OpVariablePointerNoVariablePointersRelaxedLogicalGood) {
const std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
%void = OpTypeVoid
%int = OpTypeInt 32 0
%_ptr_workgroup_int = OpTypePointer Workgroup %int
%_ptr_function_ptr = OpTypePointer Function %_ptr_workgroup_int
%voidfn = OpTypeFunction %void
%func = OpFunction %void None %voidfn
%entry = OpLabel
%var = OpVariable %_ptr_function_ptr Function
OpReturn
OpFunctionEnd
)";
auto options = getValidatorOptions();
options->relax_logical_pointer = true;
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Non memory object as parameters. (#2415) In relaxed addressing mode, we want to accept non memory objects because this is a very natural translation of hlsl. It should be fixed by legalization by inlining the calls.
2019-02-22 17:51:22 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionWithNonMemoryObject) {
// DXC generates code that looks like when given something like:
// T t;
// t.s.fn_1();
// This needs to be accepted before legalization takes place, so we
// will include it with the relaxed logical pointer.
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Vertex %1 "main"
OpSource HLSL 600
%int = OpTypeInt 32 1
%int_0 = OpConstant %int 0
%void = OpTypeVoid
%9 = OpTypeFunction %void
%_struct_5 = OpTypeStruct
%_struct_6 = OpTypeStruct %_struct_5
%_ptr_Function__struct_6 = OpTypePointer Function %_struct_6
%_ptr_Function__struct_5 = OpTypePointer Function %_struct_5
%23 = OpTypeFunction %void %_ptr_Function__struct_5
%1 = OpFunction %void None %9
%10 = OpLabel
%11 = OpVariable %_ptr_Function__struct_6 Function
%20 = OpAccessChain %_ptr_Function__struct_5 %11 %int_0
%21 = OpFunctionCall %void %12 %20
OpReturn
OpFunctionEnd
%12 = OpFunction %void None %23
%13 = OpFunctionParameter %_ptr_Function__struct_5
%14 = OpLabel
OpReturn
OpFunctionEnd
)";
auto options = getValidatorOptions();
options->relax_logical_pointer = true;
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Validate pointer variables (#2111) Fixes #2104 * Checks the rules for logical addressing and variable pointers * Has an out for relaxed logical pointers * Updated PassFixture to expose validator options * enabled relaxed logical pointers for some tests * New validator tests
2018-11-27 21:47:10 +00:00
TEST_F(ValidateIdWithMessage,
OpVariablePointerVariablePointersStorageBufferGood) {
const std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VariablePointersStorageBuffer
OpExtension "SPV_KHR_variable_pointers"
OpMemoryModel Logical GLSL450
%void = OpTypeVoid
%int = OpTypeInt 32 0
%_ptr_workgroup_int = OpTypePointer Workgroup %int
%_ptr_function_ptr = OpTypePointer Function %_ptr_workgroup_int
%voidfn = OpTypeFunction %void
%func = OpFunction %void None %voidfn
%entry = OpLabel
%var = OpVariable %_ptr_function_ptr Function
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateIdWithMessage, OpVariablePointerVariablePointersGood) {
const std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VariablePointers
OpExtension "SPV_KHR_variable_pointers"
OpMemoryModel Logical GLSL450
%void = OpTypeVoid
%int = OpTypeInt 32 0
%_ptr_workgroup_int = OpTypePointer Workgroup %int
%_ptr_function_ptr = OpTypePointer Function %_ptr_workgroup_int
%voidfn = OpTypeFunction %void
%func = OpFunction %void None %voidfn
%entry = OpLabel
%var = OpVariable %_ptr_function_ptr Function
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateIdWithMessage, OpVariablePointerVariablePointersBad) {
const std::string spirv = R"(
OpCapability Shader
OpCapability VariablePointers
OpExtension "SPV_KHR_variable_pointers"
OpMemoryModel Logical GLSL450
%void = OpTypeVoid
%int = OpTypeInt 32 0
%_ptr_workgroup_int = OpTypePointer Workgroup %int
%_ptr_uniform_ptr = OpTypePointer Uniform %_ptr_workgroup_int
%var = OpVariable %_ptr_uniform_ptr Uniform
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("In Logical addressing with variable pointers, "
"variables that allocate pointers must be in Function "
"or Private storage classes"));
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%5 = OpVariable %3 UniformConstant
%6 = OpFunction %1 None %4
%7 = OpLabel
Fix OpLoad pointee type validation.
2016-01-21 14:00:15 +00:00
%8 = OpLoad %2 %5
Assembler: Can't set an ID in instruction without result ID (#2852) Fix tests that violated this rule. Fixes #2257
2019-09-11 17:15:25 +00:00
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
Support SPV_KHR_storage_buffer_storage_class Includes interaction with SPV_KHR_variable_pointers TODO: Update capabilitly dependency tests for new capabilities.
2017-03-26 01:12:22 +00:00
// TODO: Add tests that exercise VariablePointersStorageBuffer instead of
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
// VariablePointers.
void createVariablePointerSpirvProgram(std::ostringstream* spirv,
std::string result_strategy,
bool use_varptr_cap,
bool add_helper_function) {
*spirv << "OpCapability Shader ";
if (use_varptr_cap) {
*spirv << "OpCapability VariablePointers ";
*spirv << "OpExtension \"SPV_KHR_variable_pointers\" ";
}
Validate variable pointer related function call rules (#2270) Fixes #2105 * Check storage class validity * Check memory object declaration validity
2019-02-06 19:10:40 +00:00
*spirv << "OpExtension \"SPV_KHR_storage_buffer_storage_class\" ";
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
*spirv << R"(
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %main "main"
%void = OpTypeVoid
%voidf = OpTypeFunction %void
%bool = OpTypeBool
%i32 = OpTypeInt 32 1
%f32 = OpTypeFloat 32
Validate variable pointer related function call rules (#2270) Fixes #2105 * Check storage class validity * Check memory object declaration validity
2019-02-06 19:10:40 +00:00
%f32ptr = OpTypePointer StorageBuffer %f32
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
%i = OpConstant %i32 1
%zero = OpConstant %i32 0
%float_1 = OpConstant %f32 1.0
Validate variable pointer related function call rules (#2270) Fixes #2105 * Check storage class validity * Check memory object declaration validity
2019-02-06 19:10:40 +00:00
%ptr1 = OpVariable %f32ptr StorageBuffer
%ptr2 = OpVariable %f32ptr StorageBuffer
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
)";
if (add_helper_function) {
*spirv << R"(
; ////////////////////////////////////////////////////////////
;;;; Function that returns a pointer
; ////////////////////////////////////////////////////////////
%selector_func_type = OpTypeFunction %f32ptr %bool %f32ptr %f32ptr
%choose_input_func = OpFunction %f32ptr None %selector_func_type
%is_neg_param = OpFunctionParameter %bool
%first_ptr_param = OpFunctionParameter %f32ptr
%second_ptr_param = OpFunctionParameter %f32ptr
%selector_func_begin = OpLabel
%result_ptr = OpSelect %f32ptr %is_neg_param %first_ptr_param %second_ptr_param
OpReturnValue %result_ptr
OpFunctionEnd
)";
}
*spirv << R"(
%main = OpFunction %void None %voidf
%label = OpLabel
)";
*spirv << result_strategy;
*spirv << R"(
OpReturn
OpFunctionEnd
)";
}
// With the VariablePointer Capability, OpLoad should allow loading a
// VaiablePointer. In this test the variable pointer is obtained by an OpSelect
TEST_F(ValidateIdWithMessage, OpLoadVarPtrOpSelectGood) {
std::string result_strategy = R"(
%isneg = OpSLessThan %bool %i %zero
%varptr = OpSelect %f32ptr %isneg %ptr1 %ptr2
%result = OpLoad %f32 %varptr
)";
std::ostringstream spirv;
createVariablePointerSpirvProgram(&spirv, result_strategy,
true /* Add VariablePointers Capability? */,
false /* Use Helper Function? */);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Without the VariablePointers Capability, OpLoad will not allow loading
// through a variable pointer.
Add validate logicals pass to the validator New pass checks operands of all instructions listed under 3.32.15. Relational and Logical Instructions
2017-09-07 21:27:57 +00:00
// Disabled since using OpSelect with pointers without VariablePointers will
// fail LogicalsPass.
TEST_F(ValidateIdWithMessage, DISABLED_OpLoadVarPtrOpSelectBad) {
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
std::string result_strategy = R"(
%isneg = OpSLessThan %bool %i %zero
%varptr = OpSelect %f32ptr %isneg %ptr1 %ptr2
%result = OpLoad %f32 %varptr
)";
std::ostringstream spirv;
createVariablePointerSpirvProgram(&spirv, result_strategy,
false /* Add VariablePointers Capability?*/,
false /* Use Helper Function? */);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(), HasSubstr("is not a logical pointer."));
}
// With the VariablePointer Capability, OpLoad should allow loading a
// VaiablePointer. In this test the variable pointer is obtained by an OpPhi
TEST_F(ValidateIdWithMessage, OpLoadVarPtrOpPhiGood) {
std::string result_strategy = R"(
%is_neg = OpSLessThan %bool %i %zero
OpSelectionMerge %end_label None
OpBranchConditional %is_neg %take_ptr_1 %take_ptr_2
%take_ptr_1 = OpLabel
OpBranch %end_label
%take_ptr_2 = OpLabel
OpBranch %end_label
%end_label = OpLabel
%varptr = OpPhi %f32ptr %ptr1 %take_ptr_1 %ptr2 %take_ptr_2
%result = OpLoad %f32 %varptr
)";
std::ostringstream spirv;
createVariablePointerSpirvProgram(&spirv, result_strategy,
true /* Add VariablePointers Capability?*/,
false /* Use Helper Function? */);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Checks for variable pointers (#1976) In logical addressing mode, we are not allowed to generate variables pointers. There is already a check for OpSelect. However, OpPhi and OpPtrAccessChain are not checked to make sure it does not generate an variable pointer. I've added those checks. Fixes #1957.
2018-10-16 18:57:55 +00:00
// Without the VariablePointers Capability, OpPhi can have a pointer result
// type.
TEST_F(ValidateIdWithMessage, OpPhiBad) {
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
std::string result_strategy = R"(
%is_neg = OpSLessThan %bool %i %zero
OpSelectionMerge %end_label None
OpBranchConditional %is_neg %take_ptr_1 %take_ptr_2
%take_ptr_1 = OpLabel
OpBranch %end_label
%take_ptr_2 = OpLabel
OpBranch %end_label
%end_label = OpLabel
%varptr = OpPhi %f32ptr %ptr1 %take_ptr_1 %ptr2 %take_ptr_2
%result = OpLoad %f32 %varptr
)";
std::ostringstream spirv;
createVariablePointerSpirvProgram(&spirv, result_strategy,
false /* Add VariablePointers Capability?*/,
false /* Use Helper Function? */);
CompileSuccessfully(spirv.str());
Checks for variable pointers (#1976) In logical addressing mode, we are not allowed to generate variables pointers. There is already a check for OpSelect. However, OpPhi and OpPtrAccessChain are not checked to make sure it does not generate an variable pointer. I've added those checks. Fixes #1957.
2018-10-16 18:57:55 +00:00
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Using pointers with OpPhi requires capability "
"VariablePointers or VariablePointersStorageBuffer"));
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
}
// With the VariablePointer Capability, OpLoad should allow loading through a
// VaiablePointer. In this test the variable pointer is obtained from an
// OpFunctionCall (return value from a function)
TEST_F(ValidateIdWithMessage, OpLoadVarPtrOpFunctionCallGood) {
std::ostringstream spirv;
std::string result_strategy = R"(
%isneg = OpSLessThan %bool %i %zero
%varptr = OpFunctionCall %f32ptr %choose_input_func %isneg %ptr1 %ptr2
%result = OpLoad %f32 %varptr
)";
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
createVariablePointerSpirvProgram(&spirv, result_strategy,
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
true /* Add VariablePointers Capability?*/,
true /* Use Helper Function? */);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadResultTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%5 = OpVariable %3 UniformConstant
%6 = OpFunction %1 None %4
%7 = OpLabel
Fix OpLoad pointee type validation.
2016-01-21 14:00:15 +00:00
%8 = OpLoad %3 %5
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpLoad Result Type <id> "
"'3[%_ptr_UniformConstant_uint]' does not match "
"Pointer <id> '5[%5]'s type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validator message for bad logical pointer Affects OpLoad and OpStore validation. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/588
2017-03-16 20:13:47 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadPointerBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
Fix validator message for bad logical pointer Affects OpLoad and OpStore validation. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/588
2017-03-16 20:13:47 +00:00
%5 = OpFunction %1 None %4
%6 = OpLabel
%7 = OpLoad %2 %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
// Prove that SSA checks trigger for a bad Id value.
// The next test case show the not-a-logical-pointer case.
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("ID 8[%8] has not been "
"defined"));
Fix validator message for bad logical pointer Affects OpLoad and OpStore validation. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/588
2017-03-16 20:13:47 +00:00
}
Add validation pass for conversion instructions The pass checks correctness of operands of instruction in opcode range OpConvertFToU - OpBitset. Disabled invalid tests Disabled UConvert validation until Vulkan CTS can catch up. Add validate_conversion to Android.mk Also remove duplicate entry in CMakeLists.txt.
2017-09-28 18:53:24 +00:00
// Disabled as bitcasting type to object is now not valid.
TEST_F(ValidateIdWithMessage, DISABLED_OpLoadLogicalPointerBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator message for bad logical pointer Affects OpLoad and OpStore validation. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/588
2017-03-16 20:13:47 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFloat 32
%4 = OpTypePointer UniformConstant %2
%5 = OpTypePointer UniformConstant %3
%6 = OpTypeFunction %1
%7 = OpFunction %1 None %6
%8 = OpLabel
%9 = OpBitcast %5 %4 ; Not valid in logical addressing
%10 = OpLoad %3 %9 ; Should trigger message
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fix validator message for bad logical pointer Affects OpLoad and OpStore validation. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/588
2017-03-16 20:13:47 +00:00
// Once we start checking bitcasts, we might catch that
// as the error first, instead of catching it here.
// I don't know if it's possible to generate a bad case
// if/when the validator is complete.
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
Fix validator message for bad logical pointer Affects OpLoad and OpStore validation. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/588
2017-03-16 20:13:47 +00:00
HasSubstr("OpLoad Pointer <id> '9' is not a logical pointer."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Validate storage class of target pointer for OpStore
2017-11-01 03:08:23 +00:00
%3 = OpTypePointer Uniform %2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpTypeFunction %1
%5 = OpConstant %2 42
Ensure for OpVariable that result type and storage class operand agree (#2052) From SPIR-V spec, section 3.32.8 on OpVariable: Its Storage Class operand must be the same as the Storage Class operand of the result type. Fixes #941
2018-11-16 16:22:11 +00:00
%6 = OpVariable %3 Uniform
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%7 = OpFunction %1 None %4
%8 = OpLabel
OpStore %6 %5
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStorePointerBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42
%6 = OpVariable %3 UniformConstant
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
%7 = OpConstant %2 0
%8 = OpFunction %1 None %4
%9 = OpLabel
OpStore %7 %5
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpStore Pointer <id> '7[%uint_0]' is not a logical "
"pointer."));
Fix validator message for bad logical pointer Affects OpLoad and OpStore validation. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/588
2017-03-16 20:13:47 +00:00
}
Add validation pass for conversion instructions The pass checks correctness of operands of instruction in opcode range OpConvertFToU - OpBitset. Disabled invalid tests Disabled UConvert validation until Vulkan CTS can catch up. Add validate_conversion to Android.mk Also remove duplicate entry in CMakeLists.txt.
2017-09-28 18:53:24 +00:00
// Disabled as bitcasting type to object is now not valid.
TEST_F(ValidateIdWithMessage, DISABLED_OpStoreLogicalPointerBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validator message for bad logical pointer Affects OpLoad and OpStore validation. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/588
2017-03-16 20:13:47 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFloat 32
%4 = OpTypePointer UniformConstant %2
%5 = OpTypePointer UniformConstant %3
%6 = OpTypeFunction %1
%7 = OpConstantNull %5
%8 = OpFunction %1 None %6
%9 = OpLabel
%10 = OpBitcast %5 %4 ; Not valid in logical addressing
%11 = OpStore %10 %7 ; Should trigger message
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpStore Pointer <id> '10' is not a logical pointer."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validator message for bad logical pointer Affects OpLoad and OpStore validation. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/588
2017-03-16 20:13:47 +00:00
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
// Without the VariablePointer Capability, OpStore should may not store
// through a variable pointer.
Add validate logicals pass to the validator New pass checks operands of all instructions listed under 3.32.15. Relational and Logical Instructions
2017-09-07 21:27:57 +00:00
// Disabled since using OpSelect with pointers without VariablePointers will
// fail LogicalsPass.
TEST_F(ValidateIdWithMessage, DISABLED_OpStoreVarPtrBad) {
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
std::string result_strategy = R"(
%isneg = OpSLessThan %bool %i %zero
%varptr = OpSelect %f32ptr %isneg %ptr1 %ptr2
OpStore %varptr %float_1
)";
std::ostringstream spirv;
createVariablePointerSpirvProgram(
&spirv, result_strategy, false /* Add VariablePointers Capability? */,
false /* Use Helper Function? */);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(), HasSubstr("is not a logical pointer."));
}
// With the VariablePointer Capability, OpStore should allow storing through a
// variable pointer.
TEST_F(ValidateIdWithMessage, OpStoreVarPtrGood) {
std::string result_strategy = R"(
%isneg = OpSLessThan %bool %i %zero
%varptr = OpSelect %f32ptr %isneg %ptr1 %ptr2
OpStore %varptr %float_1
)";
std::ostringstream spirv;
createVariablePointerSpirvProgram(&spirv, result_strategy,
true /* Add VariablePointers Capability? */,
false /* Use Helper Function? */);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreObjectGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Validate storage class of target pointer for OpStore
2017-11-01 03:08:23 +00:00
%3 = OpTypePointer Uniform %2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpTypeFunction %1
%5 = OpConstant %2 42
Ensure for OpVariable that result type and storage class operand agree (#2052) From SPIR-V spec, section 3.32.8 on OpVariable: Its Storage Class operand must be the same as the Storage Class operand of the result type. Fixes #941
2018-11-16 16:22:11 +00:00
%6 = OpVariable %3 Uniform
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%7 = OpFunction %1 None %4
%8 = OpLabel
Validate correct opcode uses of OpFunction Fixes https://crbug.com/873457 * Filed Khronos SPIR-V issue 352 * Updated bad tests * Added new test
2018-08-13 22:25:01 +00:00
%9 = OpUndef %1
OpStore %6 %9
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpStore Object <id> '9[%9]'s type is void."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%9 = OpTypeFloat 32
Validate storage class of target pointer for OpStore
2017-11-01 03:08:23 +00:00
%3 = OpTypePointer Uniform %2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpTypeFunction %1
%5 = OpConstant %9 3.14
Ensure for OpVariable that result type and storage class operand agree (#2052) From SPIR-V spec, section 3.32.8 on OpVariable: Its Storage Class operand must be the same as the Storage Class operand of the result type. Fixes #941
2018-11-16 16:22:11 +00:00
%6 = OpVariable %3 Uniform
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%7 = OpFunction %1 None %4
%8 = OpLabel
OpStore %6 %5
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpStore Pointer <id> '7[%7]'s type does not match "
"Object <id> '6[%float_3_1400001]'s type."));
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
}
// The next series of test check test a relaxation of the rules for stores to
// structs. The first test checks that we get a failure when the option is not
// set to relax the rule.
// TODO: Add tests for layout compatible arrays and matricies when the validator
// relaxes the rules for them as well. Also need test to check for layout
// decorations specific to those types.
TEST_F(ValidateIdWithMessage, OpStoreTypeBadStruct) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
OpMemberDecorate %1 0 Offset 0
OpMemberDecorate %1 1 Offset 4
OpMemberDecorate %2 0 Offset 0
OpMemberDecorate %2 1 Offset 4
%3 = OpTypeVoid
%4 = OpTypeFloat 32
%1 = OpTypeStruct %4 %4
%5 = OpTypePointer Uniform %1
%2 = OpTypeStruct %4 %4
%6 = OpTypeFunction %3
%7 = OpConstant %4 3.14
%8 = OpVariable %5 Uniform
%9 = OpFunction %3 None %6
%10 = OpLabel
%11 = OpCompositeConstruct %2 %7 %7
OpStore %8 %11
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpStore Pointer <id> '8[%8]'s type does not match "
"Object <id> '11[%11]'s type."));
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
}
// Same code as the last test. The difference is that we relax the rule.
// Because the structs %3 and %5 are defined the same way.
TEST_F(ValidateIdWithMessage, OpStoreTypeRelaxedStruct) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
OpMemberDecorate %1 0 Offset 0
OpMemberDecorate %1 1 Offset 4
OpMemberDecorate %2 0 Offset 0
OpMemberDecorate %2 1 Offset 4
%3 = OpTypeVoid
%4 = OpTypeFloat 32
%1 = OpTypeStruct %4 %4
%5 = OpTypePointer Uniform %1
%2 = OpTypeStruct %4 %4
%6 = OpTypeFunction %3
%7 = OpConstant %4 3.14
%8 = OpVariable %5 Uniform
%9 = OpFunction %3 None %6
%10 = OpLabel
%11 = OpCompositeConstruct %2 %7 %7
OpStore %8 %11
OpReturn
OpFunctionEnd)";
spvValidatorOptionsSetRelaxStoreStruct(options_, true);
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Same code as the last test excect for an extra decoration on one of the
// members. With the relaxed rules, the code is still valid.
TEST_F(ValidateIdWithMessage, OpStoreTypeRelaxedStructWithExtraDecoration) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
OpMemberDecorate %1 0 Offset 0
OpMemberDecorate %1 1 Offset 4
OpMemberDecorate %1 0 RelaxedPrecision
OpMemberDecorate %2 0 Offset 0
OpMemberDecorate %2 1 Offset 4
%3 = OpTypeVoid
%4 = OpTypeFloat 32
%1 = OpTypeStruct %4 %4
%5 = OpTypePointer Uniform %1
%2 = OpTypeStruct %4 %4
%6 = OpTypeFunction %3
%7 = OpConstant %4 3.14
%8 = OpVariable %5 Uniform
%9 = OpFunction %3 None %6
%10 = OpLabel
%11 = OpCompositeConstruct %2 %7 %7
OpStore %8 %11
OpReturn
OpFunctionEnd)";
spvValidatorOptionsSetRelaxStoreStruct(options_, true);
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// This test check that we recursively traverse the struct to check if they are
// interchangable.
TEST_F(ValidateIdWithMessage, OpStoreTypeRelaxedNestedStruct) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
OpMemberDecorate %1 0 Offset 0
OpMemberDecorate %1 1 Offset 4
OpMemberDecorate %2 0 Offset 0
OpMemberDecorate %2 1 Offset 8
OpMemberDecorate %3 0 Offset 0
OpMemberDecorate %3 1 Offset 4
OpMemberDecorate %4 0 Offset 0
OpMemberDecorate %4 1 Offset 8
%5 = OpTypeVoid
%6 = OpTypeInt 32 0
%7 = OpTypeFloat 32
%1 = OpTypeStruct %7 %6
%2 = OpTypeStruct %1 %1
%8 = OpTypePointer Uniform %2
%3 = OpTypeStruct %7 %6
%4 = OpTypeStruct %3 %3
%9 = OpTypeFunction %5
%10 = OpConstant %6 7
%11 = OpConstant %7 3.14
Add composite instruction validation pass Validates instructions in the opcode range from OpVectorExtractDynamic to OpTranspose.
2017-12-05 15:15:51 +00:00
%12 = OpConstantComposite %3 %11 %10
%13 = OpVariable %8 Uniform
%14 = OpFunction %5 None %9
%15 = OpLabel
%16 = OpCompositeConstruct %4 %12 %12
OpStore %13 %16
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
OpReturn
OpFunctionEnd)";
spvValidatorOptionsSetRelaxStoreStruct(options_, true);
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// This test check that the even with the relaxed rules an error is identified
// if the members of the struct are in a different order.
TEST_F(ValidateIdWithMessage, OpStoreTypeBadRelaxedStruct1) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
OpMemberDecorate %1 0 Offset 0
OpMemberDecorate %1 1 Offset 4
OpMemberDecorate %2 0 Offset 0
OpMemberDecorate %2 1 Offset 8
OpMemberDecorate %3 0 Offset 0
OpMemberDecorate %3 1 Offset 4
OpMemberDecorate %4 0 Offset 0
OpMemberDecorate %4 1 Offset 8
%5 = OpTypeVoid
%6 = OpTypeInt 32 0
%7 = OpTypeFloat 32
%1 = OpTypeStruct %6 %7
%2 = OpTypeStruct %1 %1
%8 = OpTypePointer Uniform %2
%3 = OpTypeStruct %7 %6
%4 = OpTypeStruct %3 %3
%9 = OpTypeFunction %5
%10 = OpConstant %6 7
%11 = OpConstant %7 3.14
Add composite instruction validation pass Validates instructions in the opcode range from OpVectorExtractDynamic to OpTranspose.
2017-12-05 15:15:51 +00:00
%12 = OpConstantComposite %3 %11 %10
%13 = OpVariable %8 Uniform
%14 = OpFunction %5 None %9
%15 = OpLabel
%16 = OpCompositeConstruct %4 %12 %12
OpStore %13 %16
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
OpReturn
OpFunctionEnd)";
spvValidatorOptionsSetRelaxStoreStruct(options_, true);
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpStore Pointer <id> '13[%13]'s layout does not match Object "
"<id> '16[%16]'s layout."));
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
}
// This test check that the even with the relaxed rules an error is identified
// if the members of the struct are at different offsets.
TEST_F(ValidateIdWithMessage, OpStoreTypeBadRelaxedStruct2) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
OpMemberDecorate %1 0 Offset 4
OpMemberDecorate %1 1 Offset 0
OpMemberDecorate %2 0 Offset 0
OpMemberDecorate %2 1 Offset 8
OpMemberDecorate %3 0 Offset 0
OpMemberDecorate %3 1 Offset 4
OpMemberDecorate %4 0 Offset 0
OpMemberDecorate %4 1 Offset 8
%5 = OpTypeVoid
%6 = OpTypeInt 32 0
%7 = OpTypeFloat 32
%1 = OpTypeStruct %7 %6
%2 = OpTypeStruct %1 %1
%8 = OpTypePointer Uniform %2
%3 = OpTypeStruct %7 %6
%4 = OpTypeStruct %3 %3
%9 = OpTypeFunction %5
%10 = OpConstant %6 7
%11 = OpConstant %7 3.14
Add composite instruction validation pass Validates instructions in the opcode range from OpVectorExtractDynamic to OpTranspose.
2017-12-05 15:15:51 +00:00
%12 = OpConstantComposite %3 %11 %10
%13 = OpVariable %8 Uniform
%14 = OpFunction %5 None %9
%15 = OpLabel
%16 = OpCompositeConstruct %4 %12 %12
OpStore %13 %16
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
OpReturn
OpFunctionEnd)";
spvValidatorOptionsSetRelaxStoreStruct(options_, true);
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpStore Pointer <id> '13[%13]'s layout does not match Object "
"<id> '16[%16]'s layout."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Allow relaxing validation of pointers in logical addressing mode In HLSL structured buffer legalization, pointer to pointer types are emitted to indicate a structured buffer variable should be treated as an alias of some other variable. We need an option to relax the check of pointer types in logical addressing mode to catch other validation errors.
2018-01-07 15:50:01 +00:00
TEST_F(ValidateIdWithMessage, OpStoreTypeRelaxedLogicalPointerReturnPointer) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
const std::string spirv = R"(
Allow relaxing validation of pointers in logical addressing mode In HLSL structured buffer legalization, pointer to pointer types are emitted to indicate a structured buffer variable should be treated as an alias of some other variable. We need an option to relax the check of pointer types in logical addressing mode to catch other validation errors.
2018-01-07 15:50:01 +00:00
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
%1 = OpTypeInt 32 1
%2 = OpTypePointer Function %1
%3 = OpTypeFunction %2 %2
%4 = OpFunction %2 None %3
%5 = OpFunctionParameter %2
%6 = OpLabel
OpReturnValue %5
OpFunctionEnd)";
spvValidatorOptionsSetRelaxLogicalPointer(options_, true);
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateIdWithMessage, OpStoreTypeRelaxedLogicalPointerAllocPointer) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
const std::string spirv = R"(
Allow relaxing validation of pointers in logical addressing mode In HLSL structured buffer legalization, pointer to pointer types are emitted to indicate a structured buffer variable should be treated as an alias of some other variable. We need an option to relax the check of pointer types in logical addressing mode to catch other validation errors.
2018-01-07 15:50:01 +00:00
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
%1 = OpTypeVoid
%2 = OpTypeInt 32 1
%3 = OpTypeFunction %1 ; void(void)
%4 = OpTypePointer Uniform %2 ; int*
%5 = OpTypePointer Private %4 ; int** (Private)
%6 = OpTypePointer Function %4 ; int** (Function)
%7 = OpVariable %5 Private
%8 = OpFunction %1 None %3
%9 = OpLabel
%10 = OpVariable %6 Function
OpReturn
OpFunctionEnd)";
spvValidatorOptionsSetRelaxLogicalPointer(options_, true);
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreVoid) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Validate storage class of target pointer for OpStore
2017-11-01 03:08:23 +00:00
%3 = OpTypePointer Uniform %2
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%4 = OpTypeFunction %1
Ensure for OpVariable that result type and storage class operand agree (#2052) From SPIR-V spec, section 3.32.8 on OpVariable: Its Storage Class operand must be the same as the Storage Class operand of the result type. Fixes #941
2018-11-16 16:22:11 +00:00
%6 = OpVariable %3 Uniform
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%7 = OpFunction %1 None %4
%8 = OpLabel
%9 = OpFunctionCall %1 %7
OpStore %6 %9
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpStore Object <id> '8[%8]'s type is void."));
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreLabel) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Validate storage class of target pointer for OpStore
2017-11-01 03:08:23 +00:00
%3 = OpTypePointer Uniform %2
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%4 = OpTypeFunction %1
Ensure for OpVariable that result type and storage class operand agree (#2052) From SPIR-V spec, section 3.32.8 on OpVariable: Its Storage Class operand must be the same as the Storage Class operand of the result type. Fixes #941
2018-11-16 16:22:11 +00:00
%6 = OpVariable %3 Uniform
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%7 = OpFunction %1 None %4
%8 = OpLabel
OpStore %6 %8
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
Broader check for ids that require a type (#2259) Broader check for ids that require a type Fixes https://crbug.com/911700 * Adds a broader check for when id operands require a type * updated a few tests * added a test to catch the original issue
2019-01-03 18:55:43 +00:00
HasSubstr("Operand 7[%7] requires a type"));
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
}
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
// TODO: enable when this bug is fixed:
// https://cvs.khronos.org/bugzilla/show_bug.cgi?id=15404
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, DISABLED_OpStoreFunction) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
%3 = OpTypePointer UniformConstant %2
%4 = OpTypeFunction %2
%5 = OpConstant %2 123
%6 = OpVariable %3 UniformConstant
%7 = OpFunction %2 None %4
%8 = OpLabel
OpStore %6 %7
OpReturnValue %5
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Remove spvOpcodeIsObject(). Also - Add type_id to spv_id_info_t. - Use spv_id_info_t::type_id instead of words[1]. Triggered some asserts on tests, where the code incorrectly assumed words[1] had a type. Remove the asserts and handle gracefully. - Add tests for OpStore of a label, a void, and a function.
2016-01-22 19:27:00 +00:00
}
Validate storage class of target pointer for OpStore
2017-11-01 03:08:23 +00:00
TEST_F(ValidateIdWithMessage, OpStoreBuiltin) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = R"(
Validate storage class of target pointer for OpStore
2017-11-01 03:08:23 +00:00
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %main "main" %gl_GlobalInvocationID
OpExecutionMode %main LocalSize 1 1 1
OpSource GLSL 450
OpName %main "main"
OpName %gl_GlobalInvocationID "gl_GlobalInvocationID"
OpDecorate %gl_GlobalInvocationID BuiltIn GlobalInvocationId
%int = OpTypeInt 32 1
%uint = OpTypeInt 32 0
%v3uint = OpTypeVector %uint 3
%_ptr_Input_v3uint = OpTypePointer Input %v3uint
%gl_GlobalInvocationID = OpVariable %_ptr_Input_v3uint Input
%zero = OpConstant %uint 0
%v3uint_000 = OpConstantComposite %v3uint %zero %zero %zero
%void = OpTypeVoid
%voidfunc = OpTypeFunction %void
%main = OpFunction %void None %voidfunc
%lmain = OpLabel
OpStore %gl_GlobalInvocationID %v3uint_000
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("storage class is read-only"));
Validate storage class of target pointer for OpStore
2017-11-01 03:08:23 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemoryGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpConstant %2 42
%5 = OpVariable %3 UniformConstant %4
%6 = OpTypePointer Function %2
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %6 Function
OpCopyMemory %10 %5 None
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemoryNonPointerTarget) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Uniform %2
%4 = OpTypeFunction %1 %2 %3
%5 = OpFunction %1 None %4
%6 = OpFunctionParameter %2
%7 = OpFunctionParameter %3
%8 = OpLabel
OpCopyMemory %6 %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Target operand <id> '6[%6]' is not a pointer."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
TEST_F(ValidateIdWithMessage, OpCopyMemoryNonPointerSource) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Uniform %2
%4 = OpTypeFunction %1 %2 %3
%5 = OpFunction %1 None %4
%6 = OpFunctionParameter %2
%7 = OpFunctionParameter %3
%8 = OpLabel
OpCopyMemory %7 %6
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Source operand <id> '6[%6]' is not a pointer."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemoryBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpConstant %2 42
%5 = OpVariable %3 UniformConstant %4
%11 = OpTypeFloat 32
%6 = OpTypePointer Function %11
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %6 Function
OpCopyMemory %10 %5 None
OpReturn
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Target <id> '5[%5]'s type does not match "
"Source <id> '2[%uint]'s type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemoryVoidTarget) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Uniform %1
%4 = OpTypePointer Uniform %2
Split function opcode validation into new files. * Moved function opcode validation out of idUsage and into new files * minor style changes * General opcode checking is in validate_function.cpp * Execution limitation checking is in validate_execution_limitations.cpp * Execution limitations was split into a new pass as it requires other validation to register those limitations first.
2018-08-10 13:53:17 +00:00
%5 = OpTypeFunction %1 %3 %4
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
%6 = OpFunction %1 None %5
%7 = OpFunctionParameter %3
%8 = OpFunctionParameter %4
%9 = OpLabel
OpCopyMemory %7 %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Target operand <id> '7[%7]' cannot be a void "
"pointer."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
TEST_F(ValidateIdWithMessage, OpCopyMemoryVoidSource) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Uniform %1
%4 = OpTypePointer Uniform %2
Split function opcode validation into new files. * Moved function opcode validation out of idUsage and into new files * minor style changes * General opcode checking is in validate_function.cpp * Execution limitation checking is in validate_execution_limitations.cpp * Execution limitations was split into a new pass as it requires other validation to register those limitations first.
2018-08-10 13:53:17 +00:00
%5 = OpTypeFunction %1 %3 %4
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
%6 = OpFunction %1 None %5
%7 = OpFunctionParameter %3
%8 = OpFunctionParameter %4
%9 = OpLabel
OpCopyMemory %8 %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Source operand <id> '7[%7]' cannot be a void "
"pointer."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpVariable %3 UniformConstant %5
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %4 Function
OpCopyMemorySized %10 %6 %5 None
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedTargetBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpVariable %3 UniformConstant %5
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
Broader check for ids that require a type (#2259) Broader check for ids that require a type Fixes https://crbug.com/911700 * Adds a broader check for when id operands require a type * updated a few tests * added a test to catch the original issue
2019-01-03 18:55:43 +00:00
OpCopyMemorySized %5 %5 %5 None
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
Broader check for ids that require a type (#2259) Broader check for ids that require a type Fixes https://crbug.com/911700 * Adds a broader check for when id operands require a type * updated a few tests * added a test to catch the original issue
2019-01-03 18:55:43 +00:00
HasSubstr("Target operand <id> '5[%uint_4]' is not a pointer."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSourceBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpTypeFunction %1
%7 = OpFunction %1 None %6
%8 = OpLabel
%9 = OpVariable %4 Function
Validate uses of OpTypeFunction. (#1867) In the specification of `OpTypeFunction`, it says > OpFunction is the only valid use of OpTypeFunction. This commit add a check in the validator for this rule. A test started to fail because the new check happens before the check the test case is testing. Updated the test case to still fail the check it was suppose to fail originally. http://crbug.com/874571
2018-08-27 15:41:25 +00:00
OpCopyMemorySized %9 %5 %5 None
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Source operand <id> '5[%uint_4]' is not a pointer."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpVariable %3 UniformConstant %5
%7 = OpTypeFunction %1
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %4 Function
OpCopyMemorySized %10 %6 %6 None
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Size operand <id> '6[%6]' must be a scalar integer type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer UniformConstant %2
%4 = OpTypePointer Function %2
%5 = OpConstant %2 4
%6 = OpVariable %3 UniformConstant %5
%7 = OpTypeFunction %1
%11 = OpTypeFloat 32
%12 = OpConstant %11 1.0
%8 = OpFunction %1 None %7
%9 = OpLabel
%10 = OpVariable %4 Function
OpCopyMemorySized %10 %6 %12 None
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Size operand <id> '9[%float_1]' must be a scalar integer "
"type."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantNull) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpConstantNull %2
%4 = OpTypePointer Uniform %2
%5 = OpTypeFloat 32
%6 = OpTypePointer UniformConstant %5
%7 = OpTypeFunction %1 %4 %6
%8 = OpFunction %1 None %7
%9 = OpFunctionParameter %4
%10 = OpFunctionParameter %6
%11 = OpLabel
OpCopyMemorySized %9 %10 %3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Size operand <id> '3[%3]' cannot be a constant "
"zero."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantZero) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpConstant %2 0
%4 = OpTypePointer Uniform %2
%5 = OpTypeFloat 32
%6 = OpTypePointer UniformConstant %5
%7 = OpTypeFunction %1 %4 %6
%8 = OpFunction %1 None %7
%9 = OpFunctionParameter %4
%10 = OpFunctionParameter %6
%11 = OpLabel
OpCopyMemorySized %9 %10 %3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Size operand <id> '3[%uint_0]' cannot be a constant "
"zero."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantZero64) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 64 0
%3 = OpConstant %2 0
%4 = OpTypePointer Uniform %2
%5 = OpTypeFloat 32
%6 = OpTypePointer UniformConstant %5
%7 = OpTypeFunction %1 %4 %6
%8 = OpFunction %1 None %7
%9 = OpFunctionParameter %4
%10 = OpFunctionParameter %6
%11 = OpLabel
OpCopyMemorySized %9 %10 %3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Size operand <id> '3[%ulong_0]' cannot be a constant "
"zero."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantNegative) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 32 1
%3 = OpConstant %2 -1
%4 = OpTypePointer Uniform %2
%5 = OpTypeFloat 32
%6 = OpTypePointer UniformConstant %5
%7 = OpTypeFunction %1 %4 %6
%8 = OpFunction %1 None %7
%9 = OpFunctionParameter %4
%10 = OpFunctionParameter %6
%11 = OpLabel
OpCopyMemorySized %9 %10 %3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Size operand <id> '3[%int_n1]' cannot have the sign bit set "
"to 1."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeConstantNegative64) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 64 1
%3 = OpConstant %2 -1
%4 = OpTypePointer Uniform %2
%5 = OpTypeFloat 32
%6 = OpTypePointer UniformConstant %5
%7 = OpTypeFunction %1 %4 %6
%8 = OpFunction %1 None %7
%9 = OpFunctionParameter %4
%10 = OpFunctionParameter %6
%11 = OpLabel
OpCopyMemorySized %9 %10 %3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Size operand <id> '3[%long_n1]' cannot have the sign bit set "
"to 1."));
Unify validation of OpCopyMemory* Fixes #1800 * Refactored duplication of code between OpCopyMemory and OpCopyMemorySized validation * Fixed some bugs in OpCopyMemorySized validation * Replaced asserts with checks * Added new tests
2018-08-03 18:50:14 +00:00
}
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeUnsignedNegative) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpConstant %2 2147483648
%4 = OpTypePointer Uniform %2
%5 = OpTypeFloat 32
%6 = OpTypePointer UniformConstant %5
%7 = OpTypeFunction %1 %4 %6
%8 = OpFunction %1 None %7
%9 = OpFunctionParameter %4
%10 = OpFunctionParameter %6
%11 = OpLabel
OpCopyMemorySized %9 %10 %3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateIdWithMessage, OpCopyMemorySizedSizeUnsignedNegative64) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeInt 64 0
%3 = OpConstant %2 9223372036854775808
%4 = OpTypePointer Uniform %2
%5 = OpTypeFloat 32
%6 = OpTypePointer UniformConstant %5
%7 = OpTypeFunction %1 %4 %6
%8 = OpFunction %1 None %7
%9 = OpFunctionParameter %4
%10 = OpFunctionParameter %6
%11 = OpLabel
OpCopyMemorySized %9 %10 %3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
const char kDeeplyNestedStructureSetup[] = R"(
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
%void = OpTypeVoid
%void_f = OpTypeFunction %void
%int = OpTypeInt 32 0
%float = OpTypeFloat 32
%v3float = OpTypeVector %float 3
%mat4x3 = OpTypeMatrix %v3float 4
%_ptr_Private_mat4x3 = OpTypePointer Private %mat4x3
%_ptr_Private_float = OpTypePointer Private %float
%my_matrix = OpVariable %_ptr_Private_mat4x3 Private
%my_float_var = OpVariable %_ptr_Private_float Private
%_ptr_Function_float = OpTypePointer Function %float
%int_0 = OpConstant %int 0
%int_1 = OpConstant %int 1
%int_2 = OpConstant %int 2
%int_3 = OpConstant %int 3
%int_5 = OpConstant %int 5
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
; Making the following nested structures.
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
;
; struct S {
; bool b;
; vec4 v[5];
; int i;
; mat4x3 m[5];
; }
; uniform blockName {
; S s;
; bool cond;
Fixing bug in OpAccessChain validation code. The validation code for OpAccessChain was missing OpTypeRuntimeArray as a possible type that can be indexed into. This was caught by running the validator on VKCTS. Also adding unit tests for it.
2016-12-05 20:11:51 +00:00
; RunTimeArray arr;
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
; }
Fixing bug in OpAccessChain validation code. The validation code for OpAccessChain was missing OpTypeRuntimeArray as a possible type that can be indexed into. This was caught by running the validator on VKCTS. Also adding unit tests for it.
2016-12-05 20:11:51 +00:00
%f32arr = OpTypeRuntimeArray %float
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
%v4float = OpTypeVector %float 4
%array5_mat4x3 = OpTypeArray %mat4x3 %int_5
%array5_vec4 = OpTypeArray %v4float %int_5
%_ptr_Uniform_float = OpTypePointer Uniform %float
%_ptr_Function_vec4 = OpTypePointer Function %v4float
%_ptr_Uniform_vec4 = OpTypePointer Uniform %v4float
Validator: check OpTypeBool inside Blocks (#1405) OpTypeBool can only be used with non-externally visible shader Storage Classes: Workgroup, CrossWorkgroup, Private, and Function.
2018-08-30 13:01:37 +00:00
%struct_s = OpTypeStruct %int %array5_vec4 %int %array5_mat4x3
%struct_blockName = OpTypeStruct %struct_s %int %f32arr
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
%_ptr_Uniform_blockName = OpTypePointer Uniform %struct_blockName
%_ptr_Uniform_struct_s = OpTypePointer Uniform %struct_s
%_ptr_Uniform_array5_mat4x3 = OpTypePointer Uniform %array5_mat4x3
%_ptr_Uniform_mat4x3 = OpTypePointer Uniform %mat4x3
%_ptr_Uniform_v3float = OpTypePointer Uniform %v3float
%blockName_var = OpVariable %_ptr_Uniform_blockName Uniform
%spec_int = OpSpecConstant %int 2
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
%float_0 = OpConstant %float 0
Adding validation code for OpAccessChain. * Result Type must be an OpTypePointer. Its Type operand must be the type reached by walking the Base’s type hierarchy down to the last provided index in Indexes, and its Storage Class operand must be the same as the Storage Class of Base. * Base must be a pointer, pointing to the base of a composite object. * Indexes walk the type hierarchy to the desired depth, potentially down to scalar granularity. The first index in Indexes will select the top-level member/element/component/element of the base composite. All composite constituents use zero-based numbering, as described by their OpType... instruction. The second index will apply similarly to that result, and so on. Once any non-composite type is reached, there must be no remaining (unused) indexes. Each of the Indexes must: - be a scalar integer type, - be an OpConstant when indexing into a structure. * Check for the case where no indexes are passed to OpAccessChain. Minor improvements based on code review.
2016-11-30 18:29:12 +00:00
%func = OpFunction %void None %void_f
%my_label = OpLabel
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// In what follows, Access Chain Instruction refers to one of the following:
// OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, and
// OpInBoundsPtrAccessChain
using AccessChainInstructionTest = spvtest::ValidateBase<std::string>;
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
// Determines whether the access chain instruction requires the 'element id'
// argument.
bool AccessChainRequiresElemId(const std::string& instr) {
return (instr == "OpPtrAccessChain" || instr == "OpInBoundsPtrAccessChain");
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Valid: Access a float in a matrix using an access chain instruction.
TEST_P(AccessChainInstructionTest, AccessChainGood) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup +
"%float_entry = " + instr +
R"( %_ptr_Private_float %my_matrix )" + elem +
R"(%int_0 %int_1
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
OpReturn
OpFunctionEnd
)";
Fixing bug in OpAccessChain validation code. The validation code for OpAccessChain was missing OpTypeRuntimeArray as a possible type that can be indexed into. This was caught by running the validator on VKCTS. Also adding unit tests for it.
2016-12-05 20:11:51 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid. The result type of an access chain instruction must be a pointer.
TEST_P(AccessChainInstructionTest, AccessChainResultTypeBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%float_entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr +
R"( %float %my_matrix )" + elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = "The Result Type of " + instr +
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
" <id> '36[%36]' must be "
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
"OpTypePointer. Found OpTypeFloat.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid. The base type of an access chain instruction must be a pointer.
TEST_P(AccessChainInstructionTest, AccessChainBaseTypeVoidBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%float_entry = )" +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
instr + " %_ptr_Private_float %void " + elem +
R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 1[%void] cannot be a "
"type"));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid. The base type of an access chain instruction must be a pointer.
TEST_P(AccessChainInstructionTest, AccessChainBaseTypeNonPtrVariableBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Private_float %_ptr_Private_float )" +
elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Operand 8[%_ptr_Private_float] cannot be a type"));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: The storage class of Base and Result do not match.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest,
AccessChainResultAndBaseStorageClassDoesntMatchBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Function_float %my_matrix )" + elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err =
"The result pointer storage class and base pointer storage class in " +
instr + " do not match.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid. The base type of an access chain instruction must point to a
// composite object.
TEST_P(AccessChainInstructionTest,
AccessChainBasePtrNotPointingToCompositeBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
%entry = )" +
instr + R"( %_ptr_Private_float %my_float_var )" + elem +
R"(%int_0
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" reached non-composite type while "
"indexes still remain to be traversed.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
// Valid. No Indexes were passed to the access chain instruction. The Result
// Type is the same as the Base type.
TEST_P(AccessChainInstructionTest, AccessChainNoIndexesGood) {
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Private_float %my_float_var )" + elem +
R"(
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid. No Indexes were passed to the access chain instruction, but the
// Result Type is different from the Base type.
TEST_P(AccessChainInstructionTest, AccessChainNoIndexesBad) {
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Private_mat4x3 %my_float_var )" + elem +
R"(
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
OpReturn
OpFunctionEnd
)";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fixes issue #532. It is acceptable for OpAccessChain, OpInBoundsAccessChain, OpPtrAccessChain, OpInBoundsPtrAccessChain, OpCompositeInsert, and OpCompositeExtract to not take any indexes as arguments. In such cases, no indexing will be done on the Base pointer/composite.
2017-01-19 16:03:04 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("result type (OpTypeMatrix) does not match the type that "
"results from indexing into the base <id> (OpTypeFloat)."));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Valid: 255 indexes passed to the access chain instruction. Limit is 255.
TEST_P(AccessChainInstructionTest, AccessChainTooManyIndexesGood) {
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : "";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
int depth = 255;
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
std::string header = kGLSL450MemoryModel + kDeeplyNestedStructureSetup;
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
header.erase(header.find("%func"));
std::ostringstream spirv;
spirv << header << "\n";
// Build nested structures. Struct 'i' contains struct 'i-1'
spirv << "%s_depth_1 = OpTypeStruct %float\n";
for (int i = 2; i <= depth; ++i) {
spirv << "%s_depth_" << i << " = OpTypeStruct %s_depth_" << i - 1 << "\n";
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Define Pointer and Variable to use for the AccessChain instruction.
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
spirv << "%_ptr_Uniform_deep_struct = OpTypePointer Uniform %s_depth_"
<< depth << "\n";
spirv << "%deep_var = OpVariable %_ptr_Uniform_deep_struct Uniform\n";
// Function Start
spirv << R"(
%func = OpFunction %void None %void_f
%my_label = OpLabel
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// AccessChain with 'n' indexes (n = depth)
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
spirv << "%entry = " << instr << " %_ptr_Uniform_float %deep_var" << elem;
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
for (int i = 0; i < depth; ++i) {
spirv << " %int_0";
}
// Function end
spirv << R"(
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid: 256 indexes passed to the access chain instruction. Limit is 255.
TEST_P(AccessChainInstructionTest, AccessChainTooManyIndexesBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : "";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
std::ostringstream spirv;
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup;
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
spirv << "%entry = " << instr << " %_ptr_Private_float %my_matrix" << elem;
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
for (int i = 0; i < 256; ++i) {
spirv << " %int_0";
}
spirv << R"(
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = "The number of indexes in " + instr +
" may not exceed 255. Found 256 indexes.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Add command line options struct for the validator The limit for the number of struct members is parameterized using command line options. Add --max-struct-depth command line option. Add --max-switch-branches command line option. Add --max-function-args command line option. Add --max-control-flow-nesting-depth option. Add --max-access-chain-indexes option.
2017-02-15 18:29:33 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
}
// Valid: 10 indexes passed to the access chain instruction. (Custom limit: 10)
TEST_P(AccessChainInstructionTest, CustomizedAccessChainTooManyIndexesGood) {
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : "";
int depth = 10;
std::string header = kGLSL450MemoryModel + kDeeplyNestedStructureSetup;
header.erase(header.find("%func"));
std::ostringstream spirv;
spirv << header << "\n";
// Build nested structures. Struct 'i' contains struct 'i-1'
spirv << "%s_depth_1 = OpTypeStruct %float\n";
for (int i = 2; i <= depth; ++i) {
spirv << "%s_depth_" << i << " = OpTypeStruct %s_depth_" << i - 1 << "\n";
}
// Define Pointer and Variable to use for the AccessChain instruction.
spirv << "%_ptr_Uniform_deep_struct = OpTypePointer Uniform %s_depth_"
<< depth << "\n";
spirv << "%deep_var = OpVariable %_ptr_Uniform_deep_struct Uniform\n";
// Function Start
spirv << R"(
%func = OpFunction %void None %void_f
%my_label = OpLabel
)";
// AccessChain with 'n' indexes (n = depth)
spirv << "%entry = " << instr << " %_ptr_Uniform_float %deep_var" << elem;
for (int i = 0; i < depth; ++i) {
spirv << " %int_0";
}
// Function end
spirv << R"(
OpReturn
OpFunctionEnd
)";
spvValidatorOptionsSetUniversalLimit(
options_, spv_validator_limit_max_access_chain_indexes, 10u);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: 11 indexes passed to the access chain instruction. Custom Limit:10
TEST_P(AccessChainInstructionTest, CustomizedAccessChainTooManyIndexesBad) {
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? " %int_0 " : "";
std::ostringstream spirv;
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup;
spirv << "%entry = " << instr << " %_ptr_Private_float %my_matrix" << elem;
for (int i = 0; i < 11; ++i) {
spirv << " %int_0";
}
spirv << R"(
OpReturn
OpFunctionEnd
)";
const std::string expected_err = "The number of indexes in " + instr +
" may not exceed 10. Found 11 indexes.";
spvValidatorOptionsSetUniversalLimit(
options_, spv_validator_limit_max_access_chain_indexes, 10u);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid: Index passed to the access chain instruction is float (must be
// integer).
TEST_P(AccessChainInstructionTest, AccessChainUndefinedIndexBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
%entry = )" +
instr + R"( %_ptr_Private_float %my_matrix )" + elem +
Strict validation of where type ids are acceptable (#2142) Fixes https://crbug.com/910239 * IdPass catches many instances of invalid references to types * Test updates * Added test to catch OpArrayLength issue
2018-12-03 16:03:52 +00:00
R"(%float_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err =
"Indexes passed to " + instr + " must be of type integer.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid: The index argument that indexes into a struct must be of type
// OpConstant.
TEST_P(AccessChainInstructionTest, AccessChainStructIndexNotConstantBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%f = )" +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
instr + R"( %_ptr_Uniform_float %blockName_var )" + elem +
R"(%int_0 %spec_int %int_2
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err =
"The <id> passed to " + instr +
" to index into a structure must be an OpConstant.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: Indexing up to a vec4 granularity, but result type expected float.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest,
AccessChainStructResultTypeDoesntMatchIndexedTypeBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Uniform_float %blockName_var )" + elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_0 %int_1 %int_2
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" result type (OpTypeFloat) does not match "
"the type that results from indexing into "
"the base <id> (OpTypeVector).";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: Reach non-composite type (bool) when unused indexes remain.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainStructTooManyIndexesBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Uniform_float %blockName_var )" + elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_0 %int_2 %int_2
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" reached non-composite type while "
"indexes still remain to be traversed.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: Trying to find index 3 of the struct that has only 3 members.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainStructIndexOutOfBoundBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Uniform_float %blockName_var )" + elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_3 %int_2 %int_2
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Adding decoration class and tests. * Added the decoration class as well as the code that registers the decorations for each <id> and also decorations for struct members. * Added unit tests for decorations in ValidationState as well as decoration id tests.
2017-01-11 15:51:23 +00:00
const std::string expected_err = "Index is out of bounds: " + instr +
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
" can not find index 3 into the structure "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"<id> '25[%_struct_25]'. This structure "
"has 3 members. Largest valid index is 2.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Valid: Tests that we can index into Struct, Array, Matrix, and Vector!
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainIndexIntoAllTypesGood) {
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
// indexes that we are passing are: 0, 3, 1, 2, 0
// 0 will select the struct_s within the base struct (blockName)
// 3 will select the Array that contains 5 matrices
// 1 will select the Matrix that is at index 1 of the array
// 2 will select the column (which is a vector) within the matrix at index 2
// 0 will select the element at the index 0 of the vector. (which is a float).
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::ostringstream spirv;
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl;
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
spirv << "%ss = " << instr << " %_ptr_Uniform_struct_s %blockName_var "
<< elem << "%int_0" << std::endl;
spirv << "%sa = " << instr << " %_ptr_Uniform_array5_mat4x3 %blockName_var "
<< elem << "%int_0 %int_3" << std::endl;
spirv << "%sm = " << instr << " %_ptr_Uniform_mat4x3 %blockName_var " << elem
<< "%int_0 %int_3 %int_1" << std::endl;
spirv << "%sc = " << instr << " %_ptr_Uniform_v3float %blockName_var " << elem
<< "%int_0 %int_3 %int_1 %int_2" << std::endl;
spirv << "%entry = " << instr << " %_ptr_Uniform_float %blockName_var "
<< elem << "%int_0 %int_3 %int_1 %int_2 %int_0" << std::endl;
spirv << R"(
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
CompileSuccessfully(spirv.str());
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Valid: Access an element of OpTypeRuntimeArray.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainIndexIntoRuntimeArrayGood) {
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string instr = GetParam();
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%runtime_arr_entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Uniform_float %blockName_var )" + elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_2 %int_0
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: Unused index when accessing OpTypeRuntimeArray.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainIndexIntoRuntimeArrayBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
%runtime_arr_entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Uniform_float %blockName_var )" + elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_2 %int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err =
instr +
" reached non-composite type while indexes still remain to be traversed.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Invalid: Reached scalar type before arguments to the access chain instruction
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
// finished.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest, AccessChainMatrixMoreArgsThanNeededBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Private_float %my_matrix )" + elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_0 %int_1 %int_0
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" reached non-composite type while "
"indexes still remain to be traversed.";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
// Invalid: The result type and the type indexed into do not match.
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
TEST_P(AccessChainInstructionTest,
AccessChainResultTypeDoesntMatchIndexedTypeBad) {
const std::string instr = GetParam();
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
const std::string elem = AccessChainRequiresElemId(instr) ? "%int_0 " : "";
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + kDeeplyNestedStructureSetup + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%entry = )" +
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
instr + R"( %_ptr_Private_mat4x3 %my_matrix )" + elem +
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
R"(%int_0 %int_1
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
OpReturn
OpFunctionEnd
)";
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
const std::string expected_err = instr +
" result type (OpTypeMatrix) does not match "
"the type that results from indexing into "
"the base <id> (OpTypeFloat).";
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr(expected_err));
Adding validation for OpInBoundsAccessChain. The validation for this instruction is similar to OpAccessChain. Include a test for testing a struct with (valid) depth of 255.
2016-12-06 16:59:49 +00:00
}
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
// Run tests for Access Chain Instructions.
Remove use of deprecated googletest macro (#2286) * Remove use of deprecated googletest macro INSTANTIATE_TEST_CASE_P has been deprecated. We need to use INSTANTIATE_TEST_SUITE_P instead. * Remove extra commas from test suites.
2019-01-29 23:56:52 +00:00
INSTANTIATE_TEST_SUITE_P(
Adding validation code for PtrAccessChain. Validation for OpPtrAccessChain is similar to OpAccessChain with the following difference: OpPtrAccessChain takes an extra argument (word 4) which is the Element <id> argument. Validation for OpInBoundsPtrAccessChain is also similar to OpPtrAccessChain. Also added tests for all access chain instructions: Modified the existing parameterized tests to accommodate OpPtrAccessChain and OpInBoundsPtrAccessChain. Also fixed a typo in previous commits.
2016-12-22 19:31:21 +00:00
CheckAccessChainInstructions, AccessChainInstructionTest,
::testing::Values("OpAccessChain", "OpInBoundsAccessChain",
"OpPtrAccessChain", "OpInBoundsPtrAccessChain"));
Refactoring unit tests using TEST_P. Using parameterized unit tests to avoid duplicate code that runs the tests of OpAccessChain and OpInBoundsAccessChain. This is also a steppingstone to adding tests for OpPtrAccessChain and OpInBoundsPtrAccessChain.
2017-01-03 19:53:50 +00:00
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: OpArrayLength
// TODO: OpImagePointer
// TODO: OpGenericPtrMemSemantics
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%3 = OpTypeFunction %1 %2 %2
%4 = OpFunction %1 None %3
Fixes issue #489. From the SPIR-V Spec 2.16.1: A function declaration (an OpFunction with no basic blocks), must have a Linkage Attributes Decoration with the Import Linkage Type. A function definition (an OpFunction with basic blocks) cannot be decorated with the Import Linkage Type.
2017-01-27 16:33:33 +00:00
%5 = OpLabel
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionResultTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Fixes issue #489. From the SPIR-V Spec 2.16.1: A function declaration (an OpFunction with no basic blocks), must have a Linkage Attributes Decoration with the Import Linkage Type. A function definition (an OpFunction with basic blocks) cannot be decorated with the Import Linkage Type.
2017-01-27 16:33:33 +00:00
%3 = OpConstant %2 42
%4 = OpTypeFunction %1 %2 %2
%5 = OpFunction %2 None %4
%6 = OpLabel
Validator checks OpReturn called from void func Added check into validate_cfg which checks that OpReturn is not called from functions which are supposed to return a value.
2017-10-11 22:13:21 +00:00
OpReturnValue %3
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpFunction Result Type <id> '2[%uint]' does not "
"match the Function Type's return type <id> "
"'1[%void]'."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Validator: Test OpReturnValue type check The check already existed. I added a test for it. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/876
2017-10-12 19:20:29 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validator: Test OpReturnValue type check The check already existed. I added a test for it. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/876
2017-10-12 19:20:29 +00:00
%1 = OpTypeInt 32 0
%2 = OpTypeFloat 32
%3 = OpConstant %2 0
%4 = OpTypeFunction %1
%5 = OpFunction %1 None %4
%6 = OpLabel
OpReturnValue %3
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpReturnValue Value <id> '3[%float_0]'s type does "
"not match OpFunction's return type."));
Validator: Test OpReturnValue type check The check already existed. I added a test for it. Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/876
2017-10-12 19:20:29 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionFunctionTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%2 = OpTypeInt 32 0
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpFunction %1 None %2
Fixes issue #489. From the SPIR-V Spec 2.16.1: A function declaration (an OpFunction with no basic blocks), must have a Linkage Attributes Decoration with the Import Linkage Type. A function definition (an OpFunction with basic blocks) cannot be decorated with the Import Linkage Type.
2017-01-27 16:33:33 +00:00
%5 = OpLabel
OpReturn
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpFunction Function Type <id> '2[%uint]' is not a function "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Validate correct opcode uses of OpFunction Fixes https://crbug.com/873457 * Filed Khronos SPIR-V issue 352 * Updated bad tests * Added new test
2018-08-13 22:25:01 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionUseBad) {
const std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeFloat 32
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
OpReturnValue %3
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Invalid use of function result id 3[%3]."));
Validate correct opcode uses of OpFunction Fixes https://crbug.com/873457 * Filed Khronos SPIR-V issue 352 * Updated bad tests * Added new test
2018-08-13 22:25:01 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionParameterGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %1 %2
%4 = OpFunction %1 None %3
%5 = OpFunctionParameter %2
%6 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionParameterMultipleGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Basic SSA Validation Most uses of an ID must occur after the definition of the ID. Forward references are allowed for things like OpName, OpDecorate, and various cases of control-flow instructions such as OpBranch, OpPhi, and OpFunctionCall. TODO: Use CFG analysis for SSA checks. In particular, an ID defined inside a function body is only usable inside that function body. Also, use dominator info to catch some failing cases. Also: * Validator test cases use (standard) assignment form. * Update style to more closely follow the Google C++ style guide * Remove color-diagnostics flag. This is enabled by default on terminals with color. Prints hidden ASCII for terminals that can't handle color(Emacs) * Pass functors to SSAPass to check if the operand can be forward referenced based on its index value * Return SPV_ERROR_INVALID_ID for ID related errors spvBinaryParse returned SPV_ERROR_INVALID_BINARY for all types of errors. Since spvBinaryParse does some ID validation, this was returning inappropriate error codes for some tests. * Common fixture for validation tests. It only runs certian validation passes. * Add a SPV_VALIDATE_SSA_BIT for testing purposes * Fixtures now return error codes * Add OpName support in diag message and unit tests * Binary parsing can fail with invalid ID or invalid binary error code Tests include: * OpDecorate * OpName * OpMemberName * OpBranchConditional * OpSelectionMerge * OpMemberDecorate * OpGroupDecorate * OpDeviceEnqueue * Enable several tests failing in ID validation.
2015-11-18 20:43:43 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %1 %2 %2
%4 = OpFunction %1 None %3
%5 = OpFunctionParameter %2
%6 = OpFunctionParameter %2
%7 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Basic SSA Validation Most uses of an ID must occur after the definition of the ID. Forward references are allowed for things like OpName, OpDecorate, and various cases of control-flow instructions such as OpBranch, OpPhi, and OpFunctionCall. TODO: Use CFG analysis for SSA checks. In particular, an ID defined inside a function body is only usable inside that function body. Also, use dominator info to catch some failing cases. Also: * Validator test cases use (standard) assignment form. * Update style to more closely follow the Google C++ style guide * Remove color-diagnostics flag. This is enabled by default on terminals with color. Prints hidden ASCII for terminals that can't handle color(Emacs) * Pass functors to SSAPass to check if the operand can be forward referenced based on its index value * Return SPV_ERROR_INVALID_ID for ID related errors spvBinaryParse returned SPV_ERROR_INVALID_BINARY for all types of errors. Since spvBinaryParse does some ID validation, this was returning inappropriate error codes for some tests. * Common fixture for validation tests. It only runs certian validation passes. * Add a SPV_VALIDATE_SSA_BIT for testing purposes * Fixtures now return error codes * Add OpName support in diag message and unit tests * Binary parsing can fail with invalid ID or invalid binary error code Tests include: * OpDecorate * OpName * OpMemberName * OpBranchConditional * OpSelectionMerge * OpMemberDecorate * OpGroupDecorate * OpDeviceEnqueue * Enable several tests failing in ID validation.
2015-11-18 20:43:43 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionParameterResultTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %1 %2
%4 = OpFunction %1 None %3
%5 = OpFunctionParameter %1
%6 = OpLabel
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpFunctionParameter Result Type <id> '1[%void]' does not "
"match the OpTypeFunction parameter type of the same index."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42 ;21
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpFunction %2 None %3
%7 = OpFunctionParameter %2
%8 = OpLabel
Fix OpLoad pointee type validation.
2016-01-21 14:00:15 +00:00
OpReturnValue %7
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
%12 = OpFunctionCall %2 %6 %5
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallResultTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42 ;21
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpFunction %2 None %3
%7 = OpFunctionParameter %2
%8 = OpLabel
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
%9 = OpIAdd %2 %7 %7
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturnValue %9
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
%12 = OpFunctionCall %1 %6 %5
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpFunctionCall Result Type <id> '1[%void]'s type "
"does not match Function <id> '2[%uint]'s return "
"type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallFunctionBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42 ;21
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
%12 = OpFunctionCall %2 %5 %5
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpFunctionCall Function <id> '5[%uint_42]' is not a "
"function."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallArgumentTypeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%13 = OpTypeFloat 32
%14 = OpConstant %13 3.14
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpFunction %2 None %3
%7 = OpFunctionParameter %2
%8 = OpLabel
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
%9 = OpIAdd %2 %7 %7
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpReturnValue %9
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
%12 = OpFunctionCall %2 %6 %14
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
OpReturn
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fixes issue #493. Check function call operands and return type agree with the called function type. The validation code exists. I have fixed the unit tests.
2017-01-17 21:28:59 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpFunctionCall Argument <id> '7[%float_3_1400001]'s "
"type does not match Function <id> '2[%uint]'s "
"parameter type."));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Validation for OpSampledImage instruction. This change implements the validation for usages of OpSampledImage instruction as described in the Data Rules section of the Universal Validation Rules of the SPIR-V Spec.
2016-11-22 23:06:55 +00:00
// Valid: OpSampledImage result <id> is used in the same block by
// OpImageSampleImplictLod
TEST_F(ValidateIdWithMessage, OpSampledImageGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + sampledImageSetup + R"(
Validation for OpSampledImage instruction. This change implements the validation for usages of OpSampledImage instruction as described in the Data Rules section of the Universal Validation Rules of the SPIR-V Spec.
2016-11-22 23:06:55 +00:00
%smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst
%si_lod = OpImageSampleImplicitLod %v4float %smpld_img %const_vec_1_1
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Invalid: OpSampledImage result <id> is defined in one block and used in a
// different block.
TEST_F(ValidateIdWithMessage, OpSampledImageUsedInDifferentBlockBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + sampledImageSetup + R"(
Validation for OpSampledImage instruction. This change implements the validation for usages of OpSampledImage instruction as described in the Data Rules section of the Universal Validation Rules of the SPIR-V Spec.
2016-11-22 23:06:55 +00:00
%smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst
OpBranch %label_2
%label_2 = OpLabel
%si_lod = OpImageSampleImplicitLod %v4float %smpld_img %const_vec_1_1
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("All OpSampledImage instructions must be in the same block in "
"which their Result <id> are consumed. OpSampledImage Result "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"Type <id> '23[%23]' has a consumer in a different basic "
"block. The consumer instruction <id> is '25[%25]'."));
Validation for OpSampledImage instruction. This change implements the validation for usages of OpSampledImage instruction as described in the Data Rules section of the Universal Validation Rules of the SPIR-V Spec.
2016-11-22 23:06:55 +00:00
}
// Invalid: OpSampledImage result <id> is used by OpSelect
// Note: According to the Spec, OpSelect parameters must be either a scalar or a
// vector. Therefore, OpTypeSampledImage is an illegal parameter for OpSelect.
// However, the OpSelect validation does not catch this today. Therefore, it is
// caught by the OpSampledImage validation. If the OpSelect validation code is
// updated, the error message for this test may change.
Add validate logicals pass to the validator New pass checks operands of all instructions listed under 3.32.15. Relational and Logical Instructions
2017-09-07 21:27:57 +00:00
//
// Disabled since OpSelect catches this now.
TEST_F(ValidateIdWithMessage, DISABLED_OpSampledImageUsedInOpSelectBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + sampledImageSetup + R"(
Validation for OpSampledImage instruction. This change implements the validation for usages of OpSampledImage instruction as described in the Data Rules section of the Universal Validation Rules of the SPIR-V Spec.
2016-11-22 23:06:55 +00:00
%smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst
%select_img = OpSelect %sampled_image_type %spec_true %smpld_img %smpld_img
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Result <id> from OpSampledImage instruction must not "
"appear as operands of OpSelect. Found result <id> "
"'23' as an operand of <id> '24'."));
}
Allow sampledimage types as operand of OpCopyObject (#3222)
2020-03-09 19:03:39 +00:00
TEST_F(ValidateIdWithMessage, OpCopyObjectSampledImageGood) {
std::string spirv = kGLSL450MemoryModel + sampledImageSetup + R"(
%smpld_img = OpSampledImage %sampled_image_type %image_inst %sampler_inst
%smpld_img2 = OpCopyObject %sampled_image_type %smpld_img
%image_inst2 = OpCopyObject %image_type %image_inst
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
// Valid: Get a float in a matrix using CompositeExtract.
// Valid: Insert float into a matrix using CompositeInsert.
TEST_F(ValidateIdWithMessage, CompositeExtractInsertGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::ostringstream spirv;
Validation for Composite Extract and Insert. The validity of each command is checked based on the descripton in SPIR-V Spec Section 3.32.12 (Composite Instructions). Also checked that the number of indexes passed to these commands does not exceed the limit described in 2.17 (Universal Limits). Also added unit tests for each one.
2017-01-04 20:56:17 +00:00
spirv << kGLSL450MemoryModel << kDeeplyNestedStructureSetup << std::endl;
spirv << "%matrix = OpLoad %mat4x3 %my_matrix" << std::endl;
spirv << "%float_entry = OpCompositeExtract %float %matrix 0 1" << std::endl;
// To test CompositeInsert, insert the object back in after extraction.
spirv << "%new_composite = OpCompositeInsert %mat4x3 %float_entry %matrix 0 1"
<< std::endl;
spirv << R"(OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
#if 0
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpFunctionCallArgumentCountBar) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
const char *spirv = R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2 %2
%4 = OpTypeFunction %1
%5 = OpConstant %2 42 ;21
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpFunction %2 None %3
%7 = OpFunctionParameter %2
%8 = OpLabel
%9 = OpLoad %2 %7
OpReturnValue %9
OpFunctionEnd
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%10 = OpFunction %1 None %4
%11 = OpLabel
OpReturn
%12 = OpFunctionCall %2 %6 %5
OpFunctionEnd)";
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
CHECK(spirv, SPV_ERROR_INVALID_ID);
}
#endif
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
// TODO: The many things that changed with how images are used.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: OpTextureSample
// TODO: OpTextureSampleDref
// TODO: OpTextureSampleLod
// TODO: OpTextureSampleProj
// TODO: OpTextureSampleGrad
// TODO: OpTextureSampleOffset
// TODO: OpTextureSampleProjLod
// TODO: OpTextureSampleProjGrad
// TODO: OpTextureSampleLodOffset
// TODO: OpTextureSampleProjOffset
// TODO: OpTextureSampleGradOffset
// TODO: OpTextureSampleProjLodOffset
// TODO: OpTextureSampleProjGradOffset
// TODO: OpTextureFetchTexelLod
// TODO: OpTextureFetchTexelOffset
// TODO: OpTextureFetchSample
// TODO: OpTextureFetchTexel
// TODO: OpTextureGather
// TODO: OpTextureGatherOffset
// TODO: OpTextureGatherOffsets
// TODO: OpTextureQuerySizeLod
// TODO: OpTextureQuerySize
// TODO: OpTextureQueryLevels
// TODO: OpTextureQuerySamples
// TODO: OpConvertUToF
// TODO: OpConvertFToS
// TODO: OpConvertSToF
// TODO: OpConvertUToF
// TODO: OpUConvert
// TODO: OpSConvert
// TODO: OpFConvert
// TODO: OpConvertPtrToU
// TODO: OpConvertUToPtr
// TODO: OpPtrCastToGeneric
// TODO: OpGenericCastToPtr
// TODO: OpBitcast
// TODO: OpGenericCastToPtrExplicit
// TODO: OpSatConvertSToU
// TODO: OpSatConvertUToS
// TODO: OpVectorExtractDynamic
// TODO: OpVectorInsertDynamic
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
TEST_F(ValidateIdWithMessage, OpVectorShuffleIntGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
%int = OpTypeInt 32 0
%ivec3 = OpTypeVector %int 3
%ivec4 = OpTypeVector %int 4
%ptr_ivec3 = OpTypePointer Function %ivec3
%undef = OpUndef %ivec4
%int_42 = OpConstant %int 42
%int_0 = OpConstant %int 0
%int_2 = OpConstant %int 2
%1 = OpConstantComposite %ivec3 %int_42 %int_0 %int_2
%2 = OpTypeFunction %ivec3
%3 = OpFunction %ivec3 None %2
%4 = OpLabel
%var = OpVariable %ptr_ivec3 Function %1
%5 = OpLoad %ivec3 %var
%6 = OpVectorShuffle %ivec3 %5 %undef 2 1 0
OpReturnValue %6
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleFloatGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
%float = OpTypeFloat 32
%vec2 = OpTypeVector %float 2
%vec3 = OpTypeVector %float 3
%vec4 = OpTypeVector %float 4
%ptr_vec2 = OpTypePointer Function %vec2
%ptr_vec3 = OpTypePointer Function %vec3
%float_1 = OpConstant %float 1
%float_2 = OpConstant %float 2
%1 = OpConstantComposite %vec2 %float_2 %float_1
%2 = OpConstantComposite %vec3 %float_1 %float_2 %float_2
%3 = OpTypeFunction %vec4
%4 = OpFunction %vec4 None %3
%5 = OpLabel
%var = OpVariable %ptr_vec2 Function %1
%var2 = OpVariable %ptr_vec3 Function %2
%6 = OpLoad %vec2 %var
%7 = OpLoad %vec3 %var2
%8 = OpVectorShuffle %vec4 %6 %7 4 3 1 0xffffffff
OpReturnValue %8
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleScalarResultType) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
%float = OpTypeFloat 32
%vec2 = OpTypeVector %float 2
%ptr_vec2 = OpTypePointer Function %vec2
%float_1 = OpConstant %float 1
%float_2 = OpConstant %float 2
%1 = OpConstantComposite %vec2 %float_2 %float_1
%2 = OpTypeFunction %float
%3 = OpFunction %float None %2
%4 = OpLabel
%var = OpVariable %ptr_vec2 Function %1
%5 = OpLoad %vec2 %var
%6 = OpVectorShuffle %float %5 %5 0
OpReturnValue %6
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Result Type of OpVectorShuffle must be OpTypeVector."));
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleComponentCount) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
%int = OpTypeInt 32 0
%ivec3 = OpTypeVector %int 3
%ptr_ivec3 = OpTypePointer Function %ivec3
%int_42 = OpConstant %int 42
%int_0 = OpConstant %int 0
%int_2 = OpConstant %int 2
%1 = OpConstantComposite %ivec3 %int_42 %int_0 %int_2
%2 = OpTypeFunction %ivec3
%3 = OpFunction %ivec3 None %2
%4 = OpLabel
%var = OpVariable %ptr_ivec3 Function %1
%5 = OpLoad %ivec3 %var
%6 = OpVectorShuffle %ivec3 %5 %5 0 1
OpReturnValue %6
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpVectorShuffle component literals count does not match "
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"Result Type <id> '2[%v3uint]'s vector component count."));
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleVector1Type) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
%int = OpTypeInt 32 0
%ivec2 = OpTypeVector %int 2
%ptr_int = OpTypePointer Function %int
%undef = OpUndef %ivec2
%int_42 = OpConstant %int 42
%2 = OpTypeFunction %ivec2
%3 = OpFunction %ivec2 None %2
%4 = OpLabel
%var = OpVariable %ptr_int Function %int_42
%5 = OpLoad %int %var
%6 = OpVectorShuffle %ivec2 %5 %undef 0 0
OpReturnValue %6
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("The type of Vector 1 must be OpTypeVector."));
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleVector2Type) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
%int = OpTypeInt 32 0
%ivec2 = OpTypeVector %int 2
%ptr_ivec2 = OpTypePointer Function %ivec2
%undef = OpUndef %int
%int_42 = OpConstant %int 42
%1 = OpConstantComposite %ivec2 %int_42 %int_42
%2 = OpTypeFunction %ivec2
%3 = OpFunction %ivec2 None %2
%4 = OpLabel
%var = OpVariable %ptr_ivec2 Function %1
%5 = OpLoad %ivec2 %var
%6 = OpVectorShuffle %ivec2 %5 %undef 0 1
OpReturnValue %6
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("The type of Vector 2 must be OpTypeVector."));
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleVector1ComponentType) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
%int = OpTypeInt 32 0
%ivec3 = OpTypeVector %int 3
%ptr_ivec3 = OpTypePointer Function %ivec3
%int_42 = OpConstant %int 42
%int_0 = OpConstant %int 0
%int_2 = OpConstant %int 2
%float = OpTypeFloat 32
%vec3 = OpTypeVector %float 3
%vec4 = OpTypeVector %float 4
%ptr_vec3 = OpTypePointer Function %vec3
%float_1 = OpConstant %float 1
%float_2 = OpConstant %float 2
%1 = OpConstantComposite %ivec3 %int_42 %int_0 %int_2
%2 = OpConstantComposite %vec3 %float_1 %float_2 %float_2
%3 = OpTypeFunction %vec4
%4 = OpFunction %vec4 None %3
%5 = OpLabel
%var = OpVariable %ptr_ivec3 Function %1
%var2 = OpVariable %ptr_vec3 Function %2
%6 = OpLoad %ivec3 %var
%7 = OpLoad %vec3 %var2
%8 = OpVectorShuffle %vec4 %6 %7 4 3 1 0
OpReturnValue %8
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("The Component Type of Vector 1 must be the same as "
"ResultType."));
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleVector2ComponentType) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
%int = OpTypeInt 32 0
%ivec3 = OpTypeVector %int 3
%ptr_ivec3 = OpTypePointer Function %ivec3
%int_42 = OpConstant %int 42
%int_0 = OpConstant %int 0
%int_2 = OpConstant %int 2
%float = OpTypeFloat 32
%vec3 = OpTypeVector %float 3
%vec4 = OpTypeVector %float 4
%ptr_vec3 = OpTypePointer Function %vec3
%float_1 = OpConstant %float 1
%float_2 = OpConstant %float 2
%1 = OpConstantComposite %ivec3 %int_42 %int_0 %int_2
%2 = OpConstantComposite %vec3 %float_1 %float_2 %float_2
%3 = OpTypeFunction %vec4
%4 = OpFunction %vec4 None %3
%5 = OpLabel
%var = OpVariable %ptr_ivec3 Function %1
%var2 = OpVariable %ptr_vec3 Function %2
%6 = OpLoad %vec3 %var2
%7 = OpLoad %ivec3 %var
%8 = OpVectorShuffle %vec4 %6 %7 4 3 1 0
OpReturnValue %8
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("The Component Type of Vector 2 must be the same as "
"ResultType."));
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
}
TEST_F(ValidateIdWithMessage, OpVectorShuffleLiterals) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
%float = OpTypeFloat 32
%vec2 = OpTypeVector %float 2
%vec3 = OpTypeVector %float 3
%vec4 = OpTypeVector %float 4
%ptr_vec2 = OpTypePointer Function %vec2
%ptr_vec3 = OpTypePointer Function %vec3
%float_1 = OpConstant %float 1
%float_2 = OpConstant %float 2
%1 = OpConstantComposite %vec2 %float_2 %float_1
%2 = OpConstantComposite %vec3 %float_1 %float_2 %float_2
%3 = OpTypeFunction %vec4
%4 = OpFunction %vec4 None %3
%5 = OpLabel
%var = OpVariable %ptr_vec2 Function %1
%var2 = OpVariable %ptr_vec3 Function %2
%6 = OpLoad %vec2 %var
%7 = OpLoad %vec3 %var2
Move OpVectorShuffle check into validate_composites (#1741) This CL moves the OpVectorShuffle ID check out of validate_id and into validate_composites with the rest of the composite checks.
2018-07-30 20:12:49 +00:00
%8 = OpVectorShuffle %vec4 %6 %7 0 8 2 6
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
OpReturnValue %8
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fixup line number for OpVectorShuffle ID error. This CL updates the code to pull a valid instruction for the line number when outputting a component error in OpVectorShuffle. The error line isn't the best at this point as it points at the component, but it's better then a -1 (turning to max<size_t>) that was being output. The error messages has been updated to better reflect what the error is attempting to say. Issue 1719.
2018-07-16 14:53:46 +00:00
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
Move OpVectorShuffle check into validate_composites (#1741) This CL moves the OpVectorShuffle ID check out of validate_id and into validate_composites with the rest of the composite checks.
2018-07-30 20:12:49 +00:00
"Component index 8 is out of bounds for combined (Vector1 + Vector2) "
"size of 5."));
Validate SpvOpVectorShuffle
2017-10-13 19:53:58 +00:00
}
Validate component literals for OpVectorShuffle in WebGPU environment (#2077) Validate component literals for OpVectorShuffle in WebGPU environment Fixes #2072
2018-11-19 19:32:18 +00:00
TEST_F(ValidateIdWithMessage, WebGPUOpVectorShuffle0xFFFFFFFFLiteralBad) {
std::string spirv = R"(
OpCapability Shader
Ensure correct Addressing and Memory model set for WebGPU (#2093) Adding validation that the addressing declared by OpMemoryModel is Logical and the memory model declared is VulkanKHR. Updating a bunch of tests that were broken by this. Fixes #2060
2018-11-21 21:41:59 +00:00
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
Validate component literals for OpVectorShuffle in WebGPU environment (#2077) Validate component literals for OpVectorShuffle in WebGPU environment Fixes #2072
2018-11-19 19:32:18 +00:00
%float = OpTypeFloat 32
%vec2 = OpTypeVector %float 2
%vec3 = OpTypeVector %float 3
%vec4 = OpTypeVector %float 4
%ptr_vec2 = OpTypePointer Function %vec2
%ptr_vec3 = OpTypePointer Function %vec3
%float_1 = OpConstant %float 1
%float_2 = OpConstant %float 2
%1 = OpConstantComposite %vec2 %float_2 %float_1
%2 = OpConstantComposite %vec3 %float_1 %float_2 %float_2
%3 = OpTypeFunction %vec4
%4 = OpFunction %vec4 None %3
%5 = OpLabel
%var = OpVariable %ptr_vec2 Function %1
%var2 = OpVariable %ptr_vec3 Function %2
%6 = OpLoad %vec2 %var
%7 = OpLoad %vec3 %var2
%8 = OpVectorShuffle %vec4 %6 %7 4 3 1 0xffffffff
OpReturnValue %8
OpFunctionEnd)";
CompileSuccessfully(spirv.c_str(), SPV_ENV_WEBGPU_0);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_WEBGPU_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Component literal at operand 3 cannot be 0xFFFFFFFF in"
" WebGPU execution environment."));
}
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: OpCompositeConstruct
// TODO: OpCompositeExtract
// TODO: OpCompositeInsert
// TODO: OpCopyObject
// TODO: OpTranspose
// TODO: OpSNegate
// TODO: OpFNegate
// TODO: OpNot
// TODO: OpIAdd
// TODO: OpFAdd
// TODO: OpISub
// TODO: OpFSub
// TODO: OpIMul
// TODO: OpFMul
// TODO: OpUDiv
// TODO: OpSDiv
// TODO: OpFDiv
// TODO: OpUMod
// TODO: OpSRem
// TODO: OpSMod
// TODO: OpFRem
// TODO: OpFMod
// TODO: OpVectorTimesScalar
// TODO: OpMatrixTimesScalar
// TODO: OpVectorTimesMatrix
// TODO: OpMatrixTimesVector
// TODO: OpMatrixTimesMatrix
// TODO: OpOuterProduct
// TODO: OpDot
// TODO: OpShiftRightLogical
// TODO: OpShiftRightArithmetic
// TODO: OpShiftLeftLogical
// TODO: OpBitwiseOr
// TODO: OpBitwiseXor
// TODO: OpBitwiseAnd
// TODO: OpAny
// TODO: OpAll
// TODO: OpIsNan
// TODO: OpIsInf
// TODO: OpIsFinite
// TODO: OpIsNormal
// TODO: OpSignBitSet
// TODO: OpLessOrGreater
// TODO: OpOrdered
// TODO: OpUnordered
// TODO: OpLogicalOr
// TODO: OpLogicalXor
// TODO: OpLogicalAnd
// TODO: OpSelect
// TODO: OpIEqual
// TODO: OpFOrdEqual
// TODO: OpFUnordEqual
// TODO: OpINotEqual
// TODO: OpFOrdNotEqual
// TODO: OpFUnordNotEqual
// TODO: OpULessThan
// TODO: OpSLessThan
// TODO: OpFOrdLessThan
// TODO: OpFUnordLessThan
// TODO: OpUGreaterThan
// TODO: OpSGreaterThan
// TODO: OpFOrdGreaterThan
// TODO: OpFUnordGreaterThan
// TODO: OpULessThanEqual
// TODO: OpSLessThanEqual
// TODO: OpFOrdLessThanEqual
// TODO: OpFUnordLessThanEqual
// TODO: OpUGreaterThanEqual
// TODO: OpSGreaterThanEqual
// TODO: OpFOrdGreaterThanEqual
// TODO: OpFUnordGreaterThanEqual
// TODO: OpDPdx
// TODO: OpDPdy
// TODO: OpFWidth
// TODO: OpDPdxFine
// TODO: OpDPdyFine
// TODO: OpFwidthFine
// TODO: OpDPdxCoarse
// TODO: OpDPdyCoarse
// TODO: OpFwidthCoarse
// TODO: OpLoopMerge
// TODO: OpSelectionMerge
// TODO: OpBranch
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
TEST_F(ValidateIdWithMessage, OpPhiNotAType) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel32 + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%2 = OpTypeBool
%3 = OpConstantTrue %2
%4 = OpTypeVoid
%5 = OpTypeFunction %4
%6 = OpFunction %4 None %5
%7 = OpLabel
OpBranch %8
%8 = OpLabel
%9 = OpPhi %3 %3 %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("ID 3[%true] is not a type "
"id"));
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
}
TEST_F(ValidateIdWithMessage, OpPhiSamePredecessor) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel32 + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%2 = OpTypeBool
%3 = OpConstantTrue %2
%4 = OpTypeVoid
%5 = OpTypeFunction %4
%6 = OpFunction %4 None %5
%7 = OpLabel
OpBranchConditional %3 %8 %8
%8 = OpLabel
%9 = OpPhi %2 %3 %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateIdWithMessage, OpPhiOddArgumentNumber) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel32 + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%2 = OpTypeBool
%3 = OpConstantTrue %2
%4 = OpTypeVoid
%5 = OpTypeFunction %4
%6 = OpFunction %4 None %5
%7 = OpLabel
OpBranch %8
%8 = OpLabel
%9 = OpPhi %2 %3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpPhi does not have an equal number of incoming "
"values and basic blocks."));
}
TEST_F(ValidateIdWithMessage, OpPhiTooFewPredecessors) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel32 + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%2 = OpTypeBool
%3 = OpConstantTrue %2
%4 = OpTypeVoid
%5 = OpTypeFunction %4
%6 = OpFunction %4 None %5
%7 = OpLabel
OpBranch %8
%8 = OpLabel
%9 = OpPhi %2
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpPhi's number of incoming blocks (0) does not match "
"block's predecessor count (1)."));
}
TEST_F(ValidateIdWithMessage, OpPhiTooManyPredecessors) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel32 + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%2 = OpTypeBool
%3 = OpConstantTrue %2
%4 = OpTypeVoid
%5 = OpTypeFunction %4
%6 = OpFunction %4 None %5
%7 = OpLabel
OpBranch %8
%9 = OpLabel
OpReturn
%8 = OpLabel
%10 = OpPhi %2 %3 %7 %3 %9
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpPhi's number of incoming blocks (2) does not match "
"block's predecessor count (1)."));
}
TEST_F(ValidateIdWithMessage, OpPhiMismatchedTypes) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel32 + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%2 = OpTypeBool
%3 = OpConstantTrue %2
%4 = OpTypeVoid
%5 = OpTypeInt 32 0
%6 = OpConstant %5 0
%7 = OpTypeFunction %4
%8 = OpFunction %4 None %7
%9 = OpLabel
OpBranchConditional %3 %10 %11
%11 = OpLabel
OpBranch %10
%10 = OpLabel
%12 = OpPhi %2 %3 %9 %6 %11
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpPhi's result type <id> 2[%bool] does not match "
"incoming value <id> 6[%uint_0] type <id> "
"5[%uint]."));
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
}
TEST_F(ValidateIdWithMessage, OpPhiPredecessorNotABlock) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel32 + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%2 = OpTypeBool
%3 = OpConstantTrue %2
%4 = OpTypeVoid
%5 = OpTypeFunction %4
%6 = OpFunction %4 None %5
%7 = OpLabel
OpBranchConditional %3 %8 %9
%9 = OpLabel
OpBranch %11
%11 = OpLabel
OpBranch %8
%8 = OpLabel
%10 = OpPhi %2 %3 %7 %3 %3
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpPhi's incoming basic block <id> 3[%true] is not an "
"OpLabel."));
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
}
TEST_F(ValidateIdWithMessage, OpPhiNotAPredecessor) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel32 + R"(
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
%2 = OpTypeBool
%3 = OpConstantTrue %2
%4 = OpTypeVoid
%5 = OpTypeFunction %4
%6 = OpFunction %4 None %5
%7 = OpLabel
OpBranchConditional %3 %8 %9
%9 = OpLabel
OpBranch %11
%11 = OpLabel
OpBranch %8
%8 = OpLabel
%10 = OpPhi %2 %3 %7 %3 %9
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpPhi's incoming basic block <id> 9[%9] is not a "
"predecessor of <id> 8[%8]."));
Adding OpPhi validation rules. * Added tests * Fixes SSA check for unreachable phi parents * Fixes invalid cfg cleanup test
2018-03-23 14:10:10 +00:00
}
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
TEST_F(ValidateIdWithMessage, OpBranchConditionalGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = BranchConditionalSetup + R"(
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
%branch_cond = OpINotEqual %bool %i0 %i1
Add adjacency validation pass Validate OpPhi predecessors. Validate OpLoopMerge successors. Validate OpSelectionMerge successors. Fix collateral damage to existing tests. Remove ValidateIdWithMessage.OpSampledImageUsedInOpPhiBad.
2018-01-25 23:32:01 +00:00
OpSelectionMerge %end None
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
OpBranchConditional %branch_cond %target_t %target_f
)" + BranchConditionalTail;
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState());
}
TEST_F(ValidateIdWithMessage, OpBranchConditionalWithWeightsGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = BranchConditionalSetup + R"(
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
%branch_cond = OpINotEqual %bool %i0 %i1
Add adjacency validation pass Validate OpPhi predecessors. Validate OpLoopMerge successors. Validate OpSelectionMerge successors. Fix collateral damage to existing tests. Remove ValidateIdWithMessage.OpSampledImageUsedInOpPhiBad.
2018-01-25 23:32:01 +00:00
OpSelectionMerge %end None
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
OpBranchConditional %branch_cond %target_t %target_f 1 1
)" + BranchConditionalTail;
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState());
}
TEST_F(ValidateIdWithMessage, OpBranchConditional_CondIsScalarInt) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = BranchConditionalSetup + R"(
Add adjacency validation pass Validate OpPhi predecessors. Validate OpLoopMerge successors. Validate OpSelectionMerge successors. Fix collateral damage to existing tests. Remove ValidateIdWithMessage.OpSampledImageUsedInOpPhiBad.
2018-01-25 23:32:01 +00:00
OpSelectionMerge %end None
OpBranchConditional %i0 %target_t %target_f
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
)" + BranchConditionalTail;
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
HasSubstr(
"Condition operand for OpBranchConditional must be of boolean type"));
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
}
TEST_F(ValidateIdWithMessage, OpBranchConditional_TrueTargetIsNotLabel) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = BranchConditionalSetup + R"(
Add adjacency validation pass Validate OpPhi predecessors. Validate OpLoopMerge successors. Validate OpSelectionMerge successors. Fix collateral damage to existing tests. Remove ValidateIdWithMessage.OpSampledImageUsedInOpPhiBad.
2018-01-25 23:32:01 +00:00
OpSelectionMerge %end None
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
OpBranchConditional %true %i0 %target_f
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
)" + BranchConditionalTail;
CompileSuccessfully(spirv.c_str());
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
EXPECT_THAT(getDiagnosticString(),
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
HasSubstr("The 'True Label' operand for OpBranchConditional must "
"be the ID of an OpLabel instruction"));
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
}
TEST_F(ValidateIdWithMessage, OpBranchConditional_FalseTargetIsNotLabel) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = BranchConditionalSetup + R"(
Add adjacency validation pass Validate OpPhi predecessors. Validate OpLoopMerge successors. Validate OpSelectionMerge successors. Fix collateral damage to existing tests. Remove ValidateIdWithMessage.OpSampledImageUsedInOpPhiBad.
2018-01-25 23:32:01 +00:00
OpSelectionMerge %end None
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
OpBranchConditional %true %target_t %i0
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
)" + BranchConditionalTail;
CompileSuccessfully(spirv.c_str());
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Re-format source tree - NFC. Re-formatted the source tree with the command: $ /usr/bin/clang-format -style=file -i \ $(find include source tools test utils -name '*.cpp' -or -name '*.h') This required a fix to source/val/decoration.h. It was not including spirv.h, which broke builds when the #include headers were re-ordered by clang-format.
2017-11-27 15:16:41 +00:00
EXPECT_THAT(getDiagnosticString(),
Fixing heap overflow in validation. * Changed entry point validation to check storage class of variable instead of pointer * added a test * Moved several checks after opcode validation * These checks should be able to guarantee individual instructions are ok * Updated tests due to reordered checks
2018-08-13 15:22:27 +00:00
HasSubstr("The 'False Label' operand for OpBranchConditional "
"must be the ID of an OpLabel instruction"));
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
}
TEST_F(ValidateIdWithMessage, OpBranchConditional_NotEnoughWeights) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = BranchConditionalSetup + R"(
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
%branch_cond = OpINotEqual %bool %i0 %i1
Add adjacency validation pass Validate OpPhi predecessors. Validate OpLoopMerge successors. Validate OpSelectionMerge successors. Fix collateral damage to existing tests. Remove ValidateIdWithMessage.OpSampledImageUsedInOpPhiBad.
2018-01-25 23:32:01 +00:00
OpSelectionMerge %end None
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
OpBranchConditional %branch_cond %target_t %target_f 1
)" + BranchConditionalTail;
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpBranchConditional requires either 3 or 5 parameters"));
}
TEST_F(ValidateIdWithMessage, OpBranchConditional_TooManyWeights) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = BranchConditionalSetup + R"(
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
%branch_cond = OpINotEqual %bool %i0 %i1
Add adjacency validation pass Validate OpPhi predecessors. Validate OpLoopMerge successors. Validate OpSelectionMerge successors. Fix collateral damage to existing tests. Remove ValidateIdWithMessage.OpSampledImageUsedInOpPhiBad.
2018-01-25 23:32:01 +00:00
OpSelectionMerge %end None
Add validation for OpBranchConditional
2017-10-26 20:20:32 +00:00
OpBranchConditional %branch_cond %target_t %target_f 1 2 3
)" + BranchConditionalTail;
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("OpBranchConditional requires either 3 or 5 parameters"));
}
Catch branch condition being a type Fixes https://crbug.com/903691 * Added a test
2018-11-16 19:38:14 +00:00
TEST_F(ValidateIdWithMessage, OpBranchConditional_ConditionIsAType) {
std::string spirv = BranchConditionalSetup + R"(
OpBranchConditional %bool %target_t %target_f
)" + BranchConditionalTail;
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 3[%bool] cannot be a "
"type"));
Catch branch condition being a type Fixes https://crbug.com/903691 * Added a test
2018-11-16 19:38:14 +00:00
}
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: OpSwitch
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueConstantGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%3 = OpTypeFunction %2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpConstant %2 42
%5 = OpFunction %2 None %3
%6 = OpLabel
OpReturnValue %4
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validation of return value.
2016-01-22 21:52:40 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueVariableGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0 ;10
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%3 = OpTypeFunction %2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%8 = OpTypePointer Function %2 ;18
%4 = OpConstant %2 42 ;22
%5 = OpFunction %2 None %3 ;27
%6 = OpLabel ;29
%7 = OpVariable %8 Function %4 ;34
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%9 = OpLoad %2 %7
OpReturnValue %9 ;36
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Fix validation of return value.
2016-01-22 21:52:40 +00:00
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueExpressionGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%3 = OpTypeFunction %2
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%4 = OpConstant %2 42
%5 = OpFunction %2 None %3
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%6 = OpLabel
%7 = OpIAdd %2 %4 %4
OpReturnValue %7
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsType) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2
%5 = OpFunction %2 None %3
Only use '%' as variable name prefix. Since now we can distinguish between def and use according to the variable's location, there is no need to keep two variable prefixes. Also reformat tests to use the value generating instruction format ("<result-id> = <opcode> <operand>..").
2015-08-21 15:52:29 +00:00
%6 = OpLabel
OpReturnValue %1
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 1[%void] cannot be a "
"type"));
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsLabel) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2
%5 = OpFunction %2 None %3
%6 = OpLabel
OpReturnValue %6
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(),
Broader check for ids that require a type (#2259) Broader check for ids that require a type Fixes https://crbug.com/911700 * Adds a broader check for when id operands require a type * updated a few tests * added a test to catch the original issue
2019-01-03 18:55:43 +00:00
HasSubstr("Operand 5[%5] requires a type"));
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsVoid) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %1
%5 = OpFunction %1 None %3
%6 = OpLabel
%7 = OpFunctionCall %1 %5
OpReturnValue %7
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpReturnValue value's type <id> '1[%void]' is missing or "
"void."));
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsVariableInPhysical) {
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
// It's valid to return a pointer in a physical addressing model.
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpCapabilitySetup + R"(
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
OpMemoryModel Physical32 OpenCL
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
Ensure for OpVariable that result type and storage class operand agree (#2052) From SPIR-V spec, section 3.32.8 on OpVariable: Its Storage Class operand must be the same as the Storage Class operand of the result type. Fixes #941
2018-11-16 16:22:11 +00:00
%3 = OpTypePointer Function %2
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
%4 = OpTypeFunction %3
%5 = OpFunction %3 None %4
%6 = OpLabel
%7 = OpVariable %3 Function
OpReturnValue %7
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpReturnValueIsVariableInLogical) {
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
// It's invalid to return a pointer in a physical addressing model.
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpCapabilitySetup + R"(
In physical addressing, functions can return pointers Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/229
2016-06-13 21:26:09 +00:00
OpMemoryModel Logical GLSL450
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
Ensure for OpVariable that result type and storage class operand agree (#2052) From SPIR-V spec, section 3.32.8 on OpVariable: Its Storage Class operand must be the same as the Storage Class operand of the result type. Fixes #941
2018-11-16 16:22:11 +00:00
%3 = OpTypePointer Function %2
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%4 = OpTypeFunction %3
%5 = OpFunction %3 None %4
%6 = OpLabel
%7 = OpVariable %3 Function
OpReturnValue %7
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpReturnValue value's type <id> "
"'3[%_ptr_Function_uint]' is a pointer, which is "
"invalid in the Logical addressing model."));
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
// With the VariablePointer Capability, the return value of a function is
// allowed to be a pointer.
TEST_F(ValidateIdWithMessage, OpReturnValueVarPtrGood) {
std::ostringstream spirv;
createVariablePointerSpirvProgram(&spirv,
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
"" /* Instructions to add to "main" */,
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
true /* Add VariablePointers Capability?*/,
true /* Use Helper Function? */);
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
// Without the VariablePointer Capability, the return value of a function is
// *not* allowed to be a pointer.
Add validate logicals pass to the validator New pass checks operands of all instructions listed under 3.32.15. Relational and Logical Instructions
2017-09-07 21:27:57 +00:00
// Disabled since using OpSelect with pointers without VariablePointers will
// fail LogicalsPass.
TEST_F(ValidateIdWithMessage, DISABLED_OpReturnValueVarPtrBad) {
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
std::ostringstream spirv;
createVariablePointerSpirvProgram(&spirv,
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
"" /* Instructions to add to "main" */,
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
false /* Add VariablePointers Capability?*/,
Add option to relax validation of store types. There are a number of users of spriv-opt that are hitting errors because of stores with different types. In general, this is wrong, but, in these cases, the types are the exact same except for decorations. The options is "--relax-store-struct", and it can be used with the validator or the optimizer. We assume that if layout information is missing it is consistent. For example if one struct has a offset of one of its members, and the other one does not, we will still consider them as being layout compatible. The problem will be if both struct has and offset decoration for corresponding members, and the offset are different.
2017-10-24 19:13:13 +00:00
true /* Use Helper Function? */);
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
CompileSuccessfully(spirv.str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("OpReturnValue value's type <id> '7' is a pointer, "
"which is invalid in the Logical addressing model."));
}
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
// TODO: enable when this bug is fixed:
// https://cvs.khronos.org/bugzilla/show_bug.cgi?id=15404
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, DISABLED_OpReturnValueIsFunction) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fix validation of return value.
2016-01-22 21:52:40 +00:00
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypeFunction %2
%5 = OpFunction %2 None %3
%6 = OpLabel
OpReturnValue %5
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Fix validation of return value.
2016-01-22 21:52:40 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, UndefinedTypeId) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%s = OpTypeStruct %i32
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Only allow previously declared forward refs in structs (#2920) Fixes https://crbug.com/1008130 * Restore a missing check that the only valid forward references in structs are previously declared forward pointers
2019-09-25 22:11:22 +00:00
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Operand 2[%2] requires a previous definition"));
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, UndefinedIdScope) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%u32 = OpTypeInt 32 0
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
%memsem = OpConstant %u32 0
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%void = OpTypeVoid
%void_f = OpTypeFunction %void
%f = OpFunction %void None %void_f
%l = OpLabel
OpMemoryBarrier %undef %memsem
OpReturn
OpFunctionEnd
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("ID 7[%7] has not been "
"defined"));
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, UndefinedIdMemSem) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Remove spv_validate_options_t and change tests accrodingly. Users always want to run all the checks. The spv_validate_options_t mechanism, which provides little benefits to users, complicates the internal implementation and also makes the tests exercise different paths as users do. Right now the tests are more like integration tests instead of unit tests, which should be our next refactoring aim.
2016-02-22 20:25:50 +00:00
%u32 = OpTypeInt 32 0
%scope = OpConstant %u32 0
%void = OpTypeVoid
%void_f = OpTypeFunction %void
%f = OpFunction %void None %void_f
%l = OpLabel
OpMemoryBarrier %scope %undef
OpReturn
OpFunctionEnd
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("ID 7[%7] has not been "
"defined"));
Track uses and defs during parsing. Replace two other, imperfect mechanisms for use-def tracking. Use ValidationState_t::entry_points to track entry points. Concentrate undefined-ID diagnostics in a single place. Move validate_types.h content into validate.h due to increased inter-dependency. Track uses of all IDs: TYPE_ID, SCOPE_ID, ... Also update some blurbs. Fix entry-point accumulation and move it outside ProcessIds(). Remove validate_types.h from CMakeLists.txt. Blurb for spvIsIdType. Remove redundant diagnostics for undefined IDs. Join "can not" and reformat.
2016-01-15 16:25:11 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage,
KernelOpEntryPointAndOpInBoundsPtrAccessChainGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel32 + R"(
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
OpEntryPoint Kernel %2 "simple_kernel"
OpSource OpenCL_C 200000
OpDecorate %3 BuiltIn GlobalInvocationId
OpDecorate %3 Constant
OpDecorate %4 FuncParamAttr NoCapture
OpDecorate %3 LinkageAttributes "__spirv_GlobalInvocationId" Import
%5 = OpTypeInt 32 0
%6 = OpTypeVector %5 3
%7 = OpTypePointer UniformConstant %6
%3 = OpVariable %7 UniformConstant
%8 = OpTypeVoid
%9 = OpTypeStruct %5
%10 = OpTypePointer CrossWorkgroup %9
%11 = OpTypeFunction %8 %10
%12 = OpConstant %5 0
%13 = OpTypePointer CrossWorkgroup %5
%14 = OpConstant %5 42
%2 = OpFunction %8 None %11
%4 = OpFunctionParameter %10
%15 = OpLabel
%16 = OpLoad %6 %3 Aligned 0
%17 = OpCompositeExtract %5 %16 0
%18 = OpInBoundsPtrAccessChain %13 %4 %17 %12
OpStore %18 %14 Aligned 4
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpPtrAccessChainGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel64 + R"(
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
OpEntryPoint Kernel %2 "another_kernel"
OpSource OpenCL_C 200000
OpDecorate %3 BuiltIn GlobalInvocationId
OpDecorate %3 Constant
OpDecorate %4 FuncParamAttr NoCapture
OpDecorate %3 LinkageAttributes "__spirv_GlobalInvocationId" Import
%5 = OpTypeInt 64 0
%6 = OpTypeVector %5 3
%7 = OpTypePointer UniformConstant %6
%3 = OpVariable %7 UniformConstant
%8 = OpTypeVoid
%9 = OpTypeInt 32 0
%10 = OpTypeStruct %9
%11 = OpTypePointer CrossWorkgroup %10
%12 = OpTypeFunction %8 %11
%13 = OpConstant %5 4294967295
%14 = OpConstant %9 0
%15 = OpTypePointer CrossWorkgroup %9
%16 = OpConstant %9 42
%2 = OpFunction %8 None %12
%4 = OpFunctionParameter %11
%17 = OpLabel
%18 = OpLoad %6 %3 Aligned 0
%19 = OpCompositeExtract %5 %18 0
%20 = OpBitwiseAnd %5 %19 %13
%21 = OpPtrAccessChain %15 %4 %20 %14
OpStore %21 %16 Aligned 4
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
Don't check kernel entry-point signatures. Recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer. * spvOpcodeIsPointer: recognize SpvOpInBoundsPtrAccessChain and SpvOpPtrAccessChain as opcodes returning a pointer * isValid<SpvOpEntryPoint>: don't check kernel function signatures (these don't have to be 'void main(void)') * added tests for kernel OpEntryPoint, OpInBoundsPtrAccessChain and OpPtrAccessChain, as well as facilities to actually test kernel/OpenCL SPIR-V * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469 * use ASSERT_TRUE instead of ASSERT_EQ * added pow and pown test (pow(val, 2.0f) and pown(val, 3)) Revert " * fixed pow and pown specification (both should take 2 parameters), spec bug reported at https://www.khronos.org/bugzilla/show_bug.cgi?id=1469" This reverts commit c3d5a87e73334b25aa4278964eea6d1c7625cd81. Revert " * added pow and pown test (pow(val, 2.0f) and pown(val, 3))" This reverts commit 7624aec720a51dc212704dc92eff6ae3634d2d6c.
2016-03-01 18:56:14 +00:00
}
Checks for variable pointers (#1976) In logical addressing mode, we are not allowed to generate variables pointers. There is already a check for OpSelect. However, OpPhi and OpPtrAccessChain are not checked to make sure it does not generate an variable pointer. I've added those checks. Fixes #1957.
2018-10-16 18:57:55 +00:00
TEST_F(ValidateIdWithMessage, StgBufOpPtrAccessChainGood) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VariablePointersStorageBuffer
OpExtension "SPV_KHR_variable_pointers"
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %3 ""
%int = OpTypeInt 32 0
%int_2 = OpConstant %int 2
%int_4 = OpConstant %int 4
%struct = OpTypeStruct %int
%array = OpTypeArray %struct %int_4
%ptr = OpTypePointer StorageBuffer %array
%var = OpVariable %ptr StorageBuffer
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpFunction %1 None %2
%4 = OpLabel
%5 = OpPtrAccessChain %ptr %var %int_2
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadBitcastPointerGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel64 + R"(
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%2 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%3 = OpTypeInt 32 0
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%4 = OpTypeFloat 32
%5 = OpTypePointer UniformConstant %3
%6 = OpTypePointer UniformConstant %4
%7 = OpVariable %5 UniformConstant
%8 = OpTypeFunction %2
%9 = OpFunction %2 None %8
%10 = OpLabel
%11 = OpBitcast %6 %7
%12 = OpLoad %4 %11
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpLoadBitcastNonPointerBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel64 + R"(
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%2 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%3 = OpTypeInt 32 0
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%4 = OpTypeFloat 32
%5 = OpTypePointer UniformConstant %3
%6 = OpTypeFunction %2
%7 = OpVariable %5 UniformConstant
%8 = OpFunction %2 None %6
%9 = OpLabel
%10 = OpLoad %3 %7
%11 = OpBitcast %4 %10
%12 = OpLoad %3 %11
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpLoad type for pointer <id> '11[%11]' is not a pointer "
"type."));
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreBitcastPointerGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel64 + R"(
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%2 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%3 = OpTypeInt 32 0
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%4 = OpTypeFloat 32
%5 = OpTypePointer Function %3
%6 = OpTypePointer Function %4
%7 = OpTypeFunction %2
%8 = OpConstant %3 42
%9 = OpFunction %2 None %7
%10 = OpLabel
%11 = OpVariable %6 Function
%12 = OpBitcast %5 %11
OpStore %12 %8
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
}
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
TEST_F(ValidateIdWithMessage, OpStoreBitcastNonPointerBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kOpenCLMemoryModel64 + R"(
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%2 = OpTypeVoid
The Signedness in OpTypeInt must always be 0. When Kernel capability is used, The Signedness in OpTypeInt must always be 0. Fixes issue #492.
2017-02-09 21:23:40 +00:00
%3 = OpTypeInt 32 0
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
%4 = OpTypeFloat 32
%5 = OpTypePointer Function %4
%6 = OpTypeFunction %2
%7 = OpConstant %4 42
%8 = OpFunction %2 None %6
%9 = OpLabel
%10 = OpVariable %5 Function
%11 = OpBitcast %3 %7
OpStore %11 %7
OpReturn
OpFunctionEnd)";
Adding validation for OpSpecConstantComposite. SpecConstantComposite may specialize to a vector, matrix, array, or struct. In each case, the number of components and type of components that are being specialized to must match the expected result type. Removed use of macros in these tests. Now using the spvValidateBase class. Using CompileSuccessfully(), and ValidateInstructions() to compile to binary and run the validator. Also using getDiagnosticString() to check the proper error message string. All the heavy lifting is done in ValidateBase class.
2016-11-16 16:04:13 +00:00
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Making the unit tests more robust. It is best to check the error messages of unit tests that fail validation. This will ensure that a validation failure is due to what we expect and not due to some secondary reason. Updating SPIR-V Validator unit tests with error message checks.
2017-01-23 23:31:14 +00:00
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpStore type for pointer <id> '11[%11]' is not a pointer "
"type."));
bitcast fixes * ValidationState_t and idUsage now store the addressing model and memory model of the SPIR-V module (this is necessary for certain instructions that need different checks depending on if the logical or physical addressing model is used) * removed SpvOpPtrAccessChain and SpvOpInBoundsPtrAccessChain from spvOpcodeIsPointer again as these are disallowed in logical addressing mode and only allowed in physical addressing mode (which doesn't use/need spvOpcodeIsPointer in the first place) * added SpvOpImageTexelPointer and SpvOpCopyObject to spvOpcodeIsPointer * OpLoad/OpStore now only check if the used pointer operand originated from a valid pointer producing opcode in logical addressing mode (as per 2.16.1) * moved bitcast pointer tests to the kernel / physical addressing model part (+cleanup) * renamed spvOpcodeIsPointer to spvOpcodeReturnsLogicalPointer to clarify this function is only meant to be used with the logical addressing model
2016-03-02 21:17:54 +00:00
}
Add a test that exercises wrong usage of result id Result <id> resulting from an instruction within a function may not be used outside that function.
2016-12-05 19:00:18 +00:00
// Result <id> resulting from an instruction within a function may not be used
// outside that function.
TEST_F(ValidateIdWithMessage, ResultIdUsedOutsideOfFunctionBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Add a test that exercises wrong usage of result id Result <id> resulting from an instruction within a function may not be used outside that function.
2016-12-05 19:00:18 +00:00
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeInt 32 0
%4 = OpTypePointer Function %3
%5 = OpFunction %1 None %2
%6 = OpLabel
%7 = OpVariable %4 Function
OpReturn
OpFunctionEnd
%8 = OpFunction %1 None %2
%9 = OpLabel
%10 = OpLoad %3 %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
"ID 7[%7] defined in block 6[%6] does not dominate its use in block "
"9[%9]"));
Add a test that exercises wrong usage of result id Result <id> resulting from an instruction within a function may not be used outside that function.
2016-12-05 19:00:18 +00:00
}
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
TEST_F(ValidateIdWithMessage, SpecIdTargetNotSpecializationConstant) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Change Ids in tests to avoid confusion The assembler assigns ID numbers sequentially, so it's confusing to have a %1 in the source assembly when it isn't the first mentioned ID. Rewrite the ID names to avoid this situation in a few cases.
2017-03-07 14:49:43 +00:00
OpDecorate %1 SpecId 200
%void = OpTypeVoid
%2 = OpTypeFunction %void
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
%int = OpTypeInt 32 0
Change Ids in tests to avoid confusion The assembler assigns ID numbers sequentially, so it's confusing to have a %1 in the source assembly when it isn't the first mentioned ID. Rewrite the ID names to avoid this situation in a few cases.
2017-03-07 14:49:43 +00:00
%1 = OpConstant %int 3
Validate all type ids. (#1868) * Validate all type ids. The validator does not check if the type of an instruction is actually a type unless the OpCode has a specific requirement. For example, OpFAdd is checked, but OpUndef is not. The commit add a generic check that if there is a type id then the id defines a type. http://crbug.com/876694 * Merge other checks for type into new one. There are a couple check that the type id is a type for specific opcodes. Those have been mereged into 1. Small changes to other test cases to make them valid enough for the purpose of the test.
2018-08-28 03:45:32 +00:00
%main = OpFunction %void None %2
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
%4 = OpLabel
Validator checks OpReturn called from void func Added check into validate_cfg which checks that OpReturn is not called from functions which are supposed to return a value.
2017-10-11 22:13:21 +00:00
OpReturnValue %1
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Split annotation opcode validation into new file. * Moves annotation opcode checks from idUsage into a new pass * minor style updates
2018-08-08 18:21:27 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpDecorate SpecId decoration target <id> "
"'1[%uint_3]' is not a scalar specialization "
"constant."));
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
}
TEST_F(ValidateIdWithMessage, SpecIdTargetOpSpecConstantOpBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Change Ids in tests to avoid confusion The assembler assigns ID numbers sequentially, so it's confusing to have a %1 in the source assembly when it isn't the first mentioned ID. Rewrite the ID names to avoid this situation in a few cases.
2017-03-07 14:49:43 +00:00
OpDecorate %1 SpecId 200
%void = OpTypeVoid
%2 = OpTypeFunction %void
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
%int = OpTypeInt 32 0
%3 = OpConstant %int 1
%4 = OpConstant %int 2
Change Ids in tests to avoid confusion The assembler assigns ID numbers sequentially, so it's confusing to have a %1 in the source assembly when it isn't the first mentioned ID. Rewrite the ID names to avoid this situation in a few cases.
2017-03-07 14:49:43 +00:00
%1 = OpSpecConstantOp %int IAdd %3 %4
Validate all type ids. (#1868) * Validate all type ids. The validator does not check if the type of an instruction is actually a type unless the OpCode has a specific requirement. For example, OpFAdd is checked, but OpUndef is not. The commit add a generic check that if there is a type id then the id defines a type. http://crbug.com/876694 * Merge other checks for type into new one. There are a couple check that the type id is a type for specific opcodes. Those have been mereged into 1. Small changes to other test cases to make them valid enough for the purpose of the test.
2018-08-28 03:45:32 +00:00
%main = OpFunction %void None %2
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
%6 = OpLabel
Validator checks OpReturn called from void func Added check into validate_cfg which checks that OpReturn is not called from functions which are supposed to return a value.
2017-10-11 22:13:21 +00:00
OpReturnValue %3
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Split annotation opcode validation into new file. * Moves annotation opcode checks from idUsage into a new pass * minor style updates
2018-08-08 18:21:27 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpDecorate SpecId decoration target <id> '1[%1]' is "
"not a scalar specialization constant."));
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
}
TEST_F(ValidateIdWithMessage, SpecIdTargetOpSpecConstantCompositeBad) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Change Ids in tests to avoid confusion The assembler assigns ID numbers sequentially, so it's confusing to have a %1 in the source assembly when it isn't the first mentioned ID. Rewrite the ID names to avoid this situation in a few cases.
2017-03-07 14:49:43 +00:00
OpDecorate %1 SpecId 200
%void = OpTypeVoid
%2 = OpTypeFunction %void
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
%int = OpTypeInt 32 0
Validator checks OpReturn called from void func Added check into validate_cfg which checks that OpReturn is not called from functions which are supposed to return a value.
2017-10-11 22:13:21 +00:00
%3 = OpConstant %int 1
Change Ids in tests to avoid confusion The assembler assigns ID numbers sequentially, so it's confusing to have a %1 in the source assembly when it isn't the first mentioned ID. Rewrite the ID names to avoid this situation in a few cases.
2017-03-07 14:49:43 +00:00
%1 = OpSpecConstantComposite %int
Validate all type ids. (#1868) * Validate all type ids. The validator does not check if the type of an instruction is actually a type unless the OpCode has a specific requirement. For example, OpFAdd is checked, but OpUndef is not. The commit add a generic check that if there is a type id then the id defines a type. http://crbug.com/876694 * Merge other checks for type into new one. There are a couple check that the type id is a type for specific opcodes. Those have been mereged into 1. Small changes to other test cases to make them valid enough for the purpose of the test.
2018-08-28 03:45:32 +00:00
%main = OpFunction %void None %2
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
%4 = OpLabel
Validator checks OpReturn called from void func Added check into validate_cfg which checks that OpReturn is not called from functions which are supposed to return a value.
2017-10-11 22:13:21 +00:00
OpReturnValue %3
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
Split annotation opcode validation into new file. * Moves annotation opcode checks from idUsage into a new pass * minor style updates
2018-08-08 18:21:27 +00:00
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("OpDecorate SpecId decoration target <id> '1[%1]' is "
"not a scalar specialization constant."));
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
}
TEST_F(ValidateIdWithMessage, SpecIdTargetGood) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
OpDecorate %3 SpecId 200
OpDecorate %4 SpecId 201
OpDecorate %5 SpecId 202
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%int = OpTypeInt 32 0
%bool = OpTypeBool
%3 = OpSpecConstant %int 3
%4 = OpSpecConstantTrue %bool
%5 = OpSpecConstantFalse %bool
%main = OpFunction %1 None %2
%6 = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_SUCCESS, ValidateAndRetrieveValidationState());
}
Fixup line number for OpVectorShuffle ID error. This CL updates the code to pull a valid instruction for the line number when outputting a component error in OpVectorShuffle. The error line isn't the best at this point as it points at the component, but it's better then a -1 (turning to max<size_t>) that was being output. The error messages has been updated to better reflect what the error is attempting to say. Issue 1719.
2018-07-16 14:53:46 +00:00
TEST_F(ValidateIdWithMessage, CorrectErrorForShuffle) {
Remove using std::<foo> statements. (#1756) Many of the files have using std::<foo> statements in them, but then the use of <foo> will be inconsistently std::<foo> or <foo> scattered through the file. This CL removes all of the using statements and updates the code to have the required std:: prefix.
2018-08-01 18:58:12 +00:00
std::string spirv = kGLSL450MemoryModel + R"(
Fixup line number for OpVectorShuffle ID error. This CL updates the code to pull a valid instruction for the line number when outputting a component error in OpVectorShuffle. The error line isn't the best at this point as it points at the component, but it's better then a -1 (turning to max<size_t>) that was being output. The error messages has been updated to better reflect what the error is attempting to say. Issue 1719.
2018-07-16 14:53:46 +00:00
%uint = OpTypeInt 32 0
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%v2float = OpTypeVector %float 2
%void = OpTypeVoid
%548 = OpTypeFunction %void
%CS = OpFunction %void None %548
%550 = OpLabel
%6275 = OpUndef %v2float
%6280 = OpUndef %v2float
%6282 = OpVectorShuffle %v4float %6275 %6280 0 1 4 5
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv.c_str());
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
Move OpVectorShuffle check into validate_composites (#1741) This CL moves the OpVectorShuffle ID check out of validate_id and into validate_composites with the rest of the composite checks.
2018-07-30 20:12:49 +00:00
"Component index 4 is out of bounds for combined (Vector1 + Vector2) "
"size of 4."));
Checks for variable pointers (#1976) In logical addressing mode, we are not allowed to generate variables pointers. There is already a check for OpSelect. However, OpPhi and OpPtrAccessChain are not checked to make sure it does not generate an variable pointer. I've added those checks. Fixes #1957.
2018-10-16 18:57:55 +00:00
EXPECT_EQ(25, getErrorPosition().index);
Fixup line number for OpVectorShuffle ID error. This CL updates the code to pull a valid instruction for the line number when outputting a component error in OpVectorShuffle. The error line isn't the best at this point as it points at the component, but it's better then a -1 (turning to max<size_t>) that was being output. The error messages has been updated to better reflect what the error is attempting to say. Issue 1719.
2018-07-16 14:53:46 +00:00
}
Disallow void types in structs (#1832) Fixes #1831 * Adds validation check that void is not a member of a struct * added a test
2018-08-14 12:55:49 +00:00
TEST_F(ValidateIdWithMessage, VoidStructMember) {
const std::string spirv = kGLSL450MemoryModel + R"(
%void = OpTypeVoid
%struct = OpTypeStruct %void
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Structures cannot contain a void type."));
}
Validate uses of OpTypeFunction. (#1867) In the specification of `OpTypeFunction`, it says > OpFunction is the only valid use of OpTypeFunction. This commit add a check in the validator for this rule. A test started to fail because the new check happens before the check the test case is testing. Updated the test case to still fail the check it was suppose to fail originally. http://crbug.com/874571
2018-08-27 15:41:25 +00:00
TEST_F(ValidateIdWithMessage, TypeFunctionBadUse) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypePointer Function %2
%4 = OpFunction %1 None %2
%5 = OpLabel
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("Invalid use of function type result id 2[%2]."));
Validate uses of OpTypeFunction. (#1867) In the specification of `OpTypeFunction`, it says > OpFunction is the only valid use of OpTypeFunction. This commit add a check in the validator for this rule. A test started to fail because the new check happens before the check the test case is testing. Updated the test case to still fail the check it was suppose to fail originally. http://crbug.com/874571
2018-08-27 15:41:25 +00:00
}
Validate all type ids. (#1868) * Validate all type ids. The validator does not check if the type of an instruction is actually a type unless the OpCode has a specific requirement. For example, OpFAdd is checked, but OpUndef is not. The commit add a generic check that if there is a type id then the id defines a type. http://crbug.com/876694 * Merge other checks for type into new one. There are a couple check that the type id is a type for specific opcodes. Those have been mereged into 1. Small changes to other test cases to make them valid enough for the purpose of the test.
2018-08-28 03:45:32 +00:00
TEST_F(ValidateIdWithMessage, BadTypeId) {
std::string spirv = kGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeFloat 32
%4 = OpConstant %3 0
%5 = OpFunction %1 None %2
%6 = OpLabel
%7 = OpUndef %4
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
EXPECT_THAT(getDiagnosticString(), HasSubstr("ID 4[%float_0] is not a type "
"id"));
Validate all type ids. (#1868) * Validate all type ids. The validator does not check if the type of an instruction is actually a type unless the OpCode has a specific requirement. For example, OpFAdd is checked, but OpUndef is not. The commit add a generic check that if there is a type id then the id defines a type. http://crbug.com/876694 * Merge other checks for type into new one. There are a couple check that the type id is a type for specific opcodes. Those have been mereged into 1. Small changes to other test cases to make them valid enough for the purpose of the test.
2018-08-28 03:45:32 +00:00
}
Memory access checks for vulkan mem model (#1909) * MakePointerVisibleKHR cannot be used with OpStore * MakePointerAvailableKHR cannot be used with OpLoad * MakePointerAvailableKHR and MakePointerVisibleKHR both require NonPrivatePointerKHR * NonPrivatePointerKHR is limited to a subset of storage classes * many tests
2018-10-15 13:30:47 +00:00
TEST_F(ValidateIdWithMessage, VulkanMemoryModelLoadMakePointerVisibleGood) {
std::string spirv = R"(
OpCapability Shader
OpCapability VulkanMemoryModelKHR
OpCapability Linkage
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypeFunction %1
%6 = OpConstant %2 2
%7 = OpFunction %1 None %5
%8 = OpLabel
%9 = OpLoad %2 %4 NonPrivatePointerKHR|MakePointerVisibleKHR %6
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelLoadMakePointerVisibleMissingNonPrivatePointer) {
std::string spirv = R"(
OpCapability Shader
OpCapability VulkanMemoryModelKHR
OpCapability Linkage
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypeFunction %1
%6 = OpConstant %2 2
%7 = OpFunction %1 None %5
%8 = OpLabel
%9 = OpLoad %2 %4 MakePointerVisibleKHR %6
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR must be specified if "
"MakePointerVisibleKHR is specified."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelLoadNonPrivatePointerBadStorageClass) {
std::string spirv = R"(
OpCapability Shader
OpCapability VulkanMemoryModelKHR
OpCapability Linkage
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Private %2
%4 = OpVariable %3 Private
%5 = OpTypeFunction %1
%6 = OpConstant %2 2
%7 = OpFunction %1 None %5
%8 = OpLabel
%9 = OpLoad %2 %4 NonPrivatePointerKHR
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR requires a pointer in Uniform, "
"Workgroup, CrossWorkgroup, Generic, Image or "
"StorageBuffer storage classes."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelLoadMakePointerAvailableCannotBeUsed) {
std::string spirv = R"(
OpCapability Shader
OpCapability VulkanMemoryModelKHR
OpCapability Linkage
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypeFunction %1
%6 = OpConstant %2 2
%7 = OpFunction %1 None %5
%8 = OpLabel
%9 = OpLoad %2 %4 NonPrivatePointerKHR|MakePointerAvailableKHR %6
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("MakePointerAvailableKHR cannot be used with OpLoad"));
}
TEST_F(ValidateIdWithMessage, VulkanMemoryModelStoreMakePointerAvailableGood) {
std::string spirv = R"(
OpCapability Shader
OpCapability VulkanMemoryModelKHR
OpCapability Linkage
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Uniform %2
%4 = OpVariable %3 Uniform
%5 = OpTypeFunction %1
%6 = OpConstant %2 5
%7 = OpFunction %1 None %5
%8 = OpLabel
OpStore %4 %6 NonPrivatePointerKHR|MakePointerAvailableKHR %6
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelStoreMakePointerAvailableMissingNonPrivatePointer) {
std::string spirv = R"(
OpCapability Shader
OpCapability VulkanMemoryModelKHR
OpCapability Linkage
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Uniform %2
%4 = OpVariable %3 Uniform
%5 = OpTypeFunction %1
%6 = OpConstant %2 5
%7 = OpFunction %1 None %5
%8 = OpLabel
OpStore %4 %6 MakePointerAvailableKHR %6
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR must be specified if "
"MakePointerAvailableKHR is specified."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelStoreNonPrivatePointerBadStorageClass) {
std::string spirv = R"(
OpCapability Shader
OpCapability VulkanMemoryModelKHR
OpCapability Linkage
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Output %2
%4 = OpVariable %3 Output
%5 = OpTypeFunction %1
%6 = OpConstant %2 5
%7 = OpFunction %1 None %5
%8 = OpLabel
OpStore %4 %6 NonPrivatePointerKHR
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR requires a pointer in Uniform, "
"Workgroup, CrossWorkgroup, Generic, Image or "
"StorageBuffer storage classes."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelStoreMakePointerVisibleCannotBeUsed) {
std::string spirv = R"(
OpCapability Shader
OpCapability VulkanMemoryModelKHR
OpCapability Linkage
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Uniform %2
%4 = OpVariable %3 Uniform
%5 = OpTypeFunction %1
%6 = OpConstant %2 5
%7 = OpFunction %1 None %5
%8 = OpLabel
OpStore %4 %6 NonPrivatePointerKHR|MakePointerVisibleKHR %6
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("MakePointerVisibleKHR cannot be used with OpStore."));
}
TEST_F(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryAvailable) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemory %4 %6 NonPrivatePointerKHR|MakePointerAvailableKHR %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryVisible) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemory %4 %6 NonPrivatePointerKHR|MakePointerVisibleKHR %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage, VulkanMemoryModelCopyMemoryAvailableAndVisible) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemory %4 %6 NonPrivatePointerKHR|MakePointerAvailableKHR|MakePointerVisibleKHR %7 %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelCopyMemoryAvailableMissingNonPrivatePointer) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemory %4 %6 MakePointerAvailableKHR %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR must be specified if "
"MakePointerAvailableKHR is specified."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelCopyMemoryVisibleMissingNonPrivatePointer) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemory %4 %6 MakePointerVisibleKHR %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR must be specified if "
"MakePointerVisibleKHR is specified."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelCopyMemoryAvailableBadStorageClass) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Output %2
%4 = OpVariable %3 Output
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemory %4 %6 NonPrivatePointerKHR
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR requires a pointer in Uniform, "
"Workgroup, CrossWorkgroup, Generic, Image or "
"StorageBuffer storage classes."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelCopyMemoryVisibleBadStorageClass) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Input %2
%6 = OpVariable %5 Input
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemory %4 %6 NonPrivatePointerKHR
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR requires a pointer in Uniform, "
"Workgroup, CrossWorkgroup, Generic, Image or "
"StorageBuffer storage classes."));
}
TEST_F(ValidateIdWithMessage, VulkanMemoryModelCopyMemorySizedAvailable) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability Addresses
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemorySized %4 %6 %7 NonPrivatePointerKHR|MakePointerAvailableKHR %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage, VulkanMemoryModelCopyMemorySizedVisible) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability Addresses
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemorySized %4 %6 %7 NonPrivatePointerKHR|MakePointerVisibleKHR %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelCopyMemorySizedAvailableAndVisible) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability Addresses
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemorySized %4 %6 %7 NonPrivatePointerKHR|MakePointerAvailableKHR|MakePointerVisibleKHR %7 %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelCopyMemorySizedAvailableMissingNonPrivatePointer) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability Addresses
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemorySized %4 %6 %7 MakePointerAvailableKHR %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR must be specified if "
"MakePointerAvailableKHR is specified."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelCopyMemorySizedVisibleMissingNonPrivatePointer) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability Addresses
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemorySized %4 %6 %7 MakePointerVisibleKHR %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR must be specified if "
"MakePointerVisibleKHR is specified."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelCopyMemorySizedAvailableBadStorageClass) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability Addresses
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Output %2
%4 = OpVariable %3 Output
%5 = OpTypePointer Uniform %2
%6 = OpVariable %5 Uniform
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemorySized %4 %6 %7 NonPrivatePointerKHR
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR requires a pointer in Uniform, "
"Workgroup, CrossWorkgroup, Generic, Image or "
"StorageBuffer storage classes."));
}
TEST_F(ValidateIdWithMessage,
VulkanMemoryModelCopyMemorySizedVisibleBadStorageClass) {
std::string spirv = R"(
OpCapability Shader
OpCapability Linkage
OpCapability Addresses
OpCapability VulkanMemoryModelKHR
OpExtension "SPV_KHR_vulkan_memory_model"
OpMemoryModel Logical VulkanKHR
%1 = OpTypeVoid
%2 = OpTypeInt 32 0
%3 = OpTypePointer Workgroup %2
%4 = OpVariable %3 Workgroup
%5 = OpTypePointer Input %2
%6 = OpVariable %5 Input
%7 = OpConstant %2 2
%8 = OpConstant %2 5
%9 = OpTypeFunction %1
%10 = OpFunction %1 None %9
%11 = OpLabel
OpCopyMemorySized %4 %6 %7 NonPrivatePointerKHR
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("NonPrivatePointerKHR requires a pointer in Uniform, "
"Workgroup, CrossWorkgroup, Generic, Image or "
"StorageBuffer storage classes."));
}
Put test classes in anonymous namespace. Put TestFixture.h classes in a namespace. Remove unused #includes.
2015-08-31 19:24:32 +00:00
Validate uses of ids defined in unreachable blocks. (#2146) * Validate uses of ids defined in unreachable blocks. For some reason we do not make sure the uses of ids that are defined in unreachable blocks are dominated by their def. This is causing invalid code to pass the validator. Fixes #2143 * Add test for unreachable code after a return. We want to allow code like: ``` void foo() { a = ...; ... return; // for debugging <use of a>; ... } ``` I added a test to make sure that something like this is still accepted by the validator. * Add test for unreachable def used in phi.
2018-12-03 17:49:27 +00:00
TEST_F(ValidateIdWithMessage, IdDefInUnreachableBlock1) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeFloat 32
%4 = OpTypeFunction %3
%5 = OpFunction %1 None %2
%6 = OpLabel
Validate that OpUnreacahble is not statically reachable (#2473) * Adds a validator check that ensures no block reachable from the entry block is terminated by OpUnreachable * Updated tests * Added new tests
2019-03-29 14:49:37 +00:00
OpReturn
%7 = OpLabel
%8 = OpFunctionCall %3 %9
Validate uses of ids defined in unreachable blocks. (#2146) * Validate uses of ids defined in unreachable blocks. For some reason we do not make sure the uses of ids that are defined in unreachable blocks are dominated by their def. This is causing invalid code to pass the validator. Fixes #2143 * Add test for unreachable code after a return. We want to allow code like: ``` void foo() { a = ...; ... return; // for debugging <use of a>; ... } ``` I added a test to make sure that something like this is still accepted by the validator. * Add test for unreachable def used in phi.
2018-12-03 17:49:27 +00:00
OpUnreachable
OpFunctionEnd
Validate that OpUnreacahble is not statically reachable (#2473) * Adds a validator check that ensures no block reachable from the entry block is terminated by OpUnreachable * Updated tests * Added new tests
2019-03-29 14:49:37 +00:00
%9 = OpFunction %3 None %4
%10 = OpLabel
OpReturnValue %8
Validate uses of ids defined in unreachable blocks. (#2146) * Validate uses of ids defined in unreachable blocks. For some reason we do not make sure the uses of ids that are defined in unreachable blocks are dominated by their def. This is causing invalid code to pass the validator. Fixes #2143 * Add test for unreachable code after a return. We want to allow code like: ``` void foo() { a = ...; ... return; // for debugging <use of a>; ... } ``` I added a test to make sure that something like this is still accepted by the validator. * Add test for unreachable def used in phi.
2018-12-03 17:49:27 +00:00
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
Validate that OpUnreacahble is not statically reachable (#2473) * Adds a validator check that ensures no block reachable from the entry block is terminated by OpUnreachable * Updated tests * Added new tests
2019-03-29 14:49:37 +00:00
HasSubstr("ID 8[%8] defined in block 7[%7] does not dominate its "
"use in block 10[%10]\n %10 = OpLabel"));
Validate uses of ids defined in unreachable blocks. (#2146) * Validate uses of ids defined in unreachable blocks. For some reason we do not make sure the uses of ids that are defined in unreachable blocks are dominated by their def. This is causing invalid code to pass the validator. Fixes #2143 * Add test for unreachable code after a return. We want to allow code like: ``` void foo() { a = ...; ... return; // for debugging <use of a>; ... } ``` I added a test to make sure that something like this is still accepted by the validator. * Add test for unreachable def used in phi.
2018-12-03 17:49:27 +00:00
}
TEST_F(ValidateIdWithMessage, IdDefInUnreachableBlock2) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeFloat 32
%4 = OpTypeFunction %3
%5 = OpFunction %1 None %2
%6 = OpLabel
OpReturn
%7 = OpLabel
%8 = OpFunctionCall %3 %9
OpUnreachable
OpFunctionEnd
%9 = OpFunction %3 None %4
%10 = OpLabel
OpReturnValue %8
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("ID 8[%8] defined in block 7[%7] does not dominate its "
"use in block 10[%10]\n %10 = OpLabel"));
Validate uses of ids defined in unreachable blocks. (#2146) * Validate uses of ids defined in unreachable blocks. For some reason we do not make sure the uses of ids that are defined in unreachable blocks are dominated by their def. This is causing invalid code to pass the validator. Fixes #2143 * Add test for unreachable code after a return. We want to allow code like: ``` void foo() { a = ...; ... return; // for debugging <use of a>; ... } ``` I added a test to make sure that something like this is still accepted by the validator. * Add test for unreachable def used in phi.
2018-12-03 17:49:27 +00:00
}
TEST_F(ValidateIdWithMessage, IdDefInUnreachableBlock3) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeFloat 32
%4 = OpTypeFunction %3
%5 = OpFunction %1 None %2
%6 = OpLabel
OpReturn
%7 = OpLabel
%8 = OpFunctionCall %3 %9
OpReturn
OpFunctionEnd
%9 = OpFunction %3 None %4
%10 = OpLabel
OpReturnValue %8
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("ID 8[%8] defined in block 7[%7] does not dominate its "
"use in block 10[%10]\n %10 = OpLabel"));
Validate uses of ids defined in unreachable blocks. (#2146) * Validate uses of ids defined in unreachable blocks. For some reason we do not make sure the uses of ids that are defined in unreachable blocks are dominated by their def. This is causing invalid code to pass the validator. Fixes #2143 * Add test for unreachable code after a return. We want to allow code like: ``` void foo() { a = ...; ... return; // for debugging <use of a>; ... } ``` I added a test to make sure that something like this is still accepted by the validator. * Add test for unreachable def used in phi.
2018-12-03 17:49:27 +00:00
}
TEST_F(ValidateIdWithMessage, IdDefInUnreachableBlock4) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeFloat 32
%4 = OpTypeFunction %3
%5 = OpFunction %1 None %2
%6 = OpLabel
OpReturn
%7 = OpLabel
%8 = OpUndef %3
%9 = OpCopyObject %3 %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage, IdDefInUnreachableBlock5) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeFloat 32
%4 = OpTypeFunction %3
%5 = OpFunction %1 None %2
%6 = OpLabel
OpReturn
%7 = OpLabel
%8 = OpUndef %3
OpBranch %9
%9 = OpLabel
%10 = OpCopyObject %3 %8
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage, IdDefInUnreachableBlock6) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeFloat 32
%4 = OpTypeFunction %3
%5 = OpFunction %1 None %2
%6 = OpLabel
OpBranch %7
%8 = OpLabel
%9 = OpUndef %3
OpBranch %7
%7 = OpLabel
%10 = OpCopyObject %3 %9
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("ID 9[%9] defined in block 8[%8] does not dominate its "
"use in block 7[%7]\n %7 = OpLabel"));
Validate uses of ids defined in unreachable blocks. (#2146) * Validate uses of ids defined in unreachable blocks. For some reason we do not make sure the uses of ids that are defined in unreachable blocks are dominated by their def. This is causing invalid code to pass the validator. Fixes #2143 * Add test for unreachable code after a return. We want to allow code like: ``` void foo() { a = ...; ... return; // for debugging <use of a>; ... } ``` I added a test to make sure that something like this is still accepted by the validator. * Add test for unreachable def used in phi.
2018-12-03 17:49:27 +00:00
}
TEST_F(ValidateIdWithMessage, ReachableDefUnreachableUse) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%1 = OpTypeVoid
%2 = OpTypeFunction %1
%3 = OpTypeFloat 32
%4 = OpTypeFunction %3
%5 = OpFunction %1 None %2
%6 = OpLabel
%7 = OpUndef %3
OpReturn
%8 = OpLabel
%9 = OpCopyObject %3 %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
}
TEST_F(ValidateIdWithMessage, UnreachableDefUsedInPhi) {
const std::string spirv = kNoKernelGLSL450MemoryModel + R"(
%void = OpTypeVoid
%3 = OpTypeFunction %void
%float = OpTypeFloat 32
%bool = OpTypeBool
%6 = OpTypeFunction %float
%1 = OpFunction %void None %3
%7 = OpLabel
%8 = OpUndef %bool
OpSelectionMerge %9 None
OpBranchConditional %8 %10 %9
%10 = OpLabel
%11 = OpUndef %float
OpBranch %9
%12 = OpLabel
%13 = OpUndef %float
OpUnreachable
%9 = OpLabel
%14 = OpPhi %float %11 %10 %13 %7
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(
getDiagnosticString(),
[val] Fixup id name output (#2158) This CL changes the id/name output from the validator to always use a consistent id[%name] style. This removes the need for getIdOrName. The name lookup is changed to use the NameMapper so the output is consistent with what the disassembler will produce. Fixes #2137
2018-12-03 22:01:30 +00:00
HasSubstr("In OpPhi instruction 14[%14], ID 13[%13] definition does not "
"dominate its parent 7[%7]\n %14 = OpPhi %float %11 %10 %13 "
"%7"));
Validate uses of ids defined in unreachable blocks. (#2146) * Validate uses of ids defined in unreachable blocks. For some reason we do not make sure the uses of ids that are defined in unreachable blocks are dominated by their def. This is causing invalid code to pass the validator. Fixes #2143 * Add test for unreachable code after a return. We want to allow code like: ``` void foo() { a = ...; ... return; // for debugging <use of a>; ... } ``` I added a test to make sure that something like this is still accepted by the validator. * Add test for unreachable def used in phi.
2018-12-03 17:49:27 +00:00
}
Validate OpForwardPointer (#2156) * Validate OpForwardPointer The validator does not have a a check that OpForwardPointer is giving a forward reference to a pointer type. We add that check. https://crbug.com/910852 * Remove more specialized check. There was a check that the forward pointer is actually a poiner type, but it was only done if it was used in a struct. This was too specific. Remove it in favour of the more general check that was added. * Format * Check the storage type in OpTypeForwardPointer * Fix typo is test case epxected results.
2018-12-04 18:35:49 +00:00
TEST_F(ValidateIdWithMessage, OpTypeForwardPointerNotAPointerType) {
std::string spirv = R"(
OpCapability GenericPointer
OpCapability VariablePointersStorageBuffer
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %1 "main"
OpExecutionMode %1 OriginLowerLeft
OpTypeForwardPointer %2 CrossWorkgroup
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%1 = OpFunction %2 DontInline %3
%4 = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Pointer type in OpTypeForwardPointer is not a pointer "
"type.\n OpTypeForwardPointer %void CrossWorkgroup"));
}
TEST_F(ValidateIdWithMessage, OpTypeForwardPointerWrongStorageClass) {
std::string spirv = R"(
OpCapability GenericPointer
OpCapability VariablePointersStorageBuffer
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %1 "main"
OpExecutionMode %1 OriginLowerLeft
OpTypeForwardPointer %2 CrossWorkgroup
%int = OpTypeInt 32 1
%2 = OpTypePointer Function %int
%void = OpTypeVoid
%3 = OpTypeFunction %void
%1 = OpFunction %void None %3
%4 = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(spirv, SPV_ENV_UNIVERSAL_1_3);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Storage class in OpTypeForwardPointer does not match the "
"pointer definition.\n OpTypeForwardPointer "
"%_ptr_Function_int CrossWorkgroup"));
}
Only allow previously declared forward refs in structs (#2920) Fixes https://crbug.com/1008130 * Restore a missing check that the only valid forward references in structs are previously declared forward pointers
2019-09-25 22:11:22 +00:00
TEST_F(ValidateIdWithMessage, MissingForwardPointer) {
const std::string spirv = R"(
OpCapability Linkage
OpCapability Shader
OpMemoryModel Logical Simple
%float = OpTypeFloat 32
%_struct_9 = OpTypeStruct %float %_ptr_Uniform__struct_9
%_ptr_Uniform__struct_9 = OpTypePointer Uniform %_struct_9
%1278 = OpVariable %_ptr_Uniform__struct_9 Uniform
)";
CompileSuccessfully(spirv);
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"Operand 3[%_ptr_Uniform__struct_2] requires a previous definition"));
}
Move tests into namespaces (#1689) This CL moves the test into namespaces based on their directories.
2018-07-11 13:24:49 +00:00
} // namespace
} // namespace val
} // namespace spvtools
Reference in New Issue Copy Permalink