libretro/glslang
1
0
Fork 0
mirror of https://github.com/libretro/glslang.git synced 2024-11-27 01:40:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
glslang/hlsl/hlslParseHelper.h

287 lines
16 KiB
C
Raw Permalink 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
//
//Copyright (C) 2016 Google, Inc.
Add decompositions for some HLSL intrinsics.
2016-06-09 14:57:35 +00:00
//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
//
//All rights reserved.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions
//are met:
//
// 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.
//
//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.
//
#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();
HLSL: enable #line extension by default for HLSL source.
2016-07-23 02:46:03 +00:00
void initializeExtensionBehavior();
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void setLimits(const TBuiltInResource&);
bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false);
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
virtual const char* getGlobalUniformBlockName() { 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
Build: Remove causes of pedantic warnings. Addresses issue #352 and PR #242.
2016-07-09 04:09:10 +00:00
void reservedPpErrorCheck(const TSourceLoc&, const char* /*name*/, const char* /*op*/) { }
bool lineContinuationCheck(const TSourceLoc&, bool /*endOfComment*/) { 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 lineDirectiveShouldSetNextLine() const { return true; }
bool builtInName(const TString&);
void handlePragma(const TSourceLoc&, const TVector<TString>&);
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: 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
TIntermAggregate* handleFunctionDefinition(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);
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 remapEntryPointIO(TFunction& function);
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: Non-functional; make flatten semantics be about aggregates, not just structures.
2016-09-19 05:10:22 +00:00
TIntermTyped* handleAssign(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right) const;
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermNode*);
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*);
void addInputArgumentConversions(const TFunction&, TIntermNode*&) const;
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);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
bool parseVectorFields(const TSourceLoc&, const TString&, int vecSize, TVectorFields&);
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: 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
const TFunction* findFunction(const TSourceLoc& loc, const TFunction& call, bool& builtIn, TIntermNode* 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: 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);
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 finalizeGlobalUniformBlockLayout(TVariable& block);
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: 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: 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: 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: 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 shouldFlatten(const TType& type) const;
TIntermTyped* flattenAccess(const TSourceLoc&, 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 shouldFlattenIO(const TType&) const;
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()); }
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: 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: Sweep through the stack for consistent with "main" and entry point. Partially addresses issue #513.
2016-09-19 22:01:41 +00:00
bool inEntryPoint; // if inside a function, true if the function is the entry point
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;
HLSL: Emulate write-to-output on return-from-entry-point, for return value. This fixes issue #487 and #480. It also correctly handles output parameters from the entry point.
2016-08-28 21:00:23 +00:00
TVariable* entryPointOutput;
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
// 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
//
// - on seeing a layout declaration that sizes the array, fix everything in the
// 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: 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