AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-10-18 19:20:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
5f99fc33cd
SPIRV-Tools/source/validate_instruction.cpp

762 lines
30 KiB
C++
Raw Normal View History

Validation refactor * Organize passes into seperate files * Remove module layout logic from Cfg pass * Remove module layout logic from Functions class * Refactor ModuleLayoutPass for readability * Adapt consistent naming of layout sections (Stage/Section -> Section)
2016-01-14 04:25:11 +00:00
// Copyright (c) 2015-2016 The Khronos Group Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and/or associated documentation files (the
// "Materials"), to deal in the Materials without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Materials, and to
// permit persons to whom the Materials are furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Materials.
//
// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
// https://www.khronos.org/registry/
//
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
// Performs validation on instructions that appear inside of a SPIR-V block.
Initial capability implementation and unit tests * Register capabilility and checks * Add validate storage class capabilities checks and tests * Instruction pass refactor - More generic form of capability checking by checking operands instead of instructions * Execution Model capabilities checks * Decorate BuiltIn capability checks * Addressing Model capability checks * Memory Model capability checks * Execution Mode capability checks * Dim capability checks * SamplerAddressingMode capability checks
2016-01-23 19:14:32 +00:00
#include <cassert>
Validation refactor * Organize passes into seperate files * Remove module layout logic from Cfg pass * Remove module layout logic from Functions class * Refactor ModuleLayoutPass for readability * Adapt consistent naming of layout sections (Stage/Section -> Section)
2016-01-14 04:25:11 +00:00
#include "validate_passes.h"
Initial capability implementation and unit tests * Register capabilility and checks * Add validate storage class capabilities checks and tests * Instruction pass refactor - More generic form of capability checking by checking operands instead of instructions * Execution Model capabilities checks * Decorate BuiltIn capability checks * Addressing Model capability checks * Memory Model capability checks * Execution Mode capability checks * Dim capability checks * SamplerAddressingMode capability checks
2016-01-23 19:14:32 +00:00
using libspirv::ValidationState_t;
namespace {
#define STORAGE_CLASS_CASE(CLASS, CAPABILITY) \
case SpvStorageClass##CLASS: \
if (_.hasCapability(SpvCapability##CAPABILITY) == false) { \
return _.diag(SPV_ERROR_INVALID_CAPABILITY) \
<< #CLASS " storage class requires " #CAPABILITY " capability"; \
} \
break
spv_result_t StorageClassCapabilityCheck(ValidationState_t& _,
SpvStorageClass storage_class) {
switch (storage_class) {
STORAGE_CLASS_CASE(Input, Shader);
STORAGE_CLASS_CASE(Uniform, Shader);
STORAGE_CLASS_CASE(Output, Shader);
STORAGE_CLASS_CASE(Private, Shader);
STORAGE_CLASS_CASE(Generic, Kernel);
STORAGE_CLASS_CASE(PushConstant, Shader);
STORAGE_CLASS_CASE(AtomicCounter, AtomicStorage);
default:
// No capabilities are required for UniformConstant, WorkgroupLocal,
// WorkgroupGlobal, Function, and Image
break;
}
return SPV_SUCCESS;
}
#undef VARIABLE_STORAGE_CASE
#define DECORATION_CASE(DECORATION, CAPABILITY) \
case SpvDecoration##DECORATION: \
if (_.hasCapability(SpvCapability##CAPABILITY) == false) { \
return _.diag(SPV_ERROR_INVALID_CAPABILITY) \
<< #DECORATION " decoration requires " #CAPABILITY " capability"; \
} \
break
#define BUILTIN_CASE(BUILTIN, CAPABILITY) \
case SpvBuiltIn##BUILTIN: \
if (_.hasCapability(SpvCapability##CAPABILITY) == false) { \
return _.diag(SPV_ERROR_INVALID_CAPABILITY) \
<< #BUILTIN " builtin requires " #CAPABILITY " capability"; \
} \
break
#define BUILTIN_CASE2(BUILTIN, CAPABILITY1, CAPABILITY2) \
case SpvBuiltIn##BUILTIN: \
if (_.hasCapability(SpvCapability##CAPABILITY1) == false && \
_.hasCapability(SpvCapability##CAPABILITY2) == false) { \
return _.diag(SPV_ERROR_INVALID_CAPABILITY) \
<< #BUILTIN " builtin requires " #CAPABILITY1 " or " #CAPABILITY2 \
" capabilities"; \
} \
break
spv_result_t DecorationCapabilityCheck(ValidationState_t& _,
SpvDecoration decoration,
SpvBuiltIn optional_builtin) {
switch (decoration) {
DECORATION_CASE(RelaxedPrecision, Shader);
DECORATION_CASE(SpecId, Shader);
DECORATION_CASE(Block, Shader);
DECORATION_CASE(BufferBlock, Shader);
DECORATION_CASE(RowMajor, Matrix);
DECORATION_CASE(ColMajor, Matrix);
DECORATION_CASE(ArrayStride, Shader);
DECORATION_CASE(MatrixStride, Shader);
DECORATION_CASE(GLSLShared, Shader);
DECORATION_CASE(GLSLPacked, Shader);
DECORATION_CASE(CPacked, Kernel);
DECORATION_CASE(NoPerspective, Shader);
DECORATION_CASE(Flat, Shader);
DECORATION_CASE(Patch, Tessellation);
DECORATION_CASE(Centroid, Shader);
DECORATION_CASE(Sample, Shader);
DECORATION_CASE(Invariant, Shader);
DECORATION_CASE(Constant, Kernel);
DECORATION_CASE(Uniform, Shader);
DECORATION_CASE(SaturatedConversion, Kernel);
DECORATION_CASE(Stream, GeometryStreams);
DECORATION_CASE(Location, Shader);
DECORATION_CASE(Component, Shader);
DECORATION_CASE(Index, Shader);
DECORATION_CASE(Binding, Shader);
DECORATION_CASE(DescriptorSet, Shader);
DECORATION_CASE(XfbBuffer, TransformFeedback);
DECORATION_CASE(XfbStride, TransformFeedback);
DECORATION_CASE(FuncParamAttr, Kernel);
DECORATION_CASE(FPRoundingMode, Kernel);
DECORATION_CASE(FPFastMathMode, Kernel);
DECORATION_CASE(LinkageAttributes, Linkage);
DECORATION_CASE(NoContraction, Shader);
DECORATION_CASE(Alignment, Kernel);
DECORATION_CASE(InputAttachmentIndex, InputAttachment);
case SpvDecorationBuiltIn:
switch (optional_builtin) {
BUILTIN_CASE(Position, Shader);
BUILTIN_CASE(PointSize, Shader);
BUILTIN_CASE(ClipDistance, ClipDistance);
BUILTIN_CASE(CullDistance, CullDistance);
BUILTIN_CASE(VertexId, Shader);
BUILTIN_CASE(InstanceId, Shader);
BUILTIN_CASE2(PrimitiveId, Geometry, Tessellation);
BUILTIN_CASE2(InvocationId, Geometry, Tessellation);
BUILTIN_CASE(Layer, Geometry);
case SpvBuiltInViewportIndex:
assert(
false &&
"UNHANDLED"); // TODO(umar): missing SpvCapabilityMultiViewport
// BUILTIN_CASE(ViewportIndex, MultiViewport);
BUILTIN_CASE(TessLevelOuter, Tessellation);
BUILTIN_CASE(TessLevelInner, Tessellation);
BUILTIN_CASE(TessCoord, Tessellation);
BUILTIN_CASE(PatchVertices, Tessellation);
BUILTIN_CASE(FragCoord, Shader);
BUILTIN_CASE(PointCoord, Shader);
BUILTIN_CASE(FrontFacing, Shader);
BUILTIN_CASE(SampleId, SampleRateShading);
BUILTIN_CASE(SamplePosition, SampleRateShading);
BUILTIN_CASE(SampleMask, SampleRateShading);
BUILTIN_CASE(FragDepth, Shader);
BUILTIN_CASE(HelperInvocation, Shader);
BUILTIN_CASE(WorkDim, Kernel);
BUILTIN_CASE(GlobalSize, Kernel);
BUILTIN_CASE(EnqueuedWorkgroupSize, Kernel);
BUILTIN_CASE(GlobalOffset, Kernel);
BUILTIN_CASE(GlobalLinearId, Kernel);
BUILTIN_CASE(SubgroupSize, Kernel);
BUILTIN_CASE(SubgroupMaxSize, Kernel);
BUILTIN_CASE(NumSubgroups, Kernel);
BUILTIN_CASE(NumEnqueuedSubgroups, Kernel);
BUILTIN_CASE(SubgroupId, Kernel);
BUILTIN_CASE(SubgroupLocalInvocationId, Kernel);
BUILTIN_CASE(VertexIndex, Shader);
BUILTIN_CASE(InstanceIndex, Shader);
case SpvBuiltInNumWorkgroups:
case SpvBuiltInWorkgroupSize:
case SpvBuiltInWorkgroupId:
case SpvBuiltInLocalInvocationId:
case SpvBuiltInGlobalInvocationId:
case SpvBuiltInLocalInvocationIndex:
break;
}
default:
// No capabilities are required for Restrict, Aliased, BuiltIn, Volatile,
// Coherent, NonWritable, NonReadable, and Offset
break;
}
#undef DECORATION_CASE
#undef BUILTIN_CASE
#undef BUILTIN_CASE2
return SPV_SUCCESS;
}
#define EXECUTION_MODEL_CASE(MODEL, CAPABILITY) \
case SpvExecutionModel##MODEL: \
if (_.hasCapability(SpvCapability##CAPABILITY) == false) { \
return _.diag(SPV_ERROR_INVALID_CAPABILITY) \
<< #MODEL " execution model requires " #CAPABILITY " capability"; \
} \
break
spv_result_t ExecutionModelCapabilityCheck(ValidationState_t& _,
SpvExecutionModel execution_model) {
switch (execution_model) {
EXECUTION_MODEL_CASE(Vertex, Shader);
EXECUTION_MODEL_CASE(TessellationControl, Tessellation);
EXECUTION_MODEL_CASE(TessellationEvaluation, Tessellation);
EXECUTION_MODEL_CASE(Geometry, Geometry);
EXECUTION_MODEL_CASE(Fragment, Shader);
EXECUTION_MODEL_CASE(GLCompute, Shader);
EXECUTION_MODEL_CASE(Kernel, Kernel);
}
#undef EXECUTION_MODEL_CASE
return SPV_SUCCESS;
}
spv_result_t AddressingAndMemoryModelCapabilityCheck(
ValidationState_t& _, SpvAddressingModel addressing_model,
SpvMemoryModel memory_model) {
switch (addressing_model) {
case SpvAddressingModelPhysical32:
case SpvAddressingModelPhysical64:
if (_.hasCapability(SpvCapabilityAddresses) == false) {
return _.diag(SPV_ERROR_INVALID_CAPABILITY)
<< "Physical32 and Physical64 addressing models require the "
"Addresses capability";
}
break;
case SpvAddressingModelLogical:
break;
}
switch (memory_model) {
case SpvMemoryModelSimple:
case SpvMemoryModelGLSL450:
if (_.hasCapability(SpvCapabilityShader) == false) {
return _.diag(SPV_ERROR_INVALID_CAPABILITY)
<< "Simple and GLSL450 memory models require the Shader "
"capability";
}
break;
case SpvMemoryModelOpenCL:
if (_.hasCapability(SpvCapabilityKernel) == false) {
return _.diag(SPV_ERROR_INVALID_CAPABILITY)
<< "OpenCL memory model requires the Kernel capability";
}
break;
}
return SPV_SUCCESS;
}
#define EXECUTION_MODE_CASE(MODE, CAPABILITY) \
case SpvExecutionMode##MODE: \
if (_.hasCapability(SpvCapability##CAPABILITY) == false) { \
return _.diag(SPV_ERROR_INVALID_CAPABILITY) \
<< #MODE " mode requires " #CAPABILITY " capability"; \
} \
break
#define EXECUTION_MODE_CASE2(MODE, CAPABILITY1, CAPABILITY2) \
case SpvExecutionMode##MODE: \
if (_.hasCapability(SpvCapability##CAPABILITY1) == false && \
_.hasCapability(SpvCapability##CAPABILITY2) == false) { \
return _.diag(SPV_ERROR_INVALID_CAPABILITY) << #MODE \
" mode requires " #CAPABILITY1 " or " #CAPABILITY2 " capability"; \
} \
break
spv_result_t ExecutionModeCapabilityCheck(ValidationState_t& _,
SpvExecutionMode execution_mode) {
switch (execution_mode) {
EXECUTION_MODE_CASE(Invocations, Geometry);
EXECUTION_MODE_CASE(SpacingEqual, Tessellation);
EXECUTION_MODE_CASE(SpacingFractionalEven, Tessellation);
EXECUTION_MODE_CASE(SpacingFractionalOdd, Tessellation);
EXECUTION_MODE_CASE(VertexOrderCw, Tessellation);
EXECUTION_MODE_CASE(VertexOrderCcw, Tessellation);
EXECUTION_MODE_CASE(PixelCenterInteger, Shader);
EXECUTION_MODE_CASE(OriginUpperLeft, Shader);
EXECUTION_MODE_CASE(OriginLowerLeft, Shader);
EXECUTION_MODE_CASE(EarlyFragmentTests, Shader);
EXECUTION_MODE_CASE(PointMode, Tessellation);
EXECUTION_MODE_CASE(Xfb, TransformFeedback);
EXECUTION_MODE_CASE(DepthReplacing, Shader);
EXECUTION_MODE_CASE(DepthGreater, Shader);
EXECUTION_MODE_CASE(DepthLess, Shader);
EXECUTION_MODE_CASE(DepthUnchanged, Shader);
EXECUTION_MODE_CASE(LocalSizeHint, Kernel);
EXECUTION_MODE_CASE(InputPoints, Geometry);
EXECUTION_MODE_CASE(InputLines, Geometry);
EXECUTION_MODE_CASE(InputLinesAdjacency, Geometry);
EXECUTION_MODE_CASE2(Triangles, Geometry, Tessellation);
EXECUTION_MODE_CASE(InputTrianglesAdjacency, Geometry);
EXECUTION_MODE_CASE(Quads, Tessellation);
EXECUTION_MODE_CASE(Isolines, Tessellation);
EXECUTION_MODE_CASE2(OutputVertices, Geometry, Tessellation);
EXECUTION_MODE_CASE(OutputPoints, Geometry);
EXECUTION_MODE_CASE(OutputLineStrip, Geometry);
EXECUTION_MODE_CASE(OutputTriangleStrip, Geometry);
EXECUTION_MODE_CASE(VecTypeHint, Kernel);
EXECUTION_MODE_CASE(ContractionOff, Kernel);
case SpvExecutionModeLocalSize:
break;
}
#undef EXECUTION_MODE_CASE
#undef EXECUTION_MODE_CASE2
return SPV_SUCCESS;
}
#define DIM_CASE(DIM, CAPABILITY) \
case SpvDim##DIM: \
if (_.hasCapability(SpvCapability##CAPABILITY) == false) { \
return _.diag(SPV_ERROR_INVALID_CAPABILITY) \
<< "Dim " #DIM " requires " #CAPABILITY " capability"; \
} \
break
spv_result_t DimCapabilityCheck(ValidationState_t& _, SpvDim dim) {
switch (dim) {
DIM_CASE(1D, Sampled1D);
DIM_CASE(Cube, Shader);
DIM_CASE(Rect, SampledRect);
DIM_CASE(Buffer, SampledBuffer);
DIM_CASE(SubpassData, InputAttachment);
case SpvDim2D:
case SpvDim3D:
break;
}
#undef DIM_CASE
return SPV_SUCCESS;
}
spv_result_t SamplerAddressingModeCapabilityCheck(
ValidationState_t& _, SpvSamplerAddressingMode sampler_addressing_mode) {
std::string mode;
switch (sampler_addressing_mode) {
case SpvSamplerAddressingModeNone:
mode = "None";
break;
case SpvSamplerAddressingModeClampToEdge:
mode = "ClampToEdge";
break;
case SpvSamplerAddressingModeClamp:
mode = "Clamp";
break;
case SpvSamplerAddressingModeRepeat:
mode = "Repeat";
break;
case SpvSamplerAddressingModeRepeatMirrored:
mode = "RepeatMirrored";
break;
}
if (_.hasCapability(SpvCapabilityKernel) == false) {
return _.diag(SPV_ERROR_INVALID_CAPABILITY)
<< mode + " sample address mode requires Kernel capability";
}
return SPV_SUCCESS;
}
}
Validation refactor * Organize passes into seperate files * Remove module layout logic from Cfg pass * Remove module layout logic from Functions class * Refactor ModuleLayoutPass for readability * Adapt consistent naming of layout sections (Stage/Section -> Section)
2016-01-14 04:25:11 +00:00
namespace libspirv {
Initial capability implementation and unit tests * Register capabilility and checks * Add validate storage class capabilities checks and tests * Instruction pass refactor - More generic form of capability checking by checking operands instead of instructions * Execution Model capabilities checks * Decorate BuiltIn capability checks * Addressing Model capability checks * Memory Model capability checks * Execution Mode capability checks * Dim capability checks * SamplerAddressingMode capability checks
2016-01-23 19:14:32 +00:00
// clang-format off
Validation refactor * Organize passes into seperate files * Remove module layout logic from Cfg pass * Remove module layout logic from Functions class * Refactor ModuleLayoutPass for readability * Adapt consistent naming of layout sections (Stage/Section -> Section)
2016-01-14 04:25:11 +00:00
spv_result_t InstructionPass(ValidationState_t& _,
const spv_parsed_instruction_t* inst) {
if (_.is_enabled(SPV_VALIDATE_INSTRUCTION_BIT)) {
SpvOp opcode = inst->opcode;
switch (opcode) {
Initial capability implementation and unit tests * Register capabilility and checks * Add validate storage class capabilities checks and tests * Instruction pass refactor - More generic form of capability checking by checking operands instead of instructions * Execution Model capabilities checks * Decorate BuiltIn capability checks * Addressing Model capability checks * Memory Model capability checks * Execution Mode capability checks * Dim capability checks * SamplerAddressingMode capability checks
2016-01-23 19:14:32 +00:00
case SpvOpNop: break;
case SpvOpSourceContinued: break;
case SpvOpSource: break;
case SpvOpSourceExtension: break;
case SpvOpName: break;
case SpvOpMemberName: break;
case SpvOpString: break;
case SpvOpLine: break;
case SpvOpNoLine: break;
case SpvOpDecorate: {
SpvDecoration decoration =
static_cast<SpvDecoration>(inst->words[inst->operands[1].offset]);
SpvBuiltIn builtin = static_cast<SpvBuiltIn>(0);
if(decoration == SpvDecorationBuiltIn) {
builtin = static_cast<SpvBuiltIn>(inst->words[inst->operands[2].offset]);
}
spvCheckReturn(DecorationCapabilityCheck(_, decoration, builtin));
} break;
case SpvOpMemberDecorate: {
SpvDecoration decoration =
static_cast<SpvDecoration>(inst->words[inst->operands[2].offset]);
SpvBuiltIn builtin = static_cast<SpvBuiltIn>(0);
if(decoration == SpvDecorationBuiltIn) {
builtin = static_cast<SpvBuiltIn>(inst->words[inst->operands[3].offset]);
}
spvCheckReturn(DecorationCapabilityCheck(_, decoration, builtin));
} break;
case SpvOpDecorationGroup: break;
case SpvOpGroupDecorate: break;
case SpvOpGroupMemberDecorate: break;
case SpvOpExtension: break;
case SpvOpExtInstImport: break;
case SpvOpExtInst: break;
case SpvOpMemoryModel: {
SpvAddressingModel addressing_model =
static_cast<SpvAddressingModel>(inst->words[inst->operands[0].offset]);
SpvMemoryModel memory_model =
static_cast<SpvMemoryModel>(inst->words[inst->operands[1].offset]);
spvCheckReturn(AddressingAndMemoryModelCapabilityCheck(_,
addressing_model, memory_model));
} break;
case SpvOpEntryPoint: {
SpvExecutionModel execution_model =
static_cast<SpvExecutionModel>(inst->words[inst->operands[0].offset]);
spvCheckReturn(ExecutionModelCapabilityCheck(_, execution_model));
} break;
case SpvOpExecutionMode: {
SpvExecutionMode execution_mode =
static_cast<SpvExecutionMode>(inst->words[inst->operands[1].offset]);
spvCheckReturn(ExecutionModeCapabilityCheck(_, execution_mode));
} break;
case SpvOpCapability:
_.registerCapability(
static_cast<SpvCapability>(inst->words[inst->operands[0].offset]));
break;
case SpvOpTypeVoid: break;
case SpvOpTypeBool: break;
case SpvOpTypeInt: break;
case SpvOpTypeFloat: break;
case SpvOpTypeVector: break;
case SpvOpTypeMatrix:
if (_.hasCapability(SpvCapabilityMatrix) == false) {
return _.diag(SPV_ERROR_INVALID_CAPABILITY)
<< "Matrix type requires Matrix capability";
}
break;
case SpvOpTypeImage: {
if (_.hasCapability(SpvCapabilityImageBasic) == false) {
return _.diag(SPV_ERROR_INVALID_CAPABILITY)
<< "TypeImage requires the ImageBasic capability";
}
SpvDim dim =
static_cast<SpvDim>(inst->words[inst->operands[2].offset]);
spvCheckReturn(DimCapabilityCheck(_, dim));
} break;
case SpvOpTypeSampler: break;
case SpvOpTypeSampledImage: break;
case SpvOpTypeArray: break;
case SpvOpTypeRuntimeArray: break;
case SpvOpTypeStruct: break;
case SpvOpTypeOpaque: break;
case SpvOpTypePointer: {
const SpvStorageClass storage_class =
static_cast<SpvStorageClass>(inst->words[inst->operands[1].offset]);
spvCheckReturn(StorageClassCapabilityCheck(_, storage_class));
} break;
case SpvOpTypeFunction: break;
case SpvOpTypeEvent: break;
case SpvOpTypeDeviceEvent: break;
case SpvOpTypeReserveId: break;
case SpvOpTypeQueue: break;
case SpvOpTypePipe: break;
case SpvOpTypeForwardPointer: {
const SpvStorageClass storage_class =
static_cast<SpvStorageClass>(inst->words[inst->operands[1].offset]);
spvCheckReturn(StorageClassCapabilityCheck(_, storage_class));
} break;
case SpvOpUndef: break;
case SpvOpConstantTrue: break;
case SpvOpConstantFalse: break;
case SpvOpConstant: break;
case SpvOpConstantComposite: break;
case SpvOpConstantSampler: {
if (_.hasCapability(SpvCapabilityLiteralSampler) == false) {
return _.diag(SPV_ERROR_INVALID_CAPABILITY)
<< "ConstantSampler requires the LiteralSampler capability";
}
const SpvSamplerAddressingMode sampler_addressing_mode =
static_cast<SpvSamplerAddressingMode>(inst->words[inst->operands[1].offset]);
spvCheckReturn(SamplerAddressingModeCapabilityCheck(_, sampler_addressing_mode));
} break;
case SpvOpConstantNull: break;
case SpvOpSpecConstantTrue: break;
case SpvOpSpecConstantFalse: break;
case SpvOpSpecConstant: break;
case SpvOpSpecConstantComposite: break;
case SpvOpSpecConstantOp: break;
Validation refactor * Organize passes into seperate files * Remove module layout logic from Cfg pass * Remove module layout logic from Functions class * Refactor ModuleLayoutPass for readability * Adapt consistent naming of layout sections (Stage/Section -> Section)
2016-01-14 04:25:11 +00:00
case SpvOpVariable: {
Initial capability implementation and unit tests * Register capabilility and checks * Add validate storage class capabilities checks and tests * Instruction pass refactor - More generic form of capability checking by checking operands instead of instructions * Execution Model capabilities checks * Decorate BuiltIn capability checks * Addressing Model capability checks * Memory Model capability checks * Execution Mode capability checks * Dim capability checks * SamplerAddressingMode capability checks
2016-01-23 19:14:32 +00:00
const SpvStorageClass storage_class =
static_cast<SpvStorageClass>(inst->words[inst->operands[2].offset]);
Forbid Generic variables.
2016-01-29 21:49:40 +00:00
if (storage_class == SpvStorageClassGeneric)
return _.diag(SPV_ERROR_INVALID_BINARY)
<< "OpVariable storage class cannot be Generic";
Initial capability implementation and unit tests * Register capabilility and checks * Add validate storage class capabilities checks and tests * Instruction pass refactor - More generic form of capability checking by checking operands instead of instructions * Execution Model capabilities checks * Decorate BuiltIn capability checks * Addressing Model capability checks * Memory Model capability checks * Execution Mode capability checks * Dim capability checks * SamplerAddressingMode capability checks
2016-01-23 19:14:32 +00:00
spvCheckReturn(StorageClassCapabilityCheck(_, storage_class));
Fix in-function storage class validation. Move tests into a fixture that properly turns on the relevant passes.
2016-01-29 03:20:28 +00:00
if (_.getLayoutSection() == kLayoutFunctionDefinitions) {
Validation refactor * Organize passes into seperate files * Remove module layout logic from Cfg pass * Remove module layout logic from Functions class * Refactor ModuleLayoutPass for readability * Adapt consistent naming of layout sections (Stage/Section -> Section)
2016-01-14 04:25:11 +00:00
if (storage_class != SpvStorageClassFunction) {
return _.diag(SPV_ERROR_INVALID_LAYOUT)
<< "Variables must have a function[7] storage class inside"
" of a function";
}
} else {
if (storage_class == SpvStorageClassFunction) {
return _.diag(SPV_ERROR_INVALID_LAYOUT)
<< "Variables can not have a function[7] storage class "
"outside of a function";
}
}
} break;
Initial capability implementation and unit tests * Register capabilility and checks * Add validate storage class capabilities checks and tests * Instruction pass refactor - More generic form of capability checking by checking operands instead of instructions * Execution Model capabilities checks * Decorate BuiltIn capability checks * Addressing Model capability checks * Memory Model capability checks * Execution Mode capability checks * Dim capability checks * SamplerAddressingMode capability checks
2016-01-23 19:14:32 +00:00
case SpvOpImageTexelPointer: break;
case SpvOpLoad: break;
case SpvOpStore: break;
case SpvOpCopyMemory: break;
case SpvOpCopyMemorySized: break;
case SpvOpAccessChain: break;
case SpvOpInBoundsAccessChain: break;
case SpvOpPtrAccessChain: break;
case SpvOpArrayLength: break;
case SpvOpGenericPtrMemSemantics: break;
case SpvOpInBoundsPtrAccessChain: break;
case SpvOpFunction: break;
case SpvOpFunctionParameter: break;
case SpvOpFunctionEnd: break;
case SpvOpFunctionCall: break;
case SpvOpSampledImage: break;
case SpvOpImageSampleImplicitLod: break;
case SpvOpImageSampleExplicitLod: break;
case SpvOpImageSampleDrefImplicitLod: break;
case SpvOpImageSampleDrefExplicitLod: break;
case SpvOpImageSampleProjImplicitLod: break;
case SpvOpImageSampleProjExplicitLod: break;
case SpvOpImageSampleProjDrefImplicitLod: break;
case SpvOpImageSampleProjDrefExplicitLod: break;
case SpvOpImageFetch: break;
case SpvOpImageGather: break;
case SpvOpImageDrefGather: break;
case SpvOpImageRead: break;
case SpvOpImageWrite: break;
case SpvOpImage: break;
case SpvOpImageQueryFormat: break;
case SpvOpImageQueryOrder: break;
case SpvOpImageQuerySizeLod: break;
case SpvOpImageQuerySize: break;
case SpvOpImageQueryLod: break;
case SpvOpImageQueryLevels: break;
case SpvOpImageQuerySamples: break;
case SpvOpImageSparseSampleImplicitLod: break;
case SpvOpImageSparseSampleExplicitLod: break;
case SpvOpImageSparseSampleDrefImplicitLod: break;
case SpvOpImageSparseSampleDrefExplicitLod: break;
case SpvOpImageSparseSampleProjImplicitLod: break;
case SpvOpImageSparseSampleProjExplicitLod: break;
case SpvOpImageSparseSampleProjDrefImplicitLod: break;
case SpvOpImageSparseSampleProjDrefExplicitLod: break;
case SpvOpImageSparseFetch: break;
case SpvOpImageSparseGather: break;
case SpvOpImageSparseDrefGather: break;
case SpvOpImageSparseTexelsResident: break;
case SpvOpConvertFToU: break;
case SpvOpConvertFToS: break;
case SpvOpConvertSToF: break;
case SpvOpConvertUToF: break;
case SpvOpUConvert: break;
case SpvOpSConvert: break;
case SpvOpFConvert: break;
case SpvOpQuantizeToF16: break;
case SpvOpConvertPtrToU: break;
case SpvOpSatConvertSToU: break;
case SpvOpSatConvertUToS: break;
case SpvOpConvertUToPtr: break;
case SpvOpPtrCastToGeneric: break;
case SpvOpGenericCastToPtr: break;
case SpvOpGenericCastToPtrExplicit: {
const SpvStorageClass storage_class =
static_cast<SpvStorageClass>(inst->words[inst->operands[3].offset]);
spvCheckReturn(StorageClassCapabilityCheck(_, storage_class));
} break;
case SpvOpBitcast: break;
case SpvOpVectorExtractDynamic: break;
case SpvOpVectorInsertDynamic: break;
case SpvOpVectorShuffle: break;
case SpvOpCompositeConstruct: break;
case SpvOpCompositeExtract: break;
case SpvOpCompositeInsert: break;
case SpvOpCopyObject: break;
case SpvOpTranspose: break;
case SpvOpSNegate: break;
case SpvOpFNegate: break;
case SpvOpIAdd: break;
case SpvOpFAdd: break;
case SpvOpISub: break;
case SpvOpFSub: break;
case SpvOpIMul: break;
case SpvOpFMul: break;
case SpvOpUDiv: break;
case SpvOpSDiv: break;
case SpvOpFDiv: break;
case SpvOpUMod: break;
case SpvOpSRem: break;
case SpvOpSMod: break;
case SpvOpFRem: break;
case SpvOpFMod: break;
case SpvOpVectorTimesScalar: break;
case SpvOpMatrixTimesScalar: break;
case SpvOpVectorTimesMatrix: break;
case SpvOpMatrixTimesVector: break;
case SpvOpMatrixTimesMatrix: break;
case SpvOpOuterProduct: break;
case SpvOpDot: break;
case SpvOpIAddCarry: break;
case SpvOpISubBorrow: break;
case SpvOpUMulExtended: break;
case SpvOpSMulExtended: break; break;
case SpvOpShiftRightLogical: break;
case SpvOpShiftRightArithmetic: break;
case SpvOpShiftLeftLogical: break;
case SpvOpBitwiseOr: break;
case SpvOpBitwiseXor: break;
case SpvOpBitwiseAnd: break;
case SpvOpNot: break;
case SpvOpBitFieldInsert: break;
case SpvOpBitFieldSExtract: break;
case SpvOpBitFieldUExtract: break;
case SpvOpBitReverse: break;
case SpvOpBitCount: break;
case SpvOpAny: break;
case SpvOpAll: break;
case SpvOpIsNan: break;
case SpvOpIsInf: break;
case SpvOpIsFinite: break;
case SpvOpIsNormal: break;
case SpvOpSignBitSet: break;
case SpvOpLessOrGreater: break;
case SpvOpOrdered: break;
case SpvOpUnordered: break;
case SpvOpLogicalEqual: break;
case SpvOpLogicalNotEqual: break;
case SpvOpLogicalOr: break;
case SpvOpLogicalAnd: break;
case SpvOpLogicalNot: break;
case SpvOpSelect: break;
case SpvOpIEqual: break;
case SpvOpINotEqual: break;
case SpvOpUGreaterThan: break;
case SpvOpSGreaterThan: break;
case SpvOpUGreaterThanEqual: break;
case SpvOpSGreaterThanEqual: break;
case SpvOpULessThan: break;
case SpvOpSLessThan: break;
case SpvOpULessThanEqual: break;
case SpvOpSLessThanEqual: break;
case SpvOpFOrdEqual: break;
case SpvOpFUnordEqual: break;
case SpvOpFOrdNotEqual: break;
case SpvOpFUnordNotEqual: break;
case SpvOpFOrdLessThan: break;
case SpvOpFUnordLessThan: break;
case SpvOpFOrdGreaterThan: break;
case SpvOpFUnordGreaterThan: break;
case SpvOpFOrdLessThanEqual: break;
case SpvOpFUnordLessThanEqual: break;
case SpvOpFOrdGreaterThanEqual: break;
case SpvOpFUnordGreaterThanEqual: break;
case SpvOpDPdx: break;
case SpvOpDPdy: break;
case SpvOpFwidth: break;
case SpvOpDPdxFine: break;
case SpvOpDPdyFine: break;
case SpvOpFwidthFine: break;
case SpvOpDPdxCoarse: break;
case SpvOpDPdyCoarse: break;
case SpvOpFwidthCoarse: break;
case SpvOpPhi: break;
case SpvOpLoopMerge: break;
case SpvOpSelectionMerge: break;
case SpvOpLabel: break;
case SpvOpBranch: break;
case SpvOpBranchConditional: break;
case SpvOpSwitch: break;
case SpvOpKill: break;
case SpvOpReturn: break;
case SpvOpReturnValue: break;
case SpvOpUnreachable: break;
case SpvOpLifetimeStart: break;
case SpvOpLifetimeStop: break;
case SpvOpAtomicLoad: break;
case SpvOpAtomicStore: break;
case SpvOpAtomicExchange: break;
case SpvOpAtomicCompareExchange: break;
case SpvOpAtomicCompareExchangeWeak: break;
case SpvOpAtomicIIncrement: break;
case SpvOpAtomicIDecrement: break;
case SpvOpAtomicIAdd: break;
case SpvOpAtomicISub: break;
case SpvOpAtomicSMin: break;
case SpvOpAtomicUMin: break;
case SpvOpAtomicSMax: break;
case SpvOpAtomicUMax: break;
case SpvOpAtomicAnd: break;
case SpvOpAtomicOr: break;
case SpvOpAtomicXor: break;
case SpvOpAtomicFlagTestAndSet: break;
case SpvOpAtomicFlagClear: break;
case SpvOpEmitVertex: break;
case SpvOpEndPrimitive: break;
case SpvOpEmitStreamVertex: break;
case SpvOpEndStreamPrimitive: break;
case SpvOpControlBarrier: break;
case SpvOpMemoryBarrier: break;
case SpvOpGroupAsyncCopy: break;
case SpvOpGroupWaitEvents: break;
case SpvOpGroupAll: break;
case SpvOpGroupAny: break;
case SpvOpGroupBroadcast: break;
case SpvOpGroupIAdd: break;
case SpvOpGroupFAdd: break;
case SpvOpGroupFMin: break;
case SpvOpGroupUMin: break;
case SpvOpGroupSMin: break;
case SpvOpGroupFMax: break;
case SpvOpGroupUMax: break;
case SpvOpGroupSMax: break;
case SpvOpEnqueueMarker: break;
case SpvOpEnqueueKernel: break;
case SpvOpGetKernelNDrangeSubGroupCount: break;
case SpvOpGetKernelNDrangeMaxSubGroupSize: break;
case SpvOpGetKernelWorkGroupSize: break;
case SpvOpGetKernelPreferredWorkGroupSizeMultiple: break;
case SpvOpRetainEvent: break;
case SpvOpReleaseEvent: break;
case SpvOpCreateUserEvent: break;
case SpvOpIsValidEvent: break;
case SpvOpSetUserEventStatus: break;
case SpvOpCaptureEventProfilingInfo: break;
case SpvOpGetDefaultQueue: break;
case SpvOpBuildNDRange: break;
case SpvOpReadPipe: break;
case SpvOpWritePipe: break;
case SpvOpReservedReadPipe: break;
case SpvOpReservedWritePipe: break;
case SpvOpReserveReadPipePackets: break;
case SpvOpReserveWritePipePackets: break;
case SpvOpCommitReadPipe: break;
case SpvOpCommitWritePipe: break;
case SpvOpIsValidReserveId: break;
case SpvOpGetNumPipePackets: break;
case SpvOpGetMaxPipePackets: break;
case SpvOpGroupReserveReadPipePackets: break;
case SpvOpGroupReserveWritePipePackets: break;
case SpvOpGroupCommitReadPipe: break;
case SpvOpGroupCommitWritePipe: break;
Validation refactor * Organize passes into seperate files * Remove module layout logic from Cfg pass * Remove module layout logic from Functions class * Refactor ModuleLayoutPass for readability * Adapt consistent naming of layout sections (Stage/Section -> Section)
2016-01-14 04:25:11 +00:00
}
}
return SPV_SUCCESS;
}
Initial capability implementation and unit tests * Register capabilility and checks * Add validate storage class capabilities checks and tests * Instruction pass refactor - More generic form of capability checking by checking operands instead of instructions * Execution Model capabilities checks * Decorate BuiltIn capability checks * Addressing Model capability checks * Memory Model capability checks * Execution Mode capability checks * Dim capability checks * SamplerAddressingMode capability checks
2016-01-23 19:14:32 +00:00
// clang-format on
Validation refactor * Organize passes into seperate files * Remove module layout logic from Cfg pass * Remove module layout logic from Functions class * Refactor ModuleLayoutPass for readability * Adapt consistent naming of layout sections (Stage/Section -> Section)
2016-01-14 04:25:11 +00:00
}
Reference in New Issue Copy Permalink