microsoft
/
DirectXShaderCompiler
зеркало из https://github.com/microsoft/DirectXShaderCompiler.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
DirectXShaderCompiler/lib/HLSL/DxilValidation.cpp

4799 строки
185 KiB
C++
Исходник Обычный вид История

first commit
2016-12-28 22:52:27 +03:00
///////////////////////////////////////////////////////////////////////////////
// //
// DxilValidation.cpp //
// Copyright (C) Microsoft Corporation. All rights reserved. //
fixes #37 - License cleanup.
2017-01-28 03:48:08 +03:00
// This file is distributed under the University of Illinois Open Source //
// License. See LICENSE.TXT for details. //
first commit
2016-12-28 22:52:27 +03:00
// //
// This file provides support for validating DXIL shaders. //
// //
///////////////////////////////////////////////////////////////////////////////
#include "dxc/HLSL/DxilValidation.h"
#include "dxc/HLSL/DxilGenerationPass.h"
Make correct/consistent include capitalization (#1269) Several #included files were capitalized incorrectly in the case of files pertaining to the project, or inconsistently in the case of Windows headers which are typically only relevant where capitalization doesn't matter. In spite of that, consistent capitalization can be useful for cross platform stubbing purposes. This corrects capitalization of a few Dxil* headers and forces capitalization of Windows-specific headers to be consistent with the overwhelming majority of other cases. No functional change, just cross-platform facilitation
2018-05-10 20:47:52 +03:00
#include "dxc/HLSL/DxilOperations.h"
first commit
2016-12-28 22:52:27 +03:00
#include "dxc/HLSL/DxilModule.h"
#include "dxc/HLSL/DxilShaderModel.h"
#include "dxc/HLSL/DxilContainer.h"
#include "dxc/Support/Global.h"
Code cleanup. (#469) 1. Move DxilEmitMetadata out of DxilGenerationPass.cpp 2. Move helper function out of HLModule.
2017-07-26 21:02:20 +03:00
#include "dxc/HLSL/DxilUtil.h"
first commit
2016-12-28 22:52:27 +03:00
#include "dxc/HLSL/DxilInstructions.h"
#include "dxc/HLSL/ReducibilityAnalysis.h"
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
#include "dxc/Support/WinIncludes.h"
#include "dxc/Support/FileIOHelper.h"
first commit
2016-12-28 22:52:27 +03:00
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Analysis/CallGraph.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
#include "llvm/IR/Operator.h"
first commit
2016-12-28 22:52:27 +03:00
#include "llvm/IR/Instructions.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DiagnosticInfo.h"
#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/ADT/BitVector.h"
#include "llvm/Support/raw_ostream.h"
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Bitcode/ReaderWriter.h"
first commit
2016-12-28 22:52:27 +03:00
#include <unordered_set>
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/IR/Dominators.h"
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
#include "llvm/Analysis/PostDominators.h"
first commit
2016-12-28 22:52:27 +03:00
#include "dxc/HLSL/DxilSpanAllocator.h"
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
#include "dxc/HLSL/DxilSignatureAllocator.h"
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
#include "dxc/HLSL/DxilRootSignature.h"
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
#include <algorithm>
first commit
2016-12-28 22:52:27 +03:00
using namespace llvm;
using namespace std;
///////////////////////////////////////////////////////////////////////////////
// Error messages.
const char *hlsl::GetValidationRuleText(ValidationRule value) {
/* <py::lines('VALRULE-TEXT')>hctdb_instrhelp.get_valrule_text()</py>*/
// VALRULE-TEXT:BEGIN
switch(value) {
case hlsl::ValidationRule::BitcodeValid: return "Module bitcode is invalid";
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
case hlsl::ValidationRule::ContainerPartMatches: return "Container part '%0' does not match expected for module.";
case hlsl::ValidationRule::ContainerPartRepeated: return "More than one container part '%0'.";
case hlsl::ValidationRule::ContainerPartMissing: return "Missing part '%0' required by module.";
case hlsl::ValidationRule::ContainerPartInvalid: return "Unknown part '%0' found in DXIL container.";
case hlsl::ValidationRule::ContainerRootSignatureIncompatible: return "Root Signature in DXIL container is not compatible with shader.";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::MetaRequired: return "TODO - Required metadata missing";
case hlsl::ValidationRule::MetaKnown: return "Named metadata '%0' is unknown";
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
case hlsl::ValidationRule::MetaUsed: return "All metadata must be used by dxil";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::MetaTarget: return "Unknown target triple '%0'";
case hlsl::ValidationRule::MetaWellFormed: return "TODO - Metadata must be well-formed in operand count and types";
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
case hlsl::ValidationRule::MetaSemanticLen: return "Semantic length must be at least 1 and at most 64";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::MetaInterpModeValid: return "Invalid interpolation mode for '%0'";
case hlsl::ValidationRule::MetaSemaKindValid: return "Semantic kind for '%0' is invalid";
case hlsl::ValidationRule::MetaNoSemanticOverlap: return "Semantic '%0' overlap at %1";
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
case hlsl::ValidationRule::MetaSemaKindMatchesName: return "Semantic name %0 does not match System Value kind %1";
case hlsl::ValidationRule::MetaDuplicateSysValue: return "System value %0 appears more than once in the same signature.";
case hlsl::ValidationRule::MetaSemanticIndexMax: return "%0 semantic index exceeds maximum (%1)";
case hlsl::ValidationRule::MetaSystemValueRows: return "rows for system value semantic %0 must be 1";
case hlsl::ValidationRule::MetaSemanticShouldBeAllocated: return "%0 Semantic '%1' should have a valid packing location";
case hlsl::ValidationRule::MetaSemanticShouldNotBeAllocated: return "%0 Semantic '%1' should have a packing location of -1";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::MetaValueRange: return "Metadata value must be within range";
case hlsl::ValidationRule::MetaFlagsUsage: return "Flags must match usage";
case hlsl::ValidationRule::MetaDenseResIDs: return "Resource identifiers must be zero-based and dense";
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
case hlsl::ValidationRule::MetaSignatureOverlap: return "signature element %0 at location (%1,%2) size (%3,%4) overlaps another signature element.";
case hlsl::ValidationRule::MetaSignatureOutOfRange: return "signature element %0 at location (%1,%2) size (%3,%4) is out of range.";
case hlsl::ValidationRule::MetaSignatureIndexConflict: return "signature element %0 at location (%1,%2) size (%3,%4) has an indexing conflict with another signature element packed into the same row.";
case hlsl::ValidationRule::MetaSignatureIllegalComponentOrder: return "signature element %0 at location (%1,%2) size (%3,%4) violates component ordering rule (arb < sv < sgv).";
Group Signature Elements by Element Width (#610) This change is to enforce the new constraint on signature packing: pack signature elements by data width. Before we introduce fp16 type, every element was assumed to reserve 32 bits. Since we are introducing a new 16 bit data type, we need a new way to enforce signature rules. After discussions we decided that it would be nice to pack elements based on data width. However, we are still enforcing the rule that each row contains up to 4 elements, regardless of the size. This way, depending on the hardware support drivers can optimize packing signatures, while on DXIL level we maintain the assumption that there are 4 elements per row. We are also still constraining on the total number of rows to be 32 for now. This can be changed in the future if people find this limit to be an issue.
2017-09-06 21:04:33 +03:00
case hlsl::ValidationRule::MetaSignatureDataWidth: return "signature element %0 at location (%1, %2) size (%3, %4) has data width that differs from another element packed into the same row.";
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
case hlsl::ValidationRule::MetaIntegerInterpMode: return "signature element %0 specifies invalid interpolation mode for integer component type.";
case hlsl::ValidationRule::MetaInterpModeInOneRow: return "signature element %0 at location (%1,%2) size (%3,%4) has interpolation mode that differs from another element packed into the same row.";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::MetaSemanticCompType: return "%0 must be %1";
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
case hlsl::ValidationRule::MetaClipCullMaxRows: return "ClipDistance and CullDistance occupy more than the maximum of 2 rows combined.";
case hlsl::ValidationRule::MetaClipCullMaxComponents: return "ClipDistance and CullDistance use more than the maximum of 8 components combined.";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::MetaSignatureCompType: return "signature %0 specifies unrecognized or invalid component type";
case hlsl::ValidationRule::MetaTessellatorPartition: return "Invalid Tessellator Partitioning specified. Must be integer, pow2, fractional_odd or fractional_even.";
case hlsl::ValidationRule::MetaTessellatorOutputPrimitive: return "Invalid Tessellator Output Primitive specified. Must be point, line, triangleCW or triangleCCW.";
case hlsl::ValidationRule::MetaMaxTessFactor: return "Hull Shader MaxTessFactor must be [%0..%1]. %2 specified";
case hlsl::ValidationRule::MetaValidSamplerMode: return "Invalid sampler mode on sampler ";
case hlsl::ValidationRule::MetaFunctionAnnotation: return "Cannot find function annotation for %0";
case hlsl::ValidationRule::MetaGlcNotOnAppendConsume: return "globallycoherent cannot be used with append/consume buffers";
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
case hlsl::ValidationRule::MetaStructBufAlignment: return "structured buffer element size must be a multiple of %0 bytes (actual size %1 bytes)";
case hlsl::ValidationRule::MetaStructBufAlignmentOutOfBound: return "structured buffer elements cannot be larger than %0 bytes (actual size %1 bytes)";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::MetaEntryFunction: return "entrypoint not found";
case hlsl::ValidationRule::MetaInvalidControlFlowHint: return "Invalid control flow hint";
case hlsl::ValidationRule::MetaBranchFlatten: return "Can't use branch and flatten attributes together";
case hlsl::ValidationRule::MetaForceCaseOnSwitch: return "Attribute forcecase only works for switch";
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
case hlsl::ValidationRule::MetaControlFlowHintNotOnControlFlow: return "Control flow hint only works on control flow inst";
1. Clean more validation TODOs. 2. Support array of SV_Target.
2017-01-10 22:44:48 +03:00
case hlsl::ValidationRule::MetaTextureType: return "elements of typed buffers and textures must fit in four 32-bit quantities";
Update barycentric with new spec (#265) 1. Adding SV_Barycentric and removing barycentric intrinsics/dxilops 2. GetAttributeAtVertex only thakes no_interpolation attribute 3. SV_Barycentric can take any interpolation modifier except nointerpolation 4. SV_Barycentric can only have float3 type
2017-05-04 03:07:02 +03:00
case hlsl::ValidationRule::MetaBarycentricsInterpolation: return "SV_Barycentrics cannot be used with 'nointerpolation' type";
case hlsl::ValidationRule::MetaBarycentricsFloat3: return "only 'float3' type is allowed for SV_Barycentrics.";
Allow two SV_Barycentrics (#282) unlike other system value semantics, pixel shader is allowed to declare at most two input attributes with SV_Barycentrics, with one declaration uses perspective interpolation type while other one uses noperspective interpolation type.
2017-05-10 04:59:30 +03:00
case hlsl::ValidationRule::MetaBarycentricsTwoPerspectives: return "There can only be up to two input attributes of SV_Barycentrics with different perspective interpolation mode.";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::InstrOload: return "DXIL intrinsic overload must be valid";
case hlsl::ValidationRule::InstrCallOload: return "Call to DXIL intrinsic '%0' does not match an allowed overload signature";
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
case hlsl::ValidationRule::InstrPtrBitCast: return "Pointer type bitcast must be have same size";
case hlsl::ValidationRule::InstrMinPrecisonBitCast: return "Bitcast on minprecison types is not allowed";
case hlsl::ValidationRule::InstrStructBitCast: return "Bitcast on struct types is not allowed";
Make sure status only used by CheckAccessFullyMapped. (#763) * Make sure status only used by CheckAccessFullyMapped.
2017-11-04 04:12:15 +03:00
case hlsl::ValidationRule::InstrStatus: return "Resource status should only used by CheckAccessFullyMapped";
case hlsl::ValidationRule::InstrCheckAccessFullyMapped: return "CheckAccessFullyMapped should only used on resource status";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::InstrOpConst: return "%0 of %1 must be an immediate constant";
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
case hlsl::ValidationRule::InstrAllowed: return "Instructions must be of an allowed type";
case hlsl::ValidationRule::InstrOpCodeReserved: return "Instructions must not reference reserved opcodes";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::InstrOperandRange: return "expect %0 between %1, got %2";
case hlsl::ValidationRule::InstrNoReadingUninitialized: return "Instructions should not read uninitialized value";
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
case hlsl::ValidationRule::InstrNoGenericPtrAddrSpaceCast: return "Address space cast between pointer types must have one part to be generic address space";
Cleanup more validation TODOs.
2017-01-11 21:42:48 +03:00
case hlsl::ValidationRule::InstrInBoundsAccess: return "Access to out-of-bounds memory is disallowed";
case hlsl::ValidationRule::InstrOpConstRange: return "Constant values must be in-range for operation";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::InstrImmBiasForSampleB: return "bias amount for sample_b must be in the range [%0,%1], but %2 was specified as an immediate";
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
case hlsl::ValidationRule::InstrNoIndefiniteLog: return "No indefinite logarithm";
case hlsl::ValidationRule::InstrNoIndefiniteAsin: return "No indefinite arcsine";
case hlsl::ValidationRule::InstrNoIndefiniteAcos: return "No indefinite arccosine";
case hlsl::ValidationRule::InstrNoIDivByZero: return "No signed integer division by zero";
case hlsl::ValidationRule::InstrNoUDivByZero: return "No unsigned integer division by zero";
case hlsl::ValidationRule::InstrNoIndefiniteDsxy: return "No indefinite derivative calculation";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::InstrMinPrecisionNotPrecise: return "Instructions marked precise may not refer to minprecision values";
case hlsl::ValidationRule::InstrOnlyOneAllocConsume: return "RWStructuredBuffers may increment or decrement their counters, but not both.";
1. Clean more validation TODOs. 2. Support array of SV_Target.
2017-01-10 22:44:48 +03:00
case hlsl::ValidationRule::InstrTextureOffset: return "offset texture instructions must take offset which can resolve to integer literal in the range -8 to 7";
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
case hlsl::ValidationRule::InstrCannotPullPosition: return "%0 does not support pull-model evaluation of position";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::InstrEvalInterpolationMode: return "Interpolation mode on %0 used with eval_* instruction must be linear, linear_centroid, linear_noperspective, linear_noperspective_centroid, linear_sample or linear_noperspective_sample";
case hlsl::ValidationRule::InstrResourceCoordinateMiss: return "coord uninitialized";
case hlsl::ValidationRule::InstrResourceCoordinateTooMany: return "out of bound coord must be undef";
case hlsl::ValidationRule::InstrResourceOffsetMiss: return "offset uninitialized";
case hlsl::ValidationRule::InstrResourceOffsetTooMany: return "out of bound offset must be undef";
case hlsl::ValidationRule::InstrUndefResultForGetDimension: return "GetDimensions used undef dimension %0 on %1";
case hlsl::ValidationRule::InstrSamplerModeForLOD: return "lod instruction requires sampler declared in default mode";
case hlsl::ValidationRule::InstrSamplerModeForSample: return "sample/_l/_d/_cl_s/gather instruction requires sampler declared in default mode";
case hlsl::ValidationRule::InstrSamplerModeForSampleC: return "sample_c_*/gather_c instructions require sampler declared in comparison mode";
case hlsl::ValidationRule::InstrSampleCompType: return "sample_* instructions require resource to be declared to return UNORM, SNORM or FLOAT.";
case hlsl::ValidationRule::InstrBarrierModeUselessUGroup: return "sync can't specify both _ugroup and _uglobal. If both are needed, just specify _uglobal.";
case hlsl::ValidationRule::InstrBarrierModeNoMemory: return "sync must include some form of memory barrier - _u (UAV) and/or _g (Thread Group Shared Memory). Only _t (thread group sync) is optional. ";
case hlsl::ValidationRule::InstrBarrierModeForNonCS: return "sync in a non-Compute Shader must only sync UAV (sync_uglobal)";
case hlsl::ValidationRule::InstrWriteMaskForTypedUAVStore: return "store on typed uav must write to all four components of the UAV";
case hlsl::ValidationRule::InstrResourceKindForCalcLOD: return "lod requires resource declared as texture1D/2D/3D/Cube/CubeArray/1DArray/2DArray";
case hlsl::ValidationRule::InstrResourceKindForSample: return "sample/_l/_d requires resource declared as texture1D/2D/3D/Cube/1DArray/2DArray/CubeArray";
case hlsl::ValidationRule::InstrResourceKindForSampleC: return "samplec requires resource declared as texture1D/2D/Cube/1DArray/2DArray/CubeArray";
case hlsl::ValidationRule::InstrResourceKindForGather: return "gather requires resource declared as texture/2D/Cube/2DArray/CubeArray";
case hlsl::ValidationRule::InstrWriteMaskMatchValueForUAVStore: return "uav store write mask must match store value mask, write mask is %0 and store value mask is %1";
case hlsl::ValidationRule::InstrResourceKindForBufferLoadStore: return "buffer load/store only works on Raw/Typed/StructuredBuffer";
case hlsl::ValidationRule::InstrResourceKindForTextureStore: return "texture store only works on Texture1D/1DArray/2D/2DArray/3D";
case hlsl::ValidationRule::InstrResourceKindForGetDim: return "Invalid resource kind on GetDimensions";
case hlsl::ValidationRule::InstrResourceKindForTextureLoad: return "texture load only works on Texture1D/1DArray/2D/2DArray/3D/MS2D/MS2DArray";
case hlsl::ValidationRule::InstrResourceClassForSamplerGather: return "sample, lod and gather should on srv resource.";
case hlsl::ValidationRule::InstrResourceClassForUAVStore: return "store should on uav resource.";
case hlsl::ValidationRule::InstrResourceClassForLoad: return "load can only run on UAV/SRV resource";
case hlsl::ValidationRule::InstrOffsetOnUAVLoad: return "uav load don't support offset";
case hlsl::ValidationRule::InstrMipOnUAVLoad: return "uav load don't support mipLevel/sampleIndex";
case hlsl::ValidationRule::InstrSampleIndexForLoad2DMS: return "load on Texture2DMS/2DMSArray require sampleIndex";
case hlsl::ValidationRule::InstrCoordinateCountForRawTypedBuf: return "raw/typed buffer don't need 2 coordinates";
case hlsl::ValidationRule::InstrCoordinateCountForStructBuf: return "structured buffer require 2 coordinates";
case hlsl::ValidationRule::InstrMipLevelForGetDimension: return "Use mip level on buffer when GetDimensions";
case hlsl::ValidationRule::InstrDxilStructUser: return "Dxil struct types should only used by ExtractValue";
case hlsl::ValidationRule::InstrDxilStructUserOutOfBound: return "Index out of bound when extract value from dxil struct types";
case hlsl::ValidationRule::InstrHandleNotFromCreateHandle: return "Resource handle should returned by createHandle";
case hlsl::ValidationRule::InstrBufferUpdateCounterOnUAV: return "BufferUpdateCounter valid only on UAV";
case hlsl::ValidationRule::InstrCBufferOutOfBound: return "Cbuffer access out of bound";
case hlsl::ValidationRule::InstrCBufferClassForCBufferHandle: return "Expect Cbuffer for CBufferLoad handle";
case hlsl::ValidationRule::InstrFailToResloveTGSMPointer: return "TGSM pointers must originate from an unambiguous TGSM global variable.";
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
case hlsl::ValidationRule::InstrExtractValue: return "ExtractValue should only be used on dxil struct types and cmpxchg";
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
case hlsl::ValidationRule::InstrTGSMRaceCond: return "Race condition writing to shared memory detected, consider making this write conditional";
Update barycentric with new spec (#265) 1. Adding SV_Barycentric and removing barycentric intrinsics/dxilops 2. GetAttributeAtVertex only thakes no_interpolation attribute 3. SV_Barycentric can take any interpolation modifier except nointerpolation 4. SV_Barycentric can only have float3 type
2017-05-04 03:07:02 +03:00
case hlsl::ValidationRule::InstrAttributeAtVertexNoInterpolation: return "Attribute %0 must have nointerpolation mode in order to use GetAttributeAtVertex function.";
Support resource select for lib profile. (#940)
2017-12-20 21:47:29 +03:00
case hlsl::ValidationRule::InstrCreateHandleImmRangeID: return "Local resource must map to global resource.";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::TypesNoVector: return "Vector type '%0' is not allowed";
case hlsl::ValidationRule::TypesDefined: return "Type '%0' is not defined on DXIL primitives";
case hlsl::ValidationRule::TypesIntWidth: return "Int type '%0' has an invalid width";
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
case hlsl::ValidationRule::TypesNoMultiDim: return "Only one dimension allowed for array type";
Change bool to i32 instead of i8. (#28)
2017-01-24 04:54:09 +03:00
case hlsl::ValidationRule::TypesI8: return "I8 can only used as immediate value for intrinsic";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::SmName: return "Unknown shader model '%0'";
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
case hlsl::ValidationRule::SmDxilVersion: return "Shader model requires Dxil Version %0,%1";
case hlsl::ValidationRule::SmOpcode: return "Opcode %0 not valid in shader model %1";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::SmOperand: return "Operand must be defined in target shader model";
case hlsl::ValidationRule::SmSemantic: return "Semantic '%0' is invalid as %1 %2";
case hlsl::ValidationRule::SmNoInterpMode: return "Interpolation mode for '%0' is set but should be undefined";
1. Clean more validation TODOs. 2. Support array of SV_Target.
2017-01-10 22:44:48 +03:00
case hlsl::ValidationRule::SmNoPSOutputIdx: return "Pixel shader output registers are not indexable.";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::SmPSConsistentInterp: return "Interpolation mode for PS input position must be linear_noperspective_centroid or linear_noperspective_sample when outputting oDepthGE or oDepthLE and not running at sample frequency (which is forced by inputting SV_SampleIndex or declaring an input linear_sample or linear_noperspective_sample)";
case hlsl::ValidationRule::SmThreadGroupChannelRange: return "Declared Thread Group %0 size %1 outside valid range [%2..%3]";
case hlsl::ValidationRule::SmMaxTheadGroup: return "Declared Thread Group Count %0 (X*Y*Z) is beyond the valid maximum of %1";
case hlsl::ValidationRule::SmMaxTGSMSize: return "Total Thread Group Shared Memory storage is %0, exceeded %1";
case hlsl::ValidationRule::SmROVOnlyInPS: return "RasterizerOrdered objects are only allowed in 5.0+ pixel shaders";
case hlsl::ValidationRule::SmTessFactorForDomain: return "Required TessFactor for domain not found declared anywhere in Patch Constant data";
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
case hlsl::ValidationRule::SmTessFactorSizeMatchDomain: return "TessFactor rows, columns (%0, %1) invalid for domain %2. Expected %3 rows and 1 column.";
case hlsl::ValidationRule::SmInsideTessFactorSizeMatchDomain: return "InsideTessFactor rows, columns (%0, %1) invalid for domain %2. Expected %3 rows and 1 column.";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::SmDomainLocationIdxOOB: return "DomainLocation component index out of bounds for the domain.";
case hlsl::ValidationRule::SmHullPassThruControlPointCountMatch: return "For pass thru hull shader, input control point count must match output control point count";
case hlsl::ValidationRule::SmOutputControlPointsTotalScalars: return "Total number of scalars across all HS output control points must not exceed ";
case hlsl::ValidationRule::SmIsoLineOutputPrimitiveMismatch: return "Hull Shader declared with IsoLine Domain must specify output primitive point or line. Triangle_cw or triangle_ccw output are not compatible with the IsoLine Domain.";
case hlsl::ValidationRule::SmTriOutputPrimitiveMismatch: return "Hull Shader declared with Tri Domain must specify output primitive point, triangle_cw or triangle_ccw. Line output is not compatible with the Tri domain";
case hlsl::ValidationRule::SmValidDomain: return "Invalid Tessellator Domain specified. Must be isoline, tri or quad";
case hlsl::ValidationRule::SmPatchConstantOnlyForHSDS: return "patch constant signature only valid in HS and DS";
case hlsl::ValidationRule::SmStreamIndexRange: return "Stream index (%0) must between 0 and %1";
case hlsl::ValidationRule::SmPSOutputSemantic: return "Pixel Shader allows output semantics to be SV_Target, SV_Depth, SV_DepthGreaterEqual, SV_DepthLessEqual, SV_Coverage or SV_StencilRef, %0 found";
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
case hlsl::ValidationRule::SmPSMultipleDepthSemantic: return "Pixel Shader only allows one type of depth semantic to be declared";
case hlsl::ValidationRule::SmPSTargetIndexMatchesRow: return "SV_Target semantic index must match packed row location";
case hlsl::ValidationRule::SmPSTargetCol0: return "SV_Target packed location must start at column 0";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::SmPSCoverageAndInnerCoverage: return "InnerCoverage and Coverage are mutually exclusive.";
case hlsl::ValidationRule::SmGSOutputVertexCountRange: return "GS output vertex count must be [0..%0]. %1 specified";
case hlsl::ValidationRule::SmGSInstanceCountRange: return "GS instance count must be [1..%0]. %1 specified";
case hlsl::ValidationRule::SmDSInputControlPointCountRange: return "DS input control point count must be [0..%0]. %1 specified";
Fix validation bugs. (#10)
2017-02-08 09:18:10 +03:00
case hlsl::ValidationRule::SmHSInputControlPointCountRange: return "HS input control point count must be [0..%0]. %1 specified";
case hlsl::ValidationRule::SmZeroHSInputControlPointWithInput: return "When HS input control point count is 0, no input signature should exist";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::SmOutputControlPointCountRange: return "output control point count must be [0..%0]. %1 specified";
case hlsl::ValidationRule::SmGSValidInputPrimitive: return "GS input primitive unrecognized";
case hlsl::ValidationRule::SmGSValidOutputPrimitiveTopology: return "GS output primitive topology unrecognized";
case hlsl::ValidationRule::SmAppendAndConsumeOnSameUAV: return "BufferUpdateCounter inc and dec on a given UAV (%d) cannot both be in the same shader for shader model less than 5.1.";
case hlsl::ValidationRule::SmInvalidTextureKindOnUAV: return "Texture2DMS[Array] or TextureCube[Array] resources are not supported with UAVs";
case hlsl::ValidationRule::SmInvalidResourceKind: return "Invalid resources kind";
case hlsl::ValidationRule::SmInvalidResourceCompType: return "Invalid resource return type";
case hlsl::ValidationRule::SmSampleCountOnlyOn2DMS: return "Only Texture2DMS/2DMSArray could has sample count";
case hlsl::ValidationRule::SmCounterOnlyOnStructBuf: return "BufferUpdateCounter valid only on structured buffers";
1. Clean more validation TODOs. 2. Support array of SV_Target.
2017-01-10 22:44:48 +03:00
case hlsl::ValidationRule::SmGSTotalOutputVertexDataRange: return "Declared output vertex count (%0) multiplied by the total number of declared scalar components of output data (%1) equals %2. This value cannot be greater than %3";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::SmMultiStreamMustBePoint: return "Multiple GS output streams are used but '%0' is not pointlist";
case hlsl::ValidationRule::SmCompletePosition: return "Not all elements of SV_Position were written";
case hlsl::ValidationRule::SmUndefinedOutput: return "Not all elements of output %0 were written";
case hlsl::ValidationRule::SmCSNoReturn: return "Compute shaders can't return values, outputs must be written in writable resources (UAVs).";
case hlsl::ValidationRule::SmCBufferTemplateTypeMustBeStruct: return "D3D12 constant/texture buffer template element can only be a struct";
case hlsl::ValidationRule::SmResourceRangeOverlap: return "Resource %0 with base %1 size %2 overlap with other resource with base %3 size %4 in space %5";
case hlsl::ValidationRule::SmCBufferOffsetOverlap: return "CBuffer %0 has offset overlaps at %1";
case hlsl::ValidationRule::SmCBufferElementOverflow: return "CBuffer %0 size insufficient for element at offset %1";
Add validation for Quad operations against non pixel shaders (#986)
2018-01-16 21:33:47 +03:00
case hlsl::ValidationRule::SmOpcodeInInvalidFunction: return "opcode '%0' should only be used in '%1'";
Add ViewID slot validation for PSIn (#254)
2017-05-02 03:54:33 +03:00
case hlsl::ValidationRule::SmViewIDNeedsSlot: return "Pixel shader input signature lacks available space for ViewID";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::UniNoWaveSensitiveGradient: return "Gradient operations are not affected by wave-sensitive data or control flow.";
case hlsl::ValidationRule::FlowReducible: return "Execution flow must be reducible";
case hlsl::ValidationRule::FlowNoRecusion: return "Recursion is not permitted";
case hlsl::ValidationRule::FlowDeadLoop: return "Loop must have break";
Strip function parameter for entry and patch constant function. (#20) Strip function parameter for entry and patch constant function * Update error message for ValidationTest::MultiDimArray * Merge remote-tracking branch 'origin/master' # Conflicts: # lib/HLSL/DxilValidation.cpp # tools/clang/unittests/HLSL/ValidationTest.cpp * Update error message for ValidationTest::MultiDimArray Update error message for ValidationTest::MultiDimArray * Fix merge error. (#3) * Delete local file (#4) * Fix merge error. * Delete local file * Strip function parameter for entry and patch constant function. (#5)
2017-01-20 06:00:17 +03:00
case hlsl::ValidationRule::FlowFunctionCall: return "Function %0 with parameter is not permitted, it should be inlined";
first commit
2016-12-28 22:52:27 +03:00
case hlsl::ValidationRule::DeclDxilNsReserved: return "Declaration '%0' uses a reserved prefix";
case hlsl::ValidationRule::DeclDxilFnExtern: return "External function '%0' is not a DXIL function";
case hlsl::ValidationRule::DeclUsedInternal: return "Internal declaration '%0' is unused";
case hlsl::ValidationRule::DeclNotUsedExternal: return "External declaration '%0' is unused";
case hlsl::ValidationRule::DeclUsedExternalFunction: return "External function '%0' is unused";
case hlsl::ValidationRule::DeclFnIsCalled: return "Function '%0' is used for something other than calling";
case hlsl::ValidationRule::DeclFnFlattenParam: return "Type '%0' is a struct type but is used as a parameter in function '%1'";
Denorm to function attribute (#764) - Denorm mode to function attribute not function annotation - Adding validation rule for fp32-denorm-mode * Fix from comments
2017-11-07 05:09:14 +03:00
case hlsl::ValidationRule::DeclFnAttribute: return "Function '%0' contains invalid attribute '%1' with value '%2'";
first commit
2016-12-28 22:52:27 +03:00
}
// VALRULE-TEXT:END
llvm_unreachable("invalid value");
return "<unknown>";
}
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
namespace {
// Utility class for setting and restoring the diagnostic context so we may capture errors/warnings
struct DiagRestore {
LLVMContext &Ctx;
void *OrigDiagContext;
LLVMContext::DiagnosticHandlerTy OrigHandler;
DiagRestore(llvm::LLVMContext &Ctx, void *DiagContext) : Ctx(Ctx) {
OrigHandler = Ctx.getDiagnosticHandler();
OrigDiagContext = Ctx.getDiagnosticContext();
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
Ctx.setDiagnosticHandler(
hlsl::PrintDiagnosticContext::PrintDiagnosticHandler, DiagContext);
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
}
~DiagRestore() {
Ctx.setDiagnosticHandler(OrigHandler, OrigDiagContext);
}
};
first commit
2016-12-28 22:52:27 +03:00
class DxilErrorDiagnosticInfo : public DiagnosticInfo {
private:
const char *m_message;
public:
DxilErrorDiagnosticInfo(const char *str)
: DiagnosticInfo(DK_FirstPluginKind, DiagnosticSeverity::DS_Error),
m_message(str) { }
Change SAL __override to C++11 override (#1212)
2018-04-26 22:18:56 +03:00
void print(DiagnosticPrinter &DP) const override {
first commit
2016-12-28 22:52:27 +03:00
DP << m_message;
}
};
static void emitDxilDiag(const LLVMContext &Ctx, const char *str) {
// diagnose doesn't actually mutate anything.
LLVMContext &diagCtx = const_cast<LLVMContext &>(Ctx);
diagCtx.diagnose(DxilErrorDiagnosticInfo(str));
}
// Printing of types.
static inline DiagnosticPrinter &operator<<(DiagnosticPrinter &OS, Type &T) {
std::string O;
raw_string_ostream OSS(O);
T.print(OSS);
OS << OSS.str();
return OS;
}
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
} // anon namespace
first commit
2016-12-28 22:52:27 +03:00
namespace hlsl {
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
// PrintDiagnosticContext methods.
PrintDiagnosticContext::PrintDiagnosticContext(DiagnosticPrinter &printer)
: m_Printer(printer), m_errorsFound(false), m_warningsFound(false) {}
bool PrintDiagnosticContext::HasErrors() const { return m_errorsFound; }
bool PrintDiagnosticContext::HasWarnings() const { return m_warningsFound; }
void PrintDiagnosticContext::Handle(const DiagnosticInfo &DI) {
DI.print(m_Printer);
switch (DI.getSeverity()) {
case llvm::DiagnosticSeverity::DS_Error:
m_errorsFound = true;
break;
case llvm::DiagnosticSeverity::DS_Warning:
m_warningsFound = true;
break;
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
default:
break;
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
}
m_Printer << "\n";
}
void PrintDiagnosticContext::PrintDiagnosticHandler(const DiagnosticInfo &DI, void *Context) {
reinterpret_cast<hlsl::PrintDiagnosticContext *>(Context)->Handle(DI);
}
first commit
2016-12-28 22:52:27 +03:00
struct PSExecutionInfo {
bool SuperSampling = false;
DXIL::SemanticKind OutputDepthKind = DXIL::SemanticKind::Invalid;
const InterpolationMode *PositionInterpolationMode = nullptr;
};
struct ValidationContext {
bool Failed = false;
Module &M;
Module *pDebugModule;
DxilModule &DxilMod;
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
const DataLayout &DL;
first commit
2016-12-28 22:52:27 +03:00
DiagnosticPrinterRawOStream &DiagPrinter;
PSExecutionInfo PSExec;
DebugLoc LastDebugLocEmit;
ValidationRule LastRuleEmit;
std::unordered_set<Function *> entryFuncCallSet;
std::unordered_set<Function *> patchConstFuncCallSet;
std::unordered_map<unsigned, bool> UavCounterIncMap;
bool hasOutputPosition[DXIL::kNumOutputStreams];
Add ViewID slot validation for PSIn (#254)
2017-05-02 03:54:33 +03:00
bool hasViewID;
first commit
2016-12-28 22:52:27 +03:00
unsigned OutputPositionMask[DXIL::kNumOutputStreams];
std::vector<unsigned> outputCols;
std::vector<unsigned> patchConstCols;
unsigned domainLocSize;
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
const unsigned kDxilControlFlowHintMDKind;
const unsigned kDxilPreciseMDKind;
const unsigned kLLVMLoopMDKind;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
bool m_bCoverageIn, m_bInnerCoverageIn;
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
unsigned m_DxilMajor, m_DxilMinor;
first commit
2016-12-28 22:52:27 +03:00
ValidationContext(Module &llvmModule, Module *DebugModule,
DxilModule &dxilModule,
DiagnosticPrinterRawOStream &DiagPrn)
: M(llvmModule), pDebugModule(DebugModule), DxilMod(dxilModule),
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
DL(llvmModule.getDataLayout()),
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
kDxilControlFlowHintMDKind(llvmModule.getContext().getMDKindID(
DxilMDHelper::kDxilControlFlowHintMDName)),
kDxilPreciseMDKind(llvmModule.getContext().getMDKindID(
DxilMDHelper::kDxilPreciseAttributeMDName)),
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
kLLVMLoopMDKind(llvmModule.getContext().getMDKindID("llvm.loop")),
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
DiagPrinter(DiagPrn), LastRuleEmit((ValidationRule)-1),
Add ViewID slot validation for PSIn (#254)
2017-05-02 03:54:33 +03:00
m_bCoverageIn(false), m_bInnerCoverageIn(false),
hasViewID(false) {
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
DxilMod.GetDxilVersion(m_DxilMajor, m_DxilMinor);
first commit
2016-12-28 22:52:27 +03:00
for (unsigned i = 0; i < DXIL::kNumOutputStreams; i++) {
hasOutputPosition[i] = false;
OutputPositionMask[i] = 0;
}
outputCols.resize(DxilMod.GetOutputSignature().GetElements().size(), 0);
patchConstCols.resize(DxilMod.GetPatchConstantSignature().GetElements().size(), 0);
}
// Provide direct access to the raw_ostream in DiagPrinter.
raw_ostream &DiagStream() {
struct DiagnosticPrinterRawOStream_Pub : public DiagnosticPrinterRawOStream {
public:
raw_ostream &DiagStream() { return Stream; }
};
DiagnosticPrinterRawOStream_Pub* p = (DiagnosticPrinterRawOStream_Pub*)&DiagPrinter;
return p->DiagStream();
}
void EmitGlobalValueError(GlobalValue *GV, ValidationRule rule) {
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
EmitFormatError(rule, { GV->getName().str() });
first commit
2016-12-28 22:52:27 +03:00
}
// This is the least desirable mechanism, as it has no context.
void EmitError(ValidationRule rule) {
DiagPrinter << GetValidationRuleText(rule) << '\n';
Failed = true;
}
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
void FormatRuleText(std::string &ruleText, ArrayRef<StringRef> args) {
first commit
2016-12-28 22:52:27 +03:00
// Consider changing const char * to StringRef
for (unsigned i = 0; i < args.size(); i++) {
std::string argIdx = "%" + std::to_string(i);
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
StringRef pArg = args[i];
if (pArg == "")
first commit
2016-12-28 22:52:27 +03:00
pArg = "<null>";
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
std::string::size_type offset = ruleText.find(argIdx);
if (offset == std::string::npos)
continue;
first commit
2016-12-28 22:52:27 +03:00
unsigned size = argIdx.size();
ruleText.replace(offset, size, args[i]);
}
}
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
void EmitFormatError(ValidationRule rule, ArrayRef<StringRef> args) {
first commit
2016-12-28 22:52:27 +03:00
std::string ruleText = GetValidationRuleText(rule);
FormatRuleText(ruleText, args);
DiagPrinter << ruleText << '\n';
Failed = true;
}
void EmitMetaError(Metadata *Meta, ValidationRule rule) {
DiagPrinter << GetValidationRuleText(rule);
Meta->print(DiagStream(), &M);
DiagPrinter << '\n';
Failed = true;
}
void EmitResourceError(const hlsl::DxilResourceBase *Res, ValidationRule rule) {
DiagPrinter << GetValidationRuleText(rule);
DiagPrinter << '\'' << Res->GetGlobalName() << '\'';
DiagPrinter << '\n';
Failed = true;
}
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
void EmitResourceFormatError(const hlsl::DxilResourceBase *Res,
ValidationRule rule,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
ArrayRef<StringRef> args) {
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
std::string ruleText = GetValidationRuleText(rule);
FormatRuleText(ruleText, args);
DiagPrinter << ruleText;
DiagPrinter << '\'' << Res->GetGlobalName() << '\'';
DiagPrinter << '\n';
Failed = true;
}
first commit
2016-12-28 22:52:27 +03:00
bool IsDebugFunctionCall(Instruction *I) {
CallInst *CI = dyn_cast<CallInst>(I);
return CI && CI->getCalledFunction()->getName().startswith("llvm.dbg.");
}
DebugLoc GetDebugLoc(Instruction *I) {
DXASSERT_NOMSG(I);
if (pDebugModule) {
// Look up the matching instruction in the debug module.
llvm::Function *Fn = I->getParent()->getParent();
llvm::Function *DbgFn = pDebugModule->getFunction(Fn->getName());
if (DbgFn) {
// Linear lookup, but then again, failing validation is rare.
inst_iterator it = inst_begin(Fn);
inst_iterator dbg_it = inst_begin(DbgFn);
while (IsDebugFunctionCall(&*dbg_it)) ++dbg_it;
while (&*it != I) {
++it;
++dbg_it;
while (IsDebugFunctionCall(&*dbg_it)) ++dbg_it;
}
return dbg_it->getDebugLoc();
}
}
return I->getDebugLoc();
}
bool EmitInstrLoc(Instruction *I, ValidationRule Rule) {
const DebugLoc &L = GetDebugLoc(I);
if (L) {
// Instructions that get scalarized will likely hit
// this case. Avoid redundant diagnostic messages.
if (Rule == LastRuleEmit && L == LastDebugLocEmit) {
return false;
}
LastRuleEmit = Rule;
LastDebugLocEmit = L;
L.print(DiagStream());
DiagPrinter << ' ';
return true;
}
BasicBlock *BB = I->getParent();
Function *F = BB->getParent();
DiagPrinter << "at " << I;
DiagPrinter << " inside block ";
if (!BB->getName().empty()) {
DiagPrinter << BB->getName();
}
else {
unsigned idx = 0;
for (auto i = F->getBasicBlockList().begin(),
e = F->getBasicBlockList().end(); i != e; ++i) {
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
if (BB == &(*i)) {
first commit
2016-12-28 22:52:27 +03:00
break;
}
}
DiagPrinter << "#" << idx;
}
DiagPrinter << " of function " << *F << ' ';
return true;
}
void EmitInstrError(Instruction *I, ValidationRule rule) {
if (!EmitInstrLoc(I, rule)) return;
DiagPrinter << GetValidationRuleText(rule);
DiagPrinter << '\n';
Failed = true;
}
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
void EmitInstrFormatError(Instruction *I, ValidationRule rule, ArrayRef<StringRef> args) {
first commit
2016-12-28 22:52:27 +03:00
if (!EmitInstrLoc(I, rule)) return;
std::string ruleText = GetValidationRuleText(rule);
FormatRuleText(ruleText, args);
DiagPrinter << ruleText;
DiagPrinter << '\n';
Failed = true;
}
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
void EmitOperandOutOfRange(Instruction *I, StringRef name, StringRef range, StringRef v) {
first commit
2016-12-28 22:52:27 +03:00
if (!EmitInstrLoc(I, ValidationRule::InstrOperandRange)) return;
std::string ruleText = GetValidationRuleText(ValidationRule::InstrOperandRange);
FormatRuleText(ruleText, {name, range, v});
DiagPrinter << ruleText;
DiagPrinter << '\n';
Failed = true;
}
void EmitSignatureError(DxilSignatureElement *SE, ValidationRule rule) {
EmitFormatError(rule, { SE->GetName() });
}
void EmitTypeError(Type *Ty, ValidationRule rule) {
std::string O;
raw_string_ostream OSS(O);
Ty->print(OSS);
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
EmitFormatError(rule, { OSS.str() });
first commit
2016-12-28 22:52:27 +03:00
}
Denorm to function attribute (#764) - Denorm mode to function attribute not function annotation - Adding validation rule for fp32-denorm-mode * Fix from comments
2017-11-07 05:09:14 +03:00
void EmitFnAttributeError(Function *F, StringRef Kind, StringRef Value) {
EmitFormatError(ValidationRule::DeclFnAttribute, { F->getName(), Kind, Value });
}
first commit
2016-12-28 22:52:27 +03:00
};
static bool ValidateOpcodeInProfile(DXIL::OpCode opcode,
const ShaderModel *pSM) {
unsigned op = (unsigned)opcode;
/* <py::lines('VALOPCODESM-TEXT')>hctdb_instrhelp.get_valopcode_sm_text()</py>*/
// VALOPCODESM-TEXT:BEGIN
Integrate final opcode changes for DXIL v1.0 - Removes IAddc and ISubc - Renames USubc to USubb - Compacts opcodes
2017-02-02 02:22:29 +03:00
// Instructions: ThreadId=93, GroupId=94, ThreadIdInGroup=95,
// FlattenedThreadIdInGroup=96
if (93 <= op && op <= 96)
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
return (pSM->IsCS());
Integrate final opcode changes for DXIL v1.0 - Removes IAddc and ISubc - Renames USubc to USubb - Compacts opcodes
2017-02-02 02:22:29 +03:00
// Instructions: DomainLocation=105
if (op == 105)
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
return (pSM->IsDS());
Integrate final opcode changes for DXIL v1.0 - Removes IAddc and ISubc - Renames USubc to USubb - Compacts opcodes
2017-02-02 02:22:29 +03:00
// Instructions: LoadOutputControlPoint=103, LoadPatchConstant=104
if (103 <= op && op <= 104)
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
return (pSM->IsDS() || pSM->IsHS());
Integrate final opcode changes for DXIL v1.0 - Removes IAddc and ISubc - Renames USubc to USubb - Compacts opcodes
2017-02-02 02:22:29 +03:00
// Instructions: EmitStream=97, CutStream=98, EmitThenCutStream=99,
// GSInstanceID=100
if (97 <= op && op <= 100)
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
return (pSM->IsGS());
Integrate final opcode changes for DXIL v1.0 - Removes IAddc and ISubc - Renames USubc to USubb - Compacts opcodes
2017-02-02 02:22:29 +03:00
// Instructions: PrimitiveID=108
if (op == 108)
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
return (pSM->IsGS() || pSM->IsDS() || pSM->IsHS() || pSM->IsPS());
Integrate final opcode changes for DXIL v1.0 - Removes IAddc and ISubc - Renames USubc to USubb - Compacts opcodes
2017-02-02 02:22:29 +03:00
// Instructions: StorePatchConstant=106, OutputControlPointID=107
if (106 <= op && op <= 107)
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
return (pSM->IsHS());
Enable SampleCmpLevelZero for all shader profiles.
2017-02-10 22:43:30 +03:00
// Instructions: Sample=60, SampleBias=61, SampleCmp=64,
Integrate final opcode changes for DXIL v1.0 - Removes IAddc and ISubc - Renames USubc to USubb - Compacts opcodes
2017-02-02 02:22:29 +03:00
// RenderTargetGetSamplePosition=76, RenderTargetGetSampleCount=77,
// CalculateLOD=81, Discard=82, DerivCoarseX=83, DerivCoarseY=84,
// DerivFineX=85, DerivFineY=86, EvalSnapped=87, EvalSampleIndex=88,
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
// EvalCentroid=89, SampleIndex=90, Coverage=91, InnerCoverage=92
[linux-port] Correct conditional groupings (#1326) Clang and gcc complain when AND and OR logical operations are both used in a single conditional because of the possibility of mistakes when depending solely on operator precedence. In fact, this change fixes a few clear errors mostly in asserts that would never fire. Fixes 13 clang and 22 gcc warnings. Additionally, when two if statements are followed by an else, there may be some ambiguity in terms of which if the else applies to. It is the closest one, the second in the case of two, but it is another area of potential mistakes. Adding braces around the code intended as the block of the first if conditional clarifies this. fixed 8 clang and 8 gcc warnings. Clang complains sometimes when assignments take place in a conditional without additional parenthesis around it. It can indicate when what was meant to be an equal comparison is replaced with an assignment. fixes 2 clang warnings.
2018-06-02 11:19:14 +03:00
if ((60 <= op && op <= 61) || op == 64 || (76 <= op && op <= 77) || (81 <= op && op <= 92))
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
return (pSM->IsPS());
Update barycentric with new spec (#265) 1. Adding SV_Barycentric and removing barycentric intrinsics/dxilops 2. GetAttributeAtVertex only thakes no_interpolation attribute 3. SV_Barycentric can take any interpolation modifier except nointerpolation 4. SV_Barycentric can only have float3 type
2017-05-04 03:07:02 +03:00
// Instructions: AttributeAtVertex=137
if (op == 137)
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
return (pSM->GetMajor() > 6 || (pSM->GetMajor() == 6 && pSM->GetMinor() >= 1))
&& (pSM->IsPS());
Update barycentric with new spec (#265) 1. Adding SV_Barycentric and removing barycentric intrinsics/dxilops 2. GetAttributeAtVertex only thakes no_interpolation attribute 3. SV_Barycentric can take any interpolation modifier except nointerpolation 4. SV_Barycentric can only have float3 type
2017-05-04 03:07:02 +03:00
// Instructions: ViewID=138
if (op == 138)
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
return (pSM->GetMajor() > 6 || (pSM->GetMajor() == 6 && pSM->GetMinor() >= 1))
&& (pSM->IsVS() || pSM->IsHS() || pSM->IsDS() || pSM->IsGS() || pSM->IsPS());
RawBufferLoad and new methods for ByteAddressBuffer (#762) This change is an extension of float16 support. We are adding LoadHalf, LoadFloat, and LoadDouble method to byte address buffer so that users can access data from byte address buffer by these types. Also starting shader model 6.2, we are mapping byte address buffer and structure buffer load/store operations to RawBufferLoad/Store to differentiate raw buffer load from typed buffer load. Unlike BufferLoad for typed buffers, RawBufferLoad for min precision types will not have its min precision values as its return types, but their actual scalar size in buffer (i.e rawBufferLoad.i32 for min16int and rawBufferLoad.f32 for min16float). RawBufferLoad/Store contains additional parameters, where mask was required for correct status behavior for CheckAccessFullyMapped, and alignment is for relative alignment for future potential benefit for backend.
2017-11-08 05:15:19 +03:00
// Instructions: RawBufferLoad=139, RawBufferStore=140
if (139 <= op && op <= 140)
return (pSM->GetMajor() > 6 || (pSM->GetMajor() == 6 && pSM->GetMinor() >= 2));
first commit
2016-12-28 22:52:27 +03:00
return true;
// VALOPCODESM-TEXT:END
}
static unsigned ValidateSignatureRowCol(Instruction *I, DxilSignatureElement &SE,
Value *rowVal, Value *colVal,
ValidationContext &ValCtx) {
if (ConstantInt *constRow = dyn_cast<ConstantInt>(rowVal)) {
unsigned row = constRow->getLimitedValue();
if (row >= SE.GetRows()) {
ValCtx.EmitInstrError(I, ValidationRule::InstrOperandRange);
}
}
if (!isa<ConstantInt>(colVal)) {
// col must be const
ValCtx.EmitInstrFormatError(I, ValidationRule::InstrOpConst,
{"Col", "LoadInput/StoreOutput"});
return 0;
}
unsigned col = cast<ConstantInt>(colVal)->getLimitedValue();
if (col > SE.GetCols()) {
ValCtx.EmitInstrError(I, ValidationRule::InstrOperandRange);
} else {
if (SE.IsOutput())
ValCtx.outputCols[SE.GetID()] |= 1 << col;
if (SE.IsPatchConstant())
ValCtx.patchConstCols[SE.GetID()] |= 1 << col;
}
return col;
}
static DxilSignatureElement *ValidateSignatureAccess(Instruction *I, DxilSignature &sig,
Value *sigID, Value *rowVal, Value *colVal,
ValidationContext &ValCtx) {
if (!isa<ConstantInt>(sigID)) {
// inputID must be const
ValCtx.EmitInstrFormatError(I, ValidationRule::InstrOpConst,
{"SignatureID", "LoadInput/StoreOutput"});
return nullptr;
}
unsigned SEIdx = cast<ConstantInt>(sigID)->getLimitedValue();
if (sig.GetElements().size() <= SEIdx) {
ValCtx.EmitInstrError(I, ValidationRule::InstrOpConstRange);
return nullptr;
}
DxilSignatureElement &SE = sig.GetElement(SEIdx);
bool isOutput = sig.IsOutput();
unsigned col = ValidateSignatureRowCol(I, SE, rowVal, colVal, ValCtx);
if (isOutput && SE.GetSemantic()->GetKind() == DXIL::SemanticKind::Position) {
unsigned mask = ValCtx.OutputPositionMask[SE.GetOutputStream()];
mask |= 1<<col;
Use undef to save type for type annotation. (#35)
2017-01-25 21:40:58 +03:00
if (SE.GetOutputStream() < DXIL::kNumOutputStreams)
ValCtx.OutputPositionMask[SE.GetOutputStream()] = mask;
first commit
2016-12-28 22:52:27 +03:00
}
return &SE;
}
static DXIL::SamplerKind GetSamplerKind(Value *samplerHandle, ValidationContext &ValCtx) {
if (!isa<CallInst>(samplerHandle)) {
Cleanup more validation TODOs.
2017-01-11 21:42:48 +03:00
ValCtx.EmitError(ValidationRule::InstrHandleNotFromCreateHandle);
first commit
2016-12-28 22:52:27 +03:00
return DXIL::SamplerKind::Invalid;
}
DxilInst_CreateHandle createHandle(cast<CallInst>(samplerHandle));
if (!createHandle) {
ValCtx.EmitInstrError(cast<CallInst>(samplerHandle), ValidationRule::InstrHandleNotFromCreateHandle);
return DXIL::SamplerKind::Invalid;
}
Value *resClass = createHandle.get_resourceClass();
if (!isa<ConstantInt>(resClass)) {
return DXIL::SamplerKind::Invalid;
}
if (createHandle.get_resourceClass_val() != static_cast<unsigned>(DXIL::ResourceClass::Sampler)) {
// must be sampler.
return DXIL::SamplerKind::Invalid;
}
Value *rangeIndex = createHandle.get_rangeId();
if (!isa<ConstantInt>(rangeIndex)) {
// must be constant
return DXIL::SamplerKind::Invalid;
}
unsigned samplerIndex = cast<ConstantInt>(rangeIndex)->getLimitedValue();
auto &samplers = ValCtx.DxilMod.GetSamplers();
if (samplerIndex >= samplers.size()) {
return DXIL::SamplerKind::Invalid;
}
DxilSampler *sampler = samplers[samplerIndex].get();
Value *index = createHandle.get_index();
ConstantInt *cIndex = dyn_cast<ConstantInt>(index);
if (!sampler->GetGlobalSymbol()->getType()->getPointerElementType()->isArrayTy()) {
if (!cIndex) {
// index must be 0 for none array resource.
return DXIL::SamplerKind::Invalid;
}
}
if (cIndex) {
unsigned index = cIndex->getLimitedValue();
if (index < sampler->GetLowerBound() || index > sampler->GetUpperBound()) {
// index out of range.
return DXIL::SamplerKind::Invalid;
}
}
return sampler->GetSamplerKind();
}
static DXIL::ResourceKind GetResourceKindAndCompTy(Value *handle, DXIL::ComponentType &CompTy, DXIL::ResourceClass &ResClass,
unsigned &resIndex,
ValidationContext &ValCtx) {
CompTy = DXIL::ComponentType::Invalid;
ResClass = DXIL::ResourceClass::Invalid;
if (!isa<CallInst>(handle)) {
Cleanup more validation TODOs.
2017-01-11 21:42:48 +03:00
ValCtx.EmitError(ValidationRule::InstrHandleNotFromCreateHandle);
first commit
2016-12-28 22:52:27 +03:00
return DXIL::ResourceKind::Invalid;
}
DxilInst_CreateHandle createHandle(cast<CallInst>(handle));
if (!createHandle) {
ValCtx.EmitInstrError(cast<CallInst>(handle), ValidationRule::InstrHandleNotFromCreateHandle);
return DXIL::ResourceKind::Invalid;
}
Value *resourceClass = createHandle.get_resourceClass();
if (!isa<ConstantInt>(resourceClass)) {
return DXIL::ResourceKind::Invalid;
}
ResClass = static_cast<DXIL::ResourceClass>(createHandle.get_resourceClass_val());
switch (ResClass) {
case DXIL::ResourceClass::SRV:
case DXIL::ResourceClass::UAV:
break;
case DXIL::ResourceClass::CBuffer:
return DXIL::ResourceKind::CBuffer;
case DXIL::ResourceClass::Sampler:
return DXIL::ResourceKind::Sampler;
default:
// Emit invalid res class
return DXIL::ResourceKind::Invalid;
}
Value *rangeIndex = createHandle.get_rangeId();
if (!isa<ConstantInt>(rangeIndex)) {
Support resource select for lib profile. (#940)
2017-12-20 21:47:29 +03:00
ValCtx.EmitInstrError(cast<CallInst>(handle),
ValidationRule::InstrCreateHandleImmRangeID);
first commit
2016-12-28 22:52:27 +03:00
// must be constant
return DXIL::ResourceKind::Invalid;
}
resIndex = cast<ConstantInt>(rangeIndex)->getLimitedValue();
DxilResource *res = nullptr;
if (ResClass == DXIL::ResourceClass::UAV) {
auto &resources = ValCtx.DxilMod.GetUAVs();
if (resIndex >= resources.size()) {
return DXIL::ResourceKind::Invalid;
}
res = resources[resIndex].get();
} else {
if (ResClass != DXIL::ResourceClass::SRV) {
return DXIL::ResourceKind::Invalid;
}
auto &resources = ValCtx.DxilMod.GetSRVs();
if (resIndex >= resources.size()) {
return DXIL::ResourceKind::Invalid;
}
res = resources[resIndex].get();
}
CompTy = res->GetCompType().GetKind();
Value *index = createHandle.get_index();
ConstantInt *cIndex = dyn_cast<ConstantInt>(index);
if (!res->GetGlobalSymbol()->getType()->getPointerElementType()->isArrayTy()) {
if (!cIndex) {
// index must be 0 for none array resource.
return DXIL::ResourceKind::Invalid;
}
}
if (cIndex) {
unsigned index = cIndex->getLimitedValue();
if (index < res->GetLowerBound() || index > res->GetUpperBound()) {
// index out of range.
return DXIL::ResourceKind::Invalid;
}
}
return res->GetKind();
}
struct ResRetUsage {
bool x;
bool y;
bool z;
bool w;
bool status;
ResRetUsage() : x(false), y(false), z(false), w(false), status(false) {}
};
static void CollectGetDimResRetUsage(ResRetUsage &usage, Instruction *ResRet,
Make sure status only used by CheckAccessFullyMapped. (#763) * Make sure status only used by CheckAccessFullyMapped.
2017-11-04 04:12:15 +03:00
ValidationContext &ValCtx) {
first commit
2016-12-28 22:52:27 +03:00
const unsigned kMaxResRetElementIndex = 5;
for (User *U : ResRet->users()) {
if (ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(U)) {
for (unsigned idx : EVI->getIndices()) {
switch (idx) {
case 0:
usage.x = true;
break;
case 1:
usage.y = true;
break;
case 2:
usage.z = true;
break;
case 3:
usage.w = true;
break;
Make sure status only used by CheckAccessFullyMapped. (#763) * Make sure status only used by CheckAccessFullyMapped.
2017-11-04 04:12:15 +03:00
case DXIL::kResRetStatusIndex:
first commit
2016-12-28 22:52:27 +03:00
usage.status = true;
break;
default:
// Emit index out of bound.
ValCtx.EmitInstrError(EVI,
ValidationRule::InstrDxilStructUserOutOfBound);
break;
}
}
} else if (PHINode *PHI = dyn_cast<PHINode>(U)) {
CollectGetDimResRetUsage(usage, PHI, ValCtx);
} else {
Instruction *User = cast<Instruction>(U);
ValCtx.EmitInstrError(User, ValidationRule::InstrDxilStructUser);
}
}
}
Make sure status only used by CheckAccessFullyMapped. (#763) * Make sure status only used by CheckAccessFullyMapped.
2017-11-04 04:12:15 +03:00
static void ValidateStatus(Instruction *ResRet, ValidationContext &ValCtx) {
ResRetUsage usage;
CollectGetDimResRetUsage(usage, ResRet, ValCtx);
if (usage.status) {
for (User *U : ResRet->users()) {
if (ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(U)) {
for (unsigned idx : EVI->getIndices()) {
switch (idx) {
case DXIL::kResRetStatusIndex:
for (User *SU : EVI->users()) {
Instruction *I = cast<Instruction>(SU);
// Make sure all use is CheckAccess.
if (!isa<CallInst>(I)) {
ValCtx.EmitInstrError(I, ValidationRule::InstrStatus);
return;
}
if (!ValCtx.DxilMod.GetOP()->IsDxilOpFuncCallInst(
I, DXIL::OpCode::CheckAccessFullyMapped)) {
ValCtx.EmitInstrError(I, ValidationRule::InstrStatus);
return;
}
}
break;
}
}
}
}
}
}
first commit
2016-12-28 22:52:27 +03:00
static void ValidateResourceCoord(CallInst *CI, DXIL::ResourceKind resKind,
ArrayRef<Value *> coords,
ValidationContext &ValCtx) {
const unsigned kMaxNumCoords = 4;
unsigned numCoords = DxilResource::GetNumCoords(resKind);
for (unsigned i = 0; i < kMaxNumCoords; i++) {
if (i < numCoords) {
if (isa<UndefValue>(coords[i])) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceCoordinateMiss);
}
} else {
if (!isa<UndefValue>(coords[i])) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceCoordinateTooMany);
}
}
}
}
static void ValidateCalcLODResourceDimensionCoord(CallInst *CI, DXIL::ResourceKind resKind,
ArrayRef<Value *> coords,
ValidationContext &ValCtx) {
const unsigned kMaxNumDimCoords = 3;
unsigned numCoords = DxilResource::GetNumDimensionsForCalcLOD(resKind);
for (unsigned i = 0; i < kMaxNumDimCoords; i++) {
if (i < numCoords) {
if (isa<UndefValue>(coords[i])) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceCoordinateMiss);
}
} else {
if (!isa<UndefValue>(coords[i])) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceCoordinateTooMany);
}
}
}
}
static void ValidateResourceOffset(CallInst *CI, DXIL::ResourceKind resKind,
ArrayRef<Value *> offsets,
ValidationContext &ValCtx) {
const unsigned kMaxNumOffsets = 3;
unsigned numOffsets = DxilResource::GetNumOffsets(resKind);
bool hasOffset = !isa<UndefValue>(offsets[0]);
1. Clean more validation TODOs. 2. Support array of SV_Target.
2017-01-10 22:44:48 +03:00
auto validateOffset = [&](Value *offset) {
if (ConstantInt *cOffset = dyn_cast<ConstantInt>(offset)) {
int offset = cOffset->getValue().getSExtValue();
if (offset > 7 || offset < -8) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrTextureOffset);
}
} else {
ValCtx.EmitInstrError(CI, ValidationRule::InstrTextureOffset);
}
};
if (hasOffset) {
validateOffset(offsets[0]);
}
first commit
2016-12-28 22:52:27 +03:00
for (unsigned i = 1; i < kMaxNumOffsets; i++) {
if (i < numOffsets) {
1. Clean more validation TODOs. 2. Support array of SV_Target.
2017-01-10 22:44:48 +03:00
if (hasOffset) {
if (isa<UndefValue>(offsets[i]))
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceOffsetMiss);
else
validateOffset(offsets[i]);
first commit
2016-12-28 22:52:27 +03:00
}
} else {
if (!isa<UndefValue>(offsets[i])) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceOffsetTooMany);
}
}
}
}
static void ValidateSampleInst(CallInst *CI, Value *srvHandle, Value *samplerHandle,
ArrayRef<Value *> coords,
ArrayRef<Value *> offsets,
bool IsSampleC,
ValidationContext &ValCtx) {
if (!IsSampleC) {
if (GetSamplerKind(samplerHandle, ValCtx) != DXIL::SamplerKind::Default) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrSamplerModeForSample);
}
} else {
if (GetSamplerKind(samplerHandle, ValCtx) !=
DXIL::SamplerKind::Comparison) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrSamplerModeForSampleC);
}
}
DXIL::ComponentType compTy;
DXIL::ResourceClass resClass;
unsigned resIndex;
DXIL::ResourceKind resKind =
GetResourceKindAndCompTy(srvHandle, compTy, resClass, resIndex, ValCtx);
bool isSampleCompTy = compTy == DXIL::ComponentType::F32;
isSampleCompTy |= compTy == DXIL::ComponentType::SNormF32;
isSampleCompTy |= compTy == DXIL::ComponentType::UNormF32;
if (!isSampleCompTy) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrSampleCompType);
}
if (resClass != DXIL::ResourceClass::SRV) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceClassForSamplerGather);
}
ValidationRule rule = ValidationRule::InstrResourceKindForSample;
if (IsSampleC) {
rule = ValidationRule::InstrResourceKindForSampleC;
}
switch (resKind) {
case DXIL::ResourceKind::Texture1D:
case DXIL::ResourceKind::Texture1DArray:
case DXIL::ResourceKind::Texture2D:
case DXIL::ResourceKind::Texture2DArray:
case DXIL::ResourceKind::TextureCube:
case DXIL::ResourceKind::TextureCubeArray:
break;
case DXIL::ResourceKind::Texture3D:
if (IsSampleC) {
ValCtx.EmitInstrError(CI, rule);
}
break;
default:
ValCtx.EmitInstrError(CI, rule);
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
return;
first commit
2016-12-28 22:52:27 +03:00
}
// Coord match resource kind.
ValidateResourceCoord(CI, resKind, coords, ValCtx);
// Offset match resource kind.
ValidateResourceOffset(CI, resKind, offsets, ValCtx);
}
static void ValidateGather(CallInst *CI, Value *srvHandle, Value *samplerHandle,
ArrayRef<Value *> coords,
ArrayRef<Value *> offsets,
bool IsSampleC,
ValidationContext &ValCtx) {
if (!IsSampleC) {
if (GetSamplerKind(samplerHandle, ValCtx) != DXIL::SamplerKind::Default) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrSamplerModeForSample);
}
} else {
if (GetSamplerKind(samplerHandle, ValCtx) !=
DXIL::SamplerKind::Comparison) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrSamplerModeForSampleC);
}
}
DXIL::ComponentType compTy;
DXIL::ResourceClass resClass;
unsigned resIndex;
DXIL::ResourceKind resKind =
GetResourceKindAndCompTy(srvHandle, compTy, resClass, resIndex, ValCtx);
if (resClass != DXIL::ResourceClass::SRV) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceClassForSamplerGather);
Use undef to save type for type annotation. (#35)
2017-01-25 21:40:58 +03:00
return;
first commit
2016-12-28 22:52:27 +03:00
}
// Coord match resource kind.
ValidateResourceCoord(CI, resKind, coords, ValCtx);
// Offset match resource kind.
switch (resKind) {
case DXIL::ResourceKind::Texture2D:
case DXIL::ResourceKind::Texture2DArray: {
bool hasOffset = !isa<UndefValue>(offsets[0]);
if (hasOffset) {
if (isa<UndefValue>(offsets[1])) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceOffsetMiss);
}
}
} break;
case DXIL::ResourceKind::TextureCube:
case DXIL::ResourceKind::TextureCubeArray: {
if (!isa<UndefValue>(offsets[0])) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceOffsetTooMany);
}
if (!isa<UndefValue>(offsets[1])) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceOffsetTooMany);
}
} break;
default:
// Invalid resource type for gather.
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceKindForGather);
break;
}
}
static unsigned StoreValueToMask(ArrayRef<Value *> vals) {
unsigned mask = 0;
for (unsigned i = 0; i < 4; i++) {
if (!isa<UndefValue>(vals[i])) {
mask |= 1<<i;
}
}
return mask;
}
static int GetCBufSize(Value *cbHandle, ValidationContext &ValCtx) {
DxilInst_CreateHandle createHandle(cast<CallInst>(cbHandle));
if (!createHandle) {
ValCtx.EmitInstrError(cast<CallInst>(cbHandle),
ValidationRule::InstrHandleNotFromCreateHandle);
return -1;
}
Value *resourceClass = createHandle.get_resourceClass();
if (!isa<ConstantInt>(resourceClass)) {
Cleanup more validation TODOs.
2017-01-11 21:42:48 +03:00
ValCtx.EmitInstrError(cast<CallInst>(cbHandle),
ValidationRule::InstrOpConstRange);
first commit
2016-12-28 22:52:27 +03:00
return -1;
}
if (static_cast<DXIL::ResourceClass>(createHandle.get_resourceClass_val()) !=
DXIL::ResourceClass::CBuffer) {
ValCtx.EmitInstrError(cast<CallInst>(cbHandle), ValidationRule::InstrCBufferClassForCBufferHandle);
return -1;
}
Value *rangeIndex = createHandle.get_rangeId();
if (!isa<ConstantInt>(rangeIndex)) {
Cleanup more validation TODOs.
2017-01-11 21:42:48 +03:00
ValCtx.EmitInstrError(cast<CallInst>(cbHandle),
ValidationRule::InstrOpConstRange);
first commit
2016-12-28 22:52:27 +03:00
return -1;
}
DxilCBuffer &CB = ValCtx.DxilMod.GetCBuffer(
cast<ConstantInt>(rangeIndex)->getLimitedValue());
return CB.GetSize();
}
static unsigned GetNumVertices(DXIL::InputPrimitive inputPrimitive) {
const unsigned InputPrimitiveVertexTab[] = {
0, // Undefined = 0,
1, // Point = 1,
2, // Line = 2,
3, // Triangle = 3,
0, // Reserved4 = 4,
0, // Reserved5 = 5,
4, // LineWithAdjacency = 6,
6, // TriangleWithAdjacency = 7,
1, // ControlPointPatch1 = 8,
2, // ControlPointPatch2 = 9,
3, // ControlPointPatch3 = 10,
4, // ControlPointPatch4 = 11,
5, // ControlPointPatch5 = 12,
6, // ControlPointPatch6 = 13,
7, // ControlPointPatch7 = 14,
8, // ControlPointPatch8 = 15,
9, // ControlPointPatch9 = 16,
10, // ControlPointPatch10 = 17,
11, // ControlPointPatch11 = 18,
12, // ControlPointPatch12 = 19,
13, // ControlPointPatch13 = 20,
14, // ControlPointPatch14 = 21,
15, // ControlPointPatch15 = 22,
16, // ControlPointPatch16 = 23,
17, // ControlPointPatch17 = 24,
18, // ControlPointPatch18 = 25,
19, // ControlPointPatch19 = 26,
20, // ControlPointPatch20 = 27,
21, // ControlPointPatch21 = 28,
22, // ControlPointPatch22 = 29,
23, // ControlPointPatch23 = 30,
24, // ControlPointPatch24 = 31,
25, // ControlPointPatch25 = 32,
26, // ControlPointPatch26 = 33,
27, // ControlPointPatch27 = 34,
28, // ControlPointPatch28 = 35,
29, // ControlPointPatch29 = 36,
30, // ControlPointPatch30 = 37,
31, // ControlPointPatch31 = 38,
32, // ControlPointPatch32 = 39,
0, // LastEntry,
};
unsigned primitiveIdx = static_cast<unsigned>(inputPrimitive);
return InputPrimitiveVertexTab[primitiveIdx];
}
static void ValidateDxilOperationCallInProfile(CallInst *CI,
DXIL::OpCode opcode,
const ShaderModel *pSM,
ValidationContext &ValCtx) {
switch (opcode) {
case DXIL::OpCode::LoadInput: {
Value *inputID = CI->getArgOperand(DXIL::OperandIndex::kLoadInputIDOpIdx);
DxilSignature &inputSig = ValCtx.DxilMod.GetInputSignature();
Value *row = CI->getArgOperand(DXIL::OperandIndex::kLoadInputRowOpIdx);
Value *col = CI->getArgOperand(DXIL::OperandIndex::kLoadInputColOpIdx);
ValidateSignatureAccess(CI, inputSig, inputID, row, col, ValCtx);
// Check vertexID in ps/vs. and none array input.
Value *vertexID =
CI->getArgOperand(DXIL::OperandIndex::kLoadInputVertexIDOpIdx);
bool usedVertexID = vertexID && !isa<UndefValue>(vertexID);
if (pSM->IsVS() || pSM->IsPS()) {
if (usedVertexID) {
// use vertexID in VS/PS input.
ValCtx.EmitInstrError(CI, ValidationRule::SmOperand);
return;
}
} else {
if (ConstantInt *cVertexID = dyn_cast<ConstantInt>(vertexID)) {
int immVertexID = cVertexID->getValue().getLimitedValue();
if (cVertexID->getValue().isNegative()) {
immVertexID = cVertexID->getValue().getSExtValue();
}
const int low = 0;
int high = 0;
if (pSM->IsGS()) {
DXIL::InputPrimitive inputPrimitive =
ValCtx.DxilMod.GetInputPrimitive();
high = GetNumVertices(inputPrimitive);
} else if (pSM->IsDS()) {
high = ValCtx.DxilMod.GetInputControlPointCount();
} else if (pSM->IsHS()) {
high = ValCtx.DxilMod.GetInputControlPointCount();
} else {
ValCtx.EmitFormatError(ValidationRule::SmOpcodeInInvalidFunction,
{"LoadInput", "VS/HS/DS/GS/PS"});
}
if (immVertexID < low || immVertexID >= high) {
std::string range = std::to_string(low)+"~"+
std::to_string(high);
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
ValCtx.EmitOperandOutOfRange(CI, "VertexID", range,
std::to_string(immVertexID));
first commit
2016-12-28 22:52:27 +03:00
}
}
}
} break;
case DXIL::OpCode::DomainLocation: {
Value *colValue = CI->getArgOperand(DXIL::OperandIndex::kDomainLocationColOpIdx);
if (!isa<ConstantInt>(colValue)) {
// col must be const
ValCtx.EmitInstrFormatError(CI, ValidationRule::InstrOpConst,
{"Col", "DomainLocation"});
} else {
unsigned col = cast<ConstantInt>(colValue)->getLimitedValue();
if (col >= ValCtx.domainLocSize) {
ValCtx.EmitError(ValidationRule::SmDomainLocationIdxOOB);
}
}
} break;
case DXIL::OpCode::CBufferLoad: {
DxilInst_CBufferLoad CBLoad(CI);
Value *regIndex = CBLoad.get_byteOffset();
if (ConstantInt *cIndex = dyn_cast<ConstantInt>(regIndex)) {
int offset = cIndex->getLimitedValue();
int size = GetCBufSize(CBLoad.get_handle(), ValCtx);
if (size > 0 && offset >= size) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrCBufferOutOfBound);
}
}
} break;
case DXIL::OpCode::CBufferLoadLegacy: {
DxilInst_CBufferLoadLegacy CBLoad(CI);
Value *regIndex = CBLoad.get_regIndex();
if (ConstantInt *cIndex = dyn_cast<ConstantInt>(regIndex)) {
int offset = cIndex->getLimitedValue() * 16; // 16 bytes align
int size = GetCBufSize(CBLoad.get_handle(), ValCtx);
if (size > 0 && offset >= size) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrCBufferOutOfBound);
}
}
} break;
case DXIL::OpCode::StoreOutput: {
Value *outputID =
CI->getArgOperand(DXIL::OperandIndex::kStoreOutputIDOpIdx);
DxilSignature &outputSig = ValCtx.DxilMod.GetOutputSignature();
Value *row = CI->getArgOperand(DXIL::OperandIndex::kStoreOutputRowOpIdx);
Value *col = CI->getArgOperand(DXIL::OperandIndex::kStoreOutputColOpIdx);
ValidateSignatureAccess(CI, outputSig, outputID, row, col, ValCtx);
} break;
case DXIL::OpCode::OutputControlPointID: {
// Only used in hull shader.
Function *func = CI->getParent()->getParent();
if (ValCtx.patchConstFuncCallSet.count(func) > 0 || !ValCtx.DxilMod.GetShaderModel()->IsHS()) {
ValCtx.EmitFormatError(ValidationRule::SmOpcodeInInvalidFunction,
{"OutputControlPointID", "hull function"});
}
} break;
case DXIL::OpCode::LoadOutputControlPoint: {
// Only used in patch constant function.
Function *func = CI->getParent()->getParent();
if (ValCtx.entryFuncCallSet.count(func) > 0) {
ValCtx.EmitFormatError(
ValidationRule::SmOpcodeInInvalidFunction,
{"LoadOutputControlPoint", "PatchConstant function"});
}
Value *outputID =
CI->getArgOperand(DXIL::OperandIndex::kStoreOutputIDOpIdx);
DxilSignature &outputSig = ValCtx.DxilMod.GetOutputSignature();
Value *row = CI->getArgOperand(DXIL::OperandIndex::kStoreOutputRowOpIdx);
Value *col = CI->getArgOperand(DXIL::OperandIndex::kStoreOutputColOpIdx);
ValidateSignatureAccess(CI, outputSig, outputID, row, col, ValCtx);
} break;
case DXIL::OpCode::StorePatchConstant: {
// Only used in patch constant function.
Function *func = CI->getParent()->getParent();
if (ValCtx.entryFuncCallSet.count(func) > 0) {
ValCtx.EmitFormatError(ValidationRule::SmOpcodeInInvalidFunction,
{"StorePatchConstant", "PatchConstant function"});
}
Value *outputID =
CI->getArgOperand(DXIL::OperandIndex::kStoreOutputIDOpIdx);
DxilSignature &outputSig = ValCtx.DxilMod.GetPatchConstantSignature();
Value *row = CI->getArgOperand(DXIL::OperandIndex::kStoreOutputRowOpIdx);
Value *col = CI->getArgOperand(DXIL::OperandIndex::kStoreOutputColOpIdx);
ValidateSignatureAccess(CI, outputSig, outputID, row, col, ValCtx);
} break;
case DXIL::OpCode::EvalCentroid:
case DXIL::OpCode::EvalSampleIndex:
case DXIL::OpCode::EvalSnapped: {
// Eval* share same operand index with load input.
Value *inputID = CI->getArgOperand(DXIL::OperandIndex::kLoadInputIDOpIdx);
DxilSignature &inputSig = ValCtx.DxilMod.GetInputSignature();
Value *row = CI->getArgOperand(DXIL::OperandIndex::kLoadInputRowOpIdx);
Value *col = CI->getArgOperand(DXIL::OperandIndex::kLoadInputColOpIdx);
DxilSignatureElement *pSE =
ValidateSignatureAccess(CI, inputSig, inputID, row, col, ValCtx);
if (pSE) {
switch (pSE->GetInterpolationMode()->GetKind()) {
case DXIL::InterpolationMode::Linear:
case DXIL::InterpolationMode::LinearNoperspective:
case DXIL::InterpolationMode::LinearCentroid:
case DXIL::InterpolationMode::LinearNoperspectiveCentroid:
case DXIL::InterpolationMode::LinearSample:
case DXIL::InterpolationMode::LinearNoperspectiveSample:
break;
default:
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrEvalInterpolationMode, {pSE->GetName()});
break;
}
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
if (pSE->GetSemantic()->GetKind() == DXIL::SemanticKind::Position) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrCannotPullPosition,
{ValCtx.DxilMod.GetShaderModel()->GetName()});
}
first commit
2016-12-28 22:52:27 +03:00
}
} break;
Update barycentric with new spec (#265) 1. Adding SV_Barycentric and removing barycentric intrinsics/dxilops 2. GetAttributeAtVertex only thakes no_interpolation attribute 3. SV_Barycentric can take any interpolation modifier except nointerpolation 4. SV_Barycentric can only have float3 type
2017-05-04 03:07:02 +03:00
case DXIL::OpCode::AttributeAtVertex: {
Value *Attribute = CI->getArgOperand(DXIL::OperandIndex::kBinarySrc0OpIdx);
DxilSignature &inputSig = ValCtx.DxilMod.GetInputSignature();
Value *row = CI->getArgOperand(DXIL::OperandIndex::kLoadInputRowOpIdx);
Value *col = CI->getArgOperand(DXIL::OperandIndex::kLoadInputColOpIdx);
DxilSignatureElement *pSE =
ValidateSignatureAccess(CI, inputSig, Attribute, row, col, ValCtx);
if (pSE && pSE->GetInterpolationMode()->GetKind() !=
hlsl::InterpolationMode::Kind::Constant) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrAttributeAtVertexNoInterpolation,
{pSE->GetName()});
}
} break;
first commit
2016-12-28 22:52:27 +03:00
case DXIL::OpCode::GetDimensions: {
DxilInst_GetDimensions getDim(CI);
Value *handle = getDim.get_handle();
DXIL::ComponentType compTy;
DXIL::ResourceClass resClass;
unsigned resIndex;
DXIL::ResourceKind resKind =
GetResourceKindAndCompTy(handle, compTy, resClass, resIndex, ValCtx);
// Check the result component use.
ResRetUsage usage;
CollectGetDimResRetUsage(usage, CI, ValCtx);
// Mip level only for texture.
switch (resKind) {
case DXIL::ResourceKind::Texture1D:
if (usage.y) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrUndefResultForGetDimension,
{"y", "Texture1D"});
}
if (usage.z) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrUndefResultForGetDimension,
{"z", "Texture1D"});
}
break;
case DXIL::ResourceKind::Texture1DArray:
if (usage.z) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrUndefResultForGetDimension,
{"z", "Texture1DArray"});
}
break;
case DXIL::ResourceKind::Texture2D:
if (usage.z) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrUndefResultForGetDimension,
{"z", "Texture2D"});
}
break;
case DXIL::ResourceKind::Texture2DArray:
break;
case DXIL::ResourceKind::Texture2DMS:
if (usage.z) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrUndefResultForGetDimension,
{"z", "Texture2DMS"});
}
break;
case DXIL::ResourceKind::Texture2DMSArray:
break;
case DXIL::ResourceKind::Texture3D:
break;
case DXIL::ResourceKind::TextureCube:
if (usage.z) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrUndefResultForGetDimension,
{"z", "TextureCube"});
}
break;
case DXIL::ResourceKind::TextureCubeArray:
break;
case DXIL::ResourceKind::StructuredBuffer:
case DXIL::ResourceKind::RawBuffer:
case DXIL::ResourceKind::TypedBuffer:
case DXIL::ResourceKind::TBuffer: {
Value *mip = getDim.get_mipLevel();
if (!isa<UndefValue>(mip)) {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrMipLevelForGetDimension);
}
if (resKind != DXIL::ResourceKind::Invalid) {
if (usage.y || usage.z || usage.w) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrUndefResultForGetDimension,
{"invalid", "resource"});
}
}
} break;
default: {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrResourceKindForGetDim);
} break;
}
if (usage.status) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrUndefResultForGetDimension,
{"invalid", "resource"});
}
} break;
case DXIL::OpCode::CalculateLOD: {
DxilInst_CalculateLOD lod(CI);
Value *samplerHandle = lod.get_sampler();
if (GetSamplerKind(samplerHandle, ValCtx) != DXIL::SamplerKind::Default) {
ValCtx.EmitInstrError(CI,
ValidationRule::InstrSamplerModeForLOD);
}
Value *handle = lod.get_handle();
DXIL::ComponentType compTy;
DXIL::ResourceClass resClass;
unsigned resIndex;
DXIL::ResourceKind resKind =
GetResourceKindAndCompTy(handle, compTy, resClass, resIndex, ValCtx);
if (resClass != DXIL::ResourceClass::SRV) {
ValCtx.EmitInstrError(CI,
ValidationRule::InstrResourceClassForSamplerGather);
Use undef to save type for type annotation. (#35)
2017-01-25 21:40:58 +03:00
return;
first commit
2016-12-28 22:52:27 +03:00
}
// Coord match resource.
ValidateCalcLODResourceDimensionCoord(
CI, resKind, {lod.get_coord0(), lod.get_coord1(), lod.get_coord2()},
ValCtx);
switch (resKind) {
case DXIL::ResourceKind::Texture1D:
case DXIL::ResourceKind::Texture1DArray:
case DXIL::ResourceKind::Texture2D:
case DXIL::ResourceKind::Texture2DArray:
case DXIL::ResourceKind::Texture3D:
case DXIL::ResourceKind::TextureCube:
case DXIL::ResourceKind::TextureCubeArray:
break;
default:
ValCtx.EmitInstrError(
CI, ValidationRule::InstrResourceKindForCalcLOD);
break;
}
} break;
case DXIL::OpCode::TextureGather: {
DxilInst_TextureGather gather(CI);
ValidateGather(CI, gather.get_srv(), gather.get_sampler(),
{gather.get_coord0(), gather.get_coord1(),
gather.get_coord2(), gather.get_coord3()},
{gather.get_offset0(), gather.get_offset1()},
/*IsSampleC*/ false, ValCtx);
} break;
case DXIL::OpCode::TextureGatherCmp: {
DxilInst_TextureGatherCmp gather(CI);
ValidateGather(CI, gather.get_srv(), gather.get_sampler(),
{gather.get_coord0(), gather.get_coord1(),
gather.get_coord2(), gather.get_coord3()},
{gather.get_offset0(), gather.get_offset1()},
/*IsSampleC*/ true, ValCtx);
} break;
case DXIL::OpCode::Sample: {
DxilInst_Sample sample(CI);
ValidateSampleInst(
CI, sample.get_srv(), sample.get_sampler(),
{sample.get_coord0(), sample.get_coord1(), sample.get_coord2(),
sample.get_coord3()},
{sample.get_offset0(), sample.get_offset1(), sample.get_offset2()},
/*IsSampleC*/ false, ValCtx);
} break;
case DXIL::OpCode::SampleCmp: {
DxilInst_SampleCmp sample(CI);
ValidateSampleInst(
CI, sample.get_srv(), sample.get_sampler(),
{sample.get_coord0(), sample.get_coord1(), sample.get_coord2(),
sample.get_coord3()},
{sample.get_offset0(), sample.get_offset1(), sample.get_offset2()},
/*IsSampleC*/ true, ValCtx);
} break;
case DXIL::OpCode::SampleCmpLevelZero: {
// sampler must be comparison mode.
DxilInst_SampleCmpLevelZero sample(CI);
ValidateSampleInst(
CI, sample.get_srv(), sample.get_sampler(),
{sample.get_coord0(), sample.get_coord1(), sample.get_coord2(),
sample.get_coord3()},
{sample.get_offset0(), sample.get_offset1(), sample.get_offset2()},
/*IsSampleC*/ true, ValCtx);
} break;
case DXIL::OpCode::SampleBias: {
DxilInst_SampleBias sample(CI);
Value *bias = sample.get_bias();
if (ConstantFP *cBias = dyn_cast<ConstantFP>(bias)) {
float fBias = cBias->getValueAPF().convertToFloat();
if (fBias < DXIL::kMinMipLodBias || fBias > DXIL::kMaxMipLodBias) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrImmBiasForSampleB,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(DXIL::kMinMipLodBias),
std::to_string(DXIL::kMaxMipLodBias),
std::to_string(cBias->getValueAPF().convertToFloat())});
first commit
2016-12-28 22:52:27 +03:00
}
}
ValidateSampleInst(
CI, sample.get_srv(), sample.get_sampler(),
{sample.get_coord0(), sample.get_coord1(), sample.get_coord2(),
sample.get_coord3()},
{sample.get_offset0(), sample.get_offset1(), sample.get_offset2()},
/*IsSampleC*/ false, ValCtx);
} break;
case DXIL::OpCode::SampleGrad: {
DxilInst_SampleGrad sample(CI);
ValidateSampleInst(
CI, sample.get_srv(), sample.get_sampler(),
{sample.get_coord0(), sample.get_coord1(), sample.get_coord2(),
sample.get_coord3()},
{sample.get_offset0(), sample.get_offset1(), sample.get_offset2()},
/*IsSampleC*/ false, ValCtx);
} break;
case DXIL::OpCode::SampleLevel: {
DxilInst_SampleLevel sample(CI);
ValidateSampleInst(
CI, sample.get_srv(), sample.get_sampler(),
{sample.get_coord0(), sample.get_coord1(), sample.get_coord2(),
sample.get_coord3()},
{sample.get_offset0(), sample.get_offset1(), sample.get_offset2()},
/*IsSampleC*/ false, ValCtx);
} break;
Make sure status only used by CheckAccessFullyMapped. (#763) * Make sure status only used by CheckAccessFullyMapped.
2017-11-04 04:12:15 +03:00
case DXIL::OpCode::CheckAccessFullyMapped: {
Value *Src = CI->getArgOperand(DXIL::OperandIndex::kUnarySrc0OpIdx);
ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(Src);
if (!EVI) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrCheckAccessFullyMapped);
} else {
Value *V = EVI->getOperand(0);
bool isLegal = EVI->getNumIndices() == 1 &&
EVI->getIndices()[0] == DXIL::kResRetStatusIndex &&
ValCtx.DxilMod.GetOP()->IsResRetType(V->getType());
if (!isLegal) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrCheckAccessFullyMapped);
}
}
} break;
first commit
2016-12-28 22:52:27 +03:00
case DXIL::OpCode::Barrier: {
DxilInst_Barrier barrier(CI);
Value *mode = barrier.get_barrierMode();
ConstantInt *cMode = dyn_cast<ConstantInt>(mode);
if (!cMode) {
ValCtx.EmitInstrFormatError(CI, ValidationRule::InstrOpConst,
{"Mode", "Barrier"});
return;
}
const unsigned uglobal =
static_cast<unsigned>(DXIL::BarrierMode::UAVFenceGlobal);
const unsigned g = static_cast<unsigned>(DXIL::BarrierMode::TGSMFence);
const unsigned t =
static_cast<unsigned>(DXIL::BarrierMode::SyncThreadGroup);
const unsigned ut =
static_cast<unsigned>(DXIL::BarrierMode::UAVFenceThreadGroup);
unsigned barrierMode = cMode->getLimitedValue();
if (ValCtx.DxilMod.GetShaderModel()->IsCS()) {
bool bHasUGlobal = barrierMode & uglobal;
bool bHasGroup = barrierMode & g;
bool bHasUGroup = barrierMode & ut;
if (bHasUGlobal && bHasUGroup) {
ValCtx.EmitInstrError(CI,
ValidationRule::InstrBarrierModeUselessUGroup);
}
if (!bHasUGlobal && !bHasGroup && !bHasUGroup) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrBarrierModeNoMemory);
}
} else {
if (uglobal != barrierMode) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrBarrierModeForNonCS);
}
}
} break;
case DXIL::OpCode::BufferStore: {
DxilInst_BufferStore bufSt(CI);
DXIL::ComponentType compTy;
DXIL::ResourceClass resClass;
unsigned resIndex;
DXIL::ResourceKind resKind =
GetResourceKindAndCompTy(bufSt.get_uav(), compTy, resClass, resIndex, ValCtx);
if (resClass != DXIL::ResourceClass::UAV) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceClassForUAVStore);
}
ConstantInt *mask = dyn_cast<ConstantInt>(bufSt.get_mask());
if (!mask) {
// Mask for buffer store should be immediate.
ValCtx.EmitInstrFormatError(CI, ValidationRule::InstrOpConst, {"Mask", "BufferStore"});
return;
}
unsigned uMask = mask->getLimitedValue();
unsigned stValMask =
StoreValueToMask({bufSt.get_value0(), bufSt.get_value1(),
bufSt.get_value2(), bufSt.get_value3()});
if (stValMask != uMask) {
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrWriteMaskMatchValueForUAVStore,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(uMask), std::to_string(stValMask)});
first commit
2016-12-28 22:52:27 +03:00
}
Value *offset = bufSt.get_coord1();
switch (resKind) {
case DXIL::ResourceKind::RawBuffer:
if (!isa<UndefValue>(offset)) {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrCoordinateCountForRawTypedBuf);
}
break;
case DXIL::ResourceKind::TypedBuffer:
case DXIL::ResourceKind::TBuffer:
if (!isa<UndefValue>(offset)) {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrCoordinateCountForRawTypedBuf);
}
if (uMask != 0xf) {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrWriteMaskForTypedUAVStore);
}
break;
case DXIL::ResourceKind::StructuredBuffer:
if (isa<UndefValue>(offset)) {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrCoordinateCountForStructBuf);
}
break;
default:
ValCtx.EmitInstrError(
CI, ValidationRule::InstrResourceKindForBufferLoadStore);
break;
}
} break;
case DXIL::OpCode::TextureStore: {
DxilInst_TextureStore texSt(CI);
DXIL::ComponentType compTy;
DXIL::ResourceClass resClass;
unsigned resIndex;
DXIL::ResourceKind resKind =
GetResourceKindAndCompTy(texSt.get_srv(), compTy, resClass, resIndex, ValCtx);
if (resClass != DXIL::ResourceClass::UAV) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceClassForUAVStore);
}
ConstantInt *mask = dyn_cast<ConstantInt>(texSt.get_mask());
if (!mask) {
// Mask for buffer store should be immediate.
ValCtx.EmitInstrFormatError(CI, ValidationRule::InstrOpConst, {"Mask", "TextureStore"});
return;
}
unsigned uMask = mask->getLimitedValue();
if (uMask != 0xf) {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrWriteMaskForTypedUAVStore);
}
unsigned stValMask =
StoreValueToMask({texSt.get_value0(), texSt.get_value1(),
texSt.get_value2(), texSt.get_value3()});
if (stValMask != uMask) {
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
ValCtx.EmitInstrFormatError(
CI, ValidationRule::InstrWriteMaskMatchValueForUAVStore,
{std::to_string(uMask), std::to_string(stValMask)});
first commit
2016-12-28 22:52:27 +03:00
}
switch (resKind) {
case DXIL::ResourceKind::Texture1D:
case DXIL::ResourceKind::Texture1DArray:
case DXIL::ResourceKind::Texture2D:
case DXIL::ResourceKind::Texture2DArray:
case DXIL::ResourceKind::Texture3D:
break;
default:
ValCtx.EmitInstrError(
CI, ValidationRule::InstrResourceKindForTextureStore);
break;
}
} break;
case DXIL::OpCode::BufferLoad: {
DxilInst_BufferLoad bufLd(CI);
DXIL::ComponentType compTy;
DXIL::ResourceClass resClass;
unsigned resIndex;
DXIL::ResourceKind resKind =
GetResourceKindAndCompTy(bufLd.get_srv(), compTy, resClass, resIndex, ValCtx);
if (resClass != DXIL::ResourceClass::SRV &&
resClass != DXIL::ResourceClass::UAV) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceClassForLoad);
}
Value *offset = bufLd.get_wot();
switch (resKind) {
case DXIL::ResourceKind::RawBuffer:
case DXIL::ResourceKind::TypedBuffer:
case DXIL::ResourceKind::TBuffer:
if (!isa<UndefValue>(offset)) {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrCoordinateCountForRawTypedBuf);
}
break;
case DXIL::ResourceKind::StructuredBuffer:
if (isa<UndefValue>(offset)) {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrCoordinateCountForStructBuf);
}
break;
default:
ValCtx.EmitInstrError(
CI, ValidationRule::InstrResourceKindForBufferLoadStore);
break;
}
} break;
case DXIL::OpCode::TextureLoad: {
DxilInst_TextureLoad texLd(CI);
DXIL::ComponentType compTy;
DXIL::ResourceClass resClass;
unsigned resIndex;
DXIL::ResourceKind resKind =
GetResourceKindAndCompTy(texLd.get_srv(), compTy, resClass, resIndex, ValCtx);
Value *mipLevel = texLd.get_mipLevelOrSampleCount();
if (resClass == DXIL::ResourceClass::UAV) {
bool noOffset = isa<UndefValue>(texLd.get_offset0());
noOffset &= isa<UndefValue>(texLd.get_offset1());
noOffset &= isa<UndefValue>(texLd.get_offset2());
if (!noOffset) {
ValCtx.EmitInstrError(CI,
ValidationRule::InstrOffsetOnUAVLoad);
}
if (!isa<UndefValue>(mipLevel)) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrMipOnUAVLoad);
}
} else {
if (resClass != DXIL::ResourceClass::SRV) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrResourceClassForLoad);
}
}
switch (resKind) {
case DXIL::ResourceKind::Texture1D:
case DXIL::ResourceKind::Texture1DArray:
case DXIL::ResourceKind::Texture2D:
case DXIL::ResourceKind::Texture2DArray:
case DXIL::ResourceKind::Texture3D:
break;
case DXIL::ResourceKind::Texture2DMS:
case DXIL::ResourceKind::Texture2DMSArray: {
if (isa<UndefValue>(mipLevel)) {
ValCtx.EmitInstrError(
CI, ValidationRule::InstrSampleIndexForLoad2DMS);
}
} break;
default:
ValCtx.EmitInstrError(
CI, ValidationRule::InstrResourceKindForTextureLoad);
break;
}
} break;
case DXIL::OpCode::CutStream:
case DXIL::OpCode::EmitThenCutStream:
case DXIL::OpCode::EmitStream: {
if (pSM->IsGS()) {
unsigned streamMask = ValCtx.DxilMod.GetActiveStreamMask();
Value *streamID =
CI->getArgOperand(DXIL::OperandIndex::kStreamEmitCutIDOpIdx);
if (ConstantInt *cStreamID = dyn_cast<ConstantInt>(streamID)) {
int immStreamID = cStreamID->getValue().getLimitedValue();
if (cStreamID->getValue().isNegative() || immStreamID >= 4) {
ValCtx.EmitOperandOutOfRange(CI, "StreamID","0~4",
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(immStreamID));
first commit
2016-12-28 22:52:27 +03:00
} else {
unsigned immMask = 1 << immStreamID;
if ((streamMask & immMask) == 0) {
std::string range;
for (unsigned i = 0; i < 4; i++) {
if (streamMask & (1 << i)) {
range += std::to_string(i) + " ";
}
}
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
ValCtx.EmitOperandOutOfRange(CI, "StreamID", range,
std::to_string(immStreamID));
first commit
2016-12-28 22:52:27 +03:00
}
}
} else {
ValCtx.EmitInstrFormatError(CI, ValidationRule::InstrOpConst,
{"StreamID", "Emit/CutStream"});
}
} else {
ValCtx.EmitInstrFormatError(CI, ValidationRule::SmOpcodeInInvalidFunction,
{"Emit/CutStream", "Geometry shader"});
}
} break;
case DXIL::OpCode::BufferUpdateCounter: {
DxilInst_BufferUpdateCounter updateCounter(CI);
DXIL::ComponentType compTy;
DXIL::ResourceClass resClass;
unsigned resIndex;
DXIL::ResourceKind resKind =
GetResourceKindAndCompTy(updateCounter.get_uav(), compTy, resClass, resIndex, ValCtx);
if (resClass != DXIL::ResourceClass::UAV) {
ValCtx.EmitInstrError(CI,
ValidationRule::InstrBufferUpdateCounterOnUAV);
}
if (resKind != DXIL::ResourceKind::StructuredBuffer) {
ValCtx.EmitInstrError(CI,
ValidationRule::SmCounterOnlyOnStructBuf);
}
Value *inc = updateCounter.get_inc();
if (ConstantInt *cInc = dyn_cast<ConstantInt>(inc)) {
bool isInc = cInc->getLimitedValue() == 1;
if (ValCtx.UavCounterIncMap.count(resIndex)) {
if (isInc != ValCtx.UavCounterIncMap[resIndex]) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrOnlyOneAllocConsume);
}
}
else {
ValCtx.UavCounterIncMap[resIndex] = isInc;
}
} else {
ValCtx.EmitInstrFormatError(CI, ValidationRule::InstrOpConst, {"inc", "BufferUpdateCounter"});
}
} break;
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
case DXIL::OpCode::Asin: {
DxilInst_Asin I(CI);
if (ConstantFP *imm = dyn_cast<ConstantFP>(I.get_value())) {
if (imm->getValueAPF().isInfinity()) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrNoIndefiniteAsin);
}
}
} break;
case DXIL::OpCode::Acos: {
DxilInst_Acos I(CI);
if (ConstantFP *imm = dyn_cast<ConstantFP>(I.get_value())) {
if (imm->getValueAPF().isInfinity()) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrNoIndefiniteAcos);
}
}
} break;
case DXIL::OpCode::Log: {
DxilInst_Log I(CI);
if (ConstantFP *imm = dyn_cast<ConstantFP>(I.get_value())) {
if (imm->getValueAPF().isInfinity()) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrNoIndefiniteLog);
}
}
} break;
case DXIL::OpCode::DerivFineX:
case DXIL::OpCode::DerivFineY:
case DXIL::OpCode::DerivCoarseX:
case DXIL::OpCode::DerivCoarseY: {
Value *V = CI->getArgOperand(DXIL::OperandIndex::kUnarySrc0OpIdx);
if (ConstantFP *imm = dyn_cast<ConstantFP>(V)) {
if (imm->getValueAPF().isInfinity()) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrNoIndefiniteDsxy);
}
}
} break;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
case DXIL::OpCode::Coverage:
ValCtx.m_bCoverageIn = true;
break;
case DXIL::OpCode::InnerCoverage:
ValCtx.m_bInnerCoverageIn = true;
break;
Add ViewID slot validation for PSIn (#254)
2017-05-02 03:54:33 +03:00
case DXIL::OpCode::ViewID:
ValCtx.hasViewID = true;
break;
Add validation for Quad operations against non pixel shaders (#986)
2018-01-16 21:33:47 +03:00
case DXIL::OpCode::QuadOp:
if (!pSM->IsPS())
ValCtx.EmitFormatError(ValidationRule::SmOpcodeInInvalidFunction,
{"QuadReadAcross", "Pixel Shader"});
break;
case DXIL::OpCode::QuadReadLaneAt:
if (!pSM->IsPS())
ValCtx.EmitFormatError(ValidationRule::SmOpcodeInInvalidFunction,
{"QuadReadLaneAt", "Pixel Shader"});
break;
Add default for switch to avoid warnings. (#70)
2017-02-07 22:34:34 +03:00
default:
// Skip opcodes don't need special check.
break;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
}
if (ValCtx.m_bCoverageIn && ValCtx.m_bInnerCoverageIn) {
ValCtx.EmitError(ValidationRule::SmPSCoverageAndInnerCoverage);
first commit
2016-12-28 22:52:27 +03:00
}
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
first commit
2016-12-28 22:52:27 +03:00
}
static bool IsDxilFunction(llvm::Function *F) {
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
unsigned argSize = F->arg_size();
first commit
2016-12-28 22:52:27 +03:00
if (argSize < 1) {
// Cannot be a DXIL operation.
return false;
}
return OP::IsDxilOpFunc(F);
}
static void ValidateExternalFunction(Function *F, ValidationContext &ValCtx) {
if (!IsDxilFunction(F)) {
ValCtx.EmitGlobalValueError(F, ValidationRule::DeclDxilFnExtern);
return;
}
if (F->use_empty()) {
ValCtx.EmitGlobalValueError(F, ValidationRule::DeclUsedExternalFunction);
return;
}
const ShaderModel *pSM = ValCtx.DxilMod.GetShaderModel();
OP *hlslOP = ValCtx.DxilMod.GetOP();
Type *voidTy = Type::getVoidTy(F->getContext());
for (User *user : F->users()) {
CallInst *CI = dyn_cast<CallInst>(user);
if (!CI) {
ValCtx.EmitGlobalValueError(F, ValidationRule::DeclFnIsCalled);
continue;
}
Value *argOpcode = CI->getArgOperand(0);
ConstantInt *constOpcode = dyn_cast<ConstantInt>(argOpcode);
if (!constOpcode) {
// opcode not immediate; function body will validate this error.
continue;
}
unsigned opcode = constOpcode->getLimitedValue();
if (opcode >= (unsigned)DXIL::OpCode::NumOpCodes) {
// invalid opcode; function body will validate this error.
continue;
}
DXIL::OpCode dxilOpcode = (DXIL::OpCode)opcode;
// In some cases, no overloads are provided (void is exclusive to others)
Function *dxilFunc;
if (hlslOP->IsOverloadLegal(dxilOpcode, voidTy)) {
dxilFunc = hlslOP->GetOpFunc(dxilOpcode, voidTy);
}
else {
Translate AddUint64. (#47)
2017-01-30 23:30:25 +03:00
Type *Ty = hlslOP->GetOverloadType(dxilOpcode, CI->getCalledFunction());
first commit
2016-12-28 22:52:27 +03:00
try {
if (!hlslOP->IsOverloadLegal(dxilOpcode, Ty)) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrOload);
continue;
}
}
catch (...) {
ValCtx.EmitInstrError(CI, ValidationRule::InstrOload);
continue;
}
dxilFunc = hlslOP->GetOpFunc(dxilOpcode, Ty->getScalarType());
}
if (!dxilFunc) {
// Cannot find dxilFunction based on opcode and type.
ValCtx.EmitInstrError(CI, ValidationRule::InstrOload);
continue;
}
if (dxilFunc->getFunctionType() != F->getFunctionType()) {
ValCtx.EmitGlobalValueError(dxilFunc, ValidationRule::InstrCallOload);
continue;
}
if (!ValidateOpcodeInProfile(dxilOpcode, pSM)) {
// Opcode not available in profile.
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
ValCtx.EmitInstrFormatError(CI, ValidationRule::SmOpcode,
{hlslOP->GetOpCodeName(dxilOpcode),
pSM->GetName()});
first commit
2016-12-28 22:52:27 +03:00
continue;
}
// Check more detail.
ValidateDxilOperationCallInProfile(CI, dxilOpcode, pSM, ValCtx);
}
}
///////////////////////////////////////////////////////////////////////////////
// Instruction validation functions. //
static bool IsLLVMInstructionAllowed(llvm::Instruction &I) {
unsigned op = I.getOpcode();
/* <py::lines('OPCODE-ALLOWED')>hctdb_instrhelp.get_instrs_pred("op", lambda i: not i.is_dxil_op and i.is_allowed, "llvm_id")</py>*/
// OPCODE-ALLOWED:BEGIN
// Instructions: Ret=1, Br=2, Switch=3, Add=8, FAdd=9, Sub=10, FSub=11, Mul=12,
// FMul=13, UDiv=14, SDiv=15, FDiv=16, URem=17, SRem=18, FRem=19, Shl=20,
// LShr=21, AShr=22, And=23, Or=24, Xor=25, Alloca=26, Load=27, Store=28,
// GetElementPtr=29, AtomicCmpXchg=31, AtomicRMW=32, Trunc=33, ZExt=34,
// SExt=35, FPToUI=36, FPToSI=37, UIToFP=38, SIToFP=39, FPTrunc=40, FPExt=41,
// BitCast=44, AddrSpaceCast=45, ICmp=46, FCmp=47, PHI=48, Call=49, Select=50,
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
// ExtractValue=57
[linux-port] Correct conditional groupings (#1326) Clang and gcc complain when AND and OR logical operations are both used in a single conditional because of the possibility of mistakes when depending solely on operator precedence. In fact, this change fixes a few clear errors mostly in asserts that would never fire. Fixes 13 clang and 22 gcc warnings. Additionally, when two if statements are followed by an else, there may be some ambiguity in terms of which if the else applies to. It is the closest one, the second in the case of two, but it is another area of potential mistakes. Adding braces around the code intended as the block of the first if conditional clarifies this. fixed 8 clang and 8 gcc warnings. Clang complains sometimes when assignments take place in a conditional without additional parenthesis around it. It can indicate when what was meant to be an equal comparison is replaced with an assignment. fixes 2 clang warnings.
2018-06-02 11:19:14 +03:00
return (1 <= op && op <= 3) || (8 <= op && op <= 29) || (31 <= op && op <= 41) || (44 <= op && op <= 50) || op == 57;
first commit
2016-12-28 22:52:27 +03:00
// OPCODE-ALLOWED:END
}
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
static bool IsDxilBuiltinStructType(StructType *ST, hlsl::OP *hlslOP) {
if (ST == hlslOP->GetBinaryWithCarryType())
return true;
if (ST == hlslOP->GetBinaryWithTwoOutputsType())
return true;
if (ST == hlslOP->GetInt4Type())
return true;
if (ST == hlslOP->GetDimensionsType())
return true;
if (ST == hlslOP->GetHandleType())
return true;
if (ST == hlslOP->GetSamplePosType())
return true;
if (ST == hlslOP->GetSplitDoubleType())
return true;
unsigned EltNum = ST->getNumElements();
switch (EltNum) {
case 2:
Fp16 constant buffer and shader flag (#575) This change is to support fp16 on constant buffer. We are still keeping a row pitch of 4 dwords. So we can fit up to 8 halfs in one row. Dword data types will be aligned to dword address space for efficiency. We are also introducing new flags "use native low precision" if we have low precision type present and /no-min-precision option is enabled.
2017-08-22 01:06:45 +03:00
case 4:
case 8: { // 2 for doubles, 8 for halfs.
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
Type *EltTy = ST->getElementType(0);
return ST == hlslOP->GetCBufferRetType(EltTy);
} break;
case 5: {
Type *EltTy = ST->getElementType(0);
return ST == hlslOP->GetResRetType(EltTy);
} break;
default:
return false;
}
}
first commit
2016-12-28 22:52:27 +03:00
static bool ValidateType(Type *Ty, ValidationContext &ValCtx) {
DXASSERT_NOMSG(Ty != nullptr);
if (Ty->isPointerTy()) {
return ValidateType(Ty->getPointerElementType(), ValCtx);
}
if (Ty->isArrayTy()) {
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
Type *EltTy = Ty->getArrayElementType();
if (isa<ArrayType>(EltTy)) {
ValCtx.EmitTypeError(Ty, ValidationRule::TypesNoMultiDim);
return false;
}
return ValidateType(EltTy, ValCtx);
first commit
2016-12-28 22:52:27 +03:00
}
if (Ty->isStructTy()) {
bool result = true;
StructType *ST = cast<StructType>(Ty);
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
first commit
2016-12-28 22:52:27 +03:00
StringRef Name = ST->getName();
if (Name.startswith("dx.")) {
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
hlsl::OP *hlslOP = ValCtx.DxilMod.GetOP();
Only allow dxil struct on ExtractVal. (#49)
2017-01-31 01:56:00 +03:00
if (IsDxilBuiltinStructType(ST, hlslOP)) {
ValCtx.EmitTypeError(Ty, ValidationRule::InstrDxilStructUser);
result = false;
}
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
ValCtx.EmitTypeError(Ty, ValidationRule::DeclDxilNsReserved);
result = false;
first commit
2016-12-28 22:52:27 +03:00
}
for (auto e : ST->elements()) {
if (!ValidateType(e, ValCtx)) {
result = false;
}
}
return result;
}
if (Ty->isFloatTy() || Ty->isHalfTy() || Ty->isDoubleTy()) {
return true;
}
if (Ty->isIntegerTy()) {
unsigned width = Ty->getIntegerBitWidth();
if (width != 1 && width != 8 && width != 16 && width != 32 && width != 64) {
ValCtx.EmitTypeError(Ty, ValidationRule::TypesIntWidth);
return false;
}
return true;
}
if (Ty->isVectorTy()) {
ValCtx.EmitTypeError(Ty, ValidationRule::TypesNoVector);
return false;
}
ValCtx.EmitTypeError(Ty, ValidationRule::TypesDefined);
return false;
}
static bool GetNodeOperandAsInt(ValidationContext &ValCtx, MDNode *pMD, unsigned index, uint64_t *pValue) {
*pValue = 0;
if (pMD->getNumOperands() < index) {
ValCtx.EmitMetaError(pMD, ValidationRule::MetaWellFormed);
return false;
}
ConstantAsMetadata *C = dyn_cast<ConstantAsMetadata>(pMD->getOperand(index));
if (C == nullptr) {
ValCtx.EmitMetaError(pMD, ValidationRule::MetaWellFormed);
return false;
}
ConstantInt *CI = dyn_cast<ConstantInt>(C->getValue());
if (CI == nullptr) {
ValCtx.EmitMetaError(pMD, ValidationRule::MetaWellFormed);
return false;
}
*pValue = CI->getValue().getZExtValue();
return true;
}
static bool IsPrecise(Instruction &I, ValidationContext &ValCtx) {
MDNode *pMD = I.getMetadata(DxilMDHelper::kDxilPreciseAttributeMDName);
if (pMD == nullptr) {
return false;
}
if (pMD->getNumOperands() != 1) {
ValCtx.EmitMetaError(pMD, ValidationRule::MetaWellFormed);
return false;
}
uint64_t val;
if (!GetNodeOperandAsInt(ValCtx, pMD, 0, &val)) {
return false;
}
if (val == 1) {
return true;
}
if (val != 0) {
ValCtx.EmitMetaError(pMD, ValidationRule::MetaValueRange);
}
return false;
}
static bool IsValueMinPrec(DxilModule &DxilMod, Value *V) {
DXASSERT(DxilMod.GetGlobalFlags() & DXIL::kEnableMinPrecision,
"else caller didn't check - currently this path should never be hit "
"otherwise");
[linux-port] Dummy access to unused variables (#1325) Simply including a variable as the entirity of an expression is insufficient to silence warnings for gcc and clang. The variable is not reported as unused, which is the intent, but the expression result is reported in a warning as unused. By casting that expression as (void), both warnings are silenced. Fixes 110 clang and 40 gcc warnings.
2018-06-02 02:44:16 +03:00
(void)(DxilMod);
first commit
2016-12-28 22:52:27 +03:00
Type *Ty = V->getType();
if (Ty->isIntegerTy()) {
return 16 == Ty->getIntegerBitWidth();
}
return Ty->isHalfTy();
}
static void ValidateGradientOps(Function *F, ArrayRef<CallInst *> ops, ArrayRef<CallInst *> barriers, ValidationContext &ValCtx) {
// In the absence of wave operations, the wave validation effect need not happen.
// We haven't verified this is true at this point, but validation will fail
// later if the flags don't match in any case. Given that most shaders will
// not be using these wave operations, it's a reasonable cost saving.
if (!ValCtx.DxilMod.m_ShaderFlags.GetWaveOps()) {
return;
}
std::unique_ptr<WaveSensitivityAnalysis> WaveVal(WaveSensitivityAnalysis::create());
WaveVal->Analyze(F);
for (CallInst *op : ops) {
if (WaveVal->IsWaveSensitive(op)) {
ValCtx.EmitInstrError(op, ValidationRule::UniNoWaveSensitiveGradient);
}
}
}
static void ValidateControlFlowHint(BasicBlock &bb, ValidationContext &ValCtx) {
// Validate controlflow hint.
TerminatorInst *TI = bb.getTerminator();
if (!TI)
return;
MDNode *pNode = TI->getMetadata(DxilMDHelper::kDxilControlFlowHintMDName);
if (!pNode)
return;
if (pNode->getNumOperands() < 3)
return;
bool bHasBranch = false;
bool bHasFlatten = false;
bool bForceCase = false;
for (unsigned i = 2; i < pNode->getNumOperands(); i++) {
uint64_t value = 0;
if (GetNodeOperandAsInt(ValCtx, pNode, i, &value)) {
DXIL::ControlFlowHint hint = static_cast<DXIL::ControlFlowHint>(value);
switch (hint) {
case DXIL::ControlFlowHint::Flatten:
bHasFlatten = true;
break;
case DXIL::ControlFlowHint::Branch:
bHasBranch = true;
break;
case DXIL::ControlFlowHint::ForceCase:
bForceCase = true;
break;
default:
ValCtx.EmitMetaError(pNode,
ValidationRule::MetaInvalidControlFlowHint);
}
}
}
if (bHasBranch && bHasFlatten) {
ValCtx.EmitMetaError(pNode, ValidationRule::MetaBranchFlatten);
}
if (bForceCase && !isa<SwitchInst>(TI)) {
ValCtx.EmitMetaError(pNode, ValidationRule::MetaForceCaseOnSwitch);
}
}
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
static void ValidateTBAAMetadata(MDNode *Node, ValidationContext &ValCtx) {
switch (Node->getNumOperands()) {
case 1: {
if (Node->getOperand(0)->getMetadataID() != Metadata::MDStringKind) {
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
}
} break;
case 2: {
MDNode *rootNode = dyn_cast<MDNode>(Node->getOperand(1));
if (!rootNode) {
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
} else {
ValidateTBAAMetadata(rootNode, ValCtx);
}
} break;
case 3: {
MDNode *rootNode = dyn_cast<MDNode>(Node->getOperand(1));
if (!rootNode) {
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
} else {
ValidateTBAAMetadata(rootNode, ValCtx);
}
ConstantAsMetadata *pointsToConstMem = dyn_cast<ConstantAsMetadata>(Node->getOperand(2));
if (!pointsToConstMem) {
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
} else {
ConstantInt *isConst = dyn_cast<ConstantInt>(pointsToConstMem->getValue());
if (!isConst) {
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
} else if (isConst->getValue().getLimitedValue() > 1) {
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
}
}
} break;
default:
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
}
}
static void ValidateLoopMetadata(MDNode *Node, ValidationContext &ValCtx) {
if (Node->getNumOperands() == 0 || Node->getNumOperands() > 2) {
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
return;
}
if (Node != Node->getOperand(0).get()) {
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
return;
}
if (Node->getNumOperands() == 1) {
return;
}
MDNode *LoopNode = dyn_cast<MDNode>(Node->getOperand(1).get());
if (!LoopNode) {
ValCtx.EmitMetaError(Node, ValidationRule::MetaWellFormed);
return;
}
if (LoopNode->getNumOperands() < 1 || LoopNode->getNumOperands() > 2) {
ValCtx.EmitMetaError(LoopNode, ValidationRule::MetaWellFormed);
return;
}
if (LoopNode->getOperand(0) == LoopNode) {
ValidateLoopMetadata(LoopNode, ValCtx);
return;
}
MDString *LoopStr = dyn_cast<MDString>(LoopNode->getOperand(0));
if (!LoopStr) {
ValCtx.EmitMetaError(LoopNode, ValidationRule::MetaWellFormed);
return;
}
StringRef Name = LoopStr->getString();
if (Name != "llvm.loop.unroll.full" && Name != "llvm.loop.unroll.disable" &&
Name != "llvm.loop.unroll.count") {
ValCtx.EmitMetaError(LoopNode, ValidationRule::MetaWellFormed);
return;
}
if (Name == "llvm.loop.unroll.count") {
if (LoopNode->getNumOperands() != 2) {
ValCtx.EmitMetaError(LoopNode, ValidationRule::MetaWellFormed);
return;
}
ConstantAsMetadata *CountNode =
dyn_cast<ConstantAsMetadata>(LoopNode->getOperand(1));
if (!CountNode) {
ValCtx.EmitMetaError(LoopNode, ValidationRule::MetaWellFormed);
} else {
ConstantInt *Count = dyn_cast<ConstantInt>(CountNode->getValue());
if (!Count) {
ValCtx.EmitMetaError(CountNode, ValidationRule::MetaWellFormed);
}
}
}
}
static void ValidateInstructionMetadata(Instruction *I,
ValidationContext &ValCtx) {
SmallVector<std::pair<unsigned, MDNode *>, 2> MDNodes;
I->getAllMetadataOtherThanDebugLoc(MDNodes);
for (auto &MD : MDNodes) {
if (MD.first == ValCtx.kDxilControlFlowHintMDKind) {
if (!isa<TerminatorInst>(I)) {
ValCtx.EmitInstrError(
I, ValidationRule::MetaControlFlowHintNotOnControlFlow);
}
} else if (MD.first == ValCtx.kDxilPreciseMDKind) {
// Validated in IsPrecise.
} else if (MD.first == ValCtx.kLLVMLoopMDKind) {
ValidateLoopMetadata(MD.second, ValCtx);
} else if (MD.first == LLVMContext::MD_tbaa) {
ValidateTBAAMetadata(MD.second, ValCtx);
} else if (MD.first == LLVMContext::MD_range) {
// Validated in Verifier.cpp.
Update shader model 6.2 (#435) 1. Update shader model 6.2 2. update DXIL version to 1.2 and its tests 3. Allow noalias and alias_scope metadata per instruction for validator 1.2
2017-07-20 08:00:31 +03:00
} else if (MD.first == LLVMContext::MD_noalias ||
MD.first == LLVMContext::MD_alias_scope) {
// noalias for DXIL validator >= 1.2
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
} else {
ValCtx.EmitMetaError(MD.second, ValidationRule::MetaUsed);
}
}
}
Denorm to function attribute (#764) - Denorm mode to function attribute not function annotation - Adding validation rule for fp32-denorm-mode * Fix from comments
2017-11-07 05:09:14 +03:00
static void ValidateFunctionAttribute(Function *F, ValidationContext &ValCtx) {
Add validation to check unknown function attributes (#963)
2018-01-05 04:01:10 +03:00
AttributeSet attrSet = F->getAttributes().getFnAttributes();
Denorm to function attribute (#764) - Denorm mode to function attribute not function annotation - Adding validation rule for fp32-denorm-mode * Fix from comments
2017-11-07 05:09:14 +03:00
// fp32-denorm-mode
Add validation to check unknown function attributes (#963)
2018-01-05 04:01:10 +03:00
if (attrSet.hasAttribute(AttributeSet::FunctionIndex,
DXIL::kFP32DenormKindString)) {
Attribute attr = attrSet.getAttribute(AttributeSet::FunctionIndex,
DXIL::kFP32DenormKindString);
Denorm to function attribute (#764) - Denorm mode to function attribute not function annotation - Adding validation rule for fp32-denorm-mode * Fix from comments
2017-11-07 05:09:14 +03:00
StringRef value = attr.getValueAsString();
if (!value.equals(DXIL::kFP32DenormValueAnyString) &&
Add validation to check unknown function attributes (#963)
2018-01-05 04:01:10 +03:00
!value.equals(DXIL::kFP32DenormValueFtzString) &&
!value.equals(DXIL::kFP32DenormValuePreserveString)) {
ValCtx.EmitFnAttributeError(F, attr.getKindAsString(),
attr.getValueAsString());
}
}
// TODO: If validating libraries, we should remove all unknown function attributes.
// For each attribute, check if it is a known attribute
for (unsigned I = 0, E = attrSet.getNumSlots(); I != E; ++I) {
for (auto AttrIter = attrSet.begin(I), AttrEnd = attrSet.end(I);
AttrIter != AttrEnd; ++AttrIter) {
if (!AttrIter->isStringAttribute()) {
continue;
}
StringRef kind = AttrIter->getKindAsString();
if (!kind.equals(DXIL::kFP32DenormKindString)) {
ValCtx.EmitFnAttributeError(F, AttrIter->getKindAsString(),
AttrIter->getValueAsString());
}
Denorm to function attribute (#764) - Denorm mode to function attribute not function annotation - Adding validation rule for fp32-denorm-mode * Fix from comments
2017-11-07 05:09:14 +03:00
}
}
}
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
static void ValidateFunctionMetadata(Function *F, ValidationContext &ValCtx) {
SmallVector<std::pair<unsigned, MDNode *>, 2> MDNodes;
F->getAllMetadata(MDNodes);
for (auto &MD : MDNodes) {
ValCtx.EmitMetaError(MD.second, ValidationRule::MetaUsed);
}
}
first commit
2016-12-28 22:52:27 +03:00
static void ValidateFunctionBody(Function *F, ValidationContext &ValCtx) {
bool SupportsMinPrecision =
ValCtx.DxilMod.GetGlobalFlags() & DXIL::kEnableMinPrecision;
SmallVector<CallInst *, 16> gradientOps;
SmallVector<CallInst *, 16> barriers;
for (auto b = F->begin(), bend = F->end(); b != bend; ++b) {
for (auto i = b->begin(), iend = b->end(); i != iend; ++i) {
llvm::Instruction &I = *i;
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
if (I.hasMetadata()) {
Update shader model 6.2 (#435) 1. Update shader model 6.2 2. update DXIL version to 1.2 and its tests 3. Allow noalias and alias_scope metadata per instruction for validator 1.2
2017-07-20 08:00:31 +03:00
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
ValidateInstructionMetadata(&I, ValCtx);
}
first commit
2016-12-28 22:52:27 +03:00
// Instructions must be allowed.
if (!IsLLVMInstructionAllowed(I)) {
ValCtx.EmitInstrError(&I, ValidationRule::InstrAllowed);
continue;
}
// Instructions marked precise may not have minprecision arguments.
if (SupportsMinPrecision) {
if (IsPrecise(I, ValCtx)) {
for (auto &O : I.operands()) {
if (IsValueMinPrec(ValCtx.DxilMod, O)) {
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
ValCtx.EmitInstrError(
&I, ValidationRule::InstrMinPrecisionNotPrecise);
first commit
2016-12-28 22:52:27 +03:00
break;
}
}
}
}
// Calls to external functions.
CallInst *CI = dyn_cast<CallInst>(&I);
if (CI) {
Function *FCalled = CI->getCalledFunction();
if (FCalled->isDeclaration()) {
// External function validation will diagnose.
if (!IsDxilFunction(FCalled)) {
continue;
}
Value *opcodeVal = CI->getOperand(0);
ConstantInt *OpcodeConst = dyn_cast<ConstantInt>(opcodeVal);
if (OpcodeConst == nullptr) {
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
ValCtx.EmitInstrFormatError(&I, ValidationRule::InstrOpConst,
{"Opcode", "DXIL operation"});
first commit
2016-12-28 22:52:27 +03:00
continue;
}
unsigned opcode = OpcodeConst->getLimitedValue();
DXIL::OpCode dxilOpcode = (DXIL::OpCode)opcode;
if (OP::IsDxilOpGradient(dxilOpcode)) {
gradientOps.push_back(CI);
}
if (dxilOpcode == DXIL::OpCode::Barrier) {
barriers.push_back(CI);
}
// External function validation will check the parameter
// list. This function will check that the call does not
// violate any rules.
}
continue;
}
Change bool to i32 instead of i8. (#28)
2017-01-24 04:54:09 +03:00
for (Value *op : I.operands()) {
if (!isa<PHINode>(&I) && isa<UndefValue>(op)) {
ValCtx.EmitInstrError(&I,
ValidationRule::InstrNoReadingUninitialized);
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(op)) {
for (Value *opCE : CE->operands()) {
if (isa<UndefValue>(opCE)) {
ValCtx.EmitInstrError(
&I, ValidationRule::InstrNoReadingUninitialized);
first commit
2016-12-28 22:52:27 +03:00
}
}
}
Change bool to i32 instead of i8. (#28)
2017-01-24 04:54:09 +03:00
if (IntegerType *IT = dyn_cast<IntegerType>(op->getType())) {
if (IT->getBitWidth() == 8) {
ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
}
}
}
Type *Ty = I.getType();
if (isa<PointerType>(Ty))
Ty = Ty->getPointerElementType();
while (isa<ArrayType>(Ty))
Ty = Ty->getArrayElementType();
if (IntegerType *IT = dyn_cast<IntegerType>(Ty)) {
if (IT->getBitWidth() == 8) {
ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
}
first commit
2016-12-28 22:52:27 +03:00
}
unsigned opcode = I.getOpcode();
switch (opcode) {
case Instruction::Alloca: {
AllocaInst *AI = cast<AllocaInst>(&I);
// TODO: validate address space and alignment
Type *Ty = AI->getAllocatedType();
if (!ValidateType(Ty, ValCtx)) {
continue;
}
} break;
case Instruction::ExtractValue: {
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
ExtractValueInst *EV = cast<ExtractValueInst>(&I);
Type *Ty = EV->getAggregateOperand()->getType();
if (StructType *ST = dyn_cast<StructType>(Ty)) {
Value *Agg = EV->getAggregateOperand();
if (!isa<AtomicCmpXchgInst>(Agg) &&
!IsDxilBuiltinStructType(ST, ValCtx.DxilMod.GetOP())) {
ValCtx.EmitInstrError(EV, ValidationRule::InstrExtractValue);
}
} else {
ValCtx.EmitInstrError(EV, ValidationRule::InstrExtractValue);
}
first commit
2016-12-28 22:52:27 +03:00
} break;
case Instruction::Load: {
Type *Ty = I.getType();
if (!ValidateType(Ty, ValCtx)) {
continue;
}
} break;
case Instruction::Store: {
StoreInst *SI = cast<StoreInst>(&I);
Type *Ty = SI->getValueOperand()->getType();
if (!ValidateType(Ty, ValCtx)) {
continue;
}
} break;
case Instruction::GetElementPtr: {
Type *Ty = I.getType()->getPointerElementType();
if (!ValidateType(Ty, ValCtx)) {
continue;
}
Cleanup more validation TODOs.
2017-01-11 21:42:48 +03:00
GetElementPtrInst *GEP = cast<GetElementPtrInst>(&I);
bool allImmIndex = true;
for (auto Idx = GEP->idx_begin(), E = GEP->idx_end(); Idx != E; Idx++) {
if (!isa<ConstantInt>(Idx)) {
allImmIndex = false;
break;
}
}
if (allImmIndex) {
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
const DataLayout &DL = ValCtx.DL;
Cleanup more validation TODOs.
2017-01-11 21:42:48 +03:00
Value *Ptr = GEP->getPointerOperand();
unsigned size =
DL.getTypeAllocSize(Ptr->getType()->getPointerElementType());
unsigned valSize = DL.getTypeAllocSize(GEP->getType()->getPointerElementType());
SmallVector<Value *, 8> Indices(GEP->idx_begin(), GEP->idx_end());
unsigned offset =
DL.getIndexedOffset(GEP->getPointerOperandType(), Indices);
if ((offset + valSize) > size) {
ValCtx.EmitInstrError(GEP, ValidationRule::InstrInBoundsAccess);
}
}
first commit
2016-12-28 22:52:27 +03:00
} break;
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
case Instruction::SDiv: {
BinaryOperator *BO = cast<BinaryOperator>(&I);
Value *V = BO->getOperand(1);
if (ConstantInt *imm = dyn_cast<ConstantInt>(V)) {
if (imm->getValue().getLimitedValue() == 0) {
ValCtx.EmitInstrError(BO, ValidationRule::InstrNoIDivByZero);
}
}
} break;
case Instruction::UDiv: {
BinaryOperator *BO = cast<BinaryOperator>(&I);
Value *V = BO->getOperand(1);
if (ConstantInt *imm = dyn_cast<ConstantInt>(V)) {
if (imm->getValue().getLimitedValue() == 0) {
ValCtx.EmitInstrError(BO, ValidationRule::InstrNoUDivByZero);
}
}
} break;
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
case Instruction::AddrSpaceCast: {
AddrSpaceCastInst *Cast = cast<AddrSpaceCastInst>(&I);
unsigned ToAddrSpace = Cast->getType()->getPointerAddressSpace();
unsigned FromAddrSpace = Cast->getOperand(0)->getType()->getPointerAddressSpace();
if (ToAddrSpace != DXIL::kGenericPointerAddrSpace &&
FromAddrSpace != DXIL::kGenericPointerAddrSpace) {
ValCtx.EmitInstrError(Cast, ValidationRule::InstrNoGenericPtrAddrSpaceCast);
}
} break;
case Instruction::BitCast: {
BitCastInst *Cast = cast<BitCastInst>(&I);
Type *FromTy = Cast->getOperand(0)->getType();
Type *ToTy = Cast->getType();
if (isa<PointerType>(FromTy)) {
FromTy = FromTy->getPointerElementType();
ToTy = ToTy->getPointerElementType();
unsigned FromSize = ValCtx.DL.getTypeAllocSize(FromTy);
unsigned ToSize = ValCtx.DL.getTypeAllocSize(ToTy);
if (FromSize != ToSize) {
ValCtx.EmitInstrError(Cast, ValidationRule::InstrPtrBitCast);
continue;
}
while (isa<ArrayType>(FromTy)) {
FromTy = FromTy->getArrayElementType();
}
while (isa<ArrayType>(ToTy)) {
ToTy = ToTy->getArrayElementType();
}
}
if (isa<StructType>(FromTy) || isa<StructType>(ToTy)) {
ValCtx.EmitInstrError(Cast, ValidationRule::InstrStructBitCast);
continue;
}
Template argument for byteaddressbuffer load store (#804) This change removes new Load variations (LoadHalf, LoadFloat, etc) for RWByteAddressBuffer/ByteAddressBuffer methods and add templated Load intrinsics. This templated Load only works on scalar or vector types, and its variations (Load2, Load3, Load4, etc) do not work with templates and work as it did before (only storing uints). For Store operation, you can store any scalar or vector types of up to 16 bytes, while prior to 2018 Store only supported storing uint scalar.
2017-11-16 05:47:12 +03:00
bool IsMinPrecisionTy =
(ValCtx.DL.getTypeStoreSize(FromTy) < 4 ||
ValCtx.DL.getTypeStoreSize(ToTy) < 4) &&
!ValCtx.DxilMod.m_ShaderFlags.GetUseNativeLowPrecision();
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
if (IsMinPrecisionTy) {
ValCtx.EmitInstrError(Cast, ValidationRule::InstrMinPrecisonBitCast);
}
first commit
2016-12-28 22:52:27 +03:00
} break;
}
if (PointerType *PT = dyn_cast<PointerType>(I.getType())) {
if (PT->getAddressSpace() == DXIL::kTGSMAddrSpace) {
if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&I)) {
Value *Ptr = GEP->getPointerOperand();
if (!isa<GlobalVariable>(Ptr)) {
ValCtx.EmitInstrError(
&I, ValidationRule::InstrFailToResloveTGSMPointer);
}
} else if (BitCastInst *BCI = dyn_cast<BitCastInst>(&I)) {
Value *Ptr = BCI->getOperand(0);
if (!isa<GetElementPtrInst>(Ptr) && !isa<GlobalVariable>(Ptr)) {
ValCtx.EmitInstrError(
&I, ValidationRule::InstrFailToResloveTGSMPointer);
}
} else {
ValCtx.EmitInstrError(
&I, ValidationRule::InstrFailToResloveTGSMPointer);
}
}
}
}
ValidateControlFlowHint(*b, ValCtx);
}
if (!gradientOps.empty()) {
ValidateGradientOps(F, gradientOps, barriers, ValCtx);
}
}
static void ValidateFunction(Function &F, ValidationContext &ValCtx) {
if (F.isDeclaration()) {
ValidateExternalFunction(&F, ValCtx);
} else {
Strip function parameter for entry and patch constant function. (#20) Strip function parameter for entry and patch constant function * Update error message for ValidationTest::MultiDimArray * Merge remote-tracking branch 'origin/master' # Conflicts: # lib/HLSL/DxilValidation.cpp # tools/clang/unittests/HLSL/ValidationTest.cpp * Update error message for ValidationTest::MultiDimArray Update error message for ValidationTest::MultiDimArray * Fix merge error. (#3) * Delete local file (#4) * Fix merge error. * Delete local file * Strip function parameter for entry and patch constant function. (#5)
2017-01-20 06:00:17 +03:00
if (!F.arg_empty())
ValCtx.EmitFormatError(ValidationRule::FlowFunctionCall,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{F.getName().str()});
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
DxilFunctionAnnotation *funcAnnotation =
ValCtx.DxilMod.GetTypeSystem().GetFunctionAnnotation(&F);
first commit
2016-12-28 22:52:27 +03:00
if (!funcAnnotation) {
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaFunctionAnnotation,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{F.getName().str()});
first commit
2016-12-28 22:52:27 +03:00
return;
}
// Validate parameter type.
for (auto &arg : F.args()) {
Type *argTy = arg.getType();
if (argTy->isPointerTy())
argTy = argTy->getPointerElementType();
while (argTy->isArrayTy()) {
argTy = argTy->getArrayElementType();
}
Code cleanup. (#469) 1. Move DxilEmitMetadata out of DxilGenerationPass.cpp 2. Move helper function out of HLModule.
2017-07-26 21:02:20 +03:00
if (argTy->isStructTy()) {
first commit
2016-12-28 22:52:27 +03:00
if (arg.hasName())
ValCtx.EmitFormatError(
ValidationRule::DeclFnFlattenParam,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{arg.getName().str(), F.getName().str()});
first commit
2016-12-28 22:52:27 +03:00
else
ValCtx.EmitFormatError(ValidationRule::DeclFnFlattenParam,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(arg.getArgNo()),
F.getName().str()});
first commit
2016-12-28 22:52:27 +03:00
break;
}
}
ValidateFunctionBody(&F, ValCtx);
}
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
Denorm to function attribute (#764) - Denorm mode to function attribute not function annotation - Adding validation rule for fp32-denorm-mode * Fix from comments
2017-11-07 05:09:14 +03:00
ValidateFunctionAttribute(&F, ValCtx);
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
if (F.hasMetadata()) {
ValidateFunctionMetadata(&F, ValCtx);
}
first commit
2016-12-28 22:52:27 +03:00
}
static void ValidateGlobalVariable(GlobalVariable &GV,
ValidationContext &ValCtx) {
bool isInternalGV =
Code cleanup. (#469) 1. Move DxilEmitMetadata out of DxilGenerationPass.cpp 2. Move helper function out of HLModule.
2017-07-26 21:02:20 +03:00
dxilutil::IsStaticGlobal(&GV) || dxilutil::IsSharedMemoryGlobal(&GV);
first commit
2016-12-28 22:52:27 +03:00
if (!isInternalGV) {
if (!GV.user_empty()) {
bool hasInstructionUser = false;
for (User *U : GV.users()) {
if (isa<Instruction>(U)) {
hasInstructionUser = true;
break;
}
}
// External GV should not have instruction user.
if (hasInstructionUser) {
ValCtx.EmitGlobalValueError(&GV, ValidationRule::DeclNotUsedExternal);
}
}
// Must have metadata description for each variable.
} else {
// Internal GV must have user.
if (GV.user_empty()) {
ValCtx.EmitGlobalValueError(&GV, ValidationRule::DeclUsedInternal);
}
// Validate type for internal globals.
Code cleanup. (#469) 1. Move DxilEmitMetadata out of DxilGenerationPass.cpp 2. Move helper function out of HLModule.
2017-07-26 21:02:20 +03:00
if (dxilutil::IsStaticGlobal(&GV) || dxilutil::IsSharedMemoryGlobal(&GV)) {
first commit
2016-12-28 22:52:27 +03:00
Type *Ty = GV.getType()->getPointerElementType();
ValidateType(Ty, ValCtx);
}
}
}
Disable race condition check (#3) * Write thread group uniform value will not cause race condition. * Only report race condition when know the data is not uniform. * Disable race condition check.
2017-02-04 02:37:57 +03:00
static void CollectFixAddressAccess(Value *V,
std::vector<StoreInst *> &fixAddrTGSMList) {
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
for (User *U : V->users()) {
if (GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
if (isa<ConstantExpr>(GEP) || GEP->hasAllConstantIndices()) {
CollectFixAddressAccess(GEP, fixAddrTGSMList);
}
Disable race condition check (#3) * Write thread group uniform value will not cause race condition. * Only report race condition when know the data is not uniform. * Disable race condition check.
2017-02-04 02:37:57 +03:00
} else if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
fixAddrTGSMList.emplace_back(SI);
Fix checkin issue. (#56)
2017-01-31 23:42:45 +03:00
}
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
}
}
Disable race condition check (#3) * Write thread group uniform value will not cause race condition. * Only report race condition when know the data is not uniform. * Disable race condition check.
2017-02-04 02:37:57 +03:00
static bool IsDivergent(Value *V) {
// TODO: return correct result.
return false;
}
static void ValidateTGSMRaceCondition(std::vector<StoreInst *> &fixAddrTGSMList,
ValidationContext &ValCtx) {
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
std::unordered_set<Function *> fixAddrTGSMFuncSet;
Disable race condition check (#3) * Write thread group uniform value will not cause race condition. * Only report race condition when know the data is not uniform. * Disable race condition check.
2017-02-04 02:37:57 +03:00
for (StoreInst *I : fixAddrTGSMList) {
BasicBlock *BB = I->getParent();
fixAddrTGSMFuncSet.insert(BB->getParent());
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
}
for (auto &F : ValCtx.DxilMod.GetModule()->functions()) {
Fix checkin issue. (#56)
2017-01-31 23:42:45 +03:00
if (F.isDeclaration() || !fixAddrTGSMFuncSet.count(&F))
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
continue;
PostDominatorTree PDT;
PDT.runOnFunction(F);
BasicBlock *Entry = &F.getEntryBlock();
Disable race condition check (#3) * Write thread group uniform value will not cause race condition. * Only report race condition when know the data is not uniform. * Disable race condition check.
2017-02-04 02:37:57 +03:00
for (StoreInst *SI : fixAddrTGSMList) {
BasicBlock *BB = SI->getParent();
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
if (BB->getParent() == &F) {
if (PDT.dominates(BB, Entry)) {
Disable race condition check (#3) * Write thread group uniform value will not cause race condition. * Only report race condition when know the data is not uniform. * Disable race condition check.
2017-02-04 02:37:57 +03:00
if (IsDivergent(SI->getValueOperand()))
ValCtx.EmitInstrError(SI, ValidationRule::InstrTGSMRaceCond);
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
}
}
}
}
}
first commit
2016-12-28 22:52:27 +03:00
static void ValidateGlobalVariables(ValidationContext &ValCtx) {
DxilModule &M = ValCtx.DxilMod;
unsigned TGSMSize = 0;
Disable race condition check (#3) * Write thread group uniform value will not cause race condition. * Only report race condition when know the data is not uniform. * Disable race condition check.
2017-02-04 02:37:57 +03:00
std::vector<StoreInst*> fixAddrTGSMList;
first commit
2016-12-28 22:52:27 +03:00
const DataLayout &DL = M.GetModule()->getDataLayout();
for (GlobalVariable &GV : M.GetModule()->globals()) {
ValidateGlobalVariable(GV, ValCtx);
if (GV.getType()->getAddressSpace() == DXIL::kTGSMAddrSpace) {
TGSMSize += DL.getTypeAllocSize(GV.getType()->getElementType());
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
CollectFixAddressAccess(&GV, fixAddrTGSMList);
first commit
2016-12-28 22:52:27 +03:00
}
}
if (TGSMSize > DXIL::kMaxTGSMSize) {
ValCtx.EmitFormatError(ValidationRule::SmMaxTGSMSize,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(TGSMSize),
std::to_string(DXIL::kMaxTGSMSize)});
first commit
2016-12-28 22:52:27 +03:00
}
Check Race Condition for TGSM (#48)
2017-01-31 03:09:31 +03:00
if (!fixAddrTGSMList.empty()) {
ValidateTGSMRaceCondition(fixAddrTGSMList, ValCtx);
}
first commit
2016-12-28 22:52:27 +03:00
}
static void ValidateValidatorVersion(ValidationContext &ValCtx) {
Module *pModule = &ValCtx.M;
NamedMDNode *pNode = pModule->getNamedMetadata("dx.valver");
if (pNode == nullptr) {
return;
}
if (pNode->getNumOperands() == 1) {
MDTuple *pVerValues = dyn_cast<MDTuple>(pNode->getOperand(0));
if (pVerValues != nullptr && pVerValues->getNumOperands() == 2) {
uint64_t majorVer, minorVer;
if (GetNodeOperandAsInt(ValCtx, pVerValues, 0, &majorVer) &&
GetNodeOperandAsInt(ValCtx, pVerValues, 1, &minorVer)) {
unsigned curMajor, curMinor;
GetValidationVersion(&curMajor, &curMinor);
// This will need to be updated as major/minor versions evolve,
// depending on the degree of compat across versions.
if (majorVer == curMajor && minorVer <= curMinor) {
return;
}
}
}
}
ValCtx.EmitError(ValidationRule::MetaWellFormed);
}
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
static void ValidateDxilVersion(ValidationContext &ValCtx) {
Module *pModule = &ValCtx.M;
NamedMDNode *pNode = pModule->getNamedMetadata("dx.version");
if (pNode && pNode->getNumOperands() == 1) {
MDTuple *pVerValues = dyn_cast<MDTuple>(pNode->getOperand(0));
if (pVerValues != nullptr && pVerValues->getNumOperands() == 2) {
uint64_t majorVer, minorVer;
if (GetNodeOperandAsInt(ValCtx, pVerValues, 0, &majorVer) &&
GetNodeOperandAsInt(ValCtx, pVerValues, 1, &minorVer)) {
// This will need to be updated as dxil major/minor versions evolve,
// depending on the degree of compat across versions.
Bump up version number. (#1066) bump up version to SM6.3 and DXIL1.3
2018-02-13 00:27:48 +03:00
if ((majorVer == 1 && minorVer < 4) &&
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
(majorVer == ValCtx.m_DxilMajor && minorVer == ValCtx.m_DxilMinor)) {
return;
}
}
}
}
ValCtx.EmitError(ValidationRule::MetaWellFormed);
}
Support denorm option (#446) This change is to support preserve denorm operations. We do this by creating dxc options and propagate them all the way to dxil metadata so that drivers can see how it should handle floats. Currently we support three modes: any(default), preserve, and ftz Denorm option will be of per function flag. We store this information at function annotation metadata. This means that for DXIL 1.2 we have a new structure for function annotation. The change in structure is documented on DXIL.rst
2017-07-27 20:08:14 +03:00
static void ValidateTypeAnnotation(ValidationContext &ValCtx) {
if (ValCtx.m_DxilMajor == 1 && ValCtx.m_DxilMinor >= 2) {
Module *pModule = &ValCtx.M;
NamedMDNode *TA = pModule->getNamedMetadata("dx.typeAnnotations");
if (TA == nullptr)
return;
for (unsigned i = 0, end = TA->getNumOperands(); i < end; ++i) {
MDTuple *TANode = dyn_cast<MDTuple>(TA->getOperand(i));
if (TANode->getNumOperands() < 3) {
ValCtx.EmitMetaError(TANode, ValidationRule::MetaWellFormed);
return;
}
ConstantInt *tag = mdconst::extract<ConstantInt>(TANode->getOperand(0));
uint64_t tagValue = tag->getZExtValue();
if (tagValue != DxilMDHelper::kDxilTypeSystemStructTag &&
Denorm to function attribute (#764) - Denorm mode to function attribute not function annotation - Adding validation rule for fp32-denorm-mode * Fix from comments
2017-11-07 05:09:14 +03:00
tagValue != DxilMDHelper::kDxilTypeSystemFunctionTag) {
Support denorm option (#446) This change is to support preserve denorm operations. We do this by creating dxc options and propagate them all the way to dxil metadata so that drivers can see how it should handle floats. Currently we support three modes: any(default), preserve, and ftz Denorm option will be of per function flag. We store this information at function annotation metadata. This means that for DXIL 1.2 we have a new structure for function annotation. The change in structure is documented on DXIL.rst
2017-07-27 20:08:14 +03:00
ValCtx.EmitMetaError(TANode, ValidationRule::MetaWellFormed);
return;
}
}
}
}
first commit
2016-12-28 22:52:27 +03:00
static void ValidateMetadata(ValidationContext &ValCtx) {
Module *pModule = &ValCtx.M;
const std::string &target = pModule->getTargetTriple();
if (target != "dxil-ms-dx") {
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaTarget, {target});
first commit
2016-12-28 22:52:27 +03:00
}
Integrate: Fix to CATCH_CPP_ASSIGN_HRESULT and validation of named metadata
2017-02-08 00:02:37 +03:00
// The llvm.dbg.(cu/contents/defines/mainFileName/arg) named metadata nodes
// are only available in debug modules, not in the validated ones.
// llvm.bitsets is also disallowed.
//
// These are verified in lib/IR/Verifier.cpp.
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
StringMap<bool> llvmNamedMeta;
llvmNamedMeta["llvm.ident"];
llvmNamedMeta["llvm.module.flags"];
first commit
2016-12-28 22:52:27 +03:00
for (auto &NamedMetaNode : pModule->named_metadata()) {
if (!DxilModule::IsKnownNamedMetaData(NamedMetaNode)) {
StringRef name = NamedMetaNode.getName();
if (!name.startswith_lower("llvm."))
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaKnown, {name.str()});
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
else {
if (llvmNamedMeta.count(name) == 0) {
ValCtx.EmitFormatError(ValidationRule::MetaKnown,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{name.str()});
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
}
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
}
first commit
2016-12-28 22:52:27 +03:00
}
}
Restrict shader models accepted by DxCompiler API to 6.0 (#15) - upconvert to 6.0 in dxc.exe and d3dcompiler_dxc_bridge - restrict to 6.0 in dxcompiler API - restrict to 6.0 in DxilValidator - allow loading of SM < 6.0 for now on DXIL 0.7
2017-01-19 04:45:26 +03:00
const hlsl::ShaderModel *SM = ValCtx.DxilMod.GetShaderModel();
Dxil versioned OpCode/Class counts, and other dxil versioning fixes (#263)
2017-05-03 00:42:05 +03:00
if (!SM->IsValidForDxil()) {
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
ValCtx.EmitFormatError(ValidationRule::SmName,
{ValCtx.DxilMod.GetShaderModel()->GetName()});
first commit
2016-12-28 22:52:27 +03:00
}
Add SV_ViewID support (#251) - Add SV_ViewID loaded from intrinsic in Dxil, for input to all graphics shader stages - hctdb: rename shader_models to shader_stages, add shader_model for min required shader model - Validator: validate dxil version required for shader model - DxilModule: Add GetDxilVersion - Set Barycentric intrinsics to SM 6.1 - Update SystemValueTest for SM 6.1
2017-04-28 00:17:31 +03:00
if (SM->GetMajor() == 6) {
// Make sure DxilVersion matches the shader model.
unsigned SMDxilMajor, SMDxilMinor;
SM->GetDxilVersion(SMDxilMajor, SMDxilMinor);
if (ValCtx.m_DxilMajor != SMDxilMajor || ValCtx.m_DxilMinor != SMDxilMinor) {
ValCtx.EmitFormatError(ValidationRule::SmDxilVersion,
{std::to_string(SMDxilMajor),
std::to_string(SMDxilMinor)});
}
}
ValidateDxilVersion(ValCtx);
first commit
2016-12-28 22:52:27 +03:00
ValidateValidatorVersion(ValCtx);
Support denorm option (#446) This change is to support preserve denorm operations. We do this by creating dxc options and propagate them all the way to dxil metadata so that drivers can see how it should handle floats. Currently we support three modes: any(default), preserve, and ftz Denorm option will be of per function flag. We store this information at function annotation metadata. This means that for DXIL 1.2 we have a new structure for function annotation. The change in structure is documented on DXIL.rst
2017-07-27 20:08:14 +03:00
ValidateTypeAnnotation(ValCtx);
first commit
2016-12-28 22:52:27 +03:00
}
Clean more validation TODOs.
2017-01-11 03:24:10 +03:00
static void ValidateResourceOverlap(
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
hlsl::DxilResourceBase &res,
first commit
2016-12-28 22:52:27 +03:00
SpacesAllocator<unsigned, DxilResourceBase> &spaceAllocator,
ValidationContext &ValCtx) {
unsigned base = res.GetLowerBound();
unsigned size = res.GetRangeSize();
unsigned space = res.GetSpaceID();
auto &allocator = spaceAllocator.Get(space);
unsigned end = base + size - 1;
// unbounded
if (end < base)
end = size;
const DxilResourceBase *conflictRes = allocator.Insert(&res, base, end);
if (conflictRes) {
Disable multi-dim array type and function call. (#12)
2017-01-18 00:30:42 +03:00
ValCtx.EmitFormatError(
ValidationRule::SmResourceRangeOverlap,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{res.GetGlobalName(), std::to_string(base),
std::to_string(size),
std::to_string(conflictRes->GetLowerBound()),
std::to_string(conflictRes->GetRangeSize()),
std::to_string(space)});
first commit
2016-12-28 22:52:27 +03:00
}
}
static void ValidateResource(hlsl::DxilResource &res,
ValidationContext &ValCtx) {
switch (res.GetKind()) {
case DXIL::ResourceKind::RawBuffer:
case DXIL::ResourceKind::TypedBuffer:
case DXIL::ResourceKind::TBuffer:
case DXIL::ResourceKind::StructuredBuffer:
case DXIL::ResourceKind::Texture1D:
case DXIL::ResourceKind::Texture1DArray:
case DXIL::ResourceKind::Texture2D:
case DXIL::ResourceKind::Texture2DArray:
case DXIL::ResourceKind::Texture3D:
case DXIL::ResourceKind::TextureCube:
case DXIL::ResourceKind::TextureCubeArray:
if (res.GetSampleCount() > 0) {
ValCtx.EmitResourceError(&res, ValidationRule::SmSampleCountOnlyOn2DMS);
}
break;
case DXIL::ResourceKind::Texture2DMS:
case DXIL::ResourceKind::Texture2DMSArray:
break;
default:
ValCtx.EmitResourceError(&res, ValidationRule::SmInvalidResourceKind);
break;
}
switch (res.GetCompType().GetKind()) {
case DXIL::ComponentType::F32:
case DXIL::ComponentType::SNormF32:
case DXIL::ComponentType::UNormF32:
case DXIL::ComponentType::F64:
case DXIL::ComponentType::I32:
case DXIL::ComponentType::I64:
case DXIL::ComponentType::U32:
case DXIL::ComponentType::U64:
case DXIL::ComponentType::F16:
case DXIL::ComponentType::I16:
case DXIL::ComponentType::U16:
break;
default:
if (!res.IsStructuredBuffer() && !res.IsRawBuffer())
ValCtx.EmitResourceError(&res, ValidationRule::SmInvalidResourceCompType);
break;
}
if (res.IsStructuredBuffer()) {
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
unsigned stride = res.GetElementStride();
bool alignedTo4Bytes = (stride & 3) == 0;
Structure alignment Change (#721) Structure buffer alignment change for float16. Starting in shader model 6.2, the structure will match that of #pragma pack(8) alignment in C++ Removing padding for structure buffer. We will not have any padding in HLSL structure since load/store operation already handles offset as if padding exist in #pragma pack(8) mode in C++ Disable legacy alignment for non precision mode as it was only needed for min precision
2017-10-20 23:51:42 +03:00
if (!alignedTo4Bytes && !ValCtx.M.GetDxilModule().m_ShaderFlags.GetUseNativeLowPrecision()) {
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
ValCtx.EmitResourceFormatError(
&res, ValidationRule::MetaStructBufAlignment,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(4), std::to_string(stride)});
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
}
if (stride > DXIL::kMaxStructBufferStride) {
ValCtx.EmitResourceFormatError(
&res, ValidationRule::MetaStructBufAlignmentOutOfBound,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(DXIL::kMaxStructBufferStride),
std::to_string(stride)});
first commit
2016-12-28 22:52:27 +03:00
}
}
1. Clean more validation TODOs. 2. Support array of SV_Target.
2017-01-10 22:44:48 +03:00
if (res.IsAnyTexture() || res.IsTypedBuffer()) {
Type *RetTy = res.GetRetType();
unsigned size = ValCtx.DxilMod.GetModule()->getDataLayout().getTypeAllocSize(RetTy);
if (size > 4*4) {
ValCtx.EmitResourceError(&res, ValidationRule::MetaTextureType);
first commit
2016-12-28 22:52:27 +03:00
}
}
}
static void
CollectCBufferRanges(DxilStructAnnotation *annotation,
SpanAllocator<unsigned, DxilFieldAnnotation> &constAllocator,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
unsigned base, DxilTypeSystem &typeSys, StringRef cbName,
first commit
2016-12-28 22:52:27 +03:00
ValidationContext &ValCtx) {
unsigned cbSize = annotation->GetCBufferSize();
const StructType *ST = annotation->GetStructType();
for (int i = annotation->GetNumFields() - 1; i >= 0; i--) {
DxilFieldAnnotation &fieldAnnotation = annotation->GetFieldAnnotation(i);
Type *EltTy = ST->getElementType(i);
unsigned offset = fieldAnnotation.GetCBufferOffset();
Code cleanup. (#469) 1. Move DxilEmitMetadata out of DxilGenerationPass.cpp 2. Move helper function out of HLModule.
2017-07-26 21:02:20 +03:00
unsigned EltSize = dxilutil::GetLegacyCBufferFieldElementSize(
first commit
2016-12-28 22:52:27 +03:00
fieldAnnotation, EltTy, typeSys);
bool bOutOfBound = false;
if (!EltTy->isAggregateType()) {
bOutOfBound = (offset + EltSize) > cbSize;
if (!bOutOfBound) {
if (constAllocator.Insert(&fieldAnnotation, base + offset,
base + offset + EltSize - 1)) {
ValCtx.EmitFormatError(
ValidationRule::SmCBufferOffsetOverlap,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{cbName, std::to_string(base + offset)});
first commit
2016-12-28 22:52:27 +03:00
}
}
} else if (isa<ArrayType>(EltTy)) {
unsigned arrayCount = 1;
while (isa<ArrayType>(EltTy)) {
arrayCount *= EltTy->getArrayNumElements();
EltTy = EltTy->getArrayElementType();
}
unsigned arrayBase = base + offset;
DxilStructAnnotation *EltAnnotation = nullptr;
if (StructType *EltST = dyn_cast<StructType>(EltTy))
EltAnnotation = typeSys.GetStructAnnotation(EltST);
for (unsigned idx = 0; idx < arrayCount; idx++) {
// 16 bytes align except last component.
if (idx < (arrayCount - 1)) {
arrayBase = (arrayBase + 15) & ~(0xf);
}
if (arrayBase > (base + cbSize)) {
bOutOfBound = true;
break;
}
if (!EltAnnotation) {
if (constAllocator.Insert(&fieldAnnotation, arrayBase,
arrayBase + EltSize - 1)) {
ValCtx.EmitFormatError(
ValidationRule::SmCBufferOffsetOverlap,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{cbName, std::to_string(base + offset)});
first commit
2016-12-28 22:52:27 +03:00
}
} else {
CollectCBufferRanges(EltAnnotation,
constAllocator, arrayBase, typeSys,
cbName, ValCtx);
}
arrayBase += EltSize;
}
} else {
cast<StructType>(EltTy);
bOutOfBound = (offset + EltSize) > cbSize;
}
if (bOutOfBound) {
ValCtx.EmitFormatError(ValidationRule::SmCBufferElementOverflow,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{cbName, std::to_string(base + offset)});
first commit
2016-12-28 22:52:27 +03:00
}
}
}
static void ValidateCBuffer(DxilCBuffer &cb, ValidationContext &ValCtx) {
Type *Ty = cb.GetGlobalSymbol()->getType()->getPointerElementType();
if (cb.GetRangeSize() != 1) {
Ty = Ty->getArrayElementType();
}
if (!isa<StructType>(Ty)) {
ValCtx.EmitResourceError(&cb,
ValidationRule::SmCBufferTemplateTypeMustBeStruct);
return;
}
StructType *ST = cast<StructType>(Ty);
DxilTypeSystem &typeSys = ValCtx.DxilMod.GetTypeSystem();
DxilStructAnnotation *annotation = typeSys.GetStructAnnotation(ST);
if (!annotation)
return;
// Collect constant ranges.
std::vector<std::pair<unsigned, unsigned>> constRanges;
SpanAllocator<unsigned, DxilFieldAnnotation> constAllocator(0,
// 4096 * 16 bytes.
DXIL::kMaxCBufferSize << 4);
CollectCBufferRanges(annotation, constAllocator,
0, typeSys,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
cb.GetGlobalName(), ValCtx);
first commit
2016-12-28 22:52:27 +03:00
}
static void ValidateResources(ValidationContext &ValCtx) {
const vector<unique_ptr<DxilResource>> &uavs = ValCtx.DxilMod.GetUAVs();
bool hasROV = false;
SpacesAllocator<unsigned, DxilResourceBase> uavAllocator;
for (auto &uav : uavs) {
if (uav->IsROV()) {
hasROV = true;
if (!ValCtx.DxilMod.GetShaderModel()->IsPS()) {
ValCtx.EmitResourceError(uav.get(), ValidationRule::SmROVOnlyInPS);
}
}
switch (uav->GetKind()) {
case DXIL::ResourceKind::Texture2DMS:
case DXIL::ResourceKind::Texture2DMSArray:
case DXIL::ResourceKind::TextureCube:
case DXIL::ResourceKind::TextureCubeArray:
ValCtx.EmitResourceError(uav.get(),
ValidationRule::SmInvalidTextureKindOnUAV);
break;
default:
break;
}
if (uav->HasCounter() && !uav->IsStructuredBuffer()) {
ValCtx.EmitResourceError(uav.get(),
ValidationRule::SmCounterOnlyOnStructBuf);
}
if (uav->HasCounter() && uav->IsGloballyCoherent())
ValCtx.EmitResourceError(uav.get(),
ValidationRule::MetaGlcNotOnAppendConsume);
ValidateResource(*uav, ValCtx);
ValidateResourceOverlap(*uav, uavAllocator, ValCtx);
}
SpacesAllocator<unsigned, DxilResourceBase> srvAllocator;
const vector<unique_ptr<DxilResource>> &srvs = ValCtx.DxilMod.GetSRVs();
for (auto &srv : srvs) {
ValidateResource(*srv, ValCtx);
ValidateResourceOverlap(*srv, srvAllocator, ValCtx);
}
hlsl::DxilResourceBase *pNonDense;
if (!AreDxilResourcesDense(&ValCtx.M, &pNonDense)) {
ValCtx.EmitResourceError(pNonDense, ValidationRule::MetaDenseResIDs);
}
SpacesAllocator<unsigned, DxilResourceBase> samplerAllocator;
for (auto &sampler : ValCtx.DxilMod.GetSamplers()) {
if (sampler->GetSamplerKind() == DXIL::SamplerKind::Invalid) {
ValCtx.EmitResourceError(sampler.get(),
ValidationRule::MetaValidSamplerMode);
}
ValidateResourceOverlap(*sampler, samplerAllocator, ValCtx);
}
SpacesAllocator<unsigned, DxilResourceBase> cbufferAllocator;
for (auto &cbuffer : ValCtx.DxilMod.GetCBuffers()) {
ValidateCBuffer(*cbuffer, ValCtx);
ValidateResourceOverlap(*cbuffer, cbufferAllocator, ValCtx);
}
}
static void ValidateShaderFlags(ValidationContext &ValCtx) {
DxilModule::ShaderFlags calcFlags;
ValCtx.DxilMod.CollectShaderFlags(calcFlags);
const uint64_t mask = DxilModule::ShaderFlags::GetShaderFlagsRawForCollection();
uint64_t declaredFlagsRaw = ValCtx.DxilMod.m_ShaderFlags.GetShaderFlagsRaw();
uint64_t calcFlagsRaw = calcFlags.GetShaderFlagsRaw();
declaredFlagsRaw &= mask;
calcFlagsRaw &= mask;
if (declaredFlagsRaw == calcFlagsRaw) {
return;
}
ValCtx.EmitError(ValidationRule::MetaFlagsUsage);
ValCtx.DiagStream() << "Flags declared=" << declaredFlagsRaw
<< ", actual=" << calcFlagsRaw << "\n";
}
static void ValidateSignatureElement(DxilSignatureElement &SE,
ValidationContext &ValCtx) {
DXIL::SemanticKind semanticKind = SE.GetSemantic()->GetKind();
CompType::Kind compKind = SE.GetCompType().GetKind();
DXIL::InterpolationMode Mode = SE.GetInterpolationMode()->GetKind();
Clean more validation TODOs.
2017-01-05 00:26:27 +03:00
StringRef Name = SE.GetName();
if (Name.size() < 1 || Name.size() > 64) {
ValCtx.EmitSignatureError(&SE, ValidationRule::MetaSemanticLen);
}
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
if (semanticKind > DXIL::SemanticKind::Arbitrary && semanticKind < DXIL::SemanticKind::Invalid) {
if (semanticKind != Semantic::GetByName(SE.GetName())->GetKind()) {
ValCtx.EmitFormatError(ValidationRule::MetaSemaKindMatchesName,
{SE.GetName(), SE.GetSemantic()->GetName()});
}
}
DxilValidation accept more legal component types in signatures (#305) - Fixes SV_Position must be float4 #89 - Needs additional testing and comparison of flexibility with fxc.
2017-05-18 00:35:45 +03:00
unsigned compWidth = 0;
bool compFloat = false;
bool compInt = false;
bool compUnsigned = false;
bool compBool = false;
bool compSNorm = false;
bool compUNorm = false;
first commit
2016-12-28 22:52:27 +03:00
switch (compKind) {
DxilValidation accept more legal component types in signatures (#305) - Fixes SV_Position must be float4 #89 - Needs additional testing and comparison of flexibility with fxc.
2017-05-18 00:35:45 +03:00
case CompType::Kind::U64: compWidth = 64; compInt = true; compUnsigned = true; break;
case CompType::Kind::I64: compWidth = 64; compInt = true; break;
case CompType::Kind::U32: compWidth = 32; compInt = true; compUnsigned = true; break;
case CompType::Kind::I32: compWidth = 32; compInt = true; break;
case CompType::Kind::U16: compWidth = 16; compInt = true; compUnsigned = true; break;
case CompType::Kind::I16: compWidth = 16; compInt = true; break;
case CompType::Kind::I1: compWidth = 1; compBool = true; break;
case CompType::Kind::F64: compWidth = 64; compFloat = true; break;
case CompType::Kind::F32: compWidth = 32; compFloat = true; break;
case CompType::Kind::F16: compWidth = 16; compFloat = true; break;
case CompType::Kind::SNormF64: compWidth = 64; compFloat = true; compSNorm = true; break;
case CompType::Kind::SNormF32: compWidth = 32; compFloat = true; compSNorm = true; break;
case CompType::Kind::SNormF16: compWidth = 16; compFloat = true; compSNorm = true; break;
case CompType::Kind::UNormF64: compWidth = 64; compFloat = true; compUNorm = true; break;
case CompType::Kind::UNormF32: compWidth = 32; compFloat = true; compUNorm = true; break;
case CompType::Kind::UNormF16: compWidth = 16; compFloat = true; compUNorm = true; break;
case CompType::Kind::Invalid:
default:
ValCtx.EmitFormatError(ValidationRule::MetaSignatureCompType, { SE.GetName() });
break;
}
if (compInt || compBool) {
first commit
2016-12-28 22:52:27 +03:00
switch (Mode) {
case DXIL::InterpolationMode::Linear:
case DXIL::InterpolationMode::LinearCentroid:
case DXIL::InterpolationMode::LinearNoperspective:
case DXIL::InterpolationMode::LinearNoperspectiveCentroid:
case DXIL::InterpolationMode::LinearSample:
case DXIL::InterpolationMode::LinearNoperspectiveSample: {
ValCtx.EmitFormatError(ValidationRule::MetaIntegerInterpMode, {SE.GetName()});
} break;
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
default:
break;
first commit
2016-12-28 22:52:27 +03:00
}
}
// Elements that should not appear in the Dxil signature:
bool bAllowedInSig = true;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
bool bShouldBeAllocated = true;
first commit
2016-12-28 22:52:27 +03:00
switch (SE.GetInterpretation()) {
case DXIL::SemanticInterpretationKind::NA:
case DXIL::SemanticInterpretationKind::NotInSig:
case DXIL::SemanticInterpretationKind::Invalid:
bAllowedInSig = false;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
__fallthrough;
case DXIL::SemanticInterpretationKind::NotPacked:
case DXIL::SemanticInterpretationKind::Shadow:
bShouldBeAllocated = false;
first commit
2016-12-28 22:52:27 +03:00
break;
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
default:
break;
first commit
2016-12-28 22:52:27 +03:00
}
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
const char *inputOutput = nullptr;
if (SE.IsInput())
inputOutput = "Input";
else if (SE.IsOutput())
inputOutput = "Output";
else
inputOutput = "PatchConstant";
first commit
2016-12-28 22:52:27 +03:00
if (!bAllowedInSig) {
ValCtx.EmitFormatError(
ValidationRule::SmSemantic,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{SE.GetName(), ValCtx.DxilMod.GetShaderModel()->GetKindName(), inputOutput});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
} else if (bShouldBeAllocated && !SE.IsAllocated()) {
ValCtx.EmitFormatError(ValidationRule::MetaSemanticShouldBeAllocated,
{inputOutput, SE.GetName()});
} else if (!bShouldBeAllocated && SE.IsAllocated()) {
ValCtx.EmitFormatError(ValidationRule::MetaSemanticShouldNotBeAllocated,
{inputOutput, SE.GetName()});
first commit
2016-12-28 22:52:27 +03:00
}
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
bool bIsClipCull = false;
bool bIsTessfactor = false;
Allow two SV_Barycentrics (#282) unlike other system value semantics, pixel shader is allowed to declare at most two input attributes with SV_Barycentrics, with one declaration uses perspective interpolation type while other one uses noperspective interpolation type.
2017-05-10 04:59:30 +03:00
bool bIsBarycentric = false;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
first commit
2016-12-28 22:52:27 +03:00
switch (semanticKind) {
case DXIL::SemanticKind::Depth:
case DXIL::SemanticKind::DepthGreaterEqual:
case DXIL::SemanticKind::DepthLessEqual:
DxilValidation accept more legal component types in signatures (#305) - Fixes SV_Position must be float4 #89 - Needs additional testing and comparison of flexibility with fxc.
2017-05-18 00:35:45 +03:00
if (!compFloat || compWidth > 32 || SE.GetCols() != 1) {
first commit
2016-12-28 22:52:27 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaSemanticCompType,
{SE.GetSemantic()->GetName(), "float"});
}
break;
case DXIL::SemanticKind::Coverage:
DXASSERT(!SE.IsInput() || !bAllowedInSig, "else internal inconsistency between semantic interpretation table and validation code");
__fallthrough;
case DXIL::SemanticKind::InnerCoverage:
case DXIL::SemanticKind::OutputControlPointID:
if (compKind != CompType::Kind::U32 || SE.GetCols() != 1) {
ValCtx.EmitFormatError(ValidationRule::MetaSemanticCompType,
{SE.GetSemantic()->GetName(), "uint"});
}
break;
case DXIL::SemanticKind::Position:
DxilValidation accept more legal component types in signatures (#305) - Fixes SV_Position must be float4 #89 - Needs additional testing and comparison of flexibility with fxc.
2017-05-18 00:35:45 +03:00
if (!compFloat || compWidth > 32 || SE.GetCols() != 4) {
first commit
2016-12-28 22:52:27 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaSemanticCompType,
{SE.GetSemantic()->GetName(), "float4"});
}
break;
case DXIL::SemanticKind::Target:
DxilValidation accept more legal component types in signatures (#305) - Fixes SV_Position must be float4 #89 - Needs additional testing and comparison of flexibility with fxc.
2017-05-18 00:35:45 +03:00
if (compWidth > 32) {
first commit
2016-12-28 22:52:27 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaSemanticCompType,
{SE.GetSemantic()->GetName(), "float/int/uint"});
}
break;
case DXIL::SemanticKind::ClipDistance:
case DXIL::SemanticKind::CullDistance:
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
bIsClipCull = true;
DxilValidation accept more legal component types in signatures (#305) - Fixes SV_Position must be float4 #89 - Needs additional testing and comparison of flexibility with fxc.
2017-05-18 00:35:45 +03:00
if (!compFloat || compWidth > 32) {
first commit
2016-12-28 22:52:27 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaSemanticCompType,
{SE.GetSemantic()->GetName(), "float"});
}
// NOTE: clip cull distance size is checked at ValidateSignature.
break;
Support isfrontface as uint. (#919)
2017-12-14 07:41:51 +03:00
case DXIL::SemanticKind::IsFrontFace: {
if (!(compInt && compWidth == 32) || SE.GetCols() != 1) {
first commit
2016-12-28 22:52:27 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaSemanticCompType,
Support isfrontface as uint. (#919)
2017-12-14 07:41:51 +03:00
{SE.GetSemantic()->GetName(), "uint"});
first commit
2016-12-28 22:52:27 +03:00
}
Support isfrontface as uint. (#919)
2017-12-14 07:41:51 +03:00
} break;
first commit
2016-12-28 22:52:27 +03:00
case DXIL::SemanticKind::RenderTargetArrayIndex:
case DXIL::SemanticKind::ViewPortArrayIndex:
case DXIL::SemanticKind::VertexID:
case DXIL::SemanticKind::PrimitiveID:
case DXIL::SemanticKind::InstanceID:
case DXIL::SemanticKind::GSInstanceID:
case DXIL::SemanticKind::SampleIndex:
case DXIL::SemanticKind::StencilRef:
if ((compKind != CompType::Kind::U32 && compKind != CompType::Kind::U16) || SE.GetCols() != 1) {
ValCtx.EmitFormatError(ValidationRule::MetaSemanticCompType,
{SE.GetSemantic()->GetName(), "uint"});
}
break;
case DXIL::SemanticKind::TessFactor:
case DXIL::SemanticKind::InsideTessFactor:
// NOTE: the size check is at CheckPatchConstantSemantic.
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
bIsTessfactor = true;
DxilValidation accept more legal component types in signatures (#305) - Fixes SV_Position must be float4 #89 - Needs additional testing and comparison of flexibility with fxc.
2017-05-18 00:35:45 +03:00
if (!compFloat || compWidth > 32) {
first commit
2016-12-28 22:52:27 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaSemanticCompType,
{SE.GetSemantic()->GetName(), "float"});
}
break;
case DXIL::SemanticKind::Arbitrary:
break;
case DXIL::SemanticKind::DomainLocation:
case DXIL::SemanticKind::Invalid:
DXASSERT(!bAllowedInSig, "else internal inconsistency between semantic interpretation table and validation code");
break;
Update barycentric with new spec (#265) 1. Adding SV_Barycentric and removing barycentric intrinsics/dxilops 2. GetAttributeAtVertex only thakes no_interpolation attribute 3. SV_Barycentric can take any interpolation modifier except nointerpolation 4. SV_Barycentric can only have float3 type
2017-05-04 03:07:02 +03:00
case DXIL::SemanticKind::Barycentrics:
Allow two SV_Barycentrics (#282) unlike other system value semantics, pixel shader is allowed to declare at most two input attributes with SV_Barycentrics, with one declaration uses perspective interpolation type while other one uses noperspective interpolation type.
2017-05-10 04:59:30 +03:00
bIsBarycentric = true;
DxilValidation accept more legal component types in signatures (#305) - Fixes SV_Position must be float4 #89 - Needs additional testing and comparison of flexibility with fxc.
2017-05-18 00:35:45 +03:00
if (!compFloat || compWidth > 32) {
Update barycentric with new spec (#265) 1. Adding SV_Barycentric and removing barycentric intrinsics/dxilops 2. GetAttributeAtVertex only thakes no_interpolation attribute 3. SV_Barycentric can take any interpolation modifier except nointerpolation 4. SV_Barycentric can only have float3 type
2017-05-04 03:07:02 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaSemanticCompType, {SE.GetSemantic()->GetName(), "float"});
}
if (Mode != InterpolationMode::Kind::Linear &&
Mode != InterpolationMode::Kind::LinearCentroid &&
Mode != InterpolationMode::Kind::LinearNoperspective &&
Mode != InterpolationMode::Kind::LinearNoperspectiveCentroid &&
Mode != InterpolationMode::Kind::LinearNoperspectiveSample &&
Mode != InterpolationMode::Kind::LinearSample) {
ValCtx.EmitSignatureError(&SE, ValidationRule::MetaBarycentricsInterpolation);
}
if (SE.GetCols() != 3) {
ValCtx.EmitSignatureError(&SE, ValidationRule::MetaBarycentricsFloat3);
}
break;
first commit
2016-12-28 22:52:27 +03:00
default:
ValCtx.EmitSignatureError(&SE, ValidationRule::MetaSemaKindValid);
break;
}
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
if (ValCtx.DxilMod.GetShaderModel()->IsGS() && SE.IsOutput()) {
if (SE.GetOutputStream() >= DXIL::kNumOutputStreams) {
ValCtx.EmitFormatError(ValidationRule::SmStreamIndexRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(SE.GetOutputStream()),
std::to_string(DXIL::kNumOutputStreams - 1)});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
}
} else {
if (SE.GetOutputStream() > 0) {
ValCtx.EmitFormatError(ValidationRule::SmStreamIndexRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(SE.GetOutputStream()),
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
"0"});
}
first commit
2016-12-28 22:52:27 +03:00
}
if (ValCtx.DxilMod.GetShaderModel()->IsGS()) {
if (SE.GetOutputStream() != 0) {
if (ValCtx.DxilMod.GetStreamPrimitiveTopology() !=
DXIL::PrimitiveTopology::PointList) {
ValCtx.EmitSignatureError(&SE,
ValidationRule::SmMultiStreamMustBePoint);
}
}
}
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
if (semanticKind == DXIL::SemanticKind::Target) {
// Verify packed row == semantic index
unsigned row = SE.GetStartRow();
for (unsigned i : SE.GetSemanticIndexVec()) {
if (row != i) {
ValCtx.EmitSignatureError(&SE, ValidationRule::SmPSTargetIndexMatchesRow);
}
++row;
}
// Verify packed col is 0
if (SE.GetStartCol() != 0) {
ValCtx.EmitSignatureError(&SE, ValidationRule::SmPSTargetCol0);
}
// Verify max row used < 8
if (SE.GetStartRow() + SE.GetRows() > 8) {
ValCtx.EmitFormatError(ValidationRule::MetaSemanticIndexMax, {"SV_Target", "7"});
}
} else if (bAllowedInSig && semanticKind != DXIL::SemanticKind::Arbitrary) {
Allow two SV_Barycentrics (#282) unlike other system value semantics, pixel shader is allowed to declare at most two input attributes with SV_Barycentrics, with one declaration uses perspective interpolation type while other one uses noperspective interpolation type.
2017-05-10 04:59:30 +03:00
if (bIsBarycentric) {
if (SE.GetSemanticStartIndex() > 1) {
ValCtx.EmitFormatError(ValidationRule::MetaSemanticIndexMax, { SE.GetSemantic()->GetName(), "1" });
}
}
else if (!bIsClipCull && SE.GetSemanticStartIndex() > 0) {
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaSemanticIndexMax, {SE.GetSemantic()->GetName(), "0"});
}
// Maximum rows is 1 for system values other than Target
// with the exception of tessfactors, which are validated in CheckPatchConstantSemantic
if (!bIsTessfactor && SE.GetRows() > 1) {
ValCtx.EmitSignatureError(&SE, ValidationRule::MetaSystemValueRows);
}
}
first commit
2016-12-28 22:52:27 +03:00
if (SE.GetCols() + (SE.IsAllocated() ? SE.GetStartCol() : 0) > 4) {
unsigned size = (SE.GetRows() - 1) * 4 + SE.GetCols();
ValCtx.EmitFormatError(ValidationRule::MetaSignatureOutOfRange,
{SE.GetName(),
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(SE.GetStartRow()),
std::to_string(SE.GetStartCol()),
std::to_string(size)});
first commit
2016-12-28 22:52:27 +03:00
}
if (!SE.GetInterpolationMode()->IsValid()) {
ValCtx.EmitSignatureError(&SE, ValidationRule::MetaInterpModeValid);
}
}
static void ValidateSignatureOverlap(
DxilSignatureElement &E, unsigned maxScalars,
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
DxilSignatureAllocator &allocator,
ValidationContext &ValCtx) {
first commit
2016-12-28 22:52:27 +03:00
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
// Skip entries that are not or should not be allocated. Validation occurs in ValidateSignatureElement.
if (!E.IsAllocated())
return;
switch (E.GetInterpretation()) {
case DXIL::SemanticInterpretationKind::NA:
case DXIL::SemanticInterpretationKind::NotInSig:
case DXIL::SemanticInterpretationKind::Invalid:
case DXIL::SemanticInterpretationKind::NotPacked:
case DXIL::SemanticInterpretationKind::Shadow:
return;
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
default:
break;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
}
first commit
2016-12-28 22:52:27 +03:00
Group Signature Elements by Element Width (#610) This change is to enforce the new constraint on signature packing: pack signature elements by data width. Before we introduce fp16 type, every element was assumed to reserve 32 bits. Since we are introducing a new 16 bit data type, we need a new way to enforce signature rules. After discussions we decided that it would be nice to pack elements based on data width. However, we are still enforcing the rule that each row contains up to 4 elements, regardless of the size. This way, depending on the hardware support drivers can optimize packing signatures, while on DXIL level we maintain the assumption that there are 4 elements per row. We are also still constraining on the total number of rows to be 32 for now. This can be changed in the future if people find this limit to be an issue.
2017-09-06 21:04:33 +03:00
DxilPackElement PE(&E, allocator.UseMinPrecision());
Refactor DxilSignatureAllocator to remove DxilSignature dependencies
2017-05-17 06:11:38 +03:00
DxilSignatureAllocator::ConflictType conflict = allocator.DetectRowConflict(&PE, E.GetStartRow());
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
if (conflict == DxilSignatureAllocator::kNoConflict || conflict == DxilSignatureAllocator::kInsufficientFreeComponents)
Refactor DxilSignatureAllocator to remove DxilSignature dependencies
2017-05-17 06:11:38 +03:00
conflict = allocator.DetectColConflict(&PE, E.GetStartRow(), E.GetStartCol());
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
switch (conflict) {
case DxilSignatureAllocator::kNoConflict:
Refactor DxilSignatureAllocator to remove DxilSignature dependencies
2017-05-17 06:11:38 +03:00
allocator.PlaceElement(&PE, E.GetStartRow(), E.GetStartCol());
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
break;
case DxilSignatureAllocator::kConflictsWithIndexed:
ValCtx.EmitFormatError(ValidationRule::MetaSignatureIndexConflict,
{E.GetName(),
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(E.GetStartRow()),
std::to_string(E.GetStartCol()),
std::to_string(E.GetRows()),
std::to_string(E.GetCols())});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
break;
case DxilSignatureAllocator::kConflictsWithIndexedTessFactor:
ValCtx.EmitFormatError(ValidationRule::MetaSignatureIndexConflict,
{E.GetName(),
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(E.GetStartRow()),
std::to_string(E.GetStartCol()),
std::to_string(E.GetRows()),
std::to_string(E.GetCols())});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
break;
case DxilSignatureAllocator::kConflictsWithInterpolationMode:
ValCtx.EmitFormatError(ValidationRule::MetaInterpModeInOneRow,
{E.GetName(),
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(E.GetStartRow()),
std::to_string(E.GetStartCol()),
std::to_string(E.GetRows()),
std::to_string(E.GetCols())});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
break;
case DxilSignatureAllocator::kInsufficientFreeComponents:
DXASSERT(false, "otherwise, conflict not translated");
break;
case DxilSignatureAllocator::kOverlapElement:
ValCtx.EmitFormatError(ValidationRule::MetaSignatureOverlap,
{E.GetName(),
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(E.GetStartRow()),
std::to_string(E.GetStartCol()),
std::to_string(E.GetRows()),
std::to_string(E.GetCols())});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
break;
case DxilSignatureAllocator::kIllegalComponentOrder:
ValCtx.EmitFormatError(ValidationRule::MetaSignatureIllegalComponentOrder,
{E.GetName(),
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(E.GetStartRow()),
std::to_string(E.GetStartCol()),
std::to_string(E.GetRows()),
std::to_string(E.GetCols())});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
break;
case DxilSignatureAllocator::kConflictFit:
ValCtx.EmitFormatError(ValidationRule::MetaSignatureOutOfRange,
{E.GetName(),
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(E.GetStartRow()),
std::to_string(E.GetStartCol()),
std::to_string(E.GetRows()),
std::to_string(E.GetCols())});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
break;
Group Signature Elements by Element Width (#610) This change is to enforce the new constraint on signature packing: pack signature elements by data width. Before we introduce fp16 type, every element was assumed to reserve 32 bits. Since we are introducing a new 16 bit data type, we need a new way to enforce signature rules. After discussions we decided that it would be nice to pack elements based on data width. However, we are still enforcing the rule that each row contains up to 4 elements, regardless of the size. This way, depending on the hardware support drivers can optimize packing signatures, while on DXIL level we maintain the assumption that there are 4 elements per row. We are also still constraining on the total number of rows to be 32 for now. This can be changed in the future if people find this limit to be an issue.
2017-09-06 21:04:33 +03:00
case DxilSignatureAllocator::kConflictDataWidth:
ValCtx.EmitFormatError(ValidationRule::MetaSignatureDataWidth,
{E.GetName(),
std::to_string(E.GetStartRow()),
std::to_string(E.GetStartCol()),
std::to_string(E.GetRows()),
std::to_string(E.GetCols())});
break;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
default:
DXASSERT(false, "otherwise, unrecognized conflict type from DxilSignatureAllocator");
first commit
2016-12-28 22:52:27 +03:00
}
}
static void ValidateSignature(ValidationContext &ValCtx, const DxilSignature &S,
unsigned maxScalars) {
Group Signature Elements by Element Width (#610) This change is to enforce the new constraint on signature packing: pack signature elements by data width. Before we introduce fp16 type, every element was assumed to reserve 32 bits. Since we are introducing a new 16 bit data type, we need a new way to enforce signature rules. After discussions we decided that it would be nice to pack elements based on data width. However, we are still enforcing the rule that each row contains up to 4 elements, regardless of the size. This way, depending on the hardware support drivers can optimize packing signatures, while on DXIL level we maintain the assumption that there are 4 elements per row. We are also still constraining on the total number of rows to be 32 for now. This can be changed in the future if people find this limit to be an issue.
2017-09-06 21:04:33 +03:00
DxilSignatureAllocator allocator[DXIL::kNumOutputStreams] = {
{32, !ValCtx.DxilMod.m_ShaderFlags.GetUseNativeLowPrecision()},
{32, !ValCtx.DxilMod.m_ShaderFlags.GetUseNativeLowPrecision()},
{32, !ValCtx.DxilMod.m_ShaderFlags.GetUseNativeLowPrecision()},
{32, !ValCtx.DxilMod.m_ShaderFlags.GetUseNativeLowPrecision()}};
[linux-port] Avoid using enum class as set key. (#178) (#1288) Using an enum class as the key of an unordered_set is supported starting C++14. The two possible solutions are: a) provide a hash function b) cast to unsigned. Given the usage here, it latter is a simpler fix.
2018-05-16 20:04:16 +03:00
unordered_set<unsigned> semanticUsageSet[DXIL::kNumOutputStreams];
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
StringMap<unordered_set<unsigned>> semanticIndexMap[DXIL::kNumOutputStreams];
unordered_set<unsigned> clipcullRowSet[DXIL::kNumOutputStreams];
unsigned clipcullComponents[DXIL::kNumOutputStreams] = {0, 0, 0, 0};
first commit
2016-12-28 22:52:27 +03:00
bool isOutput = S.IsOutput();
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
unsigned TargetMask = 0;
DXIL::SemanticKind DepthKind = DXIL::SemanticKind::Invalid;
first commit
2016-12-28 22:52:27 +03:00
Allow two SV_Barycentrics (#282) unlike other system value semantics, pixel shader is allowed to declare at most two input attributes with SV_Barycentrics, with one declaration uses perspective interpolation type while other one uses noperspective interpolation type.
2017-05-10 04:59:30 +03:00
const InterpolationMode *prevBaryInterpMode = nullptr;
unsigned numBarycentrics = 0;
Group Signature Elements by Element Width (#610) This change is to enforce the new constraint on signature packing: pack signature elements by data width. Before we introduce fp16 type, every element was assumed to reserve 32 bits. Since we are introducing a new 16 bit data type, we need a new way to enforce signature rules. After discussions we decided that it would be nice to pack elements based on data width. However, we are still enforcing the rule that each row contains up to 4 elements, regardless of the size. This way, depending on the hardware support drivers can optimize packing signatures, while on DXIL level we maintain the assumption that there are 4 elements per row. We are also still constraining on the total number of rows to be 32 for now. This can be changed in the future if people find this limit to be an issue.
2017-09-06 21:04:33 +03:00
first commit
2016-12-28 22:52:27 +03:00
for (auto &E : S.GetElements()) {
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
DXIL::SemanticKind semanticKind = E->GetSemantic()->GetKind();
first commit
2016-12-28 22:52:27 +03:00
ValidateSignatureElement(*E, ValCtx);
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
// Avoid OOB indexing on streamId.
first commit
2016-12-28 22:52:27 +03:00
unsigned streamId = E->GetOutputStream();
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
if (streamId >= DXIL::kNumOutputStreams ||
!isOutput ||
!ValCtx.DxilMod.GetShaderModel()->IsGS()) {
streamId = 0;
}
// Semantic index overlap check, keyed by name.
std::string nameUpper(E->GetName());
[linux-port] Fix template ambiguities (#1277) Templated iterators often have a dependent scope, which annoys some compilers because they can't tell if the typename evaluates to a type or a variable name. This adds typename keywords to remove the ambiguity in removeResources. Additionally, the std toupper function can't be found for the sake of the templated call to std::transform in ValidateSignature function. By adding :: to clarify it, the template can be evaluated.
2018-05-12 14:52:00 +03:00
std::transform(nameUpper.begin(), nameUpper.end(), nameUpper.begin(), ::toupper);
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
unordered_set<unsigned> &semIdxSet = semanticIndexMap[streamId][nameUpper];
for (unsigned semIdx : E->GetSemanticIndexVec()) {
if (semIdxSet.count(semIdx) > 0) {
ValCtx.EmitFormatError(ValidationRule::MetaNoSemanticOverlap,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{E->GetName(), std::to_string(semIdx)});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
return;
} else
semIdxSet.insert(semIdx);
}
// SV_Target has special rules
if (semanticKind == DXIL::SemanticKind::Target) {
// Validate target overlap
if (E->GetStartRow() + E->GetRows() <= 8) {
unsigned mask = ((1 << E->GetRows()) - 1) << E->GetStartRow();
if (TargetMask & mask) {
ValCtx.EmitFormatError(ValidationRule::MetaNoSemanticOverlap,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{"SV_Target", std::to_string(E->GetStartRow())});
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
}
TargetMask = TargetMask | mask;
}
if (E->GetRows() > 1) {
ValCtx.EmitError(ValidationRule::SmNoPSOutputIdx);
}
first commit
2016-12-28 22:52:27 +03:00
continue;
}
if (E->GetSemantic()->IsInvalid())
continue;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
// validate system value semantic rules
switch (semanticKind) {
case DXIL::SemanticKind::Arbitrary:
break;
case DXIL::SemanticKind::ClipDistance:
case DXIL::SemanticKind::CullDistance:
// Validate max 8 components across 2 rows (registers)
clipcullRowSet[streamId].insert(E->GetStartRow());
if (clipcullRowSet[streamId].size() > 2) {
ValCtx.EmitError(ValidationRule::MetaClipCullMaxRows);
}
clipcullComponents[streamId] += E->GetCols();
if (clipcullComponents[streamId] > 8) {
ValCtx.EmitError(ValidationRule::MetaClipCullMaxComponents);
}
break;
case DXIL::SemanticKind::Depth:
case DXIL::SemanticKind::DepthGreaterEqual:
case DXIL::SemanticKind::DepthLessEqual:
if (DepthKind != DXIL::SemanticKind::Invalid) {
ValCtx.EmitError(ValidationRule::SmPSMultipleDepthSemantic);
1. Clean more validation TODOs. 2. Support array of SV_Target.
2017-01-10 22:44:48 +03:00
}
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
DepthKind = semanticKind;
break;
Allow two SV_Barycentrics (#282) unlike other system value semantics, pixel shader is allowed to declare at most two input attributes with SV_Barycentrics, with one declaration uses perspective interpolation type while other one uses noperspective interpolation type.
2017-05-10 04:59:30 +03:00
case DXIL::SemanticKind::Barycentrics: {
// There can only be up to two SV_Barycentrics
// with differeent perspective interpolation modes.
if (numBarycentrics++ > 1) {
ValCtx.EmitError(ValidationRule::MetaBarycentricsTwoPerspectives);
break;
}
const InterpolationMode *mode = E->GetInterpolationMode();
if (prevBaryInterpMode) {
if ((mode->IsAnyNoPerspective() && prevBaryInterpMode->IsAnyNoPerspective())
|| (!mode->IsAnyNoPerspective() && !prevBaryInterpMode->IsAnyNoPerspective())) {
ValCtx.EmitError(ValidationRule::MetaBarycentricsTwoPerspectives);
}
}
prevBaryInterpMode = mode;
break;
}
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
default:
[linux-port] Avoid using enum class as set key. (#178) (#1288) Using an enum class as the key of an unordered_set is supported starting C++14. The two possible solutions are: a) provide a hash function b) cast to unsigned. Given the usage here, it latter is a simpler fix.
2018-05-16 20:04:16 +03:00
if (semanticUsageSet[streamId].count(static_cast<unsigned>(semanticKind)) > 0) {
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
ValCtx.EmitFormatError(ValidationRule::MetaDuplicateSysValue,
{E->GetSemantic()->GetName()});
}
[linux-port] Avoid using enum class as set key. (#178) (#1288) Using an enum class as the key of an unordered_set is supported starting C++14. The two possible solutions are: a) provide a hash function b) cast to unsigned. Given the usage here, it latter is a simpler fix.
2018-05-16 20:04:16 +03:00
semanticUsageSet[streamId].insert(static_cast<unsigned>(semanticKind));
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
break;
first commit
2016-12-28 22:52:27 +03:00
}
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
// Packed element overlap check.
ValidateSignatureOverlap(*E.get(), maxScalars, allocator[streamId], ValCtx);
if (isOutput && semanticKind == DXIL::SemanticKind::Position) {
ValCtx.hasOutputPosition[E->GetOutputStream()] = true;
}
first commit
2016-12-28 22:52:27 +03:00
}
Add ViewID slot validation for PSIn (#254)
2017-05-02 03:54:33 +03:00
if (ValCtx.hasViewID && S.IsInput() && ValCtx.DxilMod.GetShaderModel()->GetKind() == DXIL::ShaderKind::Pixel) {
// Ensure sufficient space for ViewID:
Refactor DxilSignatureAllocator to remove DxilSignature dependencies
2017-05-17 06:11:38 +03:00
DxilSignatureAllocator::DummyElement viewID;
viewID.rows = 1;
viewID.cols = 1;
viewID.kind = DXIL::SemanticKind::Arbitrary;
viewID.interpolation = DXIL::InterpolationMode::Constant;
viewID.interpretation = DXIL::SemanticInterpretationKind::SGV;
Add ViewID slot validation for PSIn (#254)
2017-05-02 03:54:33 +03:00
allocator[0].PackNext(&viewID, 0, 32);
if (!viewID.IsAllocated()) {
ValCtx.EmitError(ValidationRule::SmViewIDNeedsSlot);
}
}
first commit
2016-12-28 22:52:27 +03:00
}
static void ValidateNoInterpModeSignature(ValidationContext &ValCtx, const DxilSignature &S) {
for (auto &E : S.GetElements()) {
if (!E->GetInterpolationMode()->IsUndefined()) {
ValCtx.EmitSignatureError(E.get(), ValidationRule::SmNoInterpMode);
}
}
}
static void ValidateSignatures(ValidationContext &ValCtx) {
DxilModule &M = ValCtx.DxilMod;
bool isPS = M.GetShaderModel()->IsPS();
bool isVS = M.GetShaderModel()->IsVS();
bool isGS = M.GetShaderModel()->IsGS();
bool isCS = M.GetShaderModel()->IsCS();
if (isPS) {
// PS output no interp mode.
ValidateNoInterpModeSignature(ValCtx, ValCtx.DxilMod.GetOutputSignature());
} else if (isVS) {
// VS input no interp mode.
ValidateNoInterpModeSignature(ValCtx, ValCtx.DxilMod.GetInputSignature());
}
// patch constant no interp mode.
ValidateNoInterpModeSignature(ValCtx, ValCtx.DxilMod.GetPatchConstantSignature());
unsigned maxInputScalars = DXIL::kMaxInputTotalScalars;
unsigned maxOutputScalars = 0;
unsigned maxPatchConstantScalars = 0;
switch (M.GetShaderModel()->GetKind()) {
case DXIL::ShaderKind::Compute:
break;
case DXIL::ShaderKind::Vertex:
case DXIL::ShaderKind::Geometry:
case DXIL::ShaderKind::Pixel:
maxOutputScalars = DXIL::kMaxOutputTotalScalars;
break;
case DXIL::ShaderKind::Hull:
case DXIL::ShaderKind::Domain:
maxOutputScalars = DXIL::kMaxOutputTotalScalars;
maxPatchConstantScalars = DXIL::kMaxHSOutputPatchConstantTotalScalars;
break;
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
default:
break;
first commit
2016-12-28 22:52:27 +03:00
}
ValidateSignature(ValCtx, ValCtx.DxilMod.GetInputSignature(), maxInputScalars);
ValidateSignature(ValCtx, ValCtx.DxilMod.GetOutputSignature(), maxOutputScalars);
ValidateSignature(ValCtx, ValCtx.DxilMod.GetPatchConstantSignature(), maxPatchConstantScalars);
if (isPS) {
// Gather execution information.
hlsl::PSExecutionInfo &PSExec = ValCtx.PSExec;
for (auto &E : ValCtx.DxilMod.GetInputSignature().GetElements()) {
if (E->GetKind() == DXIL::SemanticKind::SampleIndex) {
PSExec.SuperSampling = true;
continue;
}
const InterpolationMode *IM = E->GetInterpolationMode();
if (IM->IsLinearSample() || IM->IsLinearNoperspectiveSample()) {
PSExec.SuperSampling = true;
}
if (E->GetKind() == DXIL::SemanticKind::Position) {
PSExec.PositionInterpolationMode = IM;
}
}
for (auto &E : ValCtx.DxilMod.GetOutputSignature().GetElements()) {
if (E->IsAnyDepth()) {
PSExec.OutputDepthKind = E->GetKind();
break;
}
}
if (!PSExec.SuperSampling &&
PSExec.OutputDepthKind != DXIL::SemanticKind::Invalid &&
PSExec.OutputDepthKind != DXIL::SemanticKind::Depth) {
if (PSExec.PositionInterpolationMode != nullptr) {
if (!PSExec.PositionInterpolationMode->IsUndefined() &&
!PSExec.PositionInterpolationMode->IsLinearNoperspectiveCentroid() &&
!PSExec.PositionInterpolationMode->IsLinearNoperspectiveSample()) {
ValCtx.EmitError(ValidationRule::SmPSConsistentInterp);
}
}
}
// Validate PS output semantic.
DxilSignature &outputSig = M.GetOutputSignature();
for (auto &SE : outputSig.GetElements()) {
Semantic::Kind semanticKind = SE->GetSemantic()->GetKind();
switch (semanticKind) {
case Semantic::Kind::Target:
case Semantic::Kind::Coverage:
case Semantic::Kind::Depth:
case Semantic::Kind::DepthGreaterEqual:
case Semantic::Kind::DepthLessEqual:
case Semantic::Kind::StencilRef:
break;
default: {
ValCtx.EmitFormatError(ValidationRule::SmPSOutputSemantic, {SE->GetName()});
} break;
}
}
}
if (isGS) {
unsigned maxVertexCount = M.GetMaxVertexCount();
unsigned outputScalarCount = 0;
DxilSignature &outSig = ValCtx.DxilMod.GetOutputSignature();
for (auto &SE : outSig.GetElements()) {
outputScalarCount += SE->GetRows() * SE->GetCols();
}
unsigned totalOutputScalars = maxVertexCount * outputScalarCount;
if (totalOutputScalars > DXIL::kMaxGSOutputTotalScalars) {
ValCtx.EmitFormatError(
ValidationRule::SmGSTotalOutputVertexDataRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(maxVertexCount),
std::to_string(outputScalarCount),
std::to_string(totalOutputScalars),
std::to_string(DXIL::kMaxGSOutputTotalScalars)});
first commit
2016-12-28 22:52:27 +03:00
}
}
if (isCS) {
if (!ValCtx.DxilMod.GetOutputSignature().GetElements().empty() ||
!ValCtx.DxilMod.GetPatchConstantSignature().GetElements().empty()) {
ValCtx.EmitError(ValidationRule::SmCSNoReturn);
}
}
}
static void CheckPatchConstantSemantic(ValidationContext &ValCtx)
{
bool isHS = ValCtx.DxilMod.GetShaderModel()->IsHS();
DXIL::TessellatorDomain domain = ValCtx.DxilMod.GetTessellatorDomain();
DxilSignature &patchConstantSig = ValCtx.DxilMod.GetPatchConstantSignature();
const unsigned kQuadEdgeSize = 4;
const unsigned kQuadInsideSize = 2;
const unsigned kQuadDomainLocSize = 2;
const unsigned kTriEdgeSize = 3;
const unsigned kTriInsideSize = 1;
const unsigned kTriDomainLocSize = 3;
const unsigned kIsolineEdgeSize = 2;
const unsigned kIsolineInsideSize = 0;
const unsigned kIsolineDomainLocSize = 3;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
const char *domainName = "";
first commit
2016-12-28 22:52:27 +03:00
DXIL::SemanticKind kEdgeSemantic = DXIL::SemanticKind::TessFactor;
unsigned edgeSize = 0;
DXIL::SemanticKind kInsideSemantic = DXIL::SemanticKind::InsideTessFactor;
unsigned insideSize = 0;
ValCtx.domainLocSize = 0;
switch (domain) {
case DXIL::TessellatorDomain::IsoLine:
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
domainName = "IsoLine";
first commit
2016-12-28 22:52:27 +03:00
edgeSize = kIsolineEdgeSize;
insideSize = kIsolineInsideSize;
ValCtx.domainLocSize = kIsolineDomainLocSize;
break;
case DXIL::TessellatorDomain::Tri:
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
domainName = "Tri";
first commit
2016-12-28 22:52:27 +03:00
edgeSize = kTriEdgeSize;
insideSize = kTriInsideSize;
ValCtx.domainLocSize = kTriDomainLocSize;
break;
case DXIL::TessellatorDomain::Quad:
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
domainName = "Quad";
first commit
2016-12-28 22:52:27 +03:00
edgeSize = kQuadEdgeSize;
insideSize = kQuadInsideSize;
ValCtx.domainLocSize = kQuadDomainLocSize;
break;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
default:
// Don't bother with other tests if domain is invalid
return;
first commit
2016-12-28 22:52:27 +03:00
}
bool bFoundEdgeSemantic = false;
bool bFoundInsideSemantic = false;
for (auto &SE : patchConstantSig.GetElements()) {
Semantic::Kind kind = SE->GetSemantic()->GetKind();
if (kind == kEdgeSemantic) {
bFoundEdgeSemantic = true;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
if (SE->GetRows() != edgeSize || SE->GetCols() > 1) {
ValCtx.EmitFormatError(ValidationRule::SmTessFactorSizeMatchDomain,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(SE->GetRows()),
std::to_string(SE->GetCols()),
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
domainName,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(edgeSize)});
first commit
2016-12-28 22:52:27 +03:00
}
} else if (kind == kInsideSemantic) {
bFoundInsideSemantic = true;
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
if (SE->GetRows() != insideSize || SE->GetCols() > 1) {
ValCtx.EmitFormatError(ValidationRule::SmInsideTessFactorSizeMatchDomain,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(SE->GetRows()),
std::to_string(SE->GetCols()),
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
domainName,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
std::to_string(insideSize)});
first commit
2016-12-28 22:52:27 +03:00
}
}
}
if (isHS) {
if (!bFoundEdgeSemantic) {
ValCtx.EmitError(ValidationRule::SmTessFactorForDomain);
}
if (!bFoundInsideSemantic && domain != DXIL::TessellatorDomain::IsoLine) {
ValCtx.EmitError(ValidationRule::SmTessFactorForDomain);
}
}
}
static void ValidateShaderState(ValidationContext &ValCtx) {
DxilModule &M = ValCtx.DxilMod;
DXIL::ShaderKind ShaderType = M.GetShaderModel()->GetKind();
if (ShaderType == DXIL::ShaderKind::Compute) {
unsigned x = M.m_NumThreads[0];
unsigned y = M.m_NumThreads[1];
unsigned z = M.m_NumThreads[2];
unsigned threadsInGroup = x * y * z;
if ((x < DXIL::kMinCSThreadGroupX) || (x > DXIL::kMaxCSThreadGroupX)) {
ValCtx.EmitFormatError(
ValidationRule::SmThreadGroupChannelRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{"X", std::to_string(x),
std::to_string(DXIL::kMinCSThreadGroupX),
std::to_string(DXIL::kMaxCSThreadGroupX)});
first commit
2016-12-28 22:52:27 +03:00
}
if ((y < DXIL::kMinCSThreadGroupY) || (y > DXIL::kMaxCSThreadGroupY)) {
ValCtx.EmitFormatError(
ValidationRule::SmThreadGroupChannelRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{"Y", std::to_string(y),
std::to_string(DXIL::kMinCSThreadGroupY),
std::to_string(DXIL::kMaxCSThreadGroupY)});
first commit
2016-12-28 22:52:27 +03:00
}
if ((z < DXIL::kMinCSThreadGroupZ) || (z > DXIL::kMaxCSThreadGroupZ)) {
ValCtx.EmitFormatError(
ValidationRule::SmThreadGroupChannelRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{"Z", std::to_string(z),
std::to_string(DXIL::kMinCSThreadGroupZ),
std::to_string(DXIL::kMaxCSThreadGroupZ)});
first commit
2016-12-28 22:52:27 +03:00
}
if (threadsInGroup > DXIL::kMaxCSThreadsPerGroup) {
ValCtx.EmitFormatError(
ValidationRule::SmMaxTheadGroup,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(threadsInGroup),
std::to_string(DXIL::kMaxCSThreadsPerGroup)});
first commit
2016-12-28 22:52:27 +03:00
}
// type of threadID, thread group ID take care by DXIL operation overload
// check.
} else if (ShaderType == DXIL::ShaderKind::Domain) {
DXIL::TessellatorDomain domain = M.GetTessellatorDomain();
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
if (domain >= DXIL::TessellatorDomain::LastEntry)
domain = DXIL::TessellatorDomain::Undefined;
first commit
2016-12-28 22:52:27 +03:00
unsigned inputControlPointCount = M.GetInputControlPointCount();
if (inputControlPointCount > DXIL::kMaxIAPatchControlPointCount) {
ValCtx.EmitFormatError(
ValidationRule::SmDSInputControlPointCountRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(DXIL::kMaxIAPatchControlPointCount),
std::to_string(inputControlPointCount)});
first commit
2016-12-28 22:52:27 +03:00
}
if (domain == DXIL::TessellatorDomain::Undefined) {
ValCtx.EmitError(ValidationRule::SmValidDomain);
}
CheckPatchConstantSemantic(ValCtx);
} else if (ShaderType == DXIL::ShaderKind::Hull) {
DXIL::TessellatorDomain domain = M.GetTessellatorDomain();
Signature packing, codegen fixes, and validation fixes and additions. - Add DxilSignatureAllocator for signature packing - Fix signature validation. Add more validation. - Fix and add validation tests. - Fix codegen for inout params with SV like SV_Coverage - fix m_SemanticStartIndex on DxilSignatureElement::Initialize - fix DxilSignatureElement::GetColsAsMask for start col == 2 - Add diags for signature allocation failures - Use Regex in ValidationTest
2017-01-07 03:55:33 +03:00
if (domain >= DXIL::TessellatorDomain::LastEntry)
domain = DXIL::TessellatorDomain::Undefined;
first commit
2016-12-28 22:52:27 +03:00
unsigned inputControlPointCount = M.GetInputControlPointCount();
Fix validation bugs. (#10)
2017-02-08 09:18:10 +03:00
if (inputControlPointCount == 0) {
if (!M.GetInputSignature().GetElements().empty()) {
ValCtx.EmitError(
ValidationRule::SmZeroHSInputControlPointWithInput);
}
} else if (inputControlPointCount > DXIL::kMaxIAPatchControlPointCount) {
first commit
2016-12-28 22:52:27 +03:00
ValCtx.EmitFormatError(
ValidationRule::SmHSInputControlPointCountRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(DXIL::kMaxIAPatchControlPointCount),
std::to_string(inputControlPointCount)});
first commit
2016-12-28 22:52:27 +03:00
}
if (domain == DXIL::TessellatorDomain::Undefined) {
ValCtx.EmitError(ValidationRule::SmValidDomain);
}
DXIL::TessellatorPartitioning partition = M.GetTessellatorPartitioning();
if (partition == DXIL::TessellatorPartitioning::Undefined) {
ValCtx.EmitError(ValidationRule::MetaTessellatorPartition);
}
DXIL::TessellatorOutputPrimitive tessOutputPrimitive =
M.GetTessellatorOutputPrimitive();
if (tessOutputPrimitive == DXIL::TessellatorOutputPrimitive::Undefined ||
tessOutputPrimitive == DXIL::TessellatorOutputPrimitive::LastEntry) {
ValCtx.EmitError(ValidationRule::MetaTessellatorOutputPrimitive);
}
float maxTessFactor = M.GetMaxTessellationFactor();
if (maxTessFactor < DXIL::kHSMaxTessFactorLowerBound ||
maxTessFactor > DXIL::kHSMaxTessFactorUpperBound) {
ValCtx.EmitFormatError(
ValidationRule::MetaMaxTessFactor,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(DXIL::kHSMaxTessFactorLowerBound),
std::to_string(DXIL::kHSMaxTessFactorUpperBound),
std::to_string(maxTessFactor)});
first commit
2016-12-28 22:52:27 +03:00
}
// Domain and OutPrimivtive match.
switch (domain) {
case DXIL::TessellatorDomain::IsoLine:
switch (tessOutputPrimitive) {
case DXIL::TessellatorOutputPrimitive::TriangleCW:
case DXIL::TessellatorOutputPrimitive::TriangleCCW:
ValCtx.EmitError(ValidationRule::SmIsoLineOutputPrimitiveMismatch);
break;
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
default:
break;
first commit
2016-12-28 22:52:27 +03:00
}
break;
case DXIL::TessellatorDomain::Tri:
switch (tessOutputPrimitive) {
case DXIL::TessellatorOutputPrimitive::Line:
ValCtx.EmitError(ValidationRule::SmTriOutputPrimitiveMismatch);
break;
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
default:
break;
first commit
2016-12-28 22:52:27 +03:00
}
break;
case DXIL::TessellatorDomain::Quad:
switch (tessOutputPrimitive) {
case DXIL::TessellatorOutputPrimitive::Line:
ValCtx.EmitError(ValidationRule::SmTriOutputPrimitiveMismatch);
break;
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
default:
break;
first commit
2016-12-28 22:52:27 +03:00
}
break;
default:
ValCtx.EmitError(ValidationRule::SmValidDomain);
break;
}
// Check pass thru HS.
if (M.GetEntryFunction() == nullptr) {
if (M.GetShaderModel()->IsHS()) {
if (M.GetInputControlPointCount() < M.GetOutputControlPointCount()) {
ValCtx.EmitError(
ValidationRule::SmHullPassThruControlPointCountMatch);
}
// Check declared control point outputs storage amounts are ok to pass
// through (less output storage than input for control points).
DxilSignature &outSig = M.GetOutputSignature();
unsigned totalOutputCPScalars = 0;
for (auto &SE : outSig.GetElements()) {
totalOutputCPScalars += SE->GetRows() * SE->GetCols();
}
if (totalOutputCPScalars * M.GetOutputControlPointCount() >
DXIL::kMaxHSOutputControlPointsTotalScalars) {
ValCtx.EmitError(ValidationRule::SmOutputControlPointsTotalScalars);
}
} else {
ValCtx.EmitError(ValidationRule::MetaEntryFunction);
}
}
CheckPatchConstantSemantic(ValCtx);
} else if (ShaderType == DXIL::ShaderKind::Geometry) {
unsigned maxVertexCount = M.GetMaxVertexCount();
if (maxVertexCount > DXIL::kMaxGSOutputVertexCount) {
ValCtx.EmitFormatError(
ValidationRule::SmGSOutputVertexCountRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(DXIL::kMaxGSOutputVertexCount),
std::to_string(maxVertexCount)});
first commit
2016-12-28 22:52:27 +03:00
}
unsigned instanceCount = M.GetGSInstanceCount();
if (instanceCount > DXIL::kMaxGSInstanceCount || instanceCount < 1) {
ValCtx.EmitFormatError(ValidationRule::SmGSInstanceCountRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(DXIL::kMaxGSInstanceCount),
std::to_string(instanceCount)});
first commit
2016-12-28 22:52:27 +03:00
}
DXIL::PrimitiveTopology topo = M.GetStreamPrimitiveTopology();
switch (topo) {
case DXIL::PrimitiveTopology::PointList:
case DXIL::PrimitiveTopology::LineStrip:
case DXIL::PrimitiveTopology::TriangleStrip:
break;
default: {
ValCtx.EmitError(ValidationRule::SmGSValidOutputPrimitiveTopology);
} break;
}
DXIL::InputPrimitive inputPrimitive = M.GetInputPrimitive();
unsigned VertexCount = GetNumVertices(inputPrimitive);
if (VertexCount == 0 && inputPrimitive != DXIL::InputPrimitive::Undefined) {
ValCtx.EmitError(ValidationRule::SmGSValidInputPrimitive);
}
}
unsigned outputControlPointCount = M.GetOutputControlPointCount();
if (outputControlPointCount > DXIL::kMaxIAPatchControlPointCount) {
ValCtx.EmitFormatError(
ValidationRule::SmOutputControlPointCountRange,
Use i32 to fake 64bit for buffer load/store. (#63)
2017-02-03 04:48:43 +03:00
{std::to_string(DXIL::kMaxIAPatchControlPointCount),
std::to_string(outputControlPointCount)});
first commit
2016-12-28 22:52:27 +03:00
}
}
static bool
CalculateCallDepth(CallGraphNode *node,
std::unordered_map<CallGraphNode *, unsigned> &depthMap,
std::unordered_set<CallGraphNode *> &callStack,
std::unordered_set<Function *> &funcSet) {
unsigned depth = callStack.size();
funcSet.insert(node->getFunction());
for (auto it = node->begin(), ei = node->end(); it != ei; it++) {
CallGraphNode *toNode = it->second;
Close #62: strange error output on recursive function calls (#150) * Traverse call graph to report recursive calls in the front-end. * Emit function declarations only as needed. * Fix extra echo output in hctbuild help. * Remove unused test case.
2017-03-28 02:12:55 +03:00
if (callStack.insert(toNode).second == false) {
// Recursive.
first commit
2016-12-28 22:52:27 +03:00
return true;
}
if (depthMap[toNode] < depth)
depthMap[toNode] = depth;
if (CalculateCallDepth(toNode, depthMap, callStack, funcSet)) {
// Recursive
return true;
}
callStack.erase(toNode);
}
return false;
}
static void ValidateCallGraph(ValidationContext &ValCtx) {
// Build CallGraph.
CallGraph CG(*ValCtx.DxilMod.GetModule());
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
first commit
2016-12-28 22:52:27 +03:00
std::unordered_map<CallGraphNode*, unsigned> depthMap;
std::unordered_set<CallGraphNode*> callStack;
CallGraphNode *entryNode = CG[ValCtx.DxilMod.GetEntryFunction()];
depthMap[entryNode] = 0;
bool bRecursive = CalculateCallDepth(entryNode, depthMap, callStack, ValCtx.entryFuncCallSet);
if (ValCtx.DxilMod.GetShaderModel()->IsHS()) {
CallGraphNode *patchConstantNode = CG[ValCtx.DxilMod.GetPatchConstantFunction()];
depthMap[patchConstantNode] = 0;
callStack.clear();
bRecursive |= CalculateCallDepth(patchConstantNode, depthMap, callStack, ValCtx.patchConstFuncCallSet);
}
if (bRecursive) {
ValCtx.EmitError(ValidationRule::FlowNoRecusion);
}
}
static void ValidateFlowControl(ValidationContext &ValCtx) {
bool reducible =
IsReducible(*ValCtx.DxilMod.GetModule(), IrreducibilityAction::Ignore);
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
if (!reducible) {
first commit
2016-12-28 22:52:27 +03:00
ValCtx.EmitError(ValidationRule::FlowReducible);
Cleanup more Validation TODOs.
2017-01-13 04:59:37 +03:00
return;
}
first commit
2016-12-28 22:52:27 +03:00
ValidateCallGraph(ValCtx);
for (auto &F : ValCtx.DxilMod.GetModule()->functions()) {
if (F.isDeclaration())
continue;
DominatorTreeAnalysis DTA;
DominatorTree DT = DTA.run(F);
LoopInfo LI;
LI.Analyze(DT);
for (auto loopIt = LI.begin(); loopIt != LI.end(); loopIt++) {
Loop *loop = *loopIt;
SmallVector<BasicBlock *, 4> exitBlocks;
loop->getExitBlocks(exitBlocks);
if (exitBlocks.empty())
ValCtx.EmitError(ValidationRule::FlowDeadLoop);
}
}
// fxc has ERR_CONTINUE_INSIDE_SWITCH to disallow continue in switch.
// Not do it for now.
}
static void ValidateUninitializedOutput(ValidationContext &ValCtx) {
// For HS only need to check Tessfactor which is in patch constant sig.
if (ValCtx.DxilMod.GetShaderModel()->IsHS()) {
std::vector<unsigned> &patchConstCols = ValCtx.patchConstCols;
for (auto &E : ValCtx.DxilMod.GetPatchConstantSignature().GetElements()) {
unsigned mask = patchConstCols[E->GetID()];
unsigned requireMask = (1 << E->GetCols()) - 1;
// TODO: check other case uninitialized output is allowed.
if (mask != requireMask && !E->GetSemantic()->IsArbitrary()) {
ValCtx.EmitFormatError(ValidationRule::SmUndefinedOutput,
{E->GetName()});
}
}
return;
}
std::vector<unsigned> &outputCols = ValCtx.outputCols;
for (auto &E : ValCtx.DxilMod.GetOutputSignature().GetElements()) {
unsigned mask = outputCols[E->GetID()];
unsigned requireMask = (1 << E->GetCols()) - 1;
// TODO: check other case uninitialized output is allowed.
if (mask != requireMask && !E->GetSemantic()->IsArbitrary() &&
E->GetSemantic()->GetKind() != Semantic::Kind::Target) {
ValCtx.EmitFormatError(ValidationRule::SmUndefinedOutput, {E->GetName()});
}
}
}
void GetValidationVersion(_Out_ unsigned *pMajor, _Out_ unsigned *pMinor) {
Debug name part implementation (#264) * Add documentation with source-level debugging with HLSL and DXIL. * Fix trailing underscore in generate .rst documentation. * Add container support for debug name part. * Bump validator version to 1.1. * Implement debug stripping in dxc, including /Fd dir-named behavior. * Implement IDxcCompiler2 and CompileWithDebug.
2017-05-10 04:32:48 +03:00
// 1.0 is the first validator.
// 1.1 adds:
// - ILDN container part support
Update shader model 6.2 (#435) 1. Update shader model 6.2 2. update DXIL version to 1.2 and its tests 3. Allow noalias and alias_scope metadata per instruction for validator 1.2
2017-07-20 08:00:31 +03:00
// 1.2 adds:
// - Metadata for floating point denorm mode
Bump up version number. (#1066) bump up version to SM6.3 and DXIL1.3
2018-02-13 00:27:48 +03:00
// 1.3 adds:
// TODO: add comment
first commit
2016-12-28 22:52:27 +03:00
*pMajor = 1;
Bump up version number. (#1066) bump up version to SM6.3 and DXIL1.3
2018-02-13 00:27:48 +03:00
*pMinor = 3;
first commit
2016-12-28 22:52:27 +03:00
}
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
_Use_decl_annotations_ HRESULT
first commit
2016-12-28 22:52:27 +03:00
ValidateDxilModule(llvm::Module *pModule, llvm::Module *pDebugModule) {
std::string diagStr;
raw_string_ostream diagStream(diagStr);
DiagnosticPrinterRawOStream DiagPrinter(diagStream);
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
DxilModule *pDxilModule = DxilModule::TryGetDxilModule(pModule);
if (!pDxilModule) {
return DXC_E_IR_VERIFICATION_FAILED;
first commit
2016-12-28 22:52:27 +03:00
}
ValidationContext ValCtx(*pModule, pDebugModule, *pDxilModule, DiagPrinter);
ValidateMetadata(ValCtx);
ValidateShaderState(ValCtx);
ValidateGlobalVariables(ValCtx);
ValidateResources(ValCtx);
// Validate control flow and collect function call info.
// If has recursive call, call info collection will not finish.
ValidateFlowControl(ValCtx);
// Validate functions.
for (Function &F : pModule->functions()) {
ValidateFunction(F, ValCtx);
}
ValidateUninitializedOutput(ValCtx);
ValidateShaderFlags(ValCtx);
Add ViewID slot validation for PSIn (#254)
2017-05-02 03:54:33 +03:00
ValidateSignatures(ValCtx);
first commit
2016-12-28 22:52:27 +03:00
if (!pDxilModule->GetShaderModel()->IsGS()) {
unsigned posMask = ValCtx.OutputPositionMask[0];
if (posMask != 0xf && ValCtx.hasOutputPosition[0]) {
ValCtx.EmitError(ValidationRule::SmCompletePosition);
}
} else {
unsigned streamMask = ValCtx.DxilMod.GetActiveStreamMask();
for (unsigned i = 0; i < DXIL::kNumOutputStreams; i++) {
if (streamMask & (1 << i)) {
unsigned posMask = ValCtx.OutputPositionMask[i];
if (posMask != 0xf && ValCtx.hasOutputPosition[i]) {
ValCtx.EmitError(ValidationRule::SmCompletePosition);
}
}
}
}
// Ensure error messages are flushed out on error.
if (ValCtx.Failed) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
emitDxilDiag(pModule->getContext(), diagStream.str().c_str());
return DXC_E_IR_VERIFICATION_FAILED;
}
return S_OK;
}
// DXIL Container Verification Functions
static void VerifyBlobPartMatches(_In_ ValidationContext &ValCtx,
_In_ LPCSTR pName,
DxilPartWriter *pWriter,
_In_reads_bytes_opt_(Size) const void *pData,
Move Signature metadata to named node and some other cleanup.
2017-02-04 01:28:21 +03:00
_In_ uint32_t Size) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
if (!pData && pWriter->size()) {
// No blob part, but writer says non-zero size is expected.
Fix build break from automatic merge.
2017-02-10 06:03:47 +03:00
ValCtx.EmitFormatError(ValidationRule::ContainerPartMissing, {pName});
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
return;
}
// Compare sizes
if (pWriter->size() != Size) {
Fix build break from automatic merge.
2017-02-10 06:03:47 +03:00
ValCtx.EmitFormatError(ValidationRule::ContainerPartMatches, {pName});
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
return;
}
Add tests and fix bugs with container and root signature validation (#5) * Fix ValidateDxilBitcode PSV generation for Root Signature validation. - also fix validation for empty patch constant signature. * Test container and root signature validation. * Fix DXASSERT when PC in/out patch sig mismatch HS.
2017-02-08 03:57:07 +03:00
if (Size == 0) {
return;
}
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
CComPtr<AbstractMemoryStream> pOutputStream;
Add support for custom allocators (#390) Supporting a custom allocator for dxcompiler. Adds recovery for exceptions and out-of-memory handling. Add custom allocator support to linker. Fix for release-only test failure. Removes assertion about presence of command-line option registration
2017-07-07 02:45:48 +03:00
IFT(CreateMemoryStream(DxcGetThreadMallocNoRef(), &pOutputStream));
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
pOutputStream->Reserve(Size);
pWriter->write(pOutputStream);
DXASSERT(pOutputStream->GetPtrSize() == Size, "otherwise, DxilPartWriter misreported size");
if (memcmp(pData, pOutputStream->GetPtr(), Size)) {
Fix build break from automatic merge.
2017-02-10 06:03:47 +03:00
ValCtx.EmitFormatError(ValidationRule::ContainerPartMatches, {pName});
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
return;
}
return;
}
static void VerifySignatureMatches(_In_ ValidationContext &ValCtx,
DXIL::SignatureKind SigKind,
_In_reads_bytes_opt_(SigSize) const void *pSigData,
Move Signature metadata to named node and some other cleanup.
2017-02-04 01:28:21 +03:00
_In_ uint32_t SigSize) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
// Generate corresponding signature from module and memcmp
const char *pName = nullptr;
switch (SigKind)
{
case hlsl::DXIL::SignatureKind::Input:
pName = "Program Input Signature";
break;
case hlsl::DXIL::SignatureKind::Output:
pName = "Program Output Signature";
break;
case hlsl::DXIL::SignatureKind::PatchConstant:
pName = "Program Patch Constant Signature";
break;
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
default:
break;
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
}
unique_ptr<DxilPartWriter> pWriter(NewProgramSignatureWriter(ValCtx.DxilMod, SigKind));
VerifyBlobPartMatches(ValCtx, pName, pWriter.get(), pSigData, SigSize);
}
_Use_decl_annotations_
bool VerifySignatureMatches(llvm::Module *pModule,
DXIL::SignatureKind SigKind,
const void *pSigData,
Move Signature metadata to named node and some other cleanup.
2017-02-04 01:28:21 +03:00
uint32_t SigSize) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
std::string diagStr;
raw_string_ostream diagStream(diagStr);
DiagnosticPrinterRawOStream DiagPrinter(diagStream);
ValidationContext ValCtx(*pModule, nullptr, pModule->GetOrCreateDxilModule(), DiagPrinter);
VerifySignatureMatches(ValCtx, SigKind, pSigData, SigSize);
if (ValCtx.Failed) {
emitDxilDiag(pModule->getContext(), diagStream.str().c_str());
}
return !ValCtx.Failed;
}
static void VerifyPSVMatches(_In_ ValidationContext &ValCtx,
_In_reads_bytes_(PSVSize) const void *pPSVData,
Move Signature metadata to named node and some other cleanup.
2017-02-04 01:28:21 +03:00
_In_ uint32_t PSVSize) {
Copy ViewID state to PSV data and select PSV version based on validator (#291) * Make validator version a first-class citizen of DxilModule * Add validator version checks to DxilContainerAssembler - eliminates need to check validator version in dxcompilerobj.cpp * Copy dynamic index mask and ViewID state to PSV data - Make const version of DxilViewIDState::GetSerialized() that just returns serialized state
2017-05-13 00:27:22 +03:00
uint32_t PSVVersion = 1; // This should be set to the newest version
unique_ptr<DxilPartWriter> pWriter(NewPSVWriter(ValCtx.DxilMod, PSVVersion));
// Try each version in case an earlier version matches module
while (PSVVersion && pWriter->size() != PSVSize) {
PSVVersion --;
pWriter.reset(NewPSVWriter(ValCtx.DxilMod, PSVVersion));
}
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
// generate PSV data from module and memcmp
VerifyBlobPartMatches(ValCtx, "Pipeline State Validation", pWriter.get(), pPSVData, PSVSize);
}
_Use_decl_annotations_
bool VerifyPSVMatches(llvm::Module *pModule,
const void *pPSVData,
Move Signature metadata to named node and some other cleanup.
2017-02-04 01:28:21 +03:00
uint32_t PSVSize) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
std::string diagStr;
raw_string_ostream diagStream(diagStr);
DiagnosticPrinterRawOStream DiagPrinter(diagStream);
ValidationContext ValCtx(*pModule, nullptr, pModule->GetOrCreateDxilModule(), DiagPrinter);
VerifyPSVMatches(ValCtx, pPSVData, PSVSize);
if (ValCtx.Failed) {
emitDxilDiag(pModule->getContext(), diagStream.str().c_str());
}
return !ValCtx.Failed;
}
static void VerifyFeatureInfoMatches(_In_ ValidationContext &ValCtx,
_In_reads_bytes_(FeatureInfoSize) const void *pFeatureInfoData,
Move Signature metadata to named node and some other cleanup.
2017-02-04 01:28:21 +03:00
_In_ uint32_t FeatureInfoSize) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
// generate Feature Info data from module and memcmp
unique_ptr<DxilPartWriter> pWriter(NewFeatureInfoWriter(ValCtx.DxilMod));
VerifyBlobPartMatches(ValCtx, "Feature Info", pWriter.get(), pFeatureInfoData, FeatureInfoSize);
}
_Use_decl_annotations_
bool VerifyFeatureInfoMatches(llvm::Module *pModule,
const void *pFeatureInfoData,
Move Signature metadata to named node and some other cleanup.
2017-02-04 01:28:21 +03:00
uint32_t FeatureInfoSize) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
std::string diagStr;
raw_string_ostream diagStream(diagStr);
DiagnosticPrinterRawOStream DiagPrinter(diagStream);
ValidationContext ValCtx(*pModule, nullptr, pModule->GetOrCreateDxilModule(), DiagPrinter);
VerifyFeatureInfoMatches(ValCtx, pFeatureInfoData, FeatureInfoSize);
if (ValCtx.Failed) {
emitDxilDiag(pModule->getContext(), diagStream.str().c_str());
}
return !ValCtx.Failed;
}
_Use_decl_annotations_
HRESULT ValidateDxilContainerParts(llvm::Module *pModule,
llvm::Module *pDebugModule,
const DxilContainerHeader *pContainer,
Move Signature metadata to named node and some other cleanup.
2017-02-04 01:28:21 +03:00
uint32_t ContainerSize) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
DXASSERT_NOMSG(pModule);
if (!pContainer || !IsValidDxilContainer(pContainer, ContainerSize)) {
return DXC_E_CONTAINER_INVALID;
}
DxilModule *pDxilModule = DxilModule::TryGetDxilModule(pModule);
if (!pDxilModule) {
return DXC_E_IR_VERIFICATION_FAILED;
}
Add tests and fix bugs with container and root signature validation (#5) * Fix ValidateDxilBitcode PSV generation for Root Signature validation. - also fix validation for empty patch constant signature. * Test container and root signature validation. * Fix DXASSERT when PC in/out patch sig mismatch HS.
2017-02-08 03:57:07 +03:00
std::string diagStr;
raw_string_ostream DiagStream(diagStr);
DiagnosticPrinterRawOStream DiagPrinter(DiagStream);
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
ValidationContext ValCtx(*pModule, pDebugModule, *pDxilModule, DiagPrinter);
DXIL::ShaderKind ShaderKind = pDxilModule->GetShaderModel()->GetKind();
bool bTess = ShaderKind == DXIL::ShaderKind::Hull || ShaderKind == DXIL::ShaderKind::Domain;
std::unordered_set<uint32_t> FourCCFound;
const DxilPartHeader *pRootSignaturePart = nullptr;
const DxilPartHeader *pPSVPart = nullptr;
for (auto it = begin(pContainer), itEnd = end(pContainer); it != itEnd; ++it) {
const DxilPartHeader *pPart = *it;
char szFourCC[5];
PartKindToCharArray(pPart->PartFourCC, szFourCC);
if (FourCCFound.find(pPart->PartFourCC) != FourCCFound.end()) {
// Two parts with same FourCC found
Fix build break from automatic merge.
2017-02-10 06:03:47 +03:00
ValCtx.EmitFormatError(ValidationRule::ContainerPartRepeated, {szFourCC});
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
continue;
}
FourCCFound.insert(pPart->PartFourCC);
switch (pPart->PartFourCC)
{
case DFCC_InputSignature:
VerifySignatureMatches(ValCtx, DXIL::SignatureKind::Input, GetDxilPartData(pPart), pPart->PartSize);
break;
case DFCC_OutputSignature:
VerifySignatureMatches(ValCtx, DXIL::SignatureKind::Output, GetDxilPartData(pPart), pPart->PartSize);
break;
case DFCC_PatchConstantSignature:
if (bTess) {
VerifySignatureMatches(ValCtx, DXIL::SignatureKind::PatchConstant, GetDxilPartData(pPart), pPart->PartSize);
} else {
Fix build break from automatic merge.
2017-02-10 06:03:47 +03:00
ValCtx.EmitFormatError(ValidationRule::ContainerPartMatches, {"Program Patch Constant Signature"});
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
}
break;
case DFCC_FeatureInfo:
VerifyFeatureInfoMatches(ValCtx, GetDxilPartData(pPart), pPart->PartSize);
break;
case DFCC_RootSignature:
pRootSignaturePart = pPart;
break;
case DFCC_PipelineStateValidation:
pPSVPart = pPart;
VerifyPSVMatches(ValCtx, GetDxilPartData(pPart), pPart->PartSize);
break;
// Skip these
case DFCC_ResourceDef:
case DFCC_ShaderStatistics:
case DFCC_PrivateData:
case DFCC_DXIL:
case DFCC_ShaderDebugInfoDXIL:
Debug name part implementation (#264) * Add documentation with source-level debugging with HLSL and DXIL. * Fix trailing underscore in generate .rst documentation. * Add container support for debug name part. * Bump validator version to 1.1. * Implement debug stripping in dxc, including /Fd dir-named behavior. * Implement IDxcCompiler2 and CompileWithDebug.
2017-05-10 04:32:48 +03:00
case DFCC_ShaderDebugName:
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
continue;
case DFCC_Container:
default:
Fix build break from automatic merge.
2017-02-10 06:03:47 +03:00
ValCtx.EmitFormatError(ValidationRule::ContainerPartInvalid, {szFourCC});
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
break;
}
}
// Verify required parts found
if (FourCCFound.find(DFCC_InputSignature) == FourCCFound.end()) {
VerifySignatureMatches(ValCtx, DXIL::SignatureKind::Input, nullptr, 0);
}
if (FourCCFound.find(DFCC_OutputSignature) == FourCCFound.end()) {
VerifySignatureMatches(ValCtx, DXIL::SignatureKind::Output, nullptr, 0);
}
Add tests and fix bugs with container and root signature validation (#5) * Fix ValidateDxilBitcode PSV generation for Root Signature validation. - also fix validation for empty patch constant signature. * Test container and root signature validation. * Fix DXASSERT when PC in/out patch sig mismatch HS.
2017-02-08 03:57:07 +03:00
if (bTess && FourCCFound.find(DFCC_PatchConstantSignature) == FourCCFound.end() &&
pDxilModule->GetPatchConstantSignature().GetElements().size())
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
{
Fix build break from automatic merge.
2017-02-10 06:03:47 +03:00
ValCtx.EmitFormatError(ValidationRule::ContainerPartMissing, {"Program Patch Constant Signature"});
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
}
if (FourCCFound.find(DFCC_FeatureInfo) == FourCCFound.end()) {
// Could be optional, but RS1 runtime doesn't handle this case properly.
Fix build break from automatic merge.
2017-02-10 06:03:47 +03:00
ValCtx.EmitFormatError(ValidationRule::ContainerPartMissing, {"Feature Info"});
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
}
// Validate Root Signature
if (pPSVPart) {
if (pRootSignaturePart) {
try {
More RootSignature validation fixes. - Implement RootSignatureHandle::Deserialize() - Fix/clean up validation usage
2017-02-03 11:08:08 +03:00
RootSignatureHandle RS;
RS.LoadSerialized((const uint8_t*)GetDxilPartData(pRootSignaturePart), pRootSignaturePart->PartSize);
RS.Deserialize();
IFTBOOL(VerifyRootSignatureWithShaderPSV(RS.GetDesc(),
pDxilModule->GetShaderModel()->GetKind(),
GetDxilPartData(pPSVPart), pPSVPart->PartSize,
DiagStream), DXC_E_INCORRECT_ROOT_SIGNATURE);
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
} catch (...) {
ValCtx.EmitError(ValidationRule::ContainerRootSignatureIncompatible);
}
}
} else {
Fix build break from automatic merge.
2017-02-10 06:03:47 +03:00
ValCtx.EmitFormatError(ValidationRule::ContainerPartMissing, {"Pipeline State Validation"});
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
}
if (ValCtx.Failed) {
emitDxilDiag(pModule->getContext(), DiagStream.str().c_str());
return DXC_E_MALFORMED_CONTAINER;
}
return S_OK;
}
static HRESULT FindDxilPart(_In_reads_bytes_(ContainerSize) const void *pContainerBytes,
_In_ uint32_t ContainerSize,
_In_ DxilFourCC FourCC,
_In_ const DxilPartHeader **ppPart) {
const DxilContainerHeader *pContainer =
IsDxilContainerLike(pContainerBytes, ContainerSize);
if (!pContainer) {
IFR(DXC_E_CONTAINER_INVALID);
}
if (!IsValidDxilContainer(pContainer, ContainerSize)) {
IFR(DXC_E_CONTAINER_INVALID);
}
DxilPartIterator it = std::find_if(begin(pContainer), end(pContainer),
DxilPartIsType(FourCC));
if (it == end(pContainer)) {
IFR(DXC_E_CONTAINER_MISSING_DXIL);
}
const DxilProgramHeader *pProgramHeader =
reinterpret_cast<const DxilProgramHeader *>(GetDxilPartData(*it));
if (!IsValidDxilProgramHeader(pProgramHeader, (*it)->PartSize)) {
IFR(DXC_E_CONTAINER_INVALID);
}
*ppPart = *it;
return S_OK;
}
_Use_decl_annotations_
HRESULT ValidateLoadModule(const char *pIL,
uint32_t ILLength,
unique_ptr<llvm::Module> &pModule,
LLVMContext &Ctx,
Use lazy load for linking. (#527)
2017-08-07 22:14:24 +03:00
llvm::raw_ostream &DiagStream,
unsigned bLazyLoad) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
llvm::DiagnosticPrinterRawOStream DiagPrinter(DiagStream);
PrintDiagnosticContext DiagContext(DiagPrinter);
DiagRestore DR(Ctx, &DiagContext);
std::unique_ptr<llvm::MemoryBuffer> pBitcodeBuf;
pBitcodeBuf.reset(llvm::MemoryBuffer::getMemBuffer(
llvm::StringRef(pIL, ILLength), "", false).release());
Code Cleanup. (#475) Add default for switch to avoid warnings.
2017-07-27 07:35:02 +03:00
ErrorOr<std::unique_ptr<Module>> loadedModuleResult =
Use lazy load for linking. (#527)
2017-08-07 22:14:24 +03:00
bLazyLoad == 0?
llvm::parseBitcodeFile(pBitcodeBuf->getMemBufferRef(), Ctx) :
llvm::getLazyBitcodeModule(std::move(pBitcodeBuf), Ctx);
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
// DXIL disallows some LLVM bitcode constructs, like unaccounted-for sub-blocks.
// These appear as warnings, which the validator should reject.
if (DiagContext.HasErrors() || DiagContext.HasWarnings() || loadedModuleResult.getError())
return DXC_E_IR_VERIFICATION_FAILED;
pModule = std::move(loadedModuleResult.get());
return S_OK;
}
HRESULT ValidateDxilBitcode(
_In_reads_bytes_(ILLength) const char *pIL,
_In_ uint32_t ILLength,
_In_ llvm::raw_ostream &DiagStream) {
LLVMContext Ctx;
std::unique_ptr<llvm::Module> pModule;
llvm::DiagnosticPrinterRawOStream DiagPrinter(DiagStream);
PrintDiagnosticContext DiagContext(DiagPrinter);
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
Ctx.setDiagnosticHandler(PrintDiagnosticContext::PrintDiagnosticHandler,
&DiagContext, true);
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
HRESULT hr;
Use lazy load for linking. (#527)
2017-08-07 22:14:24 +03:00
if (FAILED(hr = ValidateLoadModule(pIL, ILLength, pModule, Ctx, DiagStream,
/*bLazyLoad*/ false)))
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
return hr;
if (FAILED(hr = ValidateDxilModule(pModule.get(), nullptr)))
return hr;
DxilModule &dxilModule = pModule->GetDxilModule();
if (!dxilModule.GetRootSignature().IsEmpty()) {
Copy ViewID state to PSV data and select PSV version based on validator (#291) * Make validator version a first-class citizen of DxilModule * Add validator version checks to DxilContainerAssembler - eliminates need to check validator version in dxcompilerobj.cpp * Copy dynamic index mask and ViewID state to PSV data - Make const version of DxilViewIDState::GetSerialized() that just returns serialized state
2017-05-13 00:27:22 +03:00
unique_ptr<DxilPartWriter> pWriter(NewPSVWriter(dxilModule, 0));
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
DXASSERT_NOMSG(pWriter->size());
Add tests and fix bugs with container and root signature validation (#5) * Fix ValidateDxilBitcode PSV generation for Root Signature validation. - also fix validation for empty patch constant signature. * Test container and root signature validation. * Fix DXASSERT when PC in/out patch sig mismatch HS.
2017-02-08 03:57:07 +03:00
CComPtr<AbstractMemoryStream> pOutputStream;
Add support for custom allocators (#390) Supporting a custom allocator for dxcompiler. Adds recovery for exceptions and out-of-memory handling. Add custom allocator support to linker. Fix for release-only test failure. Removes assertion about presence of command-line option registration
2017-07-07 02:45:48 +03:00
IFT(CreateMemoryStream(DxcGetThreadMallocNoRef(), &pOutputStream));
Add tests and fix bugs with container and root signature validation (#5) * Fix ValidateDxilBitcode PSV generation for Root Signature validation. - also fix validation for empty patch constant signature. * Test container and root signature validation. * Fix DXASSERT when PC in/out patch sig mismatch HS.
2017-02-08 03:57:07 +03:00
pOutputStream->Reserve(pWriter->size());
pWriter->write(pOutputStream);
More RootSignature validation fixes. - Implement RootSignatureHandle::Deserialize() - Fix/clean up validation usage
2017-02-03 11:08:08 +03:00
const DxilVersionedRootSignatureDesc* pDesc = dxilModule.GetRootSignature().GetDesc();
RootSignatureHandle RS;
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
try {
More RootSignature validation fixes. - Implement RootSignatureHandle::Deserialize() - Fix/clean up validation usage
2017-02-03 11:08:08 +03:00
if (!pDesc) {
RS.Assign(nullptr, dxilModule.GetRootSignature().GetSerialized());
RS.Deserialize();
pDesc = RS.GetDesc();
if (!pDesc)
return DXC_E_INCORRECT_ROOT_SIGNATURE;
}
IFTBOOL(VerifyRootSignatureWithShaderPSV(pDesc,
Fix RootSignature Validation bugs.
2017-02-03 07:54:35 +03:00
dxilModule.GetShaderModel()->GetKind(),
Add tests and fix bugs with container and root signature validation (#5) * Fix ValidateDxilBitcode PSV generation for Root Signature validation. - also fix validation for empty patch constant signature. * Test container and root signature validation. * Fix DXASSERT when PC in/out patch sig mismatch HS.
2017-02-08 03:57:07 +03:00
pOutputStream->GetPtr(), pWriter->size(),
Fix RootSignature Validation bugs.
2017-02-03 07:54:35 +03:00
DiagStream), DXC_E_INCORRECT_ROOT_SIGNATURE);
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
} catch (...) {
return DXC_E_INCORRECT_ROOT_SIGNATURE;
}
}
if (DiagContext.HasErrors() || DiagContext.HasWarnings()) {
return DXC_E_IR_VERIFICATION_FAILED;
}
return S_OK;
}
Use lazy load for linking. (#527)
2017-08-07 22:14:24 +03:00
static HRESULT ValidateLoadModuleFromContainer(
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
_In_reads_bytes_(ILLength) const void *pContainer,
_In_ uint32_t ContainerSize, _In_ std::unique_ptr<llvm::Module> &pModule,
_In_ std::unique_ptr<llvm::Module> &pDebugModule,
_In_ llvm::LLVMContext &Ctx, LLVMContext &DbgCtx,
Use lazy load for linking. (#527)
2017-08-07 22:14:24 +03:00
_In_ llvm::raw_ostream &DiagStream, _In_ unsigned bLazyLoad) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
llvm::DiagnosticPrinterRawOStream DiagPrinter(DiagStream);
PrintDiagnosticContext DiagContext(DiagPrinter);
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
DiagRestore DR(Ctx, &DiagContext);
DiagRestore DR2(DbgCtx, &DiagContext);
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
const DxilPartHeader *pPart = nullptr;
IFR(FindDxilPart(pContainer, ContainerSize, DFCC_DXIL, &pPart));
const char *pIL = nullptr;
uint32_t ILLength = 0;
GetDxilProgramBitcode(
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
reinterpret_cast<const DxilProgramHeader *>(GetDxilPartData(pPart)), &pIL,
&ILLength);
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
Use lazy load for linking. (#527)
2017-08-07 22:14:24 +03:00
IFR(ValidateLoadModule(pIL, ILLength, pModule, Ctx, DiagStream, bLazyLoad));
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
HRESULT hr;
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
const DxilPartHeader *pDbgPart = nullptr;
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
if (FAILED(hr = FindDxilPart(pContainer, ContainerSize,
DFCC_ShaderDebugInfoDXIL, &pDbgPart)) &&
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
hr != DXC_E_CONTAINER_MISSING_DXIL) {
return hr;
}
if (pDbgPart) {
GetDxilProgramBitcode(
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
reinterpret_cast<const DxilProgramHeader *>(GetDxilPartData(pDbgPart)),
&pIL, &ILLength);
if (FAILED(hr = ValidateLoadModule(pIL, ILLength, pDebugModule, DbgCtx,
Use lazy load for linking. (#527)
2017-08-07 22:14:24 +03:00
DiagStream, bLazyLoad))) {
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
return hr;
}
}
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
return S_OK;
}
Use lazy load for linking. (#527)
2017-08-07 22:14:24 +03:00
_Use_decl_annotations_ HRESULT ValidateLoadModuleFromContainer(
_In_reads_bytes_(ContainerSize) const void *pContainer,
_In_ uint32_t ContainerSize, _In_ std::unique_ptr<llvm::Module> &pModule,
_In_ std::unique_ptr<llvm::Module> &pDebugModule,
_In_ llvm::LLVMContext &Ctx, llvm::LLVMContext &DbgCtx,
_In_ llvm::raw_ostream &DiagStream) {
return ValidateLoadModuleFromContainer(pContainer, ContainerSize, pModule,
pDebugModule, Ctx, DbgCtx, DiagStream,
/*bLazyLoad*/ false);
}
// Lazy loads module from container, validating load, but not module.
_Use_decl_annotations_ HRESULT ValidateLoadModuleFromContainerLazy(
_In_reads_bytes_(ContainerSize) const void *pContainer,
_In_ uint32_t ContainerSize, _In_ std::unique_ptr<llvm::Module> &pModule,
_In_ std::unique_ptr<llvm::Module> &pDebugModule,
_In_ llvm::LLVMContext &Ctx, llvm::LLVMContext &DbgCtx,
_In_ llvm::raw_ostream &DiagStream) {
return ValidateLoadModuleFromContainer(pContainer, ContainerSize, pModule,
pDebugModule, Ctx, DbgCtx, DiagStream,
/*bLazyLoad*/ true);
}
Add dxcutil to share code. (#350)
2017-06-13 04:00:39 +03:00
_Use_decl_annotations_
HRESULT ValidateDxilContainer(const void *pContainer,
uint32_t ContainerSize,
llvm::raw_ostream &DiagStream) {
LLVMContext Ctx, DbgCtx;
std::unique_ptr<llvm::Module> pModule, pDebugModule;
llvm::DiagnosticPrinterRawOStream DiagPrinter(DiagStream);
PrintDiagnosticContext DiagContext(DiagPrinter);
Ctx.setDiagnosticHandler(PrintDiagnosticContext::PrintDiagnosticHandler,
&DiagContext, true);
DbgCtx.setDiagnosticHandler(PrintDiagnosticContext::PrintDiagnosticHandler,
&DiagContext, true);
IFR(ValidateLoadModuleFromContainer(pContainer, ContainerSize, pModule, pDebugModule,
Ctx, DbgCtx, DiagStream));
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
// Validate DXIL Module
IFR(ValidateDxilModule(pModule.get(), pDebugModule.get()));
if (DiagContext.HasErrors() || DiagContext.HasWarnings()) {
return DXC_E_IR_VERIFICATION_FAILED;
first commit
2016-12-28 22:52:27 +03:00
}
Implement DXIL Container validation - Implement and centralize container validation components in DxilValidation - Strip RootSignature from module metadata before serializing to container - Use existing DxilModule when serializing rather than constructing new one - Add DxilModule::TryGetDxilModule for capturing diagnostics on metadata load - Expose DxilPartWriters/DxilContainerWriter for use elsewhere (such as in validation)
2017-01-31 13:39:20 +03:00
return ValidateDxilContainerParts(pModule.get(), pDebugModule.get(),
IsDxilContainerLike(pContainer, ContainerSize), ContainerSize);
first commit
2016-12-28 22:52:27 +03:00
}
} // namespace hlsl