blob: ebeac0a1f81cb90d6ee40a4a26b8e94344d5a411 [file] [log] [blame]
John Kesseniche01a9bc2016-03-12 20:11:22 -07001//
John Kessenich927608b2017-01-06 12:34:14 -07002// Copyright (C) 2016 Google, Inc.
3// Copyright (C) 2016 LunarG, Inc.
John Kesseniche01a9bc2016-03-12 20:11:22 -07004//
John Kessenich927608b2017-01-06 12:34:14 -07005// All rights reserved.
John Kesseniche01a9bc2016-03-12 20:11:22 -07006//
John Kessenich927608b2017-01-06 12:34:14 -07007// Redistribution and use in source and binary forms, with or without
8// modification, are permitted provided that the following conditions
9// are met:
John Kesseniche01a9bc2016-03-12 20:11:22 -070010//
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 Kessenich927608b2017-01-06 12:34:14 -070023// 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 Kesseniche01a9bc2016-03-12 20:11:22 -070035//
36#ifndef HLSL_PARSE_INCLUDED_
37#define HLSL_PARSE_INCLUDED_
38
39#include "../glslang/MachineIndependent/parseVersions.h"
40#include "../glslang/MachineIndependent/ParseHelper.h"
41
42namespace glslang {
43
steve-lunarg1868b142016-10-20 13:07:10 -060044class TAttributeMap; // forward declare
45
John Kesseniche01a9bc2016-03-12 20:11:22 -070046class HlslParseContext : public TParseContextBase {
47public:
48 HlslParseContext(TSymbolTable&, TIntermediate&, bool parsingBuiltins,
John Kessenichb901ade2016-06-16 20:59:42 -060049 int version, EProfile, const SpvVersion& spvVersion, EShLanguage, TInfoSink&,
steve-lunargf1e0c872016-10-31 15:13:43 -060050 const TString sourceEntryPointName,
John Kesseniche01a9bc2016-03-12 20:11:22 -070051 bool forwardCompatible = false, EShMessages messages = EShMsgDefault);
52 virtual ~HlslParseContext();
Henrik Rydgård9a931b32016-12-21 12:48:08 +010053 void initializeExtensionBehavior() override;
LoopDawg62561462016-07-22 20:46:03 -060054
Henrik Rydgård9a931b32016-12-21 12:48:08 +010055 void setLimits(const TBuiltInResource&) override;
56 bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false) override;
57 virtual const char* getGlobalUniformBlockName() override { return "$Global"; }
John Kesseniche01a9bc2016-03-12 20:11:22 -070058
Henrik Rydgård9a931b32016-12-21 12:48:08 +010059 void reservedPpErrorCheck(const TSourceLoc&, const char* /*name*/, const char* /*op*/) override { }
60 bool lineContinuationCheck(const TSourceLoc&, bool /*endOfComment*/) override { return true; }
61 bool lineDirectiveShouldSetNextLine() const override { return true; }
John Kesseniche01a9bc2016-03-12 20:11:22 -070062 bool builtInName(const TString&);
63
Henrik Rydgård9a931b32016-12-21 12:48:08 +010064 void handlePragma(const TSourceLoc&, const TVector<TString>&) override;
John Kesseniche6e74942016-06-11 16:43:14 -060065 TIntermTyped* handleVariable(const TSourceLoc&, TSymbol* symbol, const TString* string);
John Kesseniche01a9bc2016-03-12 20:11:22 -070066 TIntermTyped* handleBracketDereference(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
steve-lunarg6b43d272016-10-06 20:12:24 -060067 TIntermTyped* handleBracketOperator(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
John Kesseniche01a9bc2016-03-12 20:11:22 -070068 void checkIndex(const TSourceLoc&, const TType&, int& index);
69
John Kesseniche01a9bc2016-03-12 20:11:22 -070070 TIntermTyped* handleBinaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right);
71 TIntermTyped* handleUnaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* childNode);
72 TIntermTyped* handleDotDereference(const TSourceLoc&, TIntermTyped* base, const TString& field);
John Kessenich7dc630f2016-09-16 01:44:43 -060073 void assignLocations(TVariable& variable);
John Kessenicha3051662016-09-02 19:13:36 -060074 TFunction& handleFunctionDeclarator(const TSourceLoc&, TFunction& function, bool prototype);
steve-lunarg1868b142016-10-20 13:07:10 -060075 TIntermAggregate* handleFunctionDefinition(const TSourceLoc&, TFunction&, const TAttributeMap&);
John Kessenicha3051662016-09-02 19:13:36 -060076 void handleFunctionBody(const TSourceLoc&, TFunction&, TIntermNode* functionBody, TIntermNode*& node);
John Kessenich6fccb3c2016-09-19 16:01:41 -060077 void remapEntryPointIO(TFunction& function);
78 void remapNonEntryPointIO(TFunction& function);
steve-lunargc4a13072016-08-09 11:28:03 -060079 TIntermNode* handleReturnValue(const TSourceLoc&, TIntermTyped*);
John Kessenich4678ca92016-05-13 09:33:42 -060080 void handleFunctionArgument(TFunction*, TIntermTyped*& arguments, TIntermTyped* newArg);
John Kessenichfdf63472017-01-13 12:27:52 -070081 TIntermTyped* handleAssign(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right);
82 TIntermTyped* handleAssignToMatrixSwizzle(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right);
steve-lunarg26d31452016-12-23 18:56:57 -070083 TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermTyped*);
LoopDawg592860c2016-06-09 08:57:35 -060084 void decomposeIntrinsic(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
LoopDawg4886f692016-06-29 10:58:58 -060085 void decomposeSampleMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
steve-lunargf49cdf42016-11-17 15:04:20 -070086 void decomposeGeometryMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
John Kesseniche01a9bc2016-03-12 20:11:22 -070087 TIntermTyped* handleLengthMethod(const TSourceLoc&, TFunction*, TIntermNode*);
steve-lunarg26d31452016-12-23 18:56:57 -070088 void addInputArgumentConversions(const TFunction&, TIntermTyped*&);
steve-lunargef33ec02016-11-02 12:42:34 -060089 TIntermTyped* addOutputArgumentConversions(const TFunction&, TIntermOperator&);
John Kesseniche01a9bc2016-03-12 20:11:22 -070090 void builtInOpCheck(const TSourceLoc&, const TFunction&, TIntermOperator&);
John Kessenichd016be12016-03-13 11:24:20 -060091 TFunction* handleConstructorCall(const TSourceLoc&, const TType&);
John Kessenich7735b942016-09-05 12:40:06 -060092 void handleSemantic(TSourceLoc, TQualifier&, const TString& semantic);
93 void handlePackOffset(const TSourceLoc&, TQualifier&, const glslang::TString& location,
John Kessenichb38f0712016-07-30 10:29:54 -060094 const glslang::TString* component);
John Kessenich7735b942016-09-05 12:40:06 -060095 void handleRegister(const TSourceLoc&, TQualifier&, const glslang::TString* profile, const glslang::TString& desc,
John Kessenichcfd7ce82016-09-05 16:03:12 -060096 int subComponent, const glslang::TString*);
John Kesseniche01a9bc2016-03-12 20:11:22 -070097
LoopDawga2b79912016-07-14 14:45:14 -060098 TIntermAggregate* handleSamplerTextureCombine(const TSourceLoc& loc, TIntermTyped* argTex, TIntermTyped* argSampler);
99
John Kesseniche01a9bc2016-03-12 20:11:22 -0700100 bool parseVectorFields(const TSourceLoc&, const TString&, int vecSize, TVectorFields&);
John Kessenich001dfa12017-01-12 16:51:18 -0700101 bool parseMatrixComponents(const TSourceLoc&, const TString&, int cols, int rows, TMatrixComponents&);
102 int getMatrixComponentsColumn(int rows, const TMatrixComponents&);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700103 void assignError(const TSourceLoc&, const char* op, TString left, TString right);
104 void unaryOpError(const TSourceLoc&, const char* op, TString operand);
105 void binaryOpError(const TSourceLoc&, const char* op, TString left, TString right);
106 void variableCheck(TIntermTyped*& nodePtr);
107 void constantValueCheck(TIntermTyped* node, const char* token);
108 void integerCheck(const TIntermTyped* node, const char* token);
109 void globalCheck(const TSourceLoc&, const char* token);
110 bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&);
111 bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&);
112 void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&);
113 void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&);
114 void structArrayCheck(const TSourceLoc&, const TType& structure);
115 void arrayDimMerge(TType& type, const TArraySizes* sizes);
116 bool voidErrorCheck(const TSourceLoc&, const TString&, TBasicType);
117 void boolCheck(const TSourceLoc&, const TIntermTyped*);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700118 void globalQualifierFix(const TSourceLoc&, TQualifier&);
119 bool structQualifierErrorCheck(const TSourceLoc&, const TPublicType& pType);
John Kessenich34e7ee72016-09-16 17:10:39 -0600120 void mergeQualifiers(TQualifier& dst, const TQualifier& src);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700121 int computeSamplerTypeIndex(TSampler&);
John Kessenichd3f11222016-11-05 10:15:53 -0600122 TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700123 void redeclareBuiltinBlock(const TSourceLoc&, TTypeList& typeList, const TString& blockName, const TString* instanceName, TArraySizes* arraySizes);
John Kessenich5aa59e22016-06-17 15:50:47 -0600124 void paramFix(TType& type);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700125 void specializationCheck(const TSourceLoc&, const TType&, const char* op);
126
John Kessenichb9e39122016-08-17 10:22:08 -0600127 void setLayoutQualifier(const TSourceLoc&, TQualifier&, TString&);
128 void setLayoutQualifier(const TSourceLoc&, TQualifier&, TString&, const TIntermTyped*);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700129 void mergeObjectLayoutQualifiers(TQualifier& dest, const TQualifier& src, bool inheritOnly);
130 void checkNoShaderLayouts(const TSourceLoc&, const TShaderQualifiers&);
131
steve-lunarg26d31452016-12-23 18:56:57 -0700132 const TFunction* findFunction(const TSourceLoc& loc, TFunction& call, bool& builtIn, TIntermTyped*& args);
John Kessenich5e69ec62016-07-05 00:02:40 -0600133 void declareTypedef(const TSourceLoc&, TString& identifier, const TType&, TArraySizes* typeArray = 0);
John Kesseniche82061d2016-09-27 14:38:57 -0600134 TIntermNode* declareVariable(const TSourceLoc&, TString& identifier, TType&, TIntermTyped* initializer = 0);
John Kessenich98ad4852016-11-27 17:39:07 -0700135 void lengthenList(const TSourceLoc&, TIntermSequence& list, int size);
John Kessenicha26a5172016-07-28 15:29:35 -0600136 TIntermTyped* addConstructor(const TSourceLoc&, TIntermNode*, const TType&);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700137 TIntermTyped* constructAggregate(TIntermNode*, const TType&, int, const TSourceLoc&);
138 TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset);
John Kessenich3d157c52016-07-25 16:05:33 -0600139 void declareBlock(const TSourceLoc&, TType&, const TString* instanceName = 0, TArraySizes* arraySizes = 0);
Henrik Rydgård9a931b32016-12-21 12:48:08 +0100140 void finalizeGlobalUniformBlockLayout(TVariable& block) override;
John Kesseniche01a9bc2016-03-12 20:11:22 -0700141 void fixBlockLocations(const TSourceLoc&, TQualifier&, TTypeList&, bool memberWithLocation, bool memberWithoutLocation);
142 void fixBlockXfbOffsets(TQualifier&, TTypeList&);
John Kessenich6dbc0a72016-09-27 19:13:05 -0600143 void fixBlockUniformOffsets(const TQualifier&, TTypeList&);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700144 void addQualifierToExisting(const TSourceLoc&, TQualifier, const TString& identifier);
145 void addQualifierToExisting(const TSourceLoc&, TQualifier, TIdentifierList&);
146 void updateStandaloneQualifierDefaults(const TSourceLoc&, const TPublicType&);
147 void wrapupSwitchSubsequence(TIntermAggregate* statements, TIntermNode* branchNode);
148 TIntermNode* addSwitch(const TSourceLoc&, TIntermTyped* expression, TIntermAggregate* body);
149
150 void updateImplicitArraySize(const TSourceLoc&, TIntermNode*, int index);
151
John Kessenicha1e2d492016-09-20 13:22:58 -0600152 void nestLooping() { ++loopNestingLevel; }
153 void unnestLooping() { --loopNestingLevel; }
154 void nestAnnotations() { ++annotationNestingLevel; }
155 void unnestAnnotations() { --annotationNestingLevel; }
John Kessenich6dbc0a72016-09-27 19:13:05 -0600156 int getAnnotationNestingLevel() { return annotationNestingLevel; }
John Kessenicha1e2d492016-09-20 13:22:58 -0600157 void pushScope() { symbolTable.push(); }
158 void popScope() { symbolTable.pop(0); }
John Kessenich0d2b6de2016-06-05 11:23:11 -0600159
John Kessenichd02dc5d2016-07-01 00:04:11 -0600160 void pushSwitchSequence(TIntermSequence* sequence) { switchSequenceStack.push_back(sequence); }
161 void popSwitchSequence() { switchSequenceStack.pop_back(); }
162
steve-lunarg90707962016-10-07 19:35:40 -0600163 // Apply L-value conversions. E.g, turning a write to a RWTexture into an ImageStore.
164 TIntermTyped* handleLvalue(const TSourceLoc&, const char* op, TIntermTyped* node);
steve-lunarg0de16da2016-10-08 10:54:52 -0600165 bool lValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*) override;
steve-lunarg90707962016-10-07 19:35:40 -0600166
steve-lunarg4f2da272016-10-10 15:24:57 -0600167 TLayoutFormat getLayoutFromTxType(const TSourceLoc&, const TType&);
168
steve-lunargf49cdf42016-11-17 15:04:20 -0700169 bool handleOutputGeometry(const TSourceLoc&, const TLayoutGeometry& geometry);
170 bool handleInputGeometry(const TSourceLoc&, const TLayoutGeometry& geometry);
171
steve-lunargf1e0c872016-10-31 15:13:43 -0600172 // Potentially rename shader entry point function
173 void renameShaderFunction(TString*& name) const;
174
steve-lunarga2b01a02016-11-28 17:09:54 -0700175 // Reset data for incrementally built referencing of flattened composite structures
176 void initFlattening() { flattenLevel.push_back(0); flattenOffset.push_back(0); }
177 void finalizeFlattening() { flattenLevel.pop_back(); flattenOffset.pop_back(); }
178
John Kesseniche01a9bc2016-03-12 20:11:22 -0700179protected:
steve-lunarga2b01a02016-11-28 17:09:54 -0700180 struct TFlattenData {
181 TFlattenData() : nextBinding(TQualifier::layoutBindingEnd) { }
182 TFlattenData(int nb) : nextBinding(nb) { }
183
184 TVector<TVariable*> members; // individual flattened variables
185 TVector<int> offsets; // offset to next tree level
186 int nextBinding; // next binding to use.
187 };
188
John Kessenichaa6d5622016-12-30 16:42:57 -0700189 void fixConstInit(const TSourceLoc&, TString& identifier, TType& type, TIntermTyped*& initializer);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700190 void inheritGlobalDefaults(TQualifier& dst) const;
191 TVariable* makeInternalVariable(const char* name, const TType&) const;
steve-lunarga2e75312016-12-14 15:22:25 -0700192 TVariable* makeInternalVariable(const TString& name, const TType& type) const {
193 return makeInternalVariable(name.c_str(), type);
194 }
steve-lunarga2b01a02016-11-28 17:09:54 -0700195 TVariable* declareNonArray(const TSourceLoc&, TString& identifier, TType&, bool track);
John Kessenichd3f11222016-11-05 10:15:53 -0600196 void declareArray(const TSourceLoc&, TString& identifier, const TType&, TSymbol*&, bool track);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700197 TIntermNode* executeInitializer(const TSourceLoc&, TIntermTyped* initializer, TVariable* variable);
198 TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer);
John Kessenich8ce6e2b2016-11-27 23:00:14 -0700199 bool isZeroConstructor(const TIntermNode*);
LoopDawg58910702016-06-13 09:22:28 -0600200 TOperator mapAtomicOp(const TSourceLoc& loc, TOperator op, bool isImage);
John Kesseniche01a9bc2016-03-12 20:11:22 -0700201
steve-lunarg90707962016-10-07 19:35:40 -0600202 // Return true if this node requires L-value conversion (e.g, to an imageStore).
203 bool shouldConvertLValue(const TIntermNode*) const;
204
steve-lunarge0b9deb2016-09-16 13:26:37 -0600205 // Array and struct flattening
steve-lunarga2b01a02016-11-28 17:09:54 -0700206 bool shouldFlatten(const TType& type) const;
steve-lunarga2e75312016-12-14 15:22:25 -0700207 TIntermTyped* flattenAccess(TIntermTyped* base, int member);
steve-lunarge0b9deb2016-09-16 13:26:37 -0600208 bool shouldFlattenIO(const TType&) const;
209 bool shouldFlattenUniform(const TType&) const;
steve-lunarga2b01a02016-11-28 17:09:54 -0700210 bool wasFlattened(const TIntermTyped* node) const;
211 bool wasFlattened(int id) const { return flattenMap.find(id) != flattenMap.end(); }
212 int addFlattenedMember(const TSourceLoc& loc, const TVariable&, const TType&, TFlattenData&, const TString& name, bool track);
213 bool isFinalFlattening(const TType& type) const { return !(type.isStruct() || type.isArray()); }
214
steve-lunarga2e75312016-12-14 15:22:25 -0700215 // Structure splitting (splits interstage builtin types into its own struct)
steve-lunarg132d3312016-12-19 15:48:01 -0700216 bool shouldSplit(const TType&);
217 TIntermTyped* splitAccessStruct(const TSourceLoc& loc, TIntermTyped*& base, int& member);
218 void splitAccessArray(const TSourceLoc& loc, TIntermTyped* base, TIntermTyped* index);
219 TType& split(TType& type, TString name, const TType* outerStructType = nullptr);
steve-lunarga2e75312016-12-14 15:22:25 -0700220 void split(TIntermTyped*);
221 void split(const TVariable&);
222 bool wasSplit(const TIntermTyped* node) const;
223 bool wasSplit(int id) const { return splitIoVars.find(id) != splitIoVars.end(); }
224 TVariable* getSplitIoVar(const TIntermTyped* node) const;
225 TVariable* getSplitIoVar(const TVariable* var) const;
226 TVariable* getSplitIoVar(int id) const;
227 void addInterstageIoToLinkage();
228
steve-lunarge0b9deb2016-09-16 13:26:37 -0600229 void flatten(const TSourceLoc& loc, const TVariable& variable);
steve-lunarga2b01a02016-11-28 17:09:54 -0700230 int flatten(const TSourceLoc& loc, const TVariable& variable, const TType&, TFlattenData&, TString name);
231 int flattenStruct(const TSourceLoc& loc, const TVariable& variable, const TType&, TFlattenData&, TString name);
232 int flattenArray(const TSourceLoc& loc, const TVariable& variable, const TType&, TFlattenData&, TString name);
steve-lunarge0b9deb2016-09-16 13:26:37 -0600233
steve-lunarga2e75312016-12-14 15:22:25 -0700234 // Type sanitization: return existing sanitized (temporary) type if there is one, else make new one.
235 TType* sanitizeType(TType*);
236
Alex Szpakowski7d39ad52017-01-08 17:54:48 -0400237 void finish() override; // post-processing
steve-lunarga2e75312016-12-14 15:22:25 -0700238
John Kesseniche01a9bc2016-03-12 20:11:22 -0700239 // Current state of parsing
240 struct TPragma contextPragma;
241 int loopNestingLevel; // 0 if outside all loops
John Kessenicha1e2d492016-09-20 13:22:58 -0600242 int annotationNestingLevel; // 0 if outside all annotations
John Kesseniche01a9bc2016-03-12 20:11:22 -0700243 int structNestingLevel; // 0 if outside blocks and structures
244 int controlFlowNestingLevel; // 0 if outside all flow control
John Kesseniche01a9bc2016-03-12 20:11:22 -0700245 TList<TIntermSequence*> switchSequenceStack; // case, node, case, case, node, ...; ensure only one node between cases; stack of them for nesting
John Kessenich6fccb3c2016-09-19 16:01:41 -0600246 bool inEntryPoint; // if inside a function, true if the function is the entry point
John Kessenich517fe7a2016-11-26 13:31:47 -0700247 bool postEntryPointReturn; // if inside a function, true if the function is the entry point and this is after a return statement
John Kesseniche01a9bc2016-03-12 20:11:22 -0700248 const TType* currentFunctionType; // the return type of the function that's currently being parsed
249 bool functionReturnsValue; // true if a non-void function has a return
John Kesseniche01a9bc2016-03-12 20:11:22 -0700250 TBuiltInResource resources;
251 TLimits& limits;
252
253 HlslParseContext(HlslParseContext&);
254 HlslParseContext& operator=(HlslParseContext&);
255
John Kesseniche01a9bc2016-03-12 20:11:22 -0700256 static const int maxSamplerIndex = EsdNumDims * (EbtNumTypes * (2 * 2 * 2)); // see computeSamplerTypeIndex()
John Kesseniche01a9bc2016-03-12 20:11:22 -0700257 TQualifier globalBufferDefaults;
258 TQualifier globalUniformDefaults;
259 TQualifier globalInputDefaults;
260 TQualifier globalOutputDefaults;
261 TString currentCaller; // name of last function body entered (not valid when at global scope)
262 TIdSetType inductiveLoopIds;
263 TVector<TIntermTyped*> needsIndexLimitationChecking;
John Kessenich6a70eb72016-08-28 15:00:23 -0600264 TVariable* entryPointOutput;
John Kesseniche01a9bc2016-03-12 20:11:22 -0700265
266 //
267 // Geometry shader input arrays:
268 // - array sizing is based on input primitive and/or explicit size
269 //
270 // Tessellation control output arrays:
271 // - array sizing is based on output layout(vertices=...) and/or explicit size
272 //
273 // Both:
274 // - array sizing is retroactive
275 // - built-in block redeclarations interact with this
276 //
277 // Design:
278 // - use a per-context "resize-list", a list of symbols whose array sizes
279 // can be fixed
280 //
281 // - the resize-list starts empty at beginning of user-shader compilation, it does
282 // not have built-ins in it
283 //
284 // - on built-in array use: copyUp() symbol and add it to the resize-list
285 //
286 // - on user array declaration: add it to the resize-list
287 //
288 // - on block redeclaration: copyUp() symbol and add it to the resize-list
289 // * note, that appropriately gives an error if redeclaring a block that
290 // was already used and hence already copied-up
291 //
John Kessenichecba76f2017-01-06 00:34:48 -0700292 // - on seeing a layout declaration that sizes the array, fix everything in the
John Kesseniche01a9bc2016-03-12 20:11:22 -0700293 // resize-list, giving errors for mismatch
294 //
295 // - on seeing an array size declaration, give errors on mismatch between it and previous
296 // array-sizing declarations
297 //
298 TVector<TSymbol*> ioArraySymbolResizeList;
John Kessenichcd0a78a2016-09-09 16:32:09 -0600299
steve-lunarga2b01a02016-11-28 17:09:54 -0700300 TMap<int, TFlattenData> flattenMap;
301 TVector<int> flattenLevel; // nested postfix operator level for flattening
302 TVector<int> flattenOffset; // cumulative offset for flattening
303
steve-lunarga2e75312016-12-14 15:22:25 -0700304 // Sanitized type map. During declarations we use the sanitized form of the type
305 // if it exists.
306 TMap<const TTypeList*, TType*> sanitizedTypeMap;
307
308 // Structure splitting data:
steve-lunarg132d3312016-12-19 15:48:01 -0700309 TMap<int, TVariable*> splitIoVars; // variables with the builtin interstage IO removed, indexed by unique ID.
310
311 // The builtin interstage IO map considers e.g, EvqPosition on input and output separately, so that we
312 // can build the linkage correctly if position appears on both sides. Otherwise, multiple positions
313 // are considered identical.
314 struct tInterstageIoData {
315 tInterstageIoData(const TType& memberType, const TType& storageType) :
316 builtIn(memberType.getQualifier().builtIn),
317 storage(storageType.getQualifier().storage) { }
318
319 TBuiltInVariable builtIn;
320 TStorageQualifier storage;
321
322 // ordering for maps
323 bool operator<(const tInterstageIoData d) const {
324 return (builtIn != d.builtIn) ? (builtIn < d.builtIn) : (storage < d.storage);
325 }
326 };
327
328 TMap<tInterstageIoData, TVariable*> interstageBuiltInIo; // individual builtin interstage IO vars, inxed by builtin type.
329
330 // We have to move array references to structs containing builtin interstage IO to the split variables.
331 // This is only handled for one level. This stores the index, because we'll need it in the future, since
332 // unlike normal array references, here the index happens before we discover what it applies to.
333 TIntermTyped* builtInIoIndex;
334 TIntermTyped* builtInIoBase;
steve-lunarga2e75312016-12-14 15:22:25 -0700335
John Kessenich7dc630f2016-09-16 01:44:43 -0600336 unsigned int nextInLocation;
337 unsigned int nextOutLocation;
steve-lunargf1e0c872016-10-31 15:13:43 -0600338
339 TString sourceEntryPointName;
John Kesseniche01a9bc2016-03-12 20:11:22 -0700340};
341
342} // end namespace glslang
343
344#endif // HLSL_PARSE_INCLUDED_