John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 1 | // |
John Kessenich | 927608b | 2017-01-06 12:34:14 -0700 | [diff] [blame] | 2 | // Copyright (C) 2016 Google, Inc. |
| 3 | // Copyright (C) 2016 LunarG, Inc. |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 4 | // |
John Kessenich | 927608b | 2017-01-06 12:34:14 -0700 | [diff] [blame] | 5 | // All rights reserved. |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 6 | // |
John Kessenich | 927608b | 2017-01-06 12:34:14 -0700 | [diff] [blame] | 7 | // Redistribution and use in source and binary forms, with or without |
| 8 | // modification, are permitted provided that the following conditions |
| 9 | // are met: |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 10 | // |
| 11 | // Redistributions of source code must retain the above copyright |
| 12 | // notice, this list of conditions and the following disclaimer. |
| 13 | // |
| 14 | // Redistributions in binary form must reproduce the above |
| 15 | // copyright notice, this list of conditions and the following |
| 16 | // disclaimer in the documentation and/or other materials provided |
| 17 | // with the distribution. |
| 18 | // |
| 19 | // Neither the name of 3Dlabs Inc. Ltd. nor the names of its |
| 20 | // contributors may be used to endorse or promote products derived |
| 21 | // from this software without specific prior written permission. |
| 22 | // |
John Kessenich | 927608b | 2017-01-06 12:34:14 -0700 | [diff] [blame] | 23 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 24 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 25 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| 26 | // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| 27 | // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| 28 | // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| 29 | // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| 30 | // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| 31 | // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 32 | // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN |
| 33 | // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| 34 | // POSSIBILITY OF SUCH DAMAGE. |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 35 | // |
| 36 | #ifndef HLSL_PARSE_INCLUDED_ |
| 37 | #define HLSL_PARSE_INCLUDED_ |
| 38 | |
| 39 | #include "../glslang/MachineIndependent/parseVersions.h" |
| 40 | #include "../glslang/MachineIndependent/ParseHelper.h" |
| 41 | |
| 42 | namespace glslang { |
| 43 | |
steve-lunarg | 1868b14 | 2016-10-20 13:07:10 -0600 | [diff] [blame] | 44 | class TAttributeMap; // forward declare |
| 45 | |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 46 | class HlslParseContext : public TParseContextBase { |
| 47 | public: |
| 48 | HlslParseContext(TSymbolTable&, TIntermediate&, bool parsingBuiltins, |
John Kessenich | b901ade | 2016-06-16 20:59:42 -0600 | [diff] [blame] | 49 | int version, EProfile, const SpvVersion& spvVersion, EShLanguage, TInfoSink&, |
steve-lunarg | f1e0c87 | 2016-10-31 15:13:43 -0600 | [diff] [blame] | 50 | const TString sourceEntryPointName, |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 51 | bool forwardCompatible = false, EShMessages messages = EShMsgDefault); |
| 52 | virtual ~HlslParseContext(); |
Henrik Rydgård | 9a931b3 | 2016-12-21 12:48:08 +0100 | [diff] [blame] | 53 | void initializeExtensionBehavior() override; |
LoopDawg | 6256146 | 2016-07-22 20:46:03 -0600 | [diff] [blame] | 54 | |
Henrik Rydgård | 9a931b3 | 2016-12-21 12:48:08 +0100 | [diff] [blame] | 55 | void setLimits(const TBuiltInResource&) override; |
| 56 | bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false) override; |
John Kessenich | 000c818 | 2017-03-22 23:21:34 -0600 | [diff] [blame] | 57 | virtual const char* getGlobalUniformBlockName() const override { return "$Global"; } |
| 58 | virtual void setUniformBlockDefaults(TType& block) const override |
| 59 | { |
| 60 | block.getQualifier().layoutPacking = ElpStd140; |
| 61 | block.getQualifier().layoutMatrix = ElmRowMajor; |
| 62 | } |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 63 | |
Henrik Rydgård | 9a931b3 | 2016-12-21 12:48:08 +0100 | [diff] [blame] | 64 | void reservedPpErrorCheck(const TSourceLoc&, const char* /*name*/, const char* /*op*/) override { } |
| 65 | bool lineContinuationCheck(const TSourceLoc&, bool /*endOfComment*/) override { return true; } |
| 66 | bool lineDirectiveShouldSetNextLine() const override { return true; } |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 67 | bool builtInName(const TString&); |
| 68 | |
Henrik Rydgård | 9a931b3 | 2016-12-21 12:48:08 +0100 | [diff] [blame] | 69 | void handlePragma(const TSourceLoc&, const TVector<TString>&) override; |
John Kessenich | f4ba25e | 2017-03-21 18:35:04 -0600 | [diff] [blame] | 70 | TIntermTyped* handleVariable(const TSourceLoc&, const TString* string); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 71 | TIntermTyped* handleBracketDereference(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index); |
steve-lunarg | 6b43d27 | 2016-10-06 20:12:24 -0600 | [diff] [blame] | 72 | TIntermTyped* handleBracketOperator(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 73 | void checkIndex(const TSourceLoc&, const TType&, int& index); |
| 74 | |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 75 | TIntermTyped* handleBinaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right); |
| 76 | TIntermTyped* handleUnaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* childNode); |
| 77 | TIntermTyped* handleDotDereference(const TSourceLoc&, TIntermTyped* base, const TString& field); |
John Kessenich | 5f12d2f | 2017-03-11 09:39:55 -0700 | [diff] [blame] | 78 | bool isBuiltInMethod(const TSourceLoc&, TIntermTyped* base, const TString& field); |
John Kessenich | 7dc630f | 2016-09-16 01:44:43 -0600 | [diff] [blame] | 79 | void assignLocations(TVariable& variable); |
John Kessenich | 088d52b | 2017-03-11 17:55:28 -0700 | [diff] [blame] | 80 | void handleFunctionDeclarator(const TSourceLoc&, TFunction& function, bool prototype); |
John Kessenich | 02467d8 | 2017-01-19 15:41:47 -0700 | [diff] [blame] | 81 | TIntermAggregate* handleFunctionDefinition(const TSourceLoc&, TFunction&, const TAttributeMap&, TIntermNode*& entryPointTree); |
| 82 | TIntermNode* transformEntryPoint(const TSourceLoc&, TFunction&, const TAttributeMap&); |
steve-lunarg | e741249 | 2017-03-23 11:56:07 -0600 | [diff] [blame] | 83 | void handleEntryPointAttributes(const TSourceLoc&, const TAttributeMap&); |
John Kessenich | a305166 | 2016-09-02 19:13:36 -0600 | [diff] [blame] | 84 | void handleFunctionBody(const TSourceLoc&, TFunction&, TIntermNode* functionBody, TIntermNode*& node); |
John Kessenich | 727b374 | 2017-02-03 17:57:55 -0700 | [diff] [blame] | 85 | void remapEntryPointIO(TFunction& function, TVariable*& returnValue, TVector<TVariable*>& inputs, TVector<TVariable*>& outputs); |
John Kessenich | 6fccb3c | 2016-09-19 16:01:41 -0600 | [diff] [blame] | 86 | void remapNonEntryPointIO(TFunction& function); |
steve-lunarg | c4a1307 | 2016-08-09 11:28:03 -0600 | [diff] [blame] | 87 | TIntermNode* handleReturnValue(const TSourceLoc&, TIntermTyped*); |
John Kessenich | 4678ca9 | 2016-05-13 09:33:42 -0600 | [diff] [blame] | 88 | void handleFunctionArgument(TFunction*, TIntermTyped*& arguments, TIntermTyped* newArg); |
John Kessenich | fdf6347 | 2017-01-13 12:27:52 -0700 | [diff] [blame] | 89 | TIntermTyped* handleAssign(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right); |
| 90 | TIntermTyped* handleAssignToMatrixSwizzle(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right); |
steve-lunarg | 26d3145 | 2016-12-23 18:56:57 -0700 | [diff] [blame] | 91 | TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermTyped*); |
LoopDawg | 592860c | 2016-06-09 08:57:35 -0600 | [diff] [blame] | 92 | void decomposeIntrinsic(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments); |
LoopDawg | 4886f69 | 2016-06-29 10:58:58 -0600 | [diff] [blame] | 93 | void decomposeSampleMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments); |
steve-lunarg | 5da1f03 | 2017-02-12 17:50:28 -0700 | [diff] [blame] | 94 | void decomposeStructBufferMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments); |
steve-lunarg | f49cdf4 | 2016-11-17 15:04:20 -0700 | [diff] [blame] | 95 | void decomposeGeometryMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments); |
steve-lunarg | 26d3145 | 2016-12-23 18:56:57 -0700 | [diff] [blame] | 96 | void addInputArgumentConversions(const TFunction&, TIntermTyped*&); |
steve-lunarg | ef33ec0 | 2016-11-02 12:42:34 -0600 | [diff] [blame] | 97 | TIntermTyped* addOutputArgumentConversions(const TFunction&, TIntermOperator&); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 98 | void builtInOpCheck(const TSourceLoc&, const TFunction&, TIntermOperator&); |
John Kessenich | c633f64 | 2017-04-03 21:48:37 -0600 | [diff] [blame] | 99 | TFunction* makeConstructorCall(const TSourceLoc&, const TType&); |
John Kessenich | 2dd643f | 2017-03-14 21:50:06 -0600 | [diff] [blame] | 100 | void handleSemantic(TSourceLoc, TQualifier&, TBuiltInVariable, const TString& upperCase); |
John Kessenich | 7735b94 | 2016-09-05 12:40:06 -0600 | [diff] [blame] | 101 | void handlePackOffset(const TSourceLoc&, TQualifier&, const glslang::TString& location, |
John Kessenich | b38f071 | 2016-07-30 10:29:54 -0600 | [diff] [blame] | 102 | const glslang::TString* component); |
John Kessenich | 7735b94 | 2016-09-05 12:40:06 -0600 | [diff] [blame] | 103 | void handleRegister(const TSourceLoc&, TQualifier&, const glslang::TString* profile, const glslang::TString& desc, |
John Kessenich | cfd7ce8 | 2016-09-05 16:03:12 -0600 | [diff] [blame] | 104 | int subComponent, const glslang::TString*); |
John Kessenich | 636b62d | 2017-04-11 19:45:00 -0600 | [diff] [blame] | 105 | TIntermTyped* convertConditionalExpression(const TSourceLoc&, TIntermTyped*, bool mustBeScalar = true); |
LoopDawg | a2b7991 | 2016-07-14 14:45:14 -0600 | [diff] [blame] | 106 | TIntermAggregate* handleSamplerTextureCombine(const TSourceLoc& loc, TIntermTyped* argTex, TIntermTyped* argSampler); |
| 107 | |
John Kessenich | c142c88 | 2017-01-13 19:34:22 -0700 | [diff] [blame] | 108 | bool parseMatrixSwizzleSelector(const TSourceLoc&, const TString&, int cols, int rows, TSwizzleSelectors<TMatrixSelector>&); |
| 109 | int getMatrixComponentsColumn(int rows, const TSwizzleSelectors<TMatrixSelector>&); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 110 | void assignError(const TSourceLoc&, const char* op, TString left, TString right); |
| 111 | void unaryOpError(const TSourceLoc&, const char* op, TString operand); |
| 112 | void binaryOpError(const TSourceLoc&, const char* op, TString left, TString right); |
| 113 | void variableCheck(TIntermTyped*& nodePtr); |
| 114 | void constantValueCheck(TIntermTyped* node, const char* token); |
| 115 | void integerCheck(const TIntermTyped* node, const char* token); |
| 116 | void globalCheck(const TSourceLoc&, const char* token); |
| 117 | bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&); |
| 118 | bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&); |
| 119 | void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&); |
| 120 | void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&); |
| 121 | void structArrayCheck(const TSourceLoc&, const TType& structure); |
| 122 | void arrayDimMerge(TType& type, const TArraySizes* sizes); |
| 123 | bool voidErrorCheck(const TSourceLoc&, const TString&, TBasicType); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 124 | void globalQualifierFix(const TSourceLoc&, TQualifier&); |
| 125 | bool structQualifierErrorCheck(const TSourceLoc&, const TPublicType& pType); |
John Kessenich | 34e7ee7 | 2016-09-16 17:10:39 -0600 | [diff] [blame] | 126 | void mergeQualifiers(TQualifier& dst, const TQualifier& src); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 127 | int computeSamplerTypeIndex(TSampler&); |
John Kessenich | d3f1122 | 2016-11-05 10:15:53 -0600 | [diff] [blame] | 128 | TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 129 | void redeclareBuiltinBlock(const TSourceLoc&, TTypeList& typeList, const TString& blockName, const TString* instanceName, TArraySizes* arraySizes); |
John Kessenich | 5aa59e2 | 2016-06-17 15:50:47 -0600 | [diff] [blame] | 130 | void paramFix(TType& type); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 131 | void specializationCheck(const TSourceLoc&, const TType&, const char* op); |
| 132 | |
John Kessenich | b9e3912 | 2016-08-17 10:22:08 -0600 | [diff] [blame] | 133 | void setLayoutQualifier(const TSourceLoc&, TQualifier&, TString&); |
| 134 | void setLayoutQualifier(const TSourceLoc&, TQualifier&, TString&, const TIntermTyped*); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 135 | void mergeObjectLayoutQualifiers(TQualifier& dest, const TQualifier& src, bool inheritOnly); |
| 136 | void checkNoShaderLayouts(const TSourceLoc&, const TShaderQualifiers&); |
| 137 | |
steve-lunarg | 26d3145 | 2016-12-23 18:56:57 -0700 | [diff] [blame] | 138 | const TFunction* findFunction(const TSourceLoc& loc, TFunction& call, bool& builtIn, TIntermTyped*& args); |
John Kessenich | 4dc835c | 2017-03-28 23:43:10 -0600 | [diff] [blame] | 139 | void declareTypedef(const TSourceLoc&, const TString& identifier, const TType&); |
John Kessenich | 727b374 | 2017-02-03 17:57:55 -0700 | [diff] [blame] | 140 | void declareStruct(const TSourceLoc&, TString& structName, TType&); |
John Kessenich | 854fe24 | 2017-03-02 14:30:59 -0700 | [diff] [blame] | 141 | TSymbol* lookupUserType(const TString&, TType&); |
John Kessenich | 4dc835c | 2017-03-28 23:43:10 -0600 | [diff] [blame] | 142 | TIntermNode* declareVariable(const TSourceLoc&, const TString& identifier, TType&, TIntermTyped* initializer = 0); |
John Kessenich | 82460b5 | 2017-04-04 11:47:42 -0600 | [diff] [blame] | 143 | void lengthenList(const TSourceLoc&, TIntermSequence& list, int size, TIntermTyped* scalarInit); |
John Kessenich | c633f64 | 2017-04-03 21:48:37 -0600 | [diff] [blame] | 144 | TIntermTyped* handleConstructor(const TSourceLoc&, TIntermTyped*, const TType&); |
| 145 | TIntermTyped* addConstructor(const TSourceLoc&, TIntermTyped*, const TType&); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 146 | TIntermTyped* constructAggregate(TIntermNode*, const TType&, int, const TSourceLoc&); |
| 147 | TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset); |
John Kessenich | 3d157c5 | 2016-07-25 16:05:33 -0600 | [diff] [blame] | 148 | void declareBlock(const TSourceLoc&, TType&, const TString* instanceName = 0, TArraySizes* arraySizes = 0); |
steve-lunarg | 8e26feb | 2017-04-10 08:19:21 -0600 | [diff] [blame] | 149 | void declareStructBufferCounter(const TSourceLoc& loc, const TType& bufferType, const TString& name); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 150 | void fixBlockLocations(const TSourceLoc&, TQualifier&, TTypeList&, bool memberWithLocation, bool memberWithoutLocation); |
| 151 | void fixBlockXfbOffsets(TQualifier&, TTypeList&); |
John Kessenich | 6dbc0a7 | 2016-09-27 19:13:05 -0600 | [diff] [blame] | 152 | void fixBlockUniformOffsets(const TQualifier&, TTypeList&); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 153 | void addQualifierToExisting(const TSourceLoc&, TQualifier, const TString& identifier); |
| 154 | void addQualifierToExisting(const TSourceLoc&, TQualifier, TIdentifierList&); |
| 155 | void updateStandaloneQualifierDefaults(const TSourceLoc&, const TPublicType&); |
| 156 | void wrapupSwitchSubsequence(TIntermAggregate* statements, TIntermNode* branchNode); |
| 157 | TIntermNode* addSwitch(const TSourceLoc&, TIntermTyped* expression, TIntermAggregate* body); |
| 158 | |
| 159 | void updateImplicitArraySize(const TSourceLoc&, TIntermNode*, int index); |
| 160 | |
John Kessenich | a1e2d49 | 2016-09-20 13:22:58 -0600 | [diff] [blame] | 161 | void nestLooping() { ++loopNestingLevel; } |
| 162 | void unnestLooping() { --loopNestingLevel; } |
| 163 | void nestAnnotations() { ++annotationNestingLevel; } |
| 164 | void unnestAnnotations() { --annotationNestingLevel; } |
John Kessenich | 6dbc0a7 | 2016-09-27 19:13:05 -0600 | [diff] [blame] | 165 | int getAnnotationNestingLevel() { return annotationNestingLevel; } |
John Kessenich | a1e2d49 | 2016-09-20 13:22:58 -0600 | [diff] [blame] | 166 | void pushScope() { symbolTable.push(); } |
| 167 | void popScope() { symbolTable.pop(0); } |
John Kessenich | 0d2b6de | 2016-06-05 11:23:11 -0600 | [diff] [blame] | 168 | |
John Kessenich | 3778979 | 2017-03-21 23:56:40 -0600 | [diff] [blame] | 169 | void pushThisScope(const TType&); |
| 170 | void popThisScope() { symbolTable.pop(0); } |
| 171 | |
| 172 | void pushImplicitThis(TVariable* thisParameter) { implicitThisStack.push_back(thisParameter); } |
| 173 | void popImplicitThis() { implicitThisStack.pop_back(); } |
| 174 | TVariable* getImplicitThis(int thisDepth) const { return implicitThisStack[implicitThisStack.size() - thisDepth]; } |
| 175 | |
John Kessenich | f3d88bd | 2017-03-19 12:24:29 -0600 | [diff] [blame] | 176 | void pushNamespace(const TString& name); |
| 177 | void popNamespace(); |
John Kessenich | 4dc835c | 2017-03-28 23:43:10 -0600 | [diff] [blame] | 178 | void getFullNamespaceName(const TString*&) const; |
John Kessenich | f3d88bd | 2017-03-19 12:24:29 -0600 | [diff] [blame] | 179 | void addScopeMangler(TString&); |
John Kessenich | 54ee28f | 2017-03-11 14:13:00 -0700 | [diff] [blame] | 180 | |
John Kessenich | d02dc5d | 2016-07-01 00:04:11 -0600 | [diff] [blame] | 181 | void pushSwitchSequence(TIntermSequence* sequence) { switchSequenceStack.push_back(sequence); } |
| 182 | void popSwitchSequence() { switchSequenceStack.pop_back(); } |
| 183 | |
John Kessenich | 4dc835c | 2017-03-28 23:43:10 -0600 | [diff] [blame] | 184 | virtual void growGlobalUniformBlock(const TSourceLoc&, TType&, const TString& memberName, TTypeList* typeList = nullptr) override; |
John Kessenich | 88c4464 | 2017-02-03 14:06:36 -0700 | [diff] [blame] | 185 | |
steve-lunarg | 9070796 | 2016-10-07 19:35:40 -0600 | [diff] [blame] | 186 | // Apply L-value conversions. E.g, turning a write to a RWTexture into an ImageStore. |
| 187 | TIntermTyped* handleLvalue(const TSourceLoc&, const char* op, TIntermTyped* node); |
steve-lunarg | 0de16da | 2016-10-08 10:54:52 -0600 | [diff] [blame] | 188 | bool lValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*) override; |
steve-lunarg | 9070796 | 2016-10-07 19:35:40 -0600 | [diff] [blame] | 189 | |
steve-lunarg | 4f2da27 | 2016-10-10 15:24:57 -0600 | [diff] [blame] | 190 | TLayoutFormat getLayoutFromTxType(const TSourceLoc&, const TType&); |
| 191 | |
steve-lunarg | f49cdf4 | 2016-11-17 15:04:20 -0700 | [diff] [blame] | 192 | bool handleOutputGeometry(const TSourceLoc&, const TLayoutGeometry& geometry); |
| 193 | bool handleInputGeometry(const TSourceLoc&, const TLayoutGeometry& geometry); |
| 194 | |
steve-lunarg | f1e0c87 | 2016-10-31 15:13:43 -0600 | [diff] [blame] | 195 | // Potentially rename shader entry point function |
John Kessenich | 4dc835c | 2017-03-28 23:43:10 -0600 | [diff] [blame] | 196 | void renameShaderFunction(const TString*& name) const; |
steve-lunarg | f1e0c87 | 2016-10-31 15:13:43 -0600 | [diff] [blame] | 197 | |
steve-lunarg | a2b01a0 | 2016-11-28 17:09:54 -0700 | [diff] [blame] | 198 | // Reset data for incrementally built referencing of flattened composite structures |
| 199 | void initFlattening() { flattenLevel.push_back(0); flattenOffset.push_back(0); } |
| 200 | void finalizeFlattening() { flattenLevel.pop_back(); flattenOffset.pop_back(); } |
| 201 | |
steve-lunarg | dd8287a | 2017-02-23 18:04:12 -0700 | [diff] [blame] | 202 | // Share struct buffer deep types |
| 203 | void shareStructBufferType(TType&); |
| 204 | |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 205 | protected: |
steve-lunarg | a2b01a0 | 2016-11-28 17:09:54 -0700 | [diff] [blame] | 206 | struct TFlattenData { |
| 207 | TFlattenData() : nextBinding(TQualifier::layoutBindingEnd) { } |
| 208 | TFlattenData(int nb) : nextBinding(nb) { } |
| 209 | |
| 210 | TVector<TVariable*> members; // individual flattened variables |
| 211 | TVector<int> offsets; // offset to next tree level |
| 212 | int nextBinding; // next binding to use. |
| 213 | }; |
| 214 | |
John Kessenich | 4dc835c | 2017-03-28 23:43:10 -0600 | [diff] [blame] | 215 | void fixConstInit(const TSourceLoc&, const TString& identifier, TType& type, TIntermTyped*& initializer); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 216 | void inheritGlobalDefaults(TQualifier& dst) const; |
| 217 | TVariable* makeInternalVariable(const char* name, const TType&) const; |
steve-lunarg | a2e7531 | 2016-12-14 15:22:25 -0700 | [diff] [blame] | 218 | TVariable* makeInternalVariable(const TString& name, const TType& type) const { |
| 219 | return makeInternalVariable(name.c_str(), type); |
| 220 | } |
John Kessenich | 82460b5 | 2017-04-04 11:47:42 -0600 | [diff] [blame] | 221 | TIntermSymbol* makeInternalVariableNode(const TSourceLoc&, const char* name, const TType&) const; |
John Kessenich | 4dc835c | 2017-03-28 23:43:10 -0600 | [diff] [blame] | 222 | TVariable* declareNonArray(const TSourceLoc&, const TString& identifier, const TType&, bool track); |
| 223 | void declareArray(const TSourceLoc&, const TString& identifier, const TType&, TSymbol*&, bool track); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 224 | TIntermNode* executeInitializer(const TSourceLoc&, TIntermTyped* initializer, TVariable* variable); |
John Kessenich | 82460b5 | 2017-04-04 11:47:42 -0600 | [diff] [blame] | 225 | TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer, TIntermTyped* scalarInit); |
| 226 | bool isScalarConstructor(const TIntermNode*); |
LoopDawg | 5891070 | 2016-06-13 09:22:28 -0600 | [diff] [blame] | 227 | TOperator mapAtomicOp(const TSourceLoc& loc, TOperator op, bool isImage); |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 228 | |
steve-lunarg | 9070796 | 2016-10-07 19:35:40 -0600 | [diff] [blame] | 229 | // Return true if this node requires L-value conversion (e.g, to an imageStore). |
| 230 | bool shouldConvertLValue(const TIntermNode*) const; |
| 231 | |
steve-lunarg | e0b9deb | 2016-09-16 13:26:37 -0600 | [diff] [blame] | 232 | // Array and struct flattening |
steve-lunarg | a2e7531 | 2016-12-14 15:22:25 -0700 | [diff] [blame] | 233 | TIntermTyped* flattenAccess(TIntermTyped* base, int member); |
steve-lunarg | e0b9deb | 2016-09-16 13:26:37 -0600 | [diff] [blame] | 234 | bool shouldFlattenUniform(const TType&) const; |
steve-lunarg | a2b01a0 | 2016-11-28 17:09:54 -0700 | [diff] [blame] | 235 | bool wasFlattened(const TIntermTyped* node) const; |
| 236 | bool wasFlattened(int id) const { return flattenMap.find(id) != flattenMap.end(); } |
| 237 | int addFlattenedMember(const TSourceLoc& loc, const TVariable&, const TType&, TFlattenData&, const TString& name, bool track); |
| 238 | bool isFinalFlattening(const TType& type) const { return !(type.isStruct() || type.isArray()); } |
| 239 | |
steve-lunarg | a2e7531 | 2016-12-14 15:22:25 -0700 | [diff] [blame] | 240 | // Structure splitting (splits interstage builtin types into its own struct) |
steve-lunarg | 132d331 | 2016-12-19 15:48:01 -0700 | [diff] [blame] | 241 | TIntermTyped* splitAccessStruct(const TSourceLoc& loc, TIntermTyped*& base, int& member); |
| 242 | void splitAccessArray(const TSourceLoc& loc, TIntermTyped* base, TIntermTyped* index); |
| 243 | TType& split(TType& type, TString name, const TType* outerStructType = nullptr); |
steve-lunarg | a2e7531 | 2016-12-14 15:22:25 -0700 | [diff] [blame] | 244 | void split(TIntermTyped*); |
| 245 | void split(const TVariable&); |
| 246 | bool wasSplit(const TIntermTyped* node) const; |
| 247 | bool wasSplit(int id) const { return splitIoVars.find(id) != splitIoVars.end(); } |
| 248 | TVariable* getSplitIoVar(const TIntermTyped* node) const; |
| 249 | TVariable* getSplitIoVar(const TVariable* var) const; |
| 250 | TVariable* getSplitIoVar(int id) const; |
| 251 | void addInterstageIoToLinkage(); |
steve-lunarg | 858c928 | 2017-01-07 08:54:10 -0700 | [diff] [blame] | 252 | void addPatchConstantInvocation(); |
steve-lunarg | f8203a0 | 2017-04-20 09:00:56 -0600 | [diff] [blame^] | 253 | TIntermTyped* makeIntegerIndex(TIntermTyped*); |
steve-lunarg | a2e7531 | 2016-12-14 15:22:25 -0700 | [diff] [blame] | 254 | |
steve-lunarg | ccb076a | 2017-04-05 11:03:02 -0600 | [diff] [blame] | 255 | void fixBuiltInIoType(TType&); |
steve-lunarg | 194f0f3 | 2017-03-17 18:51:05 -0600 | [diff] [blame] | 256 | |
steve-lunarg | e0b9deb | 2016-09-16 13:26:37 -0600 | [diff] [blame] | 257 | void flatten(const TSourceLoc& loc, const TVariable& variable); |
steve-lunarg | a2b01a0 | 2016-11-28 17:09:54 -0700 | [diff] [blame] | 258 | int flatten(const TSourceLoc& loc, const TVariable& variable, const TType&, TFlattenData&, TString name); |
| 259 | int flattenStruct(const TSourceLoc& loc, const TVariable& variable, const TType&, TFlattenData&, TString name); |
| 260 | int flattenArray(const TSourceLoc& loc, const TVariable& variable, const TType&, TFlattenData&, TString name); |
steve-lunarg | e0b9deb | 2016-09-16 13:26:37 -0600 | [diff] [blame] | 261 | |
John Kessenich | bf47286 | 2017-02-05 20:27:30 -0700 | [diff] [blame] | 262 | bool hasUniform(const TQualifier& qualifier) const; |
| 263 | void clearUniform(TQualifier& qualifier); |
| 264 | bool isInputBuiltIn(const TQualifier& qualifier) const; |
| 265 | bool hasInput(const TQualifier& qualifier) const; |
| 266 | void correctOutput(TQualifier& qualifier); |
| 267 | bool isOutputBuiltIn(const TQualifier& qualifier) const; |
| 268 | bool hasOutput(const TQualifier& qualifier) const; |
| 269 | void correctInput(TQualifier& qualifier); |
| 270 | void correctUniform(TQualifier& qualifier); |
| 271 | void clearUniformInputOutput(TQualifier& qualifier); |
| 272 | |
steve-lunarg | 5da1f03 | 2017-02-12 17:50:28 -0700 | [diff] [blame] | 273 | // Test method names |
steve-lunarg | 5da1f03 | 2017-02-12 17:50:28 -0700 | [diff] [blame] | 274 | bool isStructBufferMethod(const TString& name) const; |
| 275 | |
steve-lunarg | dd8287a | 2017-02-23 18:04:12 -0700 | [diff] [blame] | 276 | TType* getStructBufferContentType(const TType& type) const; |
| 277 | bool isStructBufferType(const TType& type) const { return getStructBufferContentType(type) != nullptr; } |
| 278 | TIntermTyped* indexStructBufferContent(const TSourceLoc& loc, TIntermTyped* buffer) const; |
steve-lunarg | 8e26feb | 2017-04-10 08:19:21 -0600 | [diff] [blame] | 279 | TIntermTyped* getStructBufferCounter(const TSourceLoc& loc, TIntermTyped* buffer); |
steve-lunarg | dd8287a | 2017-02-23 18:04:12 -0700 | [diff] [blame] | 280 | |
| 281 | // Return true if this type is a reference. This is not currently a type method in case that's |
| 282 | // a language specific answer. |
| 283 | bool isReference(const TType& type) const { return isStructBufferType(type); } |
| 284 | |
steve-lunarg | 8e26feb | 2017-04-10 08:19:21 -0600 | [diff] [blame] | 285 | // Return true if this a buffer type that has an associated counter buffer. |
| 286 | bool hasStructBuffCounter(const TString& name) const; |
| 287 | |
| 288 | // Finalization step: remove unused buffer blocks from linkage (we don't know until the |
| 289 | // shader is entirely compiled) |
| 290 | void removeUnusedStructBufferCounters(); |
| 291 | |
steve-lunarg | 858c928 | 2017-01-07 08:54:10 -0700 | [diff] [blame] | 292 | // Pass through to base class after remembering builtin mappings. |
| 293 | using TParseContextBase::trackLinkage; |
| 294 | void trackLinkage(TSymbol& variable) override; |
| 295 | |
Alex Szpakowski | 7d39ad5 | 2017-01-08 17:54:48 -0400 | [diff] [blame] | 296 | void finish() override; // post-processing |
steve-lunarg | a2e7531 | 2016-12-14 15:22:25 -0700 | [diff] [blame] | 297 | |
steve-lunarg | e752f46 | 2017-03-22 18:39:25 -0600 | [diff] [blame] | 298 | // Linkage symbol helpers |
| 299 | TIntermSymbol* findLinkageSymbol(TBuiltInVariable biType) const; |
| 300 | |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 301 | // Current state of parsing |
| 302 | struct TPragma contextPragma; |
| 303 | int loopNestingLevel; // 0 if outside all loops |
John Kessenich | a1e2d49 | 2016-09-20 13:22:58 -0600 | [diff] [blame] | 304 | int annotationNestingLevel; // 0 if outside all annotations |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 305 | int structNestingLevel; // 0 if outside blocks and structures |
| 306 | int controlFlowNestingLevel; // 0 if outside all flow control |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 307 | TList<TIntermSequence*> switchSequenceStack; // case, node, case, case, node, ...; ensure only one node between cases; stack of them for nesting |
John Kessenich | 517fe7a | 2016-11-26 13:31:47 -0700 | [diff] [blame] | 308 | bool postEntryPointReturn; // if inside a function, true if the function is the entry point and this is after a return statement |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 309 | const TType* currentFunctionType; // the return type of the function that's currently being parsed |
| 310 | bool functionReturnsValue; // true if a non-void function has a return |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 311 | TBuiltInResource resources; |
| 312 | TLimits& limits; |
| 313 | |
| 314 | HlslParseContext(HlslParseContext&); |
| 315 | HlslParseContext& operator=(HlslParseContext&); |
| 316 | |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 317 | static const int maxSamplerIndex = EsdNumDims * (EbtNumTypes * (2 * 2 * 2)); // see computeSamplerTypeIndex() |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 318 | TQualifier globalBufferDefaults; |
| 319 | TQualifier globalUniformDefaults; |
| 320 | TQualifier globalInputDefaults; |
| 321 | TQualifier globalOutputDefaults; |
| 322 | TString currentCaller; // name of last function body entered (not valid when at global scope) |
| 323 | TIdSetType inductiveLoopIds; |
| 324 | TVector<TIntermTyped*> needsIndexLimitationChecking; |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 325 | |
| 326 | // |
| 327 | // Geometry shader input arrays: |
| 328 | // - array sizing is based on input primitive and/or explicit size |
| 329 | // |
| 330 | // Tessellation control output arrays: |
| 331 | // - array sizing is based on output layout(vertices=...) and/or explicit size |
| 332 | // |
| 333 | // Both: |
| 334 | // - array sizing is retroactive |
| 335 | // - built-in block redeclarations interact with this |
| 336 | // |
| 337 | // Design: |
| 338 | // - use a per-context "resize-list", a list of symbols whose array sizes |
| 339 | // can be fixed |
| 340 | // |
| 341 | // - the resize-list starts empty at beginning of user-shader compilation, it does |
| 342 | // not have built-ins in it |
| 343 | // |
| 344 | // - on built-in array use: copyUp() symbol and add it to the resize-list |
| 345 | // |
| 346 | // - on user array declaration: add it to the resize-list |
| 347 | // |
| 348 | // - on block redeclaration: copyUp() symbol and add it to the resize-list |
| 349 | // * note, that appropriately gives an error if redeclaring a block that |
| 350 | // was already used and hence already copied-up |
| 351 | // |
John Kessenich | ecba76f | 2017-01-06 00:34:48 -0700 | [diff] [blame] | 352 | // - on seeing a layout declaration that sizes the array, fix everything in the |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 353 | // resize-list, giving errors for mismatch |
| 354 | // |
| 355 | // - on seeing an array size declaration, give errors on mismatch between it and previous |
| 356 | // array-sizing declarations |
| 357 | // |
| 358 | TVector<TSymbol*> ioArraySymbolResizeList; |
John Kessenich | cd0a78a | 2016-09-09 16:32:09 -0600 | [diff] [blame] | 359 | |
steve-lunarg | a2b01a0 | 2016-11-28 17:09:54 -0700 | [diff] [blame] | 360 | TMap<int, TFlattenData> flattenMap; |
| 361 | TVector<int> flattenLevel; // nested postfix operator level for flattening |
| 362 | TVector<int> flattenOffset; // cumulative offset for flattening |
| 363 | |
John Kessenich | bf47286 | 2017-02-05 20:27:30 -0700 | [diff] [blame] | 364 | // IO-type map. Maps a pure symbol-table form of a structure-member list into |
| 365 | // each of the (up to) three kinds of IO, as each as different allowed decorations, |
| 366 | // but HLSL allows mixing all in the same structure. |
| 367 | struct tIoKinds { |
| 368 | TTypeList* input; |
| 369 | TTypeList* output; |
| 370 | TTypeList* uniform; |
| 371 | }; |
| 372 | TMap<const TTypeList*, tIoKinds> ioTypeMap; |
steve-lunarg | a2e7531 | 2016-12-14 15:22:25 -0700 | [diff] [blame] | 373 | |
| 374 | // Structure splitting data: |
steve-lunarg | 132d331 | 2016-12-19 15:48:01 -0700 | [diff] [blame] | 375 | TMap<int, TVariable*> splitIoVars; // variables with the builtin interstage IO removed, indexed by unique ID. |
| 376 | |
steve-lunarg | dd8287a | 2017-02-23 18:04:12 -0700 | [diff] [blame] | 377 | // Structuredbuffer shared types. Typically there are only a few. |
| 378 | TVector<TType*> structBufferTypes; |
steve-lunarg | 8e26feb | 2017-04-10 08:19:21 -0600 | [diff] [blame] | 379 | |
| 380 | TMap<TString, TBuiltInVariable> structBufferBuiltIn; |
| 381 | TMap<TString, bool> structBufferCounter; |
steve-lunarg | dd8287a | 2017-02-23 18:04:12 -0700 | [diff] [blame] | 382 | |
steve-lunarg | 132d331 | 2016-12-19 15:48:01 -0700 | [diff] [blame] | 383 | // The builtin interstage IO map considers e.g, EvqPosition on input and output separately, so that we |
| 384 | // can build the linkage correctly if position appears on both sides. Otherwise, multiple positions |
| 385 | // are considered identical. |
| 386 | struct tInterstageIoData { |
steve-lunarg | 858c928 | 2017-01-07 08:54:10 -0700 | [diff] [blame] | 387 | tInterstageIoData(TBuiltInVariable bi, TStorageQualifier q) : |
| 388 | builtIn(bi), storage(q) { } |
| 389 | |
steve-lunarg | 132d331 | 2016-12-19 15:48:01 -0700 | [diff] [blame] | 390 | tInterstageIoData(const TType& memberType, const TType& storageType) : |
| 391 | builtIn(memberType.getQualifier().builtIn), |
| 392 | storage(storageType.getQualifier().storage) { } |
| 393 | |
| 394 | TBuiltInVariable builtIn; |
| 395 | TStorageQualifier storage; |
| 396 | |
| 397 | // ordering for maps |
| 398 | bool operator<(const tInterstageIoData d) const { |
| 399 | return (builtIn != d.builtIn) ? (builtIn < d.builtIn) : (storage < d.storage); |
| 400 | } |
| 401 | }; |
| 402 | |
John Kessenich | bf47286 | 2017-02-05 20:27:30 -0700 | [diff] [blame] | 403 | TMap<tInterstageIoData, TVariable*> interstageBuiltInIo; // individual builtin interstage IO vars, indexed by builtin type. |
steve-lunarg | 067eb9b | 2017-04-01 15:34:48 -0600 | [diff] [blame] | 404 | TVariable* inputPatch; |
steve-lunarg | 132d331 | 2016-12-19 15:48:01 -0700 | [diff] [blame] | 405 | |
| 406 | // We have to move array references to structs containing builtin interstage IO to the split variables. |
| 407 | // This is only handled for one level. This stores the index, because we'll need it in the future, since |
| 408 | // unlike normal array references, here the index happens before we discover what it applies to. |
| 409 | TIntermTyped* builtInIoIndex; |
| 410 | TIntermTyped* builtInIoBase; |
steve-lunarg | a2e7531 | 2016-12-14 15:22:25 -0700 | [diff] [blame] | 411 | |
John Kessenich | 7dc630f | 2016-09-16 01:44:43 -0600 | [diff] [blame] | 412 | unsigned int nextInLocation; |
| 413 | unsigned int nextOutLocation; |
steve-lunarg | f1e0c87 | 2016-10-31 15:13:43 -0600 | [diff] [blame] | 414 | |
steve-lunarg | 858c928 | 2017-01-07 08:54:10 -0700 | [diff] [blame] | 415 | TString sourceEntryPointName; |
| 416 | TFunction* entryPointFunction; |
| 417 | TIntermNode* entryPointFunctionBody; |
| 418 | |
| 419 | TString patchConstantFunctionName; // hull shader patch constant function name, from function level attribute. |
| 420 | TMap<TBuiltInVariable, TSymbol*> builtInLinkageSymbols; // used for tessellation, finding declared builtins |
| 421 | |
John Kessenich | 3778979 | 2017-03-21 23:56:40 -0600 | [diff] [blame] | 422 | TVector<TString> currentTypePrefix; // current scoping prefix for nested structures |
| 423 | TVector<TVariable*> implicitThisStack; // currently active 'this' variables for nested structures |
steve-lunarg | 08e0c08 | 2017-03-29 20:01:13 -0600 | [diff] [blame] | 424 | |
| 425 | TVariable* gsStreamOutput; // geometry shader stream outputs, for emit (Append method) |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 426 | }; |
| 427 | |
steve-lunarg | e7d0752 | 2017-03-19 18:12:37 -0600 | [diff] [blame] | 428 | // This is the prefix we use for builtin methods to avoid namespace collisions with |
| 429 | // global scope user functions. |
| 430 | // TODO: this would be better as a nonparseable character, but that would |
| 431 | // require changing the scanner. |
| 432 | #define BUILTIN_PREFIX "__BI_" |
| 433 | |
John Kessenich | e01a9bc | 2016-03-12 20:11:22 -0700 | [diff] [blame] | 434 | } // end namespace glslang |
| 435 | |
| 436 | #endif // HLSL_PARSE_INCLUDED_ |