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
4075b921f9
SPIRV-Tools/source/val/validate_builtins.cpp

3185 lines
132 KiB
C++
Raw Normal View History

Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// Copyright (c) 2018 Google LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Validates correctness of built-in variables.
Move validation files to val/ directory (#1692) This CL moves the various validate files into the val/ directory with the rest of the validation infrastructure. This matches how opt/ is setup with the passes with the infrastructure.
2018-07-11 14:27:34 +00:00
#include "source/val/validate.h"
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
#include <functional>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <stack>
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 <string>
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
#include <unordered_map>
#include <vector>
Move validation files to val/ directory (#1692) This CL moves the various validate files into the val/ directory with the rest of the validation infrastructure. This matches how opt/ is setup with the passes with the infrastructure.
2018-07-11 14:27:34 +00:00
#include "source/diagnostic.h"
#include "source/opcode.h"
#include "source/spirv_target_env.h"
#include "source/util/bitutils.h"
#include "source/val/instruction.h"
#include "source/val/validation_state.h"
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
Change libspirv to spvtools namespace (#1678) This CL changes all of the libspirv namespace code to spvtools to match the rest of the code base.
2018-07-07 13:38:00 +00:00
namespace spvtools {
Move the validation code into the val:: namespace (#1682) This CL moves the validation code to the val:: namespace. This makes it clearer which instance of the Instruction and other classes are being referred too.
2018-07-10 03:18:44 +00:00
namespace val {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
namespace {
// Returns a short textual description of the id defined by the given
// instruction.
std::string GetIdDesc(const Instruction& inst) {
std::ostringstream ss;
ss << "ID <" << inst.id() << "> (Op" << spvOpcodeString(inst.opcode()) << ")";
return ss.str();
}
// Gets underlying data type which is
// - member type if instruction is OpTypeStruct
// (member index is taken from decoration).
// - data type if id creates a pointer.
// - type of the constant if instruction is OpConst or OpSpecConst.
//
// Fails in any other case. The function is based on built-ins allowed by
// the Vulkan spec.
// TODO: If non-Vulkan validation rules are added then it might need
// to be refactored.
Change handling of unknown extentions in validtor. (#1951) This commit will change the message for unknown extensions from an error to a warning. Code was added to limit the number of warning messages so that consummer of the messages are not overwhelmed. This is standard practice in compilers. Many other issues were found at while looking into this. They have been documented in #1950. Fixes http://crbug.com/875547.
2018-10-03 19:59:40 +00:00
spv_result_t GetUnderlyingType(ValidationState_t& _,
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
const Decoration& decoration,
const Instruction& inst,
uint32_t* underlying_type) {
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
Remove asserts from GetUnderlyingType (#2646) Fixes #2463
2019-05-31 15:57:41 +00:00
if (inst.opcode() != SpvOpTypeStruct) {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< GetIdDesc(inst)
<< "Attempted to get underlying data type via member index for "
"non-struct type.";
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
*underlying_type = inst.word(decoration.struct_member_index() + 2);
return SPV_SUCCESS;
}
Remove asserts from GetUnderlyingType (#2646) Fixes #2463
2019-05-31 15:57:41 +00:00
if (inst.opcode() == SpvOpTypeStruct) {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< GetIdDesc(inst)
<< " did not find an member index to get underlying data type for "
"struct type.";
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (spvOpcodeIsConstant(inst.opcode())) {
*underlying_type = inst.type_id();
return SPV_SUCCESS;
}
uint32_t storage_class = 0;
if (!_.GetPointerTypeInfo(inst.type_id(), underlying_type, &storage_class)) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< GetIdDesc(inst)
<< " is decorated with BuiltIn. BuiltIn decoration should only be "
"applied to struct types, variables and constants.";
}
return SPV_SUCCESS;
}
// Returns Storage Class used by the instruction if applicable.
// Returns SpvStorageClassMax if not.
SpvStorageClass GetStorageClass(const Instruction& inst) {
switch (inst.opcode()) {
case SpvOpTypePointer:
case SpvOpTypeForwardPointer: {
return SpvStorageClass(inst.word(2));
}
case SpvOpVariable: {
return SpvStorageClass(inst.word(3));
}
case SpvOpGenericCastToPtrExplicit: {
return SpvStorageClass(inst.word(4));
}
default: { break; }
}
return SpvStorageClassMax;
}
Add whitelist of allowed BuiltIn decorations for WebGPU (#2337) Part of resolving #2276
2019-01-30 20:46:02 +00:00
bool IsBuiltInValidForWebGPU(SpvBuiltIn label) {
switch (label) {
case SpvBuiltInPosition:
case SpvBuiltInVertexIndex:
case SpvBuiltInInstanceIndex:
case SpvBuiltInFrontFacing:
case SpvBuiltInFragCoord:
case SpvBuiltInFragDepth:
case SpvBuiltInNumWorkgroups:
case SpvBuiltInWorkgroupSize:
case SpvBuiltInLocalInvocationId:
case SpvBuiltInGlobalInvocationId:
case SpvBuiltInLocalInvocationIndex: {
return true;
}
default:
break;
}
return false;
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// Helper class managing validation of built-ins.
// TODO: Generic functionality of this class can be moved into
// ValidationState_t to be made available to other users.
class BuiltInsValidator {
public:
Change handling of unknown extentions in validtor. (#1951) This commit will change the message for unknown extensions from an error to a warning. Code was added to limit the number of warning messages so that consummer of the messages are not overwhelmed. This is standard practice in compilers. Many other issues were found at while looking into this. They have been documented in #1950. Fixes http://crbug.com/875547.
2018-10-03 19:59:40 +00:00
BuiltInsValidator(ValidationState_t& vstate) : _(vstate) {}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// Run validation.
spv_result_t Run();
private:
// Goes through all decorations in the module, if decoration is BuiltIn
Fix major bug in validate_builtins Fixed an early return in the loop, resulting in only one decoration being checked.
2018-04-03 20:07:55 +00:00
// calls ValidateSingleBuiltInAtDefinition().
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t ValidateBuiltInsAtDefinition();
Fix major bug in validate_builtins Fixed an early return in the loop, resulting in only one decoration being checked.
2018-04-03 20:07:55 +00:00
// Validates the instruction defining an id with built-in decoration.
// Can be called multiple times for the same id, if multiple built-ins are
// specified. Seeds id_to_at_reference_checks_ with decorated ids if needed.
spv_result_t ValidateSingleBuiltInAtDefinition(const Decoration& decoration,
const Instruction& inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// The following section contains functions which are called when id defined
// by |inst| is decorated with BuiltIn |decoration|.
// Most functions are specific to a single built-in and have naming scheme:
// ValidateXYZAtDefinition. Some functions are common to multiple kinds of
// BuiltIn.
spv_result_t ValidateClipOrCullDistanceAtDefinition(
const Decoration& decoration, const Instruction& inst);
spv_result_t ValidateFragCoordAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateFragDepthAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateFrontFacingAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateHelperInvocationAtDefinition(
const Decoration& decoration, const Instruction& inst);
spv_result_t ValidateInvocationIdAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateInstanceIndexAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateLayerOrViewportIndexAtDefinition(
const Decoration& decoration, const Instruction& inst);
spv_result_t ValidatePatchVerticesAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidatePointCoordAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidatePointSizeAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidatePositionAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidatePrimitiveIdAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateSampleIdAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateSampleMaskAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateSamplePositionAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateTessCoordAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateTessLevelOuterAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateTessLevelInnerAtDefinition(const Decoration& decoration,
const Instruction& inst);
spv_result_t ValidateVertexIndexAtDefinition(const Decoration& decoration,
const Instruction& inst);
Validate that VertexId and InstanceId are not allowed in Vulkan. (#2036) The Vulkan specification does not permit use of the VertexId and InstanceId BuiltIn decorations, so add a check to ensure they are not being used when the target environment is Vulkan.
2018-11-13 14:22:49 +00:00
spv_result_t ValidateVertexIdOrInstanceIdAtDefinition(
Allow InstanceId for NV ray tracing (#2049) * Allow InstanceId for NV ray tracing Fixes #2046 * Allows InstanceId in the Vulkan environment if RayTracingNV capability is specified
2018-11-14 20:03:40 +00:00
const Decoration& decoration, const Instruction& inst);
Add WebGPU validation for LocalInvocationIndex BuiltIn decoration (#2335) Part of resolving #2276
2019-01-30 20:45:31 +00:00
spv_result_t ValidateLocalInvocationIndexAtDefinition(
const Decoration& decoration, const Instruction& inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t ValidateWorkgroupSizeAtDefinition(const Decoration& decoration,
const Instruction& inst);
// Used for GlobalInvocationId, LocalInvocationId, NumWorkgroups, WorkgroupId.
spv_result_t ValidateComputeShaderI32Vec3InputAtDefinition(
const Decoration& decoration, const Instruction& inst);
Add builtin validation for SPV_NV_shader_sm_builtins (#2656) Also add a Builtin test generator variant that takes capabilities and extensions. Tests - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in Vertex, Fragment, TessControl, TessEval, Geometry, and Compute. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in MeshNV and TaskNV shaders. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in the 6 ray tracing stages - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as Outputs. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-scalar integers (f32, uvec3) - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-32-bit integers (u64)
2019-06-06 18:53:48 +00:00
spv_result_t ValidateSMBuiltinsAtDefinition(const Decoration& decoration,
const Instruction& inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
Add validation for Subgroup builtins (#2637) Fixes #2611 * Validates builtins in the Vulkan environment: * NumSubgroups * SubgroupId * SubgroupEqMask * SubgroupGeMask * SubgroupGtMask * SubgroupLeMask * SubgroupLtMask * SubgroupLocalInvocationId * SubgroupSize
2019-06-13 12:47:05 +00:00
// Used for SubgroupEqMask, SubgroupGeMask, SubgroupGtMask, SubgroupLtMask,
// SubgroupLeMask.
spv_result_t ValidateI32Vec4InputAtDefinition(const Decoration& decoration,
const Instruction& inst);
// Used for SubgroupLocalInvocationId, SubgroupSize.
spv_result_t ValidateI32InputAtDefinition(const Decoration& decoration,
const Instruction& inst);
// Used for SubgroupId, NumSubgroups.
spv_result_t ValidateComputeI32InputAtDefinition(const Decoration& decoration,
const Instruction& inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// The following section contains functions which are called when id defined
// by |referenced_inst| is
// 1. referenced by |referenced_from_inst|
// 2. dependent on |built_in_inst| which is decorated with BuiltIn
// |decoration|. Most functions are specific to a single built-in and have
// naming scheme: ValidateXYZAtReference. Some functions are common to
// multiple kinds of BuiltIn.
spv_result_t ValidateFragCoordAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateFragDepthAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateFrontFacingAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateHelperInvocationAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateInvocationIdAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
Add precise check for allowing use of gl_InstanceID for specific vulkan raytracing stages . (#2096) * Checks that gl_InstanceID is only used in specific execution models
2018-11-27 13:35:29 +00:00
spv_result_t ValidateInstanceIdAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t ValidateInstanceIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidatePatchVerticesAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidatePointCoordAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidatePointSizeAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidatePositionAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidatePrimitiveIdAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateSampleIdAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateSampleMaskAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateSamplePositionAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateTessCoordAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateTessLevelAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
Add WebGPU validation for LocalInvocationIndex BuiltIn decoration (#2335) Part of resolving #2276
2019-01-30 20:45:31 +00:00
spv_result_t ValidateLocalInvocationIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t ValidateVertexIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateLayerOrViewportIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateWorkgroupSizeAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
spv_result_t ValidateClipOrCullDistanceAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
// Used for GlobalInvocationId, LocalInvocationId, NumWorkgroups, WorkgroupId.
spv_result_t ValidateComputeShaderI32Vec3InputAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
Add validation for Subgroup builtins (#2637) Fixes #2611 * Validates builtins in the Vulkan environment: * NumSubgroups * SubgroupId * SubgroupEqMask * SubgroupGeMask * SubgroupGtMask * SubgroupLeMask * SubgroupLtMask * SubgroupLocalInvocationId * SubgroupSize
2019-06-13 12:47:05 +00:00
// Used for SubgroupId and NumSubgroups.
spv_result_t ValidateComputeI32InputAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
Add builtin validation for SPV_NV_shader_sm_builtins (#2656) Also add a Builtin test generator variant that takes capabilities and extensions. Tests - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in Vertex, Fragment, TessControl, TessEval, Geometry, and Compute. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in MeshNV and TaskNV shaders. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in the 6 ray tracing stages - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as Outputs. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-scalar integers (f32, uvec3) - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-32-bit integers (u64)
2019-06-06 18:53:48 +00:00
spv_result_t ValidateSMBuiltinsAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// Validates that |built_in_inst| is not (even indirectly) referenced from
// within a function which can be called with |execution_model|.
//
// |comment| - text explaining why the restriction was imposed.
// |decoration| - BuiltIn decoration which causes the restriction.
// |referenced_inst| - instruction which is dependent on |built_in_inst| and
// defines the id which was referenced.
// |referenced_from_inst| - instruction which references id defined by
// |referenced_inst| from within a function.
spv_result_t ValidateNotCalledWithExecutionModel(
const char* comment, SpvExecutionModel execution_model,
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst);
// The following section contains functions which check that the decorated
// variable has the type specified in the function name. |diag| would be
// called with a corresponding error message, if validation is not successful.
spv_result_t ValidateBool(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag);
spv_result_t ValidateI32(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag);
spv_result_t ValidateI32Vec(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag);
spv_result_t ValidateI32Arr(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag);
Allow arrays of out per-primitive builtins for mesh shaders (#2617) - PrimitiveID, Layer, ViewportIndex * Add validation tests for mesh builtins
2019-05-23 19:08:59 +00:00
spv_result_t ValidateOptionalArrayedI32(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag);
spv_result_t ValidateI32Helper(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t ValidateF32(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag);
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
spv_result_t ValidateOptionalArrayedF32(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag);
spv_result_t ValidateF32Helper(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t ValidateF32Vec(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag);
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
spv_result_t ValidateOptionalArrayedF32Vec(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag);
spv_result_t ValidateF32VecHelper(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// If |num_components| is zero, the number of components is not checked.
spv_result_t ValidateF32Arr(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag);
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
spv_result_t ValidateOptionalArrayedF32Arr(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag);
spv_result_t ValidateF32ArrHelper(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// Generates strings like "Member #0 of struct ID <2>".
std::string GetDefinitionDesc(const Decoration& decoration,
const Instruction& inst) const;
// Generates strings like "ID <51> (OpTypePointer) is referencing ID <2>
// (OpTypeStruct) which is decorated with BuiltIn Position".
std::string GetReferenceDesc(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst,
SpvExecutionModel execution_model = SpvExecutionModelMax) const;
// Generates strings like "ID <51> (OpTypePointer) uses storage class
// UniformConstant".
std::string GetStorageClassDesc(const Instruction& inst) const;
// Updates inner working of the class. Is called sequentially for every
// instruction.
void Update(const Instruction& inst);
Change handling of unknown extentions in validtor. (#1951) This commit will change the message for unknown extensions from an error to a warning. Code was added to limit the number of warning messages so that consummer of the messages are not overwhelmed. This is standard practice in compilers. Many other issues were found at while looking into this. They have been documented in #1950. Fixes http://crbug.com/875547.
2018-10-03 19:59:40 +00:00
ValidationState_t& _;
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// Mapping id -> list of rules which validate instruction referencing the
// id. Rules can create new rules and add them to this container.
// Using std::map, and not std::unordered_map to avoid iterator invalidation
// during rehashing.
std::map<uint32_t, std::list<std::function<spv_result_t(const Instruction&)>>>
id_to_at_reference_checks_;
// Id of the function we are currently inside. 0 if not inside a function.
uint32_t function_id_ = 0;
// Entry points which can (indirectly) call the current function.
// The pointer either points to a vector inside to function_to_entry_points_
// or to no_entry_points_. The pointer is guaranteed to never be null.
const std::vector<uint32_t> no_entry_points;
const std::vector<uint32_t>* entry_points_ = &no_entry_points;
Execution mode/model available in validation state Refactored validate built-ins to make GetExecutionModels(entry_point) and GetExecutionModes(entry_point) available in validation state. Entry points are allowed to have multiple execution modes and execution models. Finished the last missing feature in Vulkan built-ins validation: FragDepth requires DepthReplacing.
2018-03-27 15:13:39 +00:00
// Execution models with which the current function can be called.
std::set<SpvExecutionModel> execution_models_;
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
};
void BuiltInsValidator::Update(const Instruction& inst) {
const SpvOp opcode = inst.opcode();
if (opcode == SpvOpFunction) {
// Entering a function.
assert(function_id_ == 0);
function_id_ = inst.id();
execution_models_.clear();
Fixes #1483. Validating Vulkan 1.1 barrier execution scopes * Reworked how execution model limitations are checked * Now OpFunction checks which entry points call it and checks its registered limitations instead of building a call stack in the entry point * New tests * Moving function to entry point mapping into VState
2018-04-16 17:58:11 +00:00
entry_points_ = &_.FunctionEntryPoints(function_id_);
// Collect execution models from all entry points from which the current
// function can be called.
for (const uint32_t entry_point : *entry_points_) {
if (const auto* models = _.GetExecutionModels(entry_point)) {
execution_models_.insert(models->begin(), models->end());
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
}
}
if (opcode == SpvOpFunctionEnd) {
// Exiting a function.
assert(function_id_ != 0);
function_id_ = 0;
entry_points_ = &no_entry_points;
execution_models_.clear();
}
}
std::string BuiltInsValidator::GetDefinitionDesc(
const Decoration& decoration, const Instruction& inst) const {
std::ostringstream ss;
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
assert(inst.opcode() == SpvOpTypeStruct);
ss << "Member #" << decoration.struct_member_index();
ss << " of struct ID <" << inst.id() << ">";
} else {
ss << GetIdDesc(inst);
}
return ss.str();
}
std::string BuiltInsValidator::GetReferenceDesc(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst, const Instruction& referenced_from_inst,
SpvExecutionModel execution_model) const {
std::ostringstream ss;
ss << GetIdDesc(referenced_from_inst) << " is referencing "
<< GetIdDesc(referenced_inst);
if (built_in_inst.id() != referenced_inst.id()) {
ss << " which is dependent on " << GetIdDesc(built_in_inst);
}
ss << " which is decorated with BuiltIn ";
ss << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0]);
if (function_id_) {
ss << " in function <" << function_id_ << ">";
if (execution_model != SpvExecutionModelMax) {
ss << " called with execution model ";
ss << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_EXECUTION_MODEL,
execution_model);
}
}
ss << ".";
return ss.str();
}
std::string BuiltInsValidator::GetStorageClassDesc(
const Instruction& inst) const {
std::ostringstream ss;
ss << GetIdDesc(inst) << " uses storage class ";
ss << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_STORAGE_CLASS,
GetStorageClass(inst));
ss << ".";
return ss.str();
}
spv_result_t BuiltInsValidator::ValidateBool(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
if (!_.IsBoolScalarType(underlying_type)) {
return diag(GetDefinitionDesc(decoration, inst) + " is not a bool scalar.");
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateI32(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
Allow arrays of out per-primitive builtins for mesh shaders (#2617) - PrimitiveID, Layer, ViewportIndex * Add validation tests for mesh builtins
2019-05-23 19:08:59 +00:00
return ValidateI32Helper(decoration, inst, diag, underlying_type);
}
spv_result_t BuiltInsValidator::ValidateOptionalArrayedI32(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
// Strip the array, if present.
if (_.GetIdOpcode(underlying_type) == SpvOpTypeArray) {
underlying_type = _.FindDef(underlying_type)->word(2u);
}
return ValidateI32Helper(decoration, inst, diag, underlying_type);
}
spv_result_t BuiltInsValidator::ValidateI32Helper(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (!_.IsIntScalarType(underlying_type)) {
return diag(GetDefinitionDesc(decoration, inst) + " is not an int scalar.");
}
const uint32_t bit_width = _.GetBitWidth(underlying_type);
if (bit_width != 32) {
std::ostringstream ss;
ss << GetDefinitionDesc(decoration, inst) << " has bit width " << bit_width
<< ".";
return diag(ss.str());
}
return SPV_SUCCESS;
}
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
spv_result_t BuiltInsValidator::ValidateOptionalArrayedF32(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
// Strip the array, if present.
if (_.GetIdOpcode(underlying_type) == SpvOpTypeArray) {
underlying_type = _.FindDef(underlying_type)->word(2u);
}
return ValidateF32Helper(decoration, inst, diag, underlying_type);
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t BuiltInsValidator::ValidateF32(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
return ValidateF32Helper(decoration, inst, diag, underlying_type);
}
spv_result_t BuiltInsValidator::ValidateF32Helper(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (!_.IsFloatScalarType(underlying_type)) {
return diag(GetDefinitionDesc(decoration, inst) +
" is not a float scalar.");
}
const uint32_t bit_width = _.GetBitWidth(underlying_type);
if (bit_width != 32) {
std::ostringstream ss;
ss << GetDefinitionDesc(decoration, inst) << " has bit width " << bit_width
<< ".";
return diag(ss.str());
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateI32Vec(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
if (!_.IsIntVectorType(underlying_type)) {
return diag(GetDefinitionDesc(decoration, inst) + " is not an int vector.");
}
const uint32_t actual_num_components = _.GetDimension(underlying_type);
if (_.GetDimension(underlying_type) != num_components) {
std::ostringstream ss;
ss << GetDefinitionDesc(decoration, inst) << " has "
<< actual_num_components << " components.";
return diag(ss.str());
}
const uint32_t bit_width = _.GetBitWidth(underlying_type);
if (bit_width != 32) {
std::ostringstream ss;
ss << GetDefinitionDesc(decoration, inst)
<< " has components with bit width " << bit_width << ".";
return diag(ss.str());
}
return SPV_SUCCESS;
}
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
spv_result_t BuiltInsValidator::ValidateOptionalArrayedF32Vec(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
// Strip the array, if present.
if (_.GetIdOpcode(underlying_type) == SpvOpTypeArray) {
underlying_type = _.FindDef(underlying_type)->word(2u);
}
return ValidateF32VecHelper(decoration, inst, num_components, diag,
underlying_type);
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t BuiltInsValidator::ValidateF32Vec(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
return ValidateF32VecHelper(decoration, inst, num_components, diag,
underlying_type);
}
spv_result_t BuiltInsValidator::ValidateF32VecHelper(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (!_.IsFloatVectorType(underlying_type)) {
return diag(GetDefinitionDesc(decoration, inst) +
" is not a float vector.");
}
const uint32_t actual_num_components = _.GetDimension(underlying_type);
if (_.GetDimension(underlying_type) != num_components) {
std::ostringstream ss;
ss << GetDefinitionDesc(decoration, inst) << " has "
<< actual_num_components << " components.";
return diag(ss.str());
}
const uint32_t bit_width = _.GetBitWidth(underlying_type);
if (bit_width != 32) {
std::ostringstream ss;
ss << GetDefinitionDesc(decoration, inst)
<< " has components with bit width " << bit_width << ".";
return diag(ss.str());
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateI32Arr(
const Decoration& decoration, const Instruction& inst,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
const Instruction* const type_inst = _.FindDef(underlying_type);
if (type_inst->opcode() != SpvOpTypeArray) {
return diag(GetDefinitionDesc(decoration, inst) + " is not an array.");
}
const uint32_t component_type = type_inst->word(2);
if (!_.IsIntScalarType(component_type)) {
return diag(GetDefinitionDesc(decoration, inst) +
" components are not int scalar.");
}
const uint32_t bit_width = _.GetBitWidth(component_type);
if (bit_width != 32) {
std::ostringstream ss;
ss << GetDefinitionDesc(decoration, inst)
<< " has components with bit width " << bit_width << ".";
return diag(ss.str());
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateF32Arr(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
return ValidateF32ArrHelper(decoration, inst, num_components, diag,
underlying_type);
}
spv_result_t BuiltInsValidator::ValidateOptionalArrayedF32Arr(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag) {
uint32_t underlying_type = 0;
if (spv_result_t error =
GetUnderlyingType(_, decoration, inst, &underlying_type)) {
return error;
}
// Strip an extra layer of arraying if present.
if (_.GetIdOpcode(underlying_type) == SpvOpTypeArray) {
uint32_t subtype = _.FindDef(underlying_type)->word(2u);
if (_.GetIdOpcode(subtype) == SpvOpTypeArray) {
underlying_type = subtype;
}
}
return ValidateF32ArrHelper(decoration, inst, num_components, diag,
underlying_type);
}
spv_result_t BuiltInsValidator::ValidateF32ArrHelper(
const Decoration& decoration, const Instruction& inst,
uint32_t num_components,
const std::function<spv_result_t(const std::string& message)>& diag,
uint32_t underlying_type) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
const Instruction* const type_inst = _.FindDef(underlying_type);
if (type_inst->opcode() != SpvOpTypeArray) {
return diag(GetDefinitionDesc(decoration, inst) + " is not an array.");
}
const uint32_t component_type = type_inst->word(2);
if (!_.IsFloatScalarType(component_type)) {
return diag(GetDefinitionDesc(decoration, inst) +
" components are not float scalar.");
}
const uint32_t bit_width = _.GetBitWidth(component_type);
if (bit_width != 32) {
std::ostringstream ss;
ss << GetDefinitionDesc(decoration, inst)
<< " has components with bit width " << bit_width << ".";
return diag(ss.str());
}
if (num_components != 0) {
uint64_t actual_num_components = 0;
if (!_.GetConstantValUint64(type_inst->word(3), &actual_num_components)) {
assert(0 && "Array type definition is corrupt");
}
if (actual_num_components != num_components) {
std::ostringstream ss;
ss << GetDefinitionDesc(decoration, inst) << " has "
<< actual_num_components << " components.";
return diag(ss.str());
}
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateNotCalledWithExecutionModel(
const char* comment, SpvExecutionModel execution_model,
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (function_id_) {
if (execution_models_.count(execution_model)) {
const char* execution_model_str = _.grammar().lookupOperandName(
SPV_OPERAND_TYPE_EXECUTION_MODEL, execution_model);
const char* built_in_str = _.grammar().lookupOperandName(
SPV_OPERAND_TYPE_BUILT_IN, decoration.params()[0]);
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< comment << " " << GetIdDesc(referenced_inst) << " depends on "
<< GetIdDesc(built_in_inst) << " which is decorated with BuiltIn "
<< built_in_str << "."
<< " Id <" << referenced_inst.id() << "> is later referenced by "
<< GetIdDesc(referenced_from_inst) << " in function <"
<< function_id_ << "> which is called with execution model "
<< execution_model_str << ".";
}
} else {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(
std::bind(&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
comment, execution_model, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateClipOrCullDistanceAtDefinition(
const Decoration& decoration, const Instruction& inst) {
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateClipOrCullDistanceAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateClipOrCullDistanceAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput &&
storage_class != SpvStorageClassOutput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be only used for variables with Input or Output storage "
"class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
if (storage_class == SpvStorageClassInput) {
assert(function_id_ == 0);
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
"Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance to be "
"used for variables with Input storage class if execution model is "
"Vertex.",
SpvExecutionModelVertex, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
}
if (storage_class == SpvStorageClassOutput) {
assert(function_id_ == 0);
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
"Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance to be "
"used for variables with Output storage class if execution model is "
"Fragment.",
SpvExecutionModelFragment, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
}
for (const SpvExecutionModel execution_model : execution_models_) {
switch (execution_model) {
case SpvExecutionModelFragment:
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
case SpvExecutionModelVertex: {
if (spv_result_t error = ValidateF32Arr(
decoration, built_in_inst, /* Any number of components */ 0,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &decoration, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "According to the Vulkan spec BuiltIn "
<< _.grammar().lookupOperandName(
SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " variable needs to be a 32-bit float array. "
<< message;
})) {
return error;
}
break;
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
case SpvExecutionModelTessellationControl:
case SpvExecutionModelTessellationEvaluation:
Add support for Nvidia Turing extensions
2018-09-19 18:53:33 +00:00
case SpvExecutionModelGeometry:
case SpvExecutionModelMeshNV: {
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
// The outer level of array is applied on the variable.
if (spv_result_t error = ValidateF32Arr(
decoration, built_in_inst, /* Any number of components */ 0,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &decoration, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA,
&referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "According to the Vulkan spec BuiltIn "
<< _.grammar().lookupOperandName(
SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " variable needs to be a 32-bit float array. "
<< message;
})) {
return error;
}
} else {
if (spv_result_t error = ValidateOptionalArrayedF32Arr(
decoration, built_in_inst, /* Any number of components */ 0,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &decoration, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA,
&referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "According to the Vulkan spec BuiltIn "
<< _.grammar().lookupOperandName(
SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " variable needs to be a 32-bit float array. "
<< message;
})) {
return error;
}
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
break;
}
default: {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be used only with Fragment, Vertex, "
"TessellationControl, TessellationEvaluation or Geometry "
"execution models. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(
std::bind(&BuiltInsValidator::ValidateClipOrCullDistanceAtReference,
this, decoration, built_in_inst, referenced_from_inst,
std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateFragCoordAtDefinition(
const Decoration& decoration, const Instruction& inst) {
Add WebGPU specific validation for FragCoord BuiltIn decoration (#2331) Part of resolving #2276
2019-01-30 19:53:43 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (spv_result_t error = ValidateF32Vec(
decoration, inst, 4,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add WebGPU specific validation for FragCoord BuiltIn decoration (#2331) Part of resolving #2276
2019-01-30 19:53:43 +00:00
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn FragCoord "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variable needs to be a 4-component 32-bit float "
"vector. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateFragCoordAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateFragCoordAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
Add WebGPU specific validation for FragCoord BuiltIn decoration (#2331) Part of resolving #2276
2019-01-30 19:53:43 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for FragCoord BuiltIn decoration (#2331) Part of resolving #2276
2019-01-30 19:53:43 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn FragCoord to be only used for "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelFragment) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for FragCoord BuiltIn decoration (#2331) Part of resolving #2276
2019-01-30 19:53:43 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn FragCoord to be used only with "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"Fragment execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateFragCoordAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateFragDepthAtDefinition(
const Decoration& decoration, const Instruction& inst) {
Add WebGPU specific validation for FragDepth BuiltIn decoration (#2332) Part of resolving #2276
2019-01-30 20:27:04 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (spv_result_t error = ValidateF32(
decoration, inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add WebGPU specific validation for FragDepth BuiltIn decoration (#2332) Part of resolving #2276
2019-01-30 20:27:04 +00:00
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn FragDepth "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variable needs to be a 32-bit float scalar. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateFragDepthAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateFragDepthAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
Add WebGPU specific validation for FragDepth BuiltIn decoration (#2332) Part of resolving #2276
2019-01-30 20:27:04 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassOutput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for FragDepth BuiltIn decoration (#2332) Part of resolving #2276
2019-01-30 20:27:04 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn FragDepth to be only used for "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variables with Output storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelFragment) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for FragDepth BuiltIn decoration (#2332) Part of resolving #2276
2019-01-30 20:27:04 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn FragDepth to be used only with "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"Fragment execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
Execution mode/model available in validation state Refactored validate built-ins to make GetExecutionModels(entry_point) and GetExecutionModes(entry_point) available in validation state. Entry points are allowed to have multiple execution modes and execution models. Finished the last missing feature in Vulkan built-ins validation: FragDepth requires DepthReplacing.
2018-03-27 15:13:39 +00:00
for (const uint32_t entry_point : *entry_points_) {
// Every entry point from which this function is called needs to have
// Execution Mode DepthReplacing.
const auto* modes = _.GetExecutionModes(entry_point);
if (!modes || !modes->count(SpvExecutionModeDepthReplacing)) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for FragDepth BuiltIn decoration (#2332) Part of resolving #2276
2019-01-30 20:27:04 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec requires DepthReplacing execution mode to be "
Execution mode/model available in validation state Refactored validate built-ins to make GetExecutionModels(entry_point) and GetExecutionModes(entry_point) available in validation state. Entry points are allowed to have multiple execution modes and execution models. Finished the last missing feature in Vulkan built-ins validation: FragDepth requires DepthReplacing.
2018-03-27 15:13:39 +00:00
"declared when using BuiltIn FragDepth. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst);
}
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateFragDepthAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateFrontFacingAtDefinition(
const Decoration& decoration, const Instruction& inst) {
Add WebGPU specific validation for FrontFacing BuiltIn decoration (#2330) Part of resolving #2276
2019-01-30 19:48:43 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (spv_result_t error = ValidateBool(
decoration, inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add WebGPU specific validation for FrontFacing BuiltIn decoration (#2330) Part of resolving #2276
2019-01-30 19:48:43 +00:00
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn FrontFacing "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variable needs to be a bool scalar. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateFrontFacingAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateFrontFacingAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
Add WebGPU specific validation for FrontFacing BuiltIn decoration (#2330) Part of resolving #2276
2019-01-30 19:48:43 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for FrontFacing BuiltIn decoration (#2330) Part of resolving #2276
2019-01-30 19:48:43 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn FrontFacing to be only used for "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelFragment) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for FrontFacing BuiltIn decoration (#2330) Part of resolving #2276
2019-01-30 19:48:43 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn FrontFacing to be used only with "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"Fragment execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateFrontFacingAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateHelperInvocationAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateBool(
decoration, inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn HelperInvocation "
"variable needs to be a bool scalar. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateHelperInvocationAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateHelperInvocationAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn HelperInvocation to be only used "
"for variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelFragment) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn HelperInvocation to be used only "
"with Fragment execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(
std::bind(&BuiltInsValidator::ValidateHelperInvocationAtReference, this,
decoration, built_in_inst, referenced_from_inst,
std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateInvocationIdAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32(
decoration, inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn InvocationId "
"variable needs to be a 32-bit int scalar. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateInvocationIdAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateInvocationIdAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn InvocationId to be only used for "
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelTessellationControl &&
execution_model != SpvExecutionModelGeometry) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn InvocationId to be used only "
"with TessellationControl or Geometry execution models. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateInvocationIdAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateInstanceIndexAtDefinition(
const Decoration& decoration, const Instruction& inst) {
Add WebGPU specific validation for InstanceIndex BuiltIn decoration (#2329) Part of resolving #2276
2019-01-30 19:20:55 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (spv_result_t error = ValidateI32(
decoration, inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add WebGPU specific validation for InstanceIndex BuiltIn decoration (#2329) Part of resolving #2276
2019-01-30 19:20:55 +00:00
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn InstanceIndex "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variable needs to be a 32-bit int scalar. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateInstanceIndexAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateInstanceIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
Add WebGPU specific validation for InstanceIndex BuiltIn decoration (#2329) Part of resolving #2276
2019-01-30 19:20:55 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for InstanceIndex BuiltIn decoration (#2329) Part of resolving #2276
2019-01-30 19:20:55 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn InstanceIndex to be only used for "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelVertex) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for InstanceIndex BuiltIn decoration (#2329) Part of resolving #2276
2019-01-30 19:20:55 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn InstanceIndex to be used only "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"with Vertex execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateInstanceIndexAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidatePatchVerticesAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32(
decoration, inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn PatchVertices "
"variable needs to be a 32-bit int scalar. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidatePatchVerticesAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidatePatchVerticesAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn PatchVertices to be only used for "
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelTessellationControl &&
execution_model != SpvExecutionModelTessellationEvaluation) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn PatchVertices to be used only "
"with TessellationControl or TessellationEvaluation "
"execution models. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidatePatchVerticesAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidatePointCoordAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateF32Vec(
decoration, inst, 2,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn PointCoord "
"variable needs to be a 2-component 32-bit float "
"vector. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidatePointCoordAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidatePointCoordAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn PointCoord to be only used for "
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelFragment) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn PointCoord to be used only with "
"Fragment execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidatePointCoordAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidatePointSizeAtDefinition(
const Decoration& decoration, const Instruction& inst) {
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidatePointSizeAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidatePointSizeAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput &&
storage_class != SpvStorageClassOutput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn PointSize to be only used for "
"variables with Input or Output storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
if (storage_class == SpvStorageClassInput) {
assert(function_id_ == 0);
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
"Vulkan spec doesn't allow BuiltIn PointSize to be used for "
"variables with Input storage class if execution model is Vertex.",
SpvExecutionModelVertex, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
}
for (const SpvExecutionModel execution_model : execution_models_) {
switch (execution_model) {
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
case SpvExecutionModelVertex: {
if (spv_result_t error = ValidateF32(
decoration, built_in_inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "According to the Vulkan spec BuiltIn PointSize "
"variable needs to be a 32-bit float scalar. "
<< message;
})) {
return error;
}
break;
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
case SpvExecutionModelTessellationControl:
case SpvExecutionModelTessellationEvaluation:
Add support for Nvidia Turing extensions
2018-09-19 18:53:33 +00:00
case SpvExecutionModelGeometry:
case SpvExecutionModelMeshNV: {
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
// PointSize can be a per-vertex variable for tessellation control,
// tessellation evaluation and geometry shader stages. In such cases
// variables will have an array of 32-bit floats.
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
// The array is on the variable, so this must be a 32-bit float.
if (spv_result_t error = ValidateF32(
decoration, built_in_inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA,
&referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "According to the Vulkan spec BuiltIn "
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
"PointSize variable needs to be a 32-bit "
"float scalar. "
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< message;
})) {
return error;
}
} else {
if (spv_result_t error = ValidateOptionalArrayedF32(
decoration, built_in_inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA,
&referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "According to the Vulkan spec BuiltIn "
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
"PointSize variable needs to be a 32-bit "
"float scalar. "
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< message;
})) {
return error;
}
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
break;
}
default: {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn PointSize to be used only with "
"Vertex, TessellationControl, TessellationEvaluation or "
"Geometry execution models. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidatePointSizeAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidatePositionAtDefinition(
const Decoration& decoration, const Instruction& inst) {
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidatePositionAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidatePositionAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput &&
storage_class != SpvStorageClassOutput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn Position to be only used for "
"variables with Input or Output storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
if (storage_class == SpvStorageClassInput) {
assert(function_id_ == 0);
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
"Vulkan spec doesn't allow BuiltIn Position to be used for variables "
"with Input storage class if execution model is Vertex.",
SpvExecutionModelVertex, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
}
for (const SpvExecutionModel execution_model : execution_models_) {
switch (execution_model) {
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
case SpvExecutionModelVertex: {
if (spv_result_t error = ValidateF32Vec(
decoration, built_in_inst, 4,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "According to the Vulkan spec BuiltIn Position "
"variable needs to be a 4-component 32-bit float "
"vector. "
<< message;
})) {
return error;
}
break;
}
case SpvExecutionModelGeometry:
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
case SpvExecutionModelTessellationControl:
Add support for Nvidia Turing extensions
2018-09-19 18:53:33 +00:00
case SpvExecutionModelTessellationEvaluation:
case SpvExecutionModelMeshNV: {
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
// Position can be a per-vertex variable for tessellation control,
Add support for Nvidia Turing extensions
2018-09-19 18:53:33 +00:00
// tessellation evaluation, geometry and mesh shader stages. In such
// cases variables will have an array of 4-component 32-bit float
// vectors.
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
// The array is on the variable, so this must be a 4-component
// 32-bit float vector.
if (spv_result_t error = ValidateF32Vec(
decoration, built_in_inst, 4,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA,
&referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "According to the Vulkan spec BuiltIn Position "
"variable needs to be a 4-component 32-bit "
"float vector. "
<< message;
})) {
return error;
}
} else {
if (spv_result_t error = ValidateOptionalArrayedF32Vec(
decoration, built_in_inst, 4,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA,
&referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "According to the Vulkan spec BuiltIn Position "
"variable needs to be a 4-component 32-bit "
"float vector. "
<< message;
})) {
return error;
}
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
break;
}
default: {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "Vulkan spec allows BuiltIn Position to be used only "
"with Vertex, TessellationControl, TessellationEvaluation"
" or Geometry execution models. "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
}
Add WebGPU specific validation for Position BuiltIn decoration (#2309) This CL adds in the specific checks required for WebGPU, enables running the builtin checks for WebGPU, and refactors the existing testing infrastructure to support testing the new checks. This PR is part of resolving #2276
2019-01-24 17:08:25 +00:00
if (spvIsWebGPUEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassOutput) {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< "WebGPU spec allows BuiltIn Position to be only used for "
"variables with Output storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
switch (execution_model) {
case SpvExecutionModelVertex: {
if (spv_result_t error = ValidateF32Vec(
decoration, built_in_inst, 4,
[this, &referenced_from_inst](
const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< "According to the WebGPU spec BuiltIn Position "
"variable needs to be a 4-component 32-bit float "
"vector. "
<< message;
})) {
return error;
}
break;
}
default: {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< "WebGPU spec allows BuiltIn Position to be used only "
"with the Vertex execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidatePositionAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidatePrimitiveIdAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
Allow arrays of out per-primitive builtins for mesh shaders (#2617) - PrimitiveID, Layer, ViewportIndex * Add validation tests for mesh builtins
2019-05-23 19:08:59 +00:00
// PrimitiveId can be a per-primitive variable for mesh shader stage.
// In such cases variable will have an array of 32-bit integers.
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
// This must be a 32-bit int scalar.
if (spv_result_t error = ValidateI32(
decoration, inst,
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "According to the Vulkan spec BuiltIn PrimitiveId "
"variable needs to be a 32-bit int scalar. "
<< message;
})) {
return error;
}
} else {
if (spv_result_t error = ValidateOptionalArrayedI32(
decoration, inst,
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "According to the Vulkan spec BuiltIn PrimitiveId "
"variable needs to be a 32-bit int scalar. "
<< message;
})) {
return error;
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidatePrimitiveIdAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidatePrimitiveIdAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput &&
storage_class != SpvStorageClassOutput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn PrimitiveId to be only used for "
"variables with Input or Output storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
Fix PrimitiveId builtin check for Vulkan According to Vulkan spec 1.1.72: > The PrimitiveId decoration must be used only within fragment, > tessellation control, tessellation evaluation, and geometry shaders. > In a tessellation control or tessellation evaluation shader, any > variable decorated with PrimitiveId must be declared using the Input > storage class. We were enforcing that PrimitiveId can only be used with Output storage class for TCS and TES before.
2018-04-07 01:04:35 +00:00
if (storage_class == SpvStorageClassOutput) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
assert(function_id_ == 0);
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
"Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for "
Fix PrimitiveId builtin check for Vulkan According to Vulkan spec 1.1.72: > The PrimitiveId decoration must be used only within fragment, > tessellation control, tessellation evaluation, and geometry shaders. > In a tessellation control or tessellation evaluation shader, any > variable decorated with PrimitiveId must be declared using the Input > storage class. We were enforcing that PrimitiveId can only be used with Output storage class for TCS and TES before.
2018-04-07 01:04:35 +00:00
"variables with Output storage class if execution model is "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"TessellationControl.",
SpvExecutionModelTessellationControl, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
"Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for "
Fix PrimitiveId builtin check for Vulkan According to Vulkan spec 1.1.72: > The PrimitiveId decoration must be used only within fragment, > tessellation control, tessellation evaluation, and geometry shaders. > In a tessellation control or tessellation evaluation shader, any > variable decorated with PrimitiveId must be declared using the Input > storage class. We were enforcing that PrimitiveId can only be used with Output storage class for TCS and TES before.
2018-04-07 01:04:35 +00:00
"variables with Output storage class if execution model is "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"TessellationEvaluation.",
SpvExecutionModelTessellationEvaluation, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
"Vulkan spec doesn't allow BuiltIn PrimitiveId to be used for "
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
"variables with Output storage class if execution model is "
"Fragment.",
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
SpvExecutionModelFragment, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
}
for (const SpvExecutionModel execution_model : execution_models_) {
switch (execution_model) {
case SpvExecutionModelFragment:
case SpvExecutionModelTessellationControl:
case SpvExecutionModelTessellationEvaluation:
Add support for Nvidia Turing extensions
2018-09-19 18:53:33 +00:00
case SpvExecutionModelGeometry:
case SpvExecutionModelMeshNV:
Add support for nv-raytracing-final (#2010) Add support for nv-raytracing (non-experimental)
2018-10-25 18:07:46 +00:00
case SpvExecutionModelRayGenerationNV:
case SpvExecutionModelIntersectionNV:
case SpvExecutionModelAnyHitNV:
case SpvExecutionModelClosestHitNV:
case SpvExecutionModelMissNV:
case SpvExecutionModelCallableNV: {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// Ok.
break;
}
default: {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn PrimitiveId to be used only "
"with Fragment, TessellationControl, "
"TessellationEvaluation or Geometry execution models. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidatePrimitiveIdAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateSampleIdAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32(
decoration, inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn SampleId "
"variable needs to be a 32-bit int scalar. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateSampleIdAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateSampleIdAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn SampleId to be only used for "
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelFragment) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn SampleId to be used only with "
"Fragment execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateSampleIdAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateSampleMaskAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32Arr(
decoration, inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn SampleMask "
"variable needs to be a 32-bit int array. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateSampleMaskAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateSampleMaskAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput &&
storage_class != SpvStorageClassOutput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn SampleMask to be only used for "
"variables with Input or Output storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelFragment) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "Vulkan spec allows BuiltIn SampleMask to be used only "
"with "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"Fragment execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateSampleMaskAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateSamplePositionAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateF32Vec(
decoration, inst, 2,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn SamplePosition "
"variable needs to be a 2-component 32-bit float "
"vector. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateSamplePositionAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateSamplePositionAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "Vulkan spec allows BuiltIn SamplePosition to be only used "
"for "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelFragment) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn SamplePosition to be used only "
"with "
"Fragment execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateSamplePositionAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateTessCoordAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateF32Vec(
decoration, inst, 3,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn TessCoord "
"variable needs to be a 3-component 32-bit float "
"vector. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateTessCoordAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateTessCoordAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn TessCoord to be only used for "
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelTessellationEvaluation) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn TessCoord to be used only with "
"TessellationEvaluation execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateTessCoordAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateTessLevelOuterAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateF32Arr(
decoration, inst, 4,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn TessLevelOuter "
"variable needs to be a 4-component 32-bit float "
"array. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateTessLevelAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateTessLevelInnerAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateF32Arr(
decoration, inst, 2,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "According to the Vulkan spec BuiltIn TessLevelOuter "
"variable needs to be a 2-component 32-bit float "
"array. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateTessLevelAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateTessLevelAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput &&
storage_class != SpvStorageClassOutput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be only used for variables with Input or Output storage "
"class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
if (storage_class == SpvStorageClassInput) {
assert(function_id_ == 0);
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
"Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be "
"used "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"for variables with Input storage class if execution model is "
"TessellationControl.",
SpvExecutionModelTessellationControl, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
}
if (storage_class == SpvStorageClassOutput) {
assert(function_id_ == 0);
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
"Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be "
"used "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"for variables with Output storage class if execution model is "
"TessellationEvaluation.",
SpvExecutionModelTessellationEvaluation, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
}
for (const SpvExecutionModel execution_model : execution_models_) {
switch (execution_model) {
case SpvExecutionModelTessellationControl:
case SpvExecutionModelTessellationEvaluation: {
// Ok.
break;
}
default: {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be used only with TessellationControl or "
"TessellationEvaluation execution models. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateTessLevelAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateVertexIndexAtDefinition(
const Decoration& decoration, const Instruction& inst) {
Add WebGPU specific validation for VertexIndex BuiltIn decoration (#2328) Part of resolving #2276
2019-01-30 17:22:30 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (spv_result_t error = ValidateI32(
decoration, inst,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add WebGPU specific validation for VertexIndex BuiltIn decoration (#2328) Part of resolving #2276
2019-01-30 17:22:30 +00:00
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn VertexIndex variable needs to be a "
"32-bit int scalar. "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateVertexIndexAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
Validate that VertexId and InstanceId are not allowed in Vulkan. (#2036) The Vulkan specification does not permit use of the VertexId and InstanceId BuiltIn decorations, so add a check to ensure they are not being used when the target environment is Vulkan.
2018-11-13 14:22:49 +00:00
spv_result_t BuiltInsValidator::ValidateVertexIdOrInstanceIdAtDefinition(
Allow InstanceId for NV ray tracing (#2049) * Allow InstanceId for NV ray tracing Fixes #2046 * Allows InstanceId in the Vulkan environment if RayTracingNV capability is specified
2018-11-14 20:03:40 +00:00
const Decoration& decoration, const Instruction& inst) {
const SpvBuiltIn label = SpvBuiltIn(decoration.params()[0]);
bool allow_instance_id = _.HasCapability(SpvCapabilityRayTracingNV) &&
label == SpvBuiltInInstanceId;
if (spvIsVulkanEnv(_.context()->target_env) && !allow_instance_id) {
Validate that VertexId and InstanceId are not allowed in Vulkan. (#2036) The Vulkan specification does not permit use of the VertexId and InstanceId BuiltIn decorations, so add a check to ensure they are not being used when the target environment is Vulkan.
2018-11-13 14:22:49 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "Vulkan spec doesn't allow BuiltIn VertexId/InstanceId "
"to be used.";
}
Add precise check for allowing use of gl_InstanceID for specific vulkan raytracing stages . (#2096) * Checks that gl_InstanceID is only used in specific execution models
2018-11-27 13:35:29 +00:00
if (label == SpvBuiltInInstanceId) {
return ValidateInstanceIdAtReference(decoration, inst, inst, inst);
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateInstanceIdAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
for (const SpvExecutionModel execution_model : execution_models_) {
switch (execution_model) {
case SpvExecutionModelIntersectionNV:
case SpvExecutionModelClosestHitNV:
case SpvExecutionModelAnyHitNV:
// Do nothing, valid stages
break;
default:
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< "Vulkan spec allows BuiltIn InstanceId to be used "
"only with IntersectionNV, ClosestHitNV and AnyHitNV "
"execution models. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst);
break;
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateInstanceIdAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
Validate that VertexId and InstanceId are not allowed in Vulkan. (#2036) The Vulkan specification does not permit use of the VertexId and InstanceId BuiltIn decorations, so add a check to ensure they are not being used when the target environment is Vulkan.
2018-11-13 14:22:49 +00:00
return SPV_SUCCESS;
}
Add WebGPU validation for LocalInvocationIndex BuiltIn decoration (#2335) Part of resolving #2276
2019-01-30 20:45:31 +00:00
spv_result_t BuiltInsValidator::ValidateLocalInvocationIndexAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsWebGPUEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32(
decoration, inst,
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "According to the WebGPU spec BuiltIn "
"LocalInvocationIndex variable needs to be a 32-bit "
"int."
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
return ValidateLocalInvocationIndexAtReference(decoration, inst, inst, inst);
}
spv_result_t BuiltInsValidator::ValidateLocalInvocationIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsWebGPUEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< "WebGPU spec allows BuiltIn LocalInvocationIndex to be only "
"used for variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelGLCompute) {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< "WebGPU spec allows BuiltIn VertexIndex to be used only "
"with GLCompute execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(
std::bind(&BuiltInsValidator::ValidateLocalInvocationIndexAtReference,
this, decoration, built_in_inst, referenced_from_inst,
std::placeholders::_1));
}
return SPV_SUCCESS;
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t BuiltInsValidator::ValidateVertexIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
Add WebGPU specific validation for VertexIndex BuiltIn decoration (#2328) Part of resolving #2276
2019-01-30 17:22:30 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for VertexIndex BuiltIn decoration (#2328) Part of resolving #2276
2019-01-30 17:22:30 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn VertexIndex to be only used for "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelVertex) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for VertexIndex BuiltIn decoration (#2328) Part of resolving #2276
2019-01-30 17:22:30 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn VertexIndex to be used only with "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"Vertex execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateVertexIndexAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateLayerOrViewportIndexAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
Allow arrays of out per-primitive builtins for mesh shaders (#2617) - PrimitiveID, Layer, ViewportIndex * Add validation tests for mesh builtins
2019-05-23 19:08:59 +00:00
// This can be a per-primitive variable for mesh shader stage.
// In such cases variable will have an array of 32-bit integers.
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
// This must be a 32-bit int scalar.
if (spv_result_t error = ValidateI32(
decoration, inst,
[this, &decoration,
&inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "According to the Vulkan spec BuiltIn "
<< _.grammar().lookupOperandName(
SPV_OPERAND_TYPE_BUILT_IN, decoration.params()[0])
<< "variable needs to be a 32-bit int scalar. "
<< message;
})) {
return error;
}
} else {
if (spv_result_t error = ValidateOptionalArrayedI32(
decoration, inst,
[this, &decoration,
&inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "According to the Vulkan spec BuiltIn "
<< _.grammar().lookupOperandName(
SPV_OPERAND_TYPE_BUILT_IN, decoration.params()[0])
<< "variable needs to be a 32-bit int scalar. "
<< message;
})) {
return error;
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateLayerOrViewportIndexAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateLayerOrViewportIndexAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput &&
storage_class != SpvStorageClassOutput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be only used for variables with Input or Output storage "
"class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
if (storage_class == SpvStorageClassInput) {
assert(function_id_ == 0);
Allow ViewportIndex & Layer to be used in VS/DS with extension SPV_EXT_shader_viewport_index_layer enables using ViewportIndex and Layer in vertex and tessellation shaders. Also, as per the Vulkan spec: > The ViewportIndex decoration must be used only within vertex, > tessellation evaluation, geometry, and fragment shaders. > In a vertex, tessellation evaluation, or geometry shader, any > variable decorated with ViewportIndex must be declared using > the Output storage class. > In a fragment shader, any variable decorated with ViewportIndex > must be declared using the Input storage class. Similarly for Layer.
2018-05-16 17:16:27 +00:00
for (const auto em :
{SpvExecutionModelVertex, SpvExecutionModelTessellationEvaluation,
SpvExecutionModelGeometry}) {
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(
std::bind(&BuiltInsValidator::ValidateNotCalledWithExecutionModel,
this,
"Vulkan spec doesn't allow BuiltIn Layer and "
"ViewportIndex to be "
"used for variables with Input storage class if "
"execution model is Vertex, TessellationEvaluation, or "
"Geometry.",
em, decoration, built_in_inst, referenced_from_inst,
std::placeholders::_1));
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
if (storage_class == SpvStorageClassOutput) {
assert(function_id_ == 0);
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateNotCalledWithExecutionModel, this,
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
"Vulkan spec doesn't allow BuiltIn Layer and "
"ViewportIndex to be "
"used for variables with Output storage class if "
"execution model is "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
"Fragment.",
SpvExecutionModelFragment, decoration, built_in_inst,
referenced_from_inst, std::placeholders::_1));
}
for (const SpvExecutionModel execution_model : execution_models_) {
switch (execution_model) {
case SpvExecutionModelGeometry:
Add support for Nvidia Turing extensions
2018-09-19 18:53:33 +00:00
case SpvExecutionModelFragment:
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
case SpvExecutionModelMeshNV:
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// Ok.
break;
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
case SpvExecutionModelVertex:
case SpvExecutionModelTessellationEvaluation: {
if (!_.HasCapability(SpvCapabilityShaderViewportIndexLayerEXT)) {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< "Using BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " in Vertex or Tessellation execution model requires "
"the ShaderViewportIndexLayerEXT capability.";
}
break;
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
default: {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< "Vulkan spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
Allow ViewportIndex & Layer to be used in VS/DS with extension SPV_EXT_shader_viewport_index_layer enables using ViewportIndex and Layer in vertex and tessellation shaders. Also, as per the Vulkan spec: > The ViewportIndex decoration must be used only within vertex, > tessellation evaluation, geometry, and fragment shaders. > In a vertex, tessellation evaluation, or geometry shader, any > variable decorated with ViewportIndex must be declared using > the Output storage class. > In a fragment shader, any variable decorated with ViewportIndex > must be declared using the Input storage class. Similarly for Layer.
2018-05-16 17:16:27 +00:00
<< " to be used only with Vertex, TessellationEvaluation, "
"Geometry, or Fragment execution models. "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(
std::bind(&BuiltInsValidator::ValidateLayerOrViewportIndexAtReference,
this, decoration, built_in_inst, referenced_from_inst,
std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateComputeShaderI32Vec3InputAtDefinition(
const Decoration& decoration, const Instruction& inst) {
Add WebGPU specific validation for multiple BuiltIn decorations (#2333) Covers NumWorkgroups, LocalInvocationId & GlobalInvocationId Part of resolving #2276
2019-01-30 22:00:58 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
if (spv_result_t error = ValidateI32Vec(
decoration, inst, 3,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &decoration,
&inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add WebGPU specific validation for multiple BuiltIn decorations (#2333) Covers NumWorkgroups, LocalInvocationId & GlobalInvocationId Part of resolving #2276
2019-01-30 22:00:58 +00:00
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " variable needs to be a 3-component 32-bit int "
"vector. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateComputeShaderI32Vec3InputAtReference(decoration, inst, inst,
inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateComputeShaderI32Vec3InputAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
Add WebGPU specific validation for multiple BuiltIn decorations (#2333) Covers NumWorkgroups, LocalInvocationId & GlobalInvocationId Part of resolving #2276
2019-01-30 22:00:58 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for multiple BuiltIn decorations (#2333) Covers NumWorkgroups, LocalInvocationId & GlobalInvocationId Part of resolving #2276
2019-01-30 22:00:58 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be only used for variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
Add WebGPU specific validation for multiple BuiltIn decorations (#2333) Covers NumWorkgroups, LocalInvocationId & GlobalInvocationId Part of resolving #2276
2019-01-30 22:00:58 +00:00
bool has_vulkan_model = execution_model == SpvExecutionModelGLCompute ||
execution_model == SpvExecutionModelTaskNV ||
execution_model == SpvExecutionModelMeshNV;
bool has_webgpu_model = execution_model == SpvExecutionModelGLCompute;
if ((spvIsVulkanEnv(_.context()->target_env) && !has_vulkan_model) ||
(spvIsWebGPUEnv(_.context()->target_env) && !has_webgpu_model)) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for multiple BuiltIn decorations (#2333) Covers NumWorkgroups, LocalInvocationId & GlobalInvocationId Part of resolving #2276
2019-01-30 22:00:58 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be used only with GLCompute execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateComputeShaderI32Vec3InputAtReference, this,
decoration, built_in_inst, referenced_from_inst,
std::placeholders::_1));
}
return SPV_SUCCESS;
}
Add validation for Subgroup builtins (#2637) Fixes #2611 * Validates builtins in the Vulkan environment: * NumSubgroups * SubgroupId * SubgroupEqMask * SubgroupGeMask * SubgroupGtMask * SubgroupLeMask * SubgroupLtMask * SubgroupLocalInvocationId * SubgroupSize
2019-06-13 12:47:05 +00:00
spv_result_t BuiltInsValidator::ValidateComputeI32InputAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " cannot be used as a member decoration ";
}
if (spv_result_t error = ValidateI32(
decoration, inst,
[this, &decoration,
&inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " variable needs to be a 32-bit int "
"vector. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
return ValidateComputeI32InputAtReference(decoration, inst, inst, inst);
}
spv_result_t BuiltInsValidator::ValidateComputeI32InputAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be only used for variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
for (const SpvExecutionModel execution_model : execution_models_) {
bool has_vulkan_model = execution_model == SpvExecutionModelGLCompute ||
execution_model == SpvExecutionModelTaskNV ||
execution_model == SpvExecutionModelMeshNV;
if (spvIsVulkanEnv(_.context()->target_env) && !has_vulkan_model) {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be used only with GLCompute execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(
std::bind(&BuiltInsValidator::ValidateComputeI32InputAtReference, this,
decoration, built_in_inst, referenced_from_inst,
std::placeholders::_1));
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateI32InputAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " cannot be used as a member decoration ";
}
if (spv_result_t error = ValidateI32(
decoration, inst,
[this, &decoration,
&inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " variable needs to be a 32-bit int. " << message;
})) {
return error;
}
const SpvStorageClass storage_class = GetStorageClass(inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be only used for variables with Input storage class. "
<< GetReferenceDesc(decoration, inst, inst, inst) << " "
<< GetStorageClassDesc(inst);
}
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::ValidateI32Vec4InputAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (decoration.struct_member_index() != Decoration::kInvalidMember) {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " cannot be used as a member decoration ";
}
if (spv_result_t error = ValidateI32Vec(
decoration, inst, 4,
[this, &decoration,
&inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " variable needs to be a 4-component 32-bit int "
"vector. "
<< message;
})) {
return error;
}
const SpvStorageClass storage_class = GetStorageClass(inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be only used for variables with Input storage class. "
<< GetReferenceDesc(decoration, inst, inst, inst) << " "
<< GetStorageClassDesc(inst);
}
}
return SPV_SUCCESS;
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t BuiltInsValidator::ValidateWorkgroupSizeAtDefinition(
const Decoration& decoration, const Instruction& inst) {
Add WebGPU specific validation for WorkgroupSize BuiltIn decoration (#2334) Part of resolving #2276
2019-01-30 22:01:17 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
if (spvIsVulkanEnv(_.context()->target_env) &&
!spvOpcodeIsConstant(inst.opcode())) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
<< "Vulkan spec requires BuiltIn WorkgroupSize to be a "
"constant. "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< GetIdDesc(inst) << " is not a constant.";
}
if (spv_result_t error = ValidateI32Vec(
decoration, inst, 3,
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
[this, &inst](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
Add WebGPU specific validation for WorkgroupSize BuiltIn decoration (#2334) Part of resolving #2276
2019-01-30 22:01:17 +00:00
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn WorkgroupSize variable needs to be a "
"3-component 32-bit int vector. "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
Fix bug validate_builtins (additional def checks) At every definition of a builtin id, run at-reference-check rules on the defining instruction as well. Previosly the validation was missing the case when invalid storage class was defined in the instruction which defines the built-in, and not in the instruction which references the built-in.
2018-04-03 21:52:32 +00:00
return ValidateWorkgroupSizeAtReference(decoration, inst, inst, inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
spv_result_t BuiltInsValidator::ValidateWorkgroupSizeAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
Add WebGPU specific validation for WorkgroupSize BuiltIn decoration (#2334) Part of resolving #2276
2019-01-30 22:01:17 +00:00
if (spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
for (const SpvExecutionModel execution_model : execution_models_) {
if (execution_model != SpvExecutionModelGLCompute) {
Update diag() use in validate_builtin. (#1758) This CL updates the calls to diag() in vlidate_builtings to provide the instruction.
2018-08-01 13:31:31 +00:00
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
Add WebGPU specific validation for WorkgroupSize BuiltIn decoration (#2334) Part of resolving #2276
2019-01-30 22:01:17 +00:00
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn "
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be used only with GLCompute execution model. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst, execution_model);
}
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateWorkgroupSizeAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
Add builtin validation for SPV_NV_shader_sm_builtins (#2656) Also add a Builtin test generator variant that takes capabilities and extensions. Tests - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in Vertex, Fragment, TessControl, TessEval, Geometry, and Compute. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in MeshNV and TaskNV shaders. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in the 6 ray tracing stages - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as Outputs. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-scalar integers (f32, uvec3) - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-32-bit integers (u64)
2019-06-06 18:53:48 +00:00
spv_result_t BuiltInsValidator::ValidateSMBuiltinsAtDefinition(
const Decoration& decoration, const Instruction& inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
if (spv_result_t error = ValidateI32(
decoration, inst,
[this, &inst,
&decoration](const std::string& message) -> spv_result_t {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "According to the "
<< spvLogStringForEnv(_.context()->target_env)
<< " spec BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " variable needs to be a 32-bit int scalar. "
<< message;
})) {
return error;
}
}
// Seed at reference checks with this built-in.
return ValidateSMBuiltinsAtReference(decoration, inst, inst, inst);
}
spv_result_t BuiltInsValidator::ValidateSMBuiltinsAtReference(
const Decoration& decoration, const Instruction& built_in_inst,
const Instruction& referenced_inst,
const Instruction& referenced_from_inst) {
if (spvIsVulkanEnv(_.context()->target_env)) {
const SpvStorageClass storage_class = GetStorageClass(referenced_from_inst);
if (storage_class != SpvStorageClassMax &&
storage_class != SpvStorageClassInput) {
return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
<< spvLogStringForEnv(_.context()->target_env)
<< " spec allows BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0])
<< " to be only used for "
"variables with Input storage class. "
<< GetReferenceDesc(decoration, built_in_inst, referenced_inst,
referenced_from_inst)
<< " " << GetStorageClassDesc(referenced_from_inst);
}
}
if (function_id_ == 0) {
// Propagate this rule to all dependant ids in the global scope.
id_to_at_reference_checks_[referenced_from_inst.id()].push_back(std::bind(
&BuiltInsValidator::ValidateSMBuiltinsAtReference, this, decoration,
built_in_inst, referenced_from_inst, std::placeholders::_1));
}
return SPV_SUCCESS;
}
Fix major bug in validate_builtins Fixed an early return in the loop, resulting in only one decoration being checked.
2018-04-03 20:07:55 +00:00
spv_result_t BuiltInsValidator::ValidateSingleBuiltInAtDefinition(
const Decoration& decoration, const Instruction& inst) {
const SpvBuiltIn label = SpvBuiltIn(decoration.params()[0]);
Add whitelist of allowed BuiltIn decorations for WebGPU (#2337) Part of resolving #2276
2019-01-30 20:46:02 +00:00
Add generic builtin validation of target (#2843) * Validate the target's opcode is acceptable * Update tests * New tests * move early exit for builtins a bit later in the pass
2019-09-09 18:53:30 +00:00
// Builtins can only be applied to variables, structures or constants.
auto target_opcode = inst.opcode();
if (target_opcode != SpvOpTypeStruct && target_opcode != SpvOpVariable &&
!spvOpcodeIsConstant(target_opcode)) {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "BuiltIns can only target variables, structs or constants";
}
if (!spvIsVulkanOrWebGPUEnv(_.context()->target_env)) {
// Early return. All currently implemented rules are based on Vulkan or
// WebGPU spec.
//
// TODO: If you are adding validation rules for environments other than
// Vulkan or WebGPU (or general rules which are not environment
// independent), then you need to modify or remove this condition. Consider
// also adding early returns into BuiltIn-specific rules, so that the system
// doesn't spawn new rules which don't do anything.
return SPV_SUCCESS;
}
Add whitelist of allowed BuiltIn decorations for WebGPU (#2337) Part of resolving #2276
2019-01-30 20:46:02 +00:00
if (spvIsWebGPUEnv(_.context()->target_env) &&
!IsBuiltInValidForWebGPU(label)) {
return _.diag(SPV_ERROR_INVALID_DATA, &inst)
<< "WebGPU does not allow BuiltIn "
<< _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
decoration.params()[0]);
}
Fix major bug in validate_builtins Fixed an early return in the loop, resulting in only one decoration being checked.
2018-04-03 20:07:55 +00:00
// If you are adding a new BuiltIn enum, please register it here.
// If the newly added enum has validation rules associated with it
// consider leaving a TODO and/or creating an issue.
switch (label) {
case SpvBuiltInClipDistance:
case SpvBuiltInCullDistance: {
return ValidateClipOrCullDistanceAtDefinition(decoration, inst);
}
case SpvBuiltInFragCoord: {
return ValidateFragCoordAtDefinition(decoration, inst);
}
case SpvBuiltInFragDepth: {
return ValidateFragDepthAtDefinition(decoration, inst);
}
case SpvBuiltInFrontFacing: {
return ValidateFrontFacingAtDefinition(decoration, inst);
}
case SpvBuiltInGlobalInvocationId:
case SpvBuiltInLocalInvocationId:
case SpvBuiltInNumWorkgroups:
case SpvBuiltInWorkgroupId: {
return ValidateComputeShaderI32Vec3InputAtDefinition(decoration, inst);
}
case SpvBuiltInHelperInvocation: {
return ValidateHelperInvocationAtDefinition(decoration, inst);
}
case SpvBuiltInInvocationId: {
return ValidateInvocationIdAtDefinition(decoration, inst);
}
case SpvBuiltInInstanceIndex: {
return ValidateInstanceIndexAtDefinition(decoration, inst);
}
case SpvBuiltInLayer:
case SpvBuiltInViewportIndex: {
return ValidateLayerOrViewportIndexAtDefinition(decoration, inst);
}
case SpvBuiltInPatchVertices: {
return ValidatePatchVerticesAtDefinition(decoration, inst);
}
case SpvBuiltInPointCoord: {
return ValidatePointCoordAtDefinition(decoration, inst);
}
case SpvBuiltInPointSize: {
return ValidatePointSizeAtDefinition(decoration, inst);
}
case SpvBuiltInPosition: {
return ValidatePositionAtDefinition(decoration, inst);
}
case SpvBuiltInPrimitiveId: {
return ValidatePrimitiveIdAtDefinition(decoration, inst);
}
case SpvBuiltInSampleId: {
return ValidateSampleIdAtDefinition(decoration, inst);
}
case SpvBuiltInSampleMask: {
return ValidateSampleMaskAtDefinition(decoration, inst);
}
case SpvBuiltInSamplePosition: {
return ValidateSamplePositionAtDefinition(decoration, inst);
}
Add validation for Subgroup builtins (#2637) Fixes #2611 * Validates builtins in the Vulkan environment: * NumSubgroups * SubgroupId * SubgroupEqMask * SubgroupGeMask * SubgroupGtMask * SubgroupLeMask * SubgroupLtMask * SubgroupLocalInvocationId * SubgroupSize
2019-06-13 12:47:05 +00:00
case SpvBuiltInSubgroupId:
case SpvBuiltInNumSubgroups: {
return ValidateComputeI32InputAtDefinition(decoration, inst);
}
case SpvBuiltInSubgroupLocalInvocationId:
case SpvBuiltInSubgroupSize: {
return ValidateI32InputAtDefinition(decoration, inst);
}
case SpvBuiltInSubgroupEqMask:
case SpvBuiltInSubgroupGeMask:
case SpvBuiltInSubgroupGtMask:
case SpvBuiltInSubgroupLeMask:
case SpvBuiltInSubgroupLtMask: {
return ValidateI32Vec4InputAtDefinition(decoration, inst);
}
Fix major bug in validate_builtins Fixed an early return in the loop, resulting in only one decoration being checked.
2018-04-03 20:07:55 +00:00
case SpvBuiltInTessCoord: {
return ValidateTessCoordAtDefinition(decoration, inst);
}
case SpvBuiltInTessLevelOuter: {
return ValidateTessLevelOuterAtDefinition(decoration, inst);
}
case SpvBuiltInTessLevelInner: {
return ValidateTessLevelInnerAtDefinition(decoration, inst);
}
case SpvBuiltInVertexIndex: {
return ValidateVertexIndexAtDefinition(decoration, inst);
}
case SpvBuiltInWorkgroupSize: {
return ValidateWorkgroupSizeAtDefinition(decoration, inst);
}
case SpvBuiltInVertexId:
Validate that VertexId and InstanceId are not allowed in Vulkan. (#2036) The Vulkan specification does not permit use of the VertexId and InstanceId BuiltIn decorations, so add a check to ensure they are not being used when the target environment is Vulkan.
2018-11-13 14:22:49 +00:00
case SpvBuiltInInstanceId: {
Allow InstanceId for NV ray tracing (#2049) * Allow InstanceId for NV ray tracing Fixes #2046 * Allows InstanceId in the Vulkan environment if RayTracingNV capability is specified
2018-11-14 20:03:40 +00:00
return ValidateVertexIdOrInstanceIdAtDefinition(decoration, inst);
Validate that VertexId and InstanceId are not allowed in Vulkan. (#2036) The Vulkan specification does not permit use of the VertexId and InstanceId BuiltIn decorations, so add a check to ensure they are not being used when the target environment is Vulkan.
2018-11-13 14:22:49 +00:00
}
Add WebGPU validation for LocalInvocationIndex BuiltIn decoration (#2335) Part of resolving #2276
2019-01-30 20:45:31 +00:00
case SpvBuiltInLocalInvocationIndex: {
return ValidateLocalInvocationIndexAtDefinition(decoration, inst);
}
Add builtin validation for SPV_NV_shader_sm_builtins (#2656) Also add a Builtin test generator variant that takes capabilities and extensions. Tests - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in Vertex, Fragment, TessControl, TessEval, Geometry, and Compute. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in MeshNV and TaskNV shaders. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in the 6 ray tracing stages - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as Outputs. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-scalar integers (f32, uvec3) - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-32-bit integers (u64)
2019-06-06 18:53:48 +00:00
case SpvBuiltInWarpsPerSMNV:
case SpvBuiltInSMCountNV:
case SpvBuiltInWarpIDNV:
case SpvBuiltInSMIDNV: {
return ValidateSMBuiltinsAtDefinition(decoration, inst);
}
Fix major bug in validate_builtins Fixed an early return in the loop, resulting in only one decoration being checked.
2018-04-03 20:07:55 +00:00
case SpvBuiltInWorkDim:
case SpvBuiltInGlobalSize:
case SpvBuiltInEnqueuedWorkgroupSize:
case SpvBuiltInGlobalOffset:
case SpvBuiltInGlobalLinearId:
case SpvBuiltInSubgroupMaxSize:
case SpvBuiltInNumEnqueuedSubgroups:
case SpvBuiltInBaseVertex:
case SpvBuiltInBaseInstance:
case SpvBuiltInDrawIndex:
case SpvBuiltInDeviceIndex:
case SpvBuiltInViewIndex:
case SpvBuiltInBaryCoordNoPerspAMD:
case SpvBuiltInBaryCoordNoPerspCentroidAMD:
case SpvBuiltInBaryCoordNoPerspSampleAMD:
case SpvBuiltInBaryCoordSmoothAMD:
case SpvBuiltInBaryCoordSmoothCentroidAMD:
case SpvBuiltInBaryCoordSmoothSampleAMD:
case SpvBuiltInBaryCoordPullModelAMD:
case SpvBuiltInFragStencilRefEXT:
case SpvBuiltInViewportMaskNV:
case SpvBuiltInSecondaryPositionNV:
case SpvBuiltInSecondaryViewportMaskNV:
case SpvBuiltInPositionPerViewNV:
case SpvBuiltInViewportMaskPerViewNV:
case SpvBuiltInFullyCoveredEXT:
Add support for Nvidia Turing extensions
2018-09-19 18:53:33 +00:00
case SpvBuiltInMax:
case SpvBuiltInTaskCountNV:
case SpvBuiltInPrimitiveCountNV:
case SpvBuiltInPrimitiveIndicesNV:
case SpvBuiltInClipDistancePerViewNV:
case SpvBuiltInCullDistancePerViewNV:
case SpvBuiltInLayerPerViewNV:
case SpvBuiltInMeshViewCountNV:
case SpvBuiltInMeshViewIndicesNV:
case SpvBuiltInBaryCoordNV:
case SpvBuiltInBaryCoordNoPerspNV:
Add basic support for EXT_fragment_invocation_density (#2100) Whitelisting the extension in optimizations * copying what was done for NV_shading_rate
2018-11-23 15:21:19 +00:00
case SpvBuiltInFragmentSizeNV: // alias SpvBuiltInFragSizeEXT
case SpvBuiltInInvocationsPerPixelNV: // alias
// SpvBuiltInFragInvocationCountEXT
Add support for nv-raytracing-final (#2010) Add support for nv-raytracing (non-experimental)
2018-10-25 18:07:46 +00:00
case SpvBuiltInLaunchIdNV:
case SpvBuiltInLaunchSizeNV:
case SpvBuiltInWorldRayOriginNV:
case SpvBuiltInWorldRayDirectionNV:
case SpvBuiltInObjectRayOriginNV:
case SpvBuiltInObjectRayDirectionNV:
case SpvBuiltInRayTminNV:
case SpvBuiltInRayTmaxNV:
case SpvBuiltInInstanceCustomIndexNV:
case SpvBuiltInObjectToWorldNV:
case SpvBuiltInWorldToObjectNV:
case SpvBuiltInHitTNV:
case SpvBuiltInHitKindNV:
Add builtin validation for SPV_NV_shader_sm_builtins (#2656) Also add a Builtin test generator variant that takes capabilities and extensions. Tests - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in Vertex, Fragment, TessControl, TessEval, Geometry, and Compute. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in MeshNV and TaskNV shaders. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are accepted as Inputs in the 6 ray tracing stages - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as Outputs. - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-scalar integers (f32, uvec3) - verify that the SMCountNV, SMIDNV, WarpsPerSMNV, and WarpIDNV Builtins are NOT accepted as non-32-bit integers (u64)
2019-06-06 18:53:48 +00:00
case SpvBuiltInIncomingRayFlagsNV: {
Fix major bug in validate_builtins Fixed an early return in the loop, resulting in only one decoration being checked.
2018-04-03 20:07:55 +00:00
// No validation rules (for the moment).
break;
}
}
return SPV_SUCCESS;
}
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
spv_result_t BuiltInsValidator::ValidateBuiltInsAtDefinition() {
for (const auto& kv : _.id_decorations()) {
const uint32_t id = kv.first;
Fix major bug in validate_builtins Fixed an early return in the loop, resulting in only one decoration being checked.
2018-04-03 20:07:55 +00:00
const auto& decorations = kv.second;
if (decorations.empty()) {
continue;
}
const Instruction* inst = _.FindDef(id);
assert(inst);
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
for (const auto& decoration : kv.second) {
if (decoration.dec_type() != SpvDecorationBuiltIn) {
continue;
}
Fix major bug in validate_builtins Fixed an early return in the loop, resulting in only one decoration being checked.
2018-04-03 20:07:55 +00:00
if (spv_result_t error =
ValidateSingleBuiltInAtDefinition(decoration, *inst)) {
return error;
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
}
}
}
return SPV_SUCCESS;
}
spv_result_t BuiltInsValidator::Run() {
// First pass: validate all built-ins at definition and seed
// id_to_at_reference_checks_ with built-ins.
if (auto error = ValidateBuiltInsAtDefinition()) {
return error;
}
if (id_to_at_reference_checks_.empty()) {
// No validation tasks were seeded. Nothing else to do.
return SPV_SUCCESS;
}
// Second pass: validate every id reference in the module using
// rules in id_to_at_reference_checks_.
for (const Instruction& inst : _.ordered_instructions()) {
Update(inst);
std::set<uint32_t> already_checked;
for (const auto& operand : inst.operands()) {
if (!spvIsIdType(operand.type)) {
// Not id.
continue;
}
const uint32_t id = inst.word(operand.offset);
if (id == inst.id()) {
// No need to check result id.
continue;
}
if (!already_checked.insert(id).second) {
// The instruction has already referenced this id.
continue;
}
Fixes #1472. Per-vertex variable validation fixes. Relaxs checks for per-vertex builtin variables. If the builtin decoration is applied to a variable, then those checks now allow a level of arraying on the variable before checking the type consistency. * Allows arrays of variables to be present for the per-vertex variables: * Position * PointSize * ClipDistance * CullDistance * Updated tests
2018-04-16 14:05:11 +00:00
// Instruction references the id. Run all checks associated with the id
// on the instruction. id_to_at_reference_checks_ can be modified in the
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// process, iterators are safe because it's a tree-based map.
const auto it = id_to_at_reference_checks_.find(id);
if (it != id_to_at_reference_checks_.end()) {
for (const auto& check : it->second) {
if (spv_result_t error = check(inst)) {
return error;
}
}
}
}
}
return SPV_SUCCESS;
}
Move the validation code into the val:: namespace (#1682) This CL moves the validation code to the val:: namespace. This makes it clearer which instance of the Instruction and other classes are being referred too.
2018-07-10 03:18:44 +00:00
} // namespace
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
// Validates correctness of built-in variables.
Change handling of unknown extentions in validtor. (#1951) This commit will change the message for unknown extensions from an error to a warning. Code was added to limit the number of warning messages so that consummer of the messages are not overwhelmed. This is standard practice in compilers. Many other issues were found at while looking into this. They have been documented in #1950. Fixes http://crbug.com/875547.
2018-10-03 19:59:40 +00:00
spv_result_t ValidateBuiltIns(ValidationState_t& _) {
Add Vulkan validation rules for BuiltIn variables Added a framework for validation of BuiltIn variables. The framework allows implementation of flexible abstract rules which are required for built-ins as the information (decoration, definition, reference) is not in one place, but is scattered all over the module. Validation rules are implemented as a map id -> list<functor(instrution)> Ids which are dependent on built-in types or objects receive a task list, such as "this id cannot be referenced from function which is called from entry point with execution model X; propagate this rule to your descendants in the global scope". Also refactored test/val/val_fixtures. All built-ins covered by tests
2018-02-07 16:50:26 +00:00
BuiltInsValidator validator(_);
return validator.Run();
}
Move the validation code into the val:: namespace (#1682) This CL moves the validation code to the val:: namespace. This makes it clearer which instance of the Instruction and other classes are being referred too.
2018-07-10 03:18:44 +00:00
} // namespace val
Change libspirv to spvtools namespace (#1678) This CL changes all of the libspirv namespace code to spvtools to match the rest of the code base.
2018-07-07 13:38:00 +00:00
} // namespace spvtools
Reference in New Issue Copy Permalink