RPCS3/glslang
1
0
Fork 0
mirror of https://github.com/RPCS3/glslang.git synced 2024-11-30 22:51:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
f02c8e6ba1
glslang/hlsl/hlslParseHelper.h

453 lines
24 KiB
C
Raw Normal View History

HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// Copyright (C) 2016 Google, Inc.
// Copyright (C) 2016 LunarG, Inc.
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// All rights reserved.
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
//
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
#ifndef HLSL_PARSE_INCLUDED_
#define HLSL_PARSE_INCLUDED_
#include "../glslang/MachineIndependent/parseVersions.h"
#include "../glslang/MachineIndependent/ParseHelper.h"
namespace glslang {
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
class TAttributeMap; // forward declare
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
class TFunctionDeclarator;
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
class HlslParseContext : public TParseContextBase {
public:
HlslParseContext(TSymbolTable&, TIntermediate&, bool parsingBuiltins,
SPV: Non-functional: Condense SPV-related versioning, and rationalize all uses.
2016-06-17 02:59:42 +00:00
int version, EProfile, const SpvVersion& spvVersion, EShLanguage, TInfoSink&,
allow renaming of shader entry point when creating SPIR-V Use "--source-entrypoint name" on the command line, or the TShader::setSourceEntryPoint(char*) API. When the name given to the above interfaces is detected in the shader source, it will be renamed to the entry point name supplied to the -e option or the TShader::setEntryPoint() method.
2016-10-31 21:13:43 +00:00
const TString sourceEntryPointName,
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
bool forwardCompatible = false, EShMessages messages = EShMsgDefault);
virtual ~HlslParseContext();
Fix a large number of warnings about inconsistent usage of 'override' produced by clang
2016-12-21 11:48:08 +00:00
void initializeExtensionBehavior() override;
HLSL: enable #line extension by default for HLSL source.
2016-07-23 02:46:03 +00:00
Fix a large number of warnings about inconsistent usage of 'override' produced by clang
2016-12-21 11:48:08 +00:00
void setLimits(const TBuiltInResource&) override;
bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false) override;
HLSL: Allow use of $Global members in between function calls. This allows global initializers to use $Global members.
2017-03-23 05:21:34 +00:00
virtual const char* getGlobalUniformBlockName() const override { return "$Global"; }
virtual void setUniformBlockDefaults(TType& block) const override
{
block.getQualifier().layoutPacking = ElpStd140;
block.getQualifier().layoutMatrix = ElmRowMajor;
}
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
Fix a large number of warnings about inconsistent usage of 'override' produced by clang
2016-12-21 11:48:08 +00:00
void reservedPpErrorCheck(const TSourceLoc&, const char* /*name*/, const char* /*op*/) override { }
bool lineContinuationCheck(const TSourceLoc&, bool /*endOfComment*/) override { return true; }
bool lineDirectiveShouldSetNextLine() const override { return true; }
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
bool builtInName(const TString&);
Fix a large number of warnings about inconsistent usage of 'override' produced by clang
2016-12-21 11:48:08 +00:00
void handlePragma(const TSourceLoc&, const TVector<TString>&) override;
HLSL: Non-functional: the symbol field of a token was in practice unused; remove it. Another precurser to getting member non-static functions working.
2017-03-22 00:35:04 +00:00
TIntermTyped* handleVariable(const TSourceLoc&, const TString* string);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
TIntermTyped* handleBracketDereference(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
HLSL: phase 2a: add r-value operator[] for RWTexture/RWBuffer This commit adds r-value support for RW textures and buffers. Supported is: - Function in parameter conversions - conversion of rvalue use to imageLoad
2016-10-07 02:12:24 +00:00
TIntermTyped* handleBracketOperator(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void checkIndex(const TSourceLoc&, const TType&, int& index);
TIntermTyped* handleBinaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right);
TIntermTyped* handleUnaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* childNode);
TIntermTyped* handleDotDereference(const TSourceLoc&, TIntermTyped* base, const TString& field);
HLSL: non-functional: simplify handleBuiltInMethod() to isBuiltInMethod().
2017-03-11 16:39:55 +00:00
bool isBuiltInMethod(const TSourceLoc&, TIntermTyped* base, const TString& field);
HLSL: Flatten a return struct from an entry point and assign locations after flattening. Locations now get assigned in order, but skipping built-ins, which can be done post flattening.
2016-09-16 07:44:43 +00:00
void assignLocations(TVariable& variable);
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
void handleFunctionDeclarator(const TSourceLoc&, TFunction& function, bool prototype);
HLSL: Wrap the entry-point; need to write 'in' args, and support 'inout' args. This needs some render testing, but is destined to be part of master. This also leads to a variety of other simplifications. - IO are global symbols, so only need one list of linkage nodes (deferred) - no longer need parse-context-wide 'inEntryPoint' state, entry-point is localized - several parts of splitting/flattening are now localized
2017-01-19 22:41:47 +00:00
TIntermAggregate* handleFunctionDefinition(const TSourceLoc&, TFunction&, const TAttributeMap&, TIntermNode*& entryPointTree);
TIntermNode* transformEntryPoint(const TSourceLoc&, TFunction&, const TAttributeMap&);
HLSL: pass tessellation execution modes through to SPIR-V The SPIR-V generator had assumed tessellation modes such as primitive type and vertex order would only appear in tess eval (domain) shaders. SPIR-V allows either, and HLSL allows and possibly requires them to be in the hull shader. This change: 1. Passes them through for either tessellation stage, and, 2. Does not set up defaults in the domain stage for HLSl compilation, to avoid conflicting definitions.
2017-03-23 17:56:07 +00:00
void handleEntryPointAttributes(const TSourceLoc&, const TAttributeMap&);
HLSL: Error if funcion with return type doesn't return a value.
2016-09-03 01:13:36 +00:00
void handleFunctionBody(const TSourceLoc&, TFunction&, TIntermNode* functionBody, TIntermNode*& node);
HLSL: Build IO types bottom up, as parsed, and cache the original (IO). Previously, this was done recursively, per object, and the nonIO version was cached. This reverses both those approaches.
2017-02-04 00:57:55 +00:00
void remapEntryPointIO(TFunction& function, TVariable*& returnValue, TVector<TVariable*>& inputs, TVector<TVariable*>& outputs);
Non-functional: Sweep through the stack for consistent with "main" and entry point. Partially addresses issue #513.
2016-09-19 22:01:41 +00:00
void remapNonEntryPointIO(TFunction& function);
HLSL: add implicit promotions for assignments and function returns.
2016-08-09 17:28:03 +00:00
TIntermNode* handleReturnValue(const TSourceLoc&, TIntermTyped*);
HLSL: Add function call syntax and AST building.
2016-05-13 15:33:42 +00:00
void handleFunctionArgument(TFunction*, TIntermTyped*& arguments, TIntermTyped* newArg);
HLSL: Add EOpMatrixSwizzle, selectively decomposed to other ops, for issue #670. Since EOpMatrixSwizzle is a new op, existing back-ends only work when the front end first decomposes it to other operations. So far, this is only being done for simple assignment into matrix swizzles.
2017-01-13 19:27:52 +00:00
TIntermTyped* handleAssign(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right);
TIntermTyped* handleAssignToMatrixSwizzle(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right);
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermTyped*);
Add decompositions for some HLSL intrinsics.
2016-06-09 14:57:35 +00:00
void decomposeIntrinsic(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
void decomposeSampleMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
void decomposeStructBufferMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
void decomposeGeometryMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
void pushFrontArguments(TIntermTyped* front, TIntermTyped*& arguments);
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
void addInputArgumentConversions(const TFunction&, TIntermTyped*&);
SPV: When passing structs of opaque types, flatten and pass the members instead. This avoids either A) needing uniformConstant struct, or B) initializing a struct with opaque members, as writing them is not allowed.
2017-05-26 06:01:36 +00:00
void expandArguments(const TSourceLoc&, const TFunction&, TIntermTyped*&);
HLSL: add intrinsic function implicit promotions This PR handles implicit promotions for intrinsics when there is no exact match, such as for example clamp(int, bool, float). In this case the int and bool will be promoted to a float, and the clamp(float, float, float) form used. These promotions can be mixed with shape conversions, e.g, clamp(int, bool2, float2). Output conversions are handled either via the existing addOutputArgumentConversion function, which this PR generalizes to handle either aggregates or unaries, or by intrinsic decomposition. If there are methods or intrinsics to be decomposed, then decomposition is responsible for any output conversions, which turns out to happen automatically in all current cases. This can be revisited once inout conversions are in place. Some cases of actual ambiguity were fixed in several tests, e.g, spv.register.autoassign.* Some intrinsics with only uint versions were expanded to signed ints natively, where the underlying AST and SPIR-V supports that. E.g, countbits. This avoids extraneous conversion nodes. A new function promoteAggregate is added, and used by findFunction. This is essentially a generalization of the "promote 1st or 2nd arg" algorithm in promoteBinary. The actual selection proceeds in three steps, as described in the comments in hlslParseContext::findFunction: 1. Attempt an exact match. If found, use it. 2. If not, obtain the operator from step 1, and promote arguments. 3. Re-select the intrinsic overload from the results of step 2.
2016-11-02 18:42:34 +00:00
TIntermTyped* addOutputArgumentConversions(const TFunction&, TIntermOperator&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void builtInOpCheck(const TSourceLoc&, const TFunction&, TIntermOperator&);
HLSL: Non-functional: rationalize making constructors. Improves foundation for adding scalar casts. Makes handle/make names more sane, better commented, uses more precise subclass typing, and removes mutual recursion between converting initializer lists and making constructors.
2017-04-04 03:48:37 +00:00
TFunction* makeConstructorCall(const TSourceLoc&, const TType&);
Merge branch 'TiemoJung-semantic_handling'
2017-03-15 03:50:06 +00:00
void handleSemantic(TSourceLoc, TQualifier&, TBuiltInVariable, const TString& upperCase);
HLSL Non-Functional: Move to more robust capturing of postDecls into a qualifier. This will prevent a possible future defect of thinking the type can be changed, where there is a code path today that would drop that change.
2016-09-05 18:40:06 +00:00
void handlePackOffset(const TSourceLoc&, TQualifier&, const glslang::TString& location,
HLSL: Add back in the [subcomponent] part of a 'register' decl.
2016-07-30 16:29:54 +00:00
const glslang::TString* component);
HLSL Non-Functional: Move to more robust capturing of postDecls into a qualifier. This will prevent a possible future defect of thinking the type can be changed, where there is a code path today that would drop that change.
2016-09-05 18:40:06 +00:00
void handleRegister(const TSourceLoc&, TQualifier&, const glslang::TString* profile, const glslang::TString& desc,
HLSL: Support register(..., spaceN) for setting the descriptor set. This was suggested in issue #454.
2016-09-05 22:03:12 +00:00
int subComponent, const glslang::TString*);
HLSL: Support vector 'cond ? :' -> EOpMix -> OpSelect.
2017-04-12 01:45:00 +00:00
TIntermTyped* convertConditionalExpression(const TSourceLoc&, TIntermTyped*, bool mustBeScalar = true);
HLSL: Add SampleBias and SampleGrad, and associated tests
2016-07-14 20:45:14 +00:00
TIntermAggregate* handleSamplerTextureCombine(const TSourceLoc& loc, TIntermTyped* argTex, TIntermTyped* argSampler);
Front-ends: Non-functional: Rationalize vector and matrix swizzles. This reduces code duplication in a few ways, and better encapsulates vector swizzle representation.
2017-01-14 02:34:22 +00:00
bool parseMatrixSwizzleSelector(const TSourceLoc&, const TString&, int cols, int rows, TSwizzleSelectors<TMatrixSelector>&);
int getMatrixComponentsColumn(int rows, const TSwizzleSelectors<TMatrixSelector>&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void assignError(const TSourceLoc&, const char* op, TString left, TString right);
void unaryOpError(const TSourceLoc&, const char* op, TString operand);
void binaryOpError(const TSourceLoc&, const char* op, TString left, TString right);
void variableCheck(TIntermTyped*& nodePtr);
void constantValueCheck(TIntermTyped* node, const char* token);
void integerCheck(const TIntermTyped* node, const char* token);
void globalCheck(const TSourceLoc&, const char* token);
bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&);
bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&);
void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&);
void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&);
void structArrayCheck(const TSourceLoc&, const TType& structure);
void arrayDimMerge(TType& type, const TArraySizes* sizes);
bool voidErrorCheck(const TSourceLoc&, const TString&, TBasicType);
void globalQualifierFix(const TSourceLoc&, TQualifier&);
bool structQualifierErrorCheck(const TSourceLoc&, const TPublicType& pType);
HLSL: Improve setting and testing of interpolation qualifiers. Notably, use of 'linear' on a non-input could mark it as an input.
2016-09-16 23:10:39 +00:00
void mergeQualifiers(TQualifier& dst, const TQualifier& src);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
int computeSamplerTypeIndex(TSampler&);
Whole stack: Fix stale types in the AST linker object nodes, fixing #557. Rationalizes the entire tracking of the linker object nodes, effecting GLSL, HLSL, and SPIR-V, to allow tracked objects to be fully edited before their type snapshot for linker objects. Should only effect things when the rest of the AST contained no reference to the symbol, because normal AST nodes were not stale. Also will only effect such objects when their types were edited.
2016-11-05 16:15:53 +00:00
TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void redeclareBuiltinBlock(const TSourceLoc&, TTypeList& typeList, const TString& blockName, const TString* instanceName, TArraySizes* arraySizes);
HLSL: Map parameter qualifiers from generic to function-specific and entry-point specific.
2016-06-17 21:50:47 +00:00
void paramFix(TType& type);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void specializationCheck(const TSourceLoc&, const TType&, const char* op);
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
void setLayoutQualifier(const TSourceLoc&, TQualifier&, TString&);
void setLayoutQualifier(const TSourceLoc&, TQualifier&, TString&, const TIntermTyped*);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void mergeObjectLayoutQualifiers(TQualifier& dest, const TQualifier& src, bool inheritOnly);
void checkNoShaderLayouts(const TSourceLoc&, const TShaderQualifiers&);
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
const TFunction* findFunction(const TSourceLoc& loc, TFunction& call, bool& builtIn, int& thisDepth, TIntermTyped*& args);
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
void declareTypedef(const TSourceLoc&, const TString& identifier, const TType&);
HLSL: Build IO types bottom up, as parsed, and cache the original (IO). Previously, this was done recursively, per object, and the nonIO version was cached. This reverses both those approaches.
2017-02-04 00:57:55 +00:00
void declareStruct(const TSourceLoc&, TString& structName, TType&);
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
TSymbol* lookupUserType(const TString&, TType&);
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
TIntermNode* declareVariable(const TSourceLoc&, const TString& identifier, TType&, TIntermTyped* initializer = 0);
HLSL: Fix #805: Support cast of scalars to structures. Somewhat complex due to recognizing a general scalar, but not replicating it for each member to avoid side effects.
2017-04-04 17:47:42 +00:00
void lengthenList(const TSourceLoc&, TIntermSequence& list, int size, TIntermTyped* scalarInit);
HLSL: Non-functional: rationalize making constructors. Improves foundation for adding scalar casts. Makes handle/make names more sane, better commented, uses more precise subclass typing, and removes mutual recursion between converting initializer lists and making constructors.
2017-04-04 03:48:37 +00:00
TIntermTyped* handleConstructor(const TSourceLoc&, TIntermTyped*, const TType&);
TIntermTyped* addConstructor(const TSourceLoc&, TIntermTyped*, const TType&);
HLSL: Fix #924: Convert between two different arrays with cast.
2017-06-14 05:13:10 +00:00
TIntermTyped* convertArray(TIntermTyped*, const TType&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
TIntermTyped* constructAggregate(TIntermNode*, const TType&, int, const TSourceLoc&);
TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset);
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
void declareBlock(const TSourceLoc&, TType&, const TString* instanceName = 0, TArraySizes* arraySizes = 0);
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
void declareStructBufferCounter(const TSourceLoc& loc, const TType& bufferType, const TString& name);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void fixBlockLocations(const TSourceLoc&, TQualifier&, TTypeList&, bool memberWithLocation, bool memberWithoutLocation);
void fixBlockXfbOffsets(TQualifier&, TTypeList&);
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
void fixBlockUniformOffsets(const TQualifier&, TTypeList&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void addQualifierToExisting(const TSourceLoc&, TQualifier, const TString& identifier);
void addQualifierToExisting(const TSourceLoc&, TQualifier, TIdentifierList&);
void updateStandaloneQualifierDefaults(const TSourceLoc&, const TPublicType&);
void wrapupSwitchSubsequence(TIntermAggregate* statements, TIntermNode* branchNode);
TIntermNode* addSwitch(const TSourceLoc&, TIntermTyped* expression, TIntermAggregate* body);
void updateImplicitArraySize(const TSourceLoc&, TIntermNode*, int index);
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
void nestLooping() { ++loopNestingLevel; }
void unnestLooping() { --loopNestingLevel; }
void nestAnnotations() { ++annotationNestingLevel; }
void unnestAnnotations() { --annotationNestingLevel; }
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
int getAnnotationNestingLevel() { return annotationNestingLevel; }
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
void pushScope() { symbolTable.push(); }
void popScope() { symbolTable.pop(0); }
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
void pushThisScope(const TType&, const TVector<TFunctionDeclarator>&);
HLSL: non-static member functions: track and find active anonymous 'this' scopes and members. Thanks to @steve-lunarg for his input and discussions on handling member functions.
2017-03-22 05:56:40 +00:00
void popThisScope() { symbolTable.pop(0); }
void pushImplicitThis(TVariable* thisParameter) { implicitThisStack.push_back(thisParameter); }
void popImplicitThis() { implicitThisStack.pop_back(); }
TVariable* getImplicitThis(int thisDepth) const { return implicitThisStack[implicitThisStack.size() - thisDepth]; }
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
void pushNamespace(const TString& name);
void popNamespace();
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
void getFullNamespaceName(const TString*&) const;
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
void addScopeMangler(TString&);
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
void pushSwitchSequence(TIntermSequence* sequence) { switchSequenceStack.push_back(sequence); }
void popSwitchSequence() { switchSequenceStack.pop_back(); }
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
virtual void growGlobalUniformBlock(const TSourceLoc&, TType&, const TString& memberName, TTypeList* typeList = nullptr) override;
HLSL: Have loose uniforms also go through the makeTypeNonIo() path.
2017-02-03 21:06:36 +00:00
HLSL: phase 2b: add l-value operator[] for RWTexture/RWBuffer This commit adds l-value support for RW texture and buffer objects. Supported are: - pre and post inc/decrement - function out parameters - op-assignments, such as *=, +-, etc. - result values from op-assignments. e.g, val=(MyRwTex[loc] *= 2); Not supported are: - Function inout parameters - multiple post-inc/decrement operators. E.g, MyRWTex[loc]++++;
2016-10-08 01:35:40 +00:00
// Apply L-value conversions. E.g, turning a write to a RWTexture into an ImageStore.
HLSL: Convert run-time sampler assignments to compile-time aliases. For "s.m = t", a sampler member assigned a sampler, make t an alias for s.m, and when s.m is flattened, it will flatten to the alias t. Normally, assignments to samplers are disallowed.
2017-06-02 22:28:39 +00:00
TIntermTyped* handleLvalue(const TSourceLoc&, const char* op, TIntermTyped*& node);
TIntermTyped* handleSamplerLvalue(const TSourceLoc&, const char* op, TIntermTyped*& node);
HLSL: phase 2c: use lValueErrorCheck in HLSL FE This commit splits lValueErrorCheck into machine dependent and independent parts. The GLSL form in TParseContext inherits from and invokes the machine dependent part in TParseContextBase. The base form checks language independent things. This split does not change the set of errors tested for: the test results are identical. The new base class interface is now used from the HLSL FE to test lvalues. There was one test diff due to this, where the test was writing to a uniform. It still does the same indirections, but does not attempt a uniform write.
2016-10-08 16:54:52 +00:00
bool lValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*) override;
HLSL: phase 2b: add l-value operator[] for RWTexture/RWBuffer This commit adds l-value support for RW texture and buffer objects. Supported are: - pre and post inc/decrement - function out parameters - op-assignments, such as *=, +-, etc. - result values from op-assignments. e.g, val=(MyRwTex[loc] *= 2); Not supported are: - Function inout parameters - multiple post-inc/decrement operators. E.g, MyRWTex[loc]++++;
2016-10-08 01:35:40 +00:00
HLSL: phase 3a: Add sub-vec4 rwtexture formats (qualifier.layoutFormat) This PR sets the TQualifier layoutFormat according to the HLSL image type. For instance: RWTexture1D <float2> g_tTex1df2; becomes ElfRg32f. Similar on Buffers, e.g, Buffer<float4> mybuffer; The return type for image and buffer loads is now taken from the storage format. Also, the qualifier for the return type is now (properly) a temp, not a global.
2016-10-10 21:24:57 +00:00
TLayoutFormat getLayoutFromTxType(const TSourceLoc&, const TType&);
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
bool handleOutputGeometry(const TSourceLoc&, const TLayoutGeometry& geometry);
bool handleInputGeometry(const TSourceLoc&, const TLayoutGeometry& geometry);
HLSL: implement [unroll] and [loop] attributes This adds infrastructure suitable for any front end to create SPIR-V loop control flags. The only current front end doing so is HLSL. [unroll] turns into spv::LoopControlUnrollMask [loop] turns into spv::LoopControlDontUnrollMask no specification means spv::LoopControlMaskNone
2017-05-03 02:14:50 +00:00
// Determine loop control from attributes
TLoopControl handleLoopControl(const TAttributeMap& attributes) const;
allow renaming of shader entry point when creating SPIR-V Use "--source-entrypoint name" on the command line, or the TShader::setSourceEntryPoint(char*) API. When the name given to the above interfaces is detected in the shader source, it will be renamed to the entry point name supplied to the -e option or the TShader::setEntryPoint() method.
2016-10-31 21:13:43 +00:00
// Potentially rename shader entry point function
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
void renameShaderFunction(const TString*& name) const;
allow renaming of shader entry point when creating SPIR-V Use "--source-entrypoint name" on the command line, or the TShader::setSourceEntryPoint(char*) API. When the name given to the above interfaces is detected in the shader source, it will be renamed to the entry point name supplied to the -e option or the TShader::setEntryPoint() method.
2016-10-31 21:13:43 +00:00
HLSL: Recursive composite flattening This PR implements recursive type flattening. For example, an array of structs of other structs can be flattened to individual member variables at the shader interface. This is sufficient for many purposes, e.g, uniforms containing opaque types, but is not sufficient for geometry shader arrayed inputs. That will be handled separately with structure splitting, which is not implemented by this PR. In the meantime, that case is detected and triggers an error. The recursive flattening extends the following three aspects of single-level flattening: - Flattening of structures to individual members with names such as "foo[0].samp[1]"; - Turning constant references to the nested composite type into a reference to a particular flattened member. - Shadow copies between arrays of flattened members and the nested composite type. Previous single-level flattening only flattened at the shader interface, and that is unchanged by this PR. Internally, shadow copies are, such as if the type is passed to a function. Also, the reasons for flattening are unchanged. Uniforms containing opaque types, and interface struct types are flattened. (The latter will change with structure splitting). One existing test changes: hlsl.structin.vert, which did in fact contain a nested composite type to be flattened. Two new tests are added: hlsl.structarray.flatten.frag, and hlsl.structarray.flatten.geom (currently issues an error until type splitting is online). The process of arriving at the individual member from chained postfix expressions is more complex than it was with one level. See large-ish comment above HlslParseContext::flatten() for details.
2016-11-29 00:09:54 +00:00
// Reset data for incrementally built referencing of flattened composite structures
void initFlattening() { flattenLevel.push_back(0); flattenOffset.push_back(0); }
void finalizeFlattening() { flattenLevel.pop_back(); flattenOffset.pop_back(); }
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
// Share struct buffer deep types
void shareStructBufferType(TType&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
protected:
HLSL: Recursive composite flattening This PR implements recursive type flattening. For example, an array of structs of other structs can be flattened to individual member variables at the shader interface. This is sufficient for many purposes, e.g, uniforms containing opaque types, but is not sufficient for geometry shader arrayed inputs. That will be handled separately with structure splitting, which is not implemented by this PR. In the meantime, that case is detected and triggers an error. The recursive flattening extends the following three aspects of single-level flattening: - Flattening of structures to individual members with names such as "foo[0].samp[1]"; - Turning constant references to the nested composite type into a reference to a particular flattened member. - Shadow copies between arrays of flattened members and the nested composite type. Previous single-level flattening only flattened at the shader interface, and that is unchanged by this PR. Internally, shadow copies are, such as if the type is passed to a function. Also, the reasons for flattening are unchanged. Uniforms containing opaque types, and interface struct types are flattened. (The latter will change with structure splitting). One existing test changes: hlsl.structin.vert, which did in fact contain a nested composite type to be flattened. Two new tests are added: hlsl.structarray.flatten.frag, and hlsl.structarray.flatten.geom (currently issues an error until type splitting is online). The process of arriving at the individual member from chained postfix expressions is more complex than it was with one level. See large-ish comment above HlslParseContext::flatten() for details.
2016-11-29 00:09:54 +00:00
struct TFlattenData {
TFlattenData() : nextBinding(TQualifier::layoutBindingEnd) { }
TFlattenData(int nb) : nextBinding(nb) { }
TVector<TVariable*> members; // individual flattened variables
TVector<int> offsets; // offset to next tree level
int nextBinding; // next binding to use.
};
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
void fixConstInit(const TSourceLoc&, const TString& identifier, TType& type, TIntermTyped*& initializer);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void inheritGlobalDefaults(TQualifier& dst) const;
TVariable* makeInternalVariable(const char* name, const TType&) const;
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
TVariable* makeInternalVariable(const TString& name, const TType& type) const {
return makeInternalVariable(name.c_str(), type);
}
HLSL: Fix #805: Support cast of scalars to structures. Somewhat complex due to recognizing a general scalar, but not replicating it for each member to avoid side effects.
2017-04-04 17:47:42 +00:00
TIntermSymbol* makeInternalVariableNode(const TSourceLoc&, const char* name, const TType&) const;
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
TVariable* declareNonArray(const TSourceLoc&, const TString& identifier, const TType&, bool track);
void declareArray(const TSourceLoc&, const TString& identifier, const TType&, TSymbol*&, bool track);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
TIntermNode* executeInitializer(const TSourceLoc&, TIntermTyped* initializer, TVariable* variable);
HLSL: Fix #805: Support cast of scalars to structures. Somewhat complex due to recognizing a general scalar, but not replicating it for each member to avoid side effects.
2017-04-04 17:47:42 +00:00
TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer, TIntermTyped* scalarInit);
bool isScalarConstructor(const TIntermNode*);
Implement atomic ops, bit conversions, fix fwidth stage mask, fix saturate dest modifier.
2016-06-13 15:22:28 +00:00
TOperator mapAtomicOp(const TSourceLoc& loc, TOperator op, bool isImage);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
HLSL: phase 2b: add l-value operator[] for RWTexture/RWBuffer This commit adds l-value support for RW texture and buffer objects. Supported are: - pre and post inc/decrement - function out parameters - op-assignments, such as *=, +-, etc. - result values from op-assignments. e.g, val=(MyRwTex[loc] *= 2); Not supported are: - Function inout parameters - multiple post-inc/decrement operators. E.g, MyRWTex[loc]++++;
2016-10-08 01:35:40 +00:00
// Return true if this node requires L-value conversion (e.g, to an imageStore).
bool shouldConvertLValue(const TIntermNode*) const;
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
// Array and struct flattening
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
TIntermTyped* flattenAccess(TIntermTyped* base, int member);
SPV: When passing structs of opaque types, flatten and pass the members instead. This avoids either A) needing uniformConstant struct, or B) initializing a struct with opaque members, as writing them is not allowed.
2017-05-26 06:01:36 +00:00
TIntermTyped* flattenAccess(int uniqueId, int member, const TType&);
bool shouldFlatten(const TType&) const;
HLSL: Recursive composite flattening This PR implements recursive type flattening. For example, an array of structs of other structs can be flattened to individual member variables at the shader interface. This is sufficient for many purposes, e.g, uniforms containing opaque types, but is not sufficient for geometry shader arrayed inputs. That will be handled separately with structure splitting, which is not implemented by this PR. In the meantime, that case is detected and triggers an error. The recursive flattening extends the following three aspects of single-level flattening: - Flattening of structures to individual members with names such as "foo[0].samp[1]"; - Turning constant references to the nested composite type into a reference to a particular flattened member. - Shadow copies between arrays of flattened members and the nested composite type. Previous single-level flattening only flattened at the shader interface, and that is unchanged by this PR. Internally, shadow copies are, such as if the type is passed to a function. Also, the reasons for flattening are unchanged. Uniforms containing opaque types, and interface struct types are flattened. (The latter will change with structure splitting). One existing test changes: hlsl.structin.vert, which did in fact contain a nested composite type to be flattened. Two new tests are added: hlsl.structarray.flatten.frag, and hlsl.structarray.flatten.geom (currently issues an error until type splitting is online). The process of arriving at the individual member from chained postfix expressions is more complex than it was with one level. See large-ish comment above HlslParseContext::flatten() for details.
2016-11-29 00:09:54 +00:00
bool wasFlattened(const TIntermTyped* node) const;
bool wasFlattened(int id) const { return flattenMap.find(id) != flattenMap.end(); }
int addFlattenedMember(const TSourceLoc& loc, const TVariable&, const TType&, TFlattenData&, const TString& name, bool track);
bool isFinalFlattening(const TType& type) const { return !(type.isStruct() || type.isArray()); }
SPV: When passing structs of opaque types, flatten and pass the members instead. This avoids either A) needing uniformConstant struct, or B) initializing a struct with opaque members, as writing them is not allowed.
2017-05-26 06:01:36 +00:00
// Structure splitting (splits interstage built-in types into its own struct)
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
TIntermTyped* splitAccessStruct(const TSourceLoc& loc, TIntermTyped*& base, int& member);
void splitAccessArray(const TSourceLoc& loc, TIntermTyped* base, TIntermTyped* index);
TType& split(TType& type, TString name, const TType* outerStructType = nullptr);
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
void split(TIntermTyped*);
void split(const TVariable&);
bool wasSplit(const TIntermTyped* node) const;
bool wasSplit(int id) const { return splitIoVars.find(id) != splitIoVars.end(); }
TVariable* getSplitIoVar(const TIntermTyped* node) const;
TVariable* getSplitIoVar(const TVariable* var) const;
TVariable* getSplitIoVar(int id) const;
void addInterstageIoToLinkage();
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
void addPatchConstantInvocation();
HLSL: cast non-int types to uint on Load/Store indexes Some texture and SB operations can take non-integer indexes, which should be cast to integers before use if they are not already. This adds makeIntegerIndex() for the purpose. Int types are left alone. (This was done before for operator[], but needs to apply to some other things too, hence its extraction into common function now)
2017-04-20 15:00:56 +00:00
TIntermTyped* makeIntegerIndex(TIntermTyped*);
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
HLSL: allow non-vec3 tessellation coordinate declarations HLSL requires vec2 tessellation coordinate declarations in some cases (e.g, isoline topology), where SPIR-V requires the TessCoord qualified builtin to be a vec3 in all cases. This alters the IO form of the variable to be a vec3, which will be copied to the shader's declared type if needed. This is not a validation; the shader type must be correct.
2017-04-05 17:03:02 +00:00
void fixBuiltInIoType(TType&);
HLSL: require tessellation factors to be fixed size arrays SPIR-V requires that tessellation factor arrays be size 4 (outer) or 2 (inner). HLSL allows other sizes such as 3, or even scalars. This commit converts between them by forcing the IO types to be the SPIR-V size, and allowing copies between the internal and IO types to handle these cases.
2017-03-18 00:51:05 +00:00
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
void flatten(const TSourceLoc& loc, const TVariable& variable);
HLSL: Recursive composite flattening This PR implements recursive type flattening. For example, an array of structs of other structs can be flattened to individual member variables at the shader interface. This is sufficient for many purposes, e.g, uniforms containing opaque types, but is not sufficient for geometry shader arrayed inputs. That will be handled separately with structure splitting, which is not implemented by this PR. In the meantime, that case is detected and triggers an error. The recursive flattening extends the following three aspects of single-level flattening: - Flattening of structures to individual members with names such as "foo[0].samp[1]"; - Turning constant references to the nested composite type into a reference to a particular flattened member. - Shadow copies between arrays of flattened members and the nested composite type. Previous single-level flattening only flattened at the shader interface, and that is unchanged by this PR. Internally, shadow copies are, such as if the type is passed to a function. Also, the reasons for flattening are unchanged. Uniforms containing opaque types, and interface struct types are flattened. (The latter will change with structure splitting). One existing test changes: hlsl.structin.vert, which did in fact contain a nested composite type to be flattened. Two new tests are added: hlsl.structarray.flatten.frag, and hlsl.structarray.flatten.geom (currently issues an error until type splitting is online). The process of arriving at the individual member from chained postfix expressions is more complex than it was with one level. See large-ish comment above HlslParseContext::flatten() for details.
2016-11-29 00:09:54 +00:00
int flatten(const TSourceLoc& loc, const TVariable& variable, const TType&, TFlattenData&, TString name);
int flattenStruct(const TSourceLoc& loc, const TVariable& variable, const TType&, TFlattenData&, TString name);
int flattenArray(const TSourceLoc& loc, const TVariable& variable, const TType&, TFlattenData&, TString name);
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
HLSL: Move to fine-grained control for defining input/output/uniform IO types.
2017-02-06 03:27:30 +00:00
bool hasUniform(const TQualifier& qualifier) const;
void clearUniform(TQualifier& qualifier);
bool isInputBuiltIn(const TQualifier& qualifier) const;
bool hasInput(const TQualifier& qualifier) const;
void correctOutput(TQualifier& qualifier);
bool isOutputBuiltIn(const TQualifier& qualifier) const;
bool hasOutput(const TQualifier& qualifier) const;
void correctInput(TQualifier& qualifier);
void correctUniform(TQualifier& qualifier);
void clearUniformInputOutput(TQualifier& qualifier);
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
// Test method names
bool isStructBufferMethod(const TString& name) const;
WIP: HLSL: add ability to pass struct buffers with counters to fns This modifies function parameter passing to pass the counter buffer associated with a struct buffer to a function as a hidden parameter. Similarly function declarations will have hidden parameters added to accept the associated counter buffers. There is a limitation: if a SB type may or may not have an associated counter, passing it as a function parameter will assume that it does, and the counter will appear in the linkage whether or not there is a counter method used on the object.
2017-04-27 17:22:32 +00:00
void counterBufferType(const TSourceLoc& loc, TType& type);
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
HLSL: add standard sample position return form of GetSamplePosition method Multisample textures support a GetSamplePosition() method intended to query positions given a sample index. This cannot be truly implemented in SPIR-V, but #753 requested returning standard positions for the 1..16 cases, which this PR adds. Anything besides that returns (0,0). If the standard positions are not used, this will be wrong. This should be revisited when there is a real query available.
2017-04-26 14:31:56 +00:00
// Return standard sample position array
TIntermConstantUnion* getSamplePosArray(int count);
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
TType* getStructBufferContentType(const TType& type) const;
bool isStructBufferType(const TType& type) const { return getStructBufferContentType(type) != nullptr; }
TIntermTyped* indexStructBufferContent(const TSourceLoc& loc, TIntermTyped* buffer) const;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
TIntermTyped* getStructBufferCounter(const TSourceLoc& loc, TIntermTyped* buffer);
WIP: HLSL: add ability to pass struct buffers with counters to fns This modifies function parameter passing to pass the counter buffer associated with a struct buffer to a function as a hidden parameter. Similarly function declarations will have hidden parameters added to accept the associated counter buffers. There is a limitation: if a SB type may or may not have an associated counter, passing it as a function parameter will assume that it does, and the counter will appear in the linkage whether or not there is a counter method used on the object.
2017-04-27 17:22:32 +00:00
TString getStructBuffCounterName(const TString&) const;
void addStructBuffArguments(const TSourceLoc& loc, TIntermAggregate*&);
void addStructBufferHiddenCounterParam(const TSourceLoc& loc, TParameter&, TIntermAggregate*&);
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
// Return true if this type is a reference. This is not currently a type method in case that's
// a language specific answer.
bool isReference(const TType& type) const { return isStructBufferType(type); }
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
// Return true if this a buffer type that has an associated counter buffer.
WIP: track declared builtin type [proposal] Marking as WIP since it might deserve discussion or at least explicit consideration. During type sanitization, the TQualifier's TBuiltInVariable type is lost. However, sometimes it's needed downstream. There were already two methods in use to track it through to places it was needed: one in the TParameter, and one in a map in the HlslParseContext used for structured buffers. The latter was going to be insufficient when SB types with counters are passed to user functions, and it's proving awkward to track the data to where it's needed. This PR holds a proposal: track the original declared builtin type in the TType, so it's trivially available where needed. This lets the other two mechanisms be removed (and they are in this PR). There's a side benefit of not losing certain types of information before the reflection interface. This PR is only that proposal, so it changes no test results. If it's acceptable, I'll use it for the last piece of SB counter functionality.
2017-04-24 01:44:28 +00:00
bool hasStructBuffCounter(const TType&) const;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
// Finalization step: remove unused buffer blocks from linkage (we don't know until the
// shader is entirely compiled)
void removeUnusedStructBufferCounters();
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
// Pass through to base class after remembering builtin mappings.
using TParseContextBase::trackLinkage;
void trackLinkage(TSymbol& variable) override;
Mark an overriden method in a subclass with ‘override’.
2017-01-08 21:54:48 +00:00
void finish() override; // post-processing
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
HLSL: HS return is arrayed to match SPIR-V semantics HLSL HS outputs a per ctrl point value, and the DS reads an array of that type. (It also has a per patch frequency). The per-ctrl-pt frequency is arrayed on just one side, as opposed to SPIR-V which is arrayed on both. To match semantics, the compiler creates an array behind the scenes and indexes it by invocation ID, assigning the HS return value to it.
2017-03-23 00:39:25 +00:00
// Linkage symbol helpers
TIntermSymbol* findLinkageSymbol(TBuiltInVariable biType) const;
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
// Current state of parsing
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
int annotationNestingLevel; // 0 if outside all annotations
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
HlslParseContext(HlslParseContext&);
HlslParseContext& operator=(HlslParseContext&);
static const int maxSamplerIndex = EsdNumDims * (EbtNumTypes * (2 * 2 * 2)); // see computeSamplerTypeIndex()
TQualifier globalBufferDefaults;
TQualifier globalUniformDefaults;
TQualifier globalInputDefaults;
TQualifier globalOutputDefaults;
TString currentCaller; // name of last function body entered (not valid when at global scope)
TIdSetType inductiveLoopIds;
TVector<TIntermTyped*> needsIndexLimitationChecking;
//
// Geometry shader input arrays:
// - array sizing is based on input primitive and/or explicit size
//
// Tessellation control output arrays:
// - array sizing is based on output layout(vertices=...) and/or explicit size
//
// Both:
// - array sizing is retroactive
// - built-in block redeclarations interact with this
//
// Design:
// - use a per-context "resize-list", a list of symbols whose array sizes
// can be fixed
//
// - the resize-list starts empty at beginning of user-shader compilation, it does
// not have built-ins in it
//
// - on built-in array use: copyUp() symbol and add it to the resize-list
//
// - on user array declaration: add it to the resize-list
//
// - on block redeclaration: copyUp() symbol and add it to the resize-list
// * note, that appropriately gives an error if redeclaring a block that
// was already used and hence already copied-up
//
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
// - on seeing a layout declaration that sizes the array, fix everything in the
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
// resize-list, giving errors for mismatch
//
// - on seeing an array size declaration, give errors on mismatch between it and previous
// array-sizing declarations
//
TVector<TSymbol*> ioArraySymbolResizeList;
HLSL: Flatten vertex input and fragment output structures. Vulkan can't handle structures into the vertex stage or out of the fragment stage.
2016-09-09 22:32:09 +00:00
HLSL: Recursive composite flattening This PR implements recursive type flattening. For example, an array of structs of other structs can be flattened to individual member variables at the shader interface. This is sufficient for many purposes, e.g, uniforms containing opaque types, but is not sufficient for geometry shader arrayed inputs. That will be handled separately with structure splitting, which is not implemented by this PR. In the meantime, that case is detected and triggers an error. The recursive flattening extends the following three aspects of single-level flattening: - Flattening of structures to individual members with names such as "foo[0].samp[1]"; - Turning constant references to the nested composite type into a reference to a particular flattened member. - Shadow copies between arrays of flattened members and the nested composite type. Previous single-level flattening only flattened at the shader interface, and that is unchanged by this PR. Internally, shadow copies are, such as if the type is passed to a function. Also, the reasons for flattening are unchanged. Uniforms containing opaque types, and interface struct types are flattened. (The latter will change with structure splitting). One existing test changes: hlsl.structin.vert, which did in fact contain a nested composite type to be flattened. Two new tests are added: hlsl.structarray.flatten.frag, and hlsl.structarray.flatten.geom (currently issues an error until type splitting is online). The process of arriving at the individual member from chained postfix expressions is more complex than it was with one level. See large-ish comment above HlslParseContext::flatten() for details.
2016-11-29 00:09:54 +00:00
TMap<int, TFlattenData> flattenMap;
TVector<int> flattenLevel; // nested postfix operator level for flattening
TVector<int> flattenOffset; // cumulative offset for flattening
HLSL: Move to fine-grained control for defining input/output/uniform IO types.
2017-02-06 03:27:30 +00:00
// IO-type map. Maps a pure symbol-table form of a structure-member list into
// each of the (up to) three kinds of IO, as each as different allowed decorations,
// but HLSL allows mixing all in the same structure.
struct tIoKinds {
TTypeList* input;
TTypeList* output;
TTypeList* uniform;
};
TMap<const TTypeList*, tIoKinds> ioTypeMap;
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
// Structure splitting data:
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
TMap<int, TVariable*> splitIoVars; // variables with the builtin interstage IO removed, indexed by unique ID.
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
// Structuredbuffer shared types. Typically there are only a few.
TVector<TType*> structBufferTypes;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
TMap<TString, bool> structBufferCounter;
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
// The builtin interstage IO map considers e.g, EvqPosition on input and output separately, so that we
// can build the linkage correctly if position appears on both sides. Otherwise, multiple positions
// are considered identical.
struct tInterstageIoData {
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
tInterstageIoData(TBuiltInVariable bi, TStorageQualifier q) :
builtIn(bi), storage(q) { }
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
tInterstageIoData(const TType& memberType, const TType& storageType) :
builtIn(memberType.getQualifier().builtIn),
storage(storageType.getQualifier().storage) { }
TBuiltInVariable builtIn;
TStorageQualifier storage;
// ordering for maps
bool operator<(const tInterstageIoData d) const {
return (builtIn != d.builtIn) ? (builtIn < d.builtIn) : (storage < d.storage);
}
};
HLSL: Move to fine-grained control for defining input/output/uniform IO types.
2017-02-06 03:27:30 +00:00
TMap<tInterstageIoData, TVariable*> interstageBuiltInIo; // individual builtin interstage IO vars, indexed by builtin type.
WIP: HLSL: Support InputPatch variables in patch constant functions Previously, patch constant functions only accepted OutputPatch. This adds InputPatch support, via a pseudo-builtin variable type, so that the patch can be tracked clear through from the qualifier.
2017-04-01 21:34:48 +00:00
TVariable* inputPatch;
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
// We have to move array references to structs containing builtin interstage IO to the split variables.
// This is only handled for one level. This stores the index, because we'll need it in the future, since
// unlike normal array references, here the index happens before we discover what it applies to.
TIntermTyped* builtInIoIndex;
TIntermTyped* builtInIoBase;
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
HLSL: Flatten a return struct from an entry point and assign locations after flattening. Locations now get assigned in order, but skipping built-ins, which can be done post flattening.
2016-09-16 07:44:43 +00:00
unsigned int nextInLocation;
unsigned int nextOutLocation;
allow renaming of shader entry point when creating SPIR-V Use "--source-entrypoint name" on the command line, or the TShader::setSourceEntryPoint(char*) API. When the name given to the above interfaces is detected in the shader source, it will be renamed to the entry point name supplied to the -e option or the TShader::setEntryPoint() method.
2016-10-31 21:13:43 +00:00
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
TString sourceEntryPointName;
TFunction* entryPointFunction;
TIntermNode* entryPointFunctionBody;
TString patchConstantFunctionName; // hull shader patch constant function name, from function level attribute.
TMap<TBuiltInVariable, TSymbol*> builtInLinkageSymbols; // used for tessellation, finding declared builtins
HLSL: non-static member functions: track and find active anonymous 'this' scopes and members. Thanks to @steve-lunarg for his input and discussions on handling member functions.
2017-03-22 05:56:40 +00:00
TVector<TString> currentTypePrefix; // current scoping prefix for nested structures
TVector<TVariable*> implicitThisStack; // currently active 'this' variables for nested structures
HLSL: fix GS implementation for EP wrapping The prior implementation of GS did not work with the new EP wrapping architecture. This fixes it: the Append() method now looks up the actual output rather than the internal sanitized temporary type, and writes to that.
2017-03-30 02:01:13 +00:00
TVariable* gsStreamOutput; // geometry shader stream outputs, for emit (Append method)
HLSL: add .mips[][] operator for texture types This implements mytex.mips[mip][coord] for texture types. There is some error testing, but not comprehensive. The constructs can be nested, e.g in this case the inner .mips is parsed before the completion of the outer [][] operator. tx.mips[tx.mips[a][b].x][c]
2017-05-12 23:14:31 +00:00
// This tracks the first (mip level) argument to the .mips[][] operator. Since this can be nested as
// in tx.mips[tx.mips[0][1].x][2], we need a stack. We also track the TSourceLoc for error reporting
// purposes.
struct tMipsOperatorData {
tMipsOperatorData(TSourceLoc l, TIntermTyped* m) : loc(l), mipLevel(m) { }
TSourceLoc loc;
TIntermTyped* mipLevel;
};
TVector<tMipsOperatorData> mipsOperatorMipArg;
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
};
HLSL: use prefix for builtin functions names to avoid namespace collisions It would have been possible for globally scoped user functions to collide with builtin method names. This adds a prefix to avoid polluting the namespace. Ideally this would be an invalid character to use in user identifiers, but as that requires changing the scanner, for the moment it's an unlikely yet valid prefix.
2017-03-20 00:12:37 +00:00
// This is the prefix we use for builtin methods to avoid namespace collisions with
// global scope user functions.
// TODO: this would be better as a nonparseable character, but that would
// require changing the scanner.
#define BUILTIN_PREFIX "__BI_"
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
} // end namespace glslang
#endif // HLSL_PARSE_INCLUDED_
Reference in New Issue Copy Permalink