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
bf47286fe7
glslang/hlsl/hlslParseHelper.h

357 lines
20 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: 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;
virtual const char* getGlobalUniformBlockName() override { return "$Global"; }
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: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
TIntermTyped* handleVariable(const TSourceLoc&, TSymbol* symbol, 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: 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: Error if funcion with return type doesn't return a value.
2016-09-03 01:13:36 +00:00
TFunction& 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: 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);
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: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
TIntermTyped* handleLengthMethod(const TSourceLoc&, TFunction*, TIntermNode*);
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*&);
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: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
TFunction* handleConstructorCall(const TSourceLoc&, const TType&);
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 handleSemantic(TSourceLoc, TQualifier&, const TString& semantic);
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: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
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 boolCheck(const TSourceLoc&, const TIntermTyped*);
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 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
const TFunction* findFunction(const TSourceLoc& loc, TFunction& call, bool& builtIn, TIntermTyped*& args);
HLSL: Add typedef grammar and production.
2016-07-05 06:02:40 +00:00
void declareTypedef(const TSourceLoc&, TString& identifier, const TType&, TArraySizes* typeArray = 0);
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: Rationalize combination of type arrayness and name arrayness.
2016-09-27 20:38:57 +00:00
TIntermNode* declareVariable(const TSourceLoc&, TString& identifier, TType&, TIntermTyped* initializer = 0);
HLSL: Support {...} initializer lists that are too short.
2016-11-28 00:39:07 +00:00
void lengthenList(const TSourceLoc&, TIntermSequence& list, int size);
Non-functional: Rationalize location and use of mapTypeToConstructor().
2016-07-28 21:29:35 +00:00
TIntermTyped* addConstructor(const TSourceLoc&, TIntermNode*, 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);
Fix a large number of warnings about inconsistent usage of 'override' produced by clang
2016-12-21 11:48:08 +00:00
void finalizeGlobalUniformBlockLayout(TVariable& block) override;
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 switch/case/default.
2016-07-01 06:04:11 +00:00
void pushSwitchSequence(TIntermSequence* sequence) { switchSequenceStack.push_back(sequence); }
void popSwitchSequence() { switchSequenceStack.pop_back(); }
HLSL: Have loose uniforms also go through the makeTypeNonIo() path.
2017-02-03 21:06:36 +00:00
virtual void growGlobalUniformBlock(TSourceLoc&, TType&, TString& memberName) 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
// Apply L-value conversions. E.g, turning a write to a RWTexture into an ImageStore.
TIntermTyped* handleLvalue(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);
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
void renameShaderFunction(TString*& name) 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
// 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(); }
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.
};
HLSL: Handle const with no initializer. Fixes issue #651.
2016-12-30 23:42:57 +00:00
void fixConstInit(const TSourceLoc&, 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: 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
TVariable* declareNonArray(const TSourceLoc&, TString& identifier, TType&, bool track);
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
void declareArray(const TSourceLoc&, 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);
TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer);
Fix non-Windows build error.
2016-11-28 06:00:14 +00:00
bool isZeroConstructor(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);
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
bool shouldFlattenUniform(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()); }
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 (splits interstage builtin 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();
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);
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: 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
struct TPragma contextPragma;
int loopNestingLevel; // 0 if outside all loops
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
int structNestingLevel; // 0 if outside blocks and structures
int controlFlowNestingLevel; // 0 if outside all flow control
TList<TIntermSequence*> switchSequenceStack; // case, node, case, case, node, ...; ensure only one node between cases; stack of them for nesting
Non-functional: Rename some entry-point variables to entryPoint, not main.
2016-11-26 20:31:47 +00:00
bool postEntryPointReturn; // if inside a function, true if the function is the entry point and this is after a return statement
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
const TType* currentFunctionType; // the return type of the function that's currently being parsed
bool functionReturnsValue; // true if a non-void function has a return
TBuiltInResource resources;
TLimits& limits;
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.
// 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 {
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.
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
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
};
} // end namespace glslang
#endif // HLSL_PARSE_INCLUDED_
Reference in New Issue Copy Permalink