blob: 813f18ba5598ce31f1b5816c9f0f7429edda1077 [file] [log] [blame]
John Bauman66b8ab22014-05-06 15:57:45 -04001//
John Baumand4ae8632014-05-06 16:18:33 -04002// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
John Bauman66b8ab22014-05-06 15:57:45 -04003// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//
6
7#ifndef _SYMBOL_TABLE_INCLUDED_
8#define _SYMBOL_TABLE_INCLUDED_
9
10//
11// Symbol table for parsing. Has these design characteristics:
12//
13// * Same symbol table can be used to compile many shaders, to preserve
14// effort of creating and loading with the large numbers of built-in
15// symbols.
16//
17// * Name mangling will be used to give each function a unique name
18// so that symbol table lookups are never ambiguous. This allows
19// a simpler symbol table structure.
20//
21// * Pushing and popping of scope, so symbol table will really be a stack
22// of symbol tables. Searched from the top, with new inserts going into
23// the top.
24//
25// * Constants: Compile time constant symbols will keep their values
26// in the symbol table. The parser can substitute constants at parse
27// time, including doing constant folding and constant propagation.
28//
29// * No temporaries: Temporaries made from operations (+, --, .xy, etc.)
30// are tracked in the intermediate representation, not the symbol table.
31//
32
33#include <assert.h>
34
Nicolas Capenscc863da2015-01-21 15:50:55 -050035#include "InfoSink.h"
36#include "intermediate.h"
John Bauman66b8ab22014-05-06 15:57:45 -040037
38//
39// Symbol base class. (Can build functions or variables out of these...)
40//
Nicolas Capens0a7f0c22015-02-18 14:47:31 -050041class TSymbol
42{
John Bauman66b8ab22014-05-06 15:57:45 -040043public:
Nicolas Capens978ddc52014-11-11 12:42:08 -050044 POOL_ALLOCATOR_NEW_DELETE();
John Bauman66b8ab22014-05-06 15:57:45 -040045 TSymbol(const TString *n) : name(n) { }
46 virtual ~TSymbol() { /* don't delete name, it's from the pool */ }
Nicolas Capens978ddc52014-11-11 12:42:08 -050047
John Bauman66b8ab22014-05-06 15:57:45 -040048 const TString& getName() const { return *name; }
49 virtual const TString& getMangledName() const { return getName(); }
50 virtual bool isFunction() const { return false; }
51 virtual bool isVariable() const { return false; }
52 void setUniqueId(int id) { uniqueId = id; }
53 int getUniqueId() const { return uniqueId; }
John Bauman66b8ab22014-05-06 15:57:45 -040054 TSymbol(const TSymbol&);
John Bauman66b8ab22014-05-06 15:57:45 -040055
56protected:
57 const TString *name;
58 unsigned int uniqueId; // For real comparing during code generation
59};
60
61//
62// Variable class, meaning a symbol that's not a function.
63//
64// There could be a separate class heirarchy for Constant variables;
65// Only one of int, bool, or float, (or none) is correct for
66// any particular use, but it's easy to do this way, and doesn't
67// seem worth having separate classes, and "getConst" can't simply return
68// different values for different types polymorphically, so this is
69// just simple and pragmatic.
70//
Nicolas Capens0a7f0c22015-02-18 14:47:31 -050071class TVariable : public TSymbol
72{
John Bauman66b8ab22014-05-06 15:57:45 -040073public:
74 TVariable(const TString *name, const TType& t, bool uT = false ) : TSymbol(name), type(t), userType(uT), unionArray(0), arrayInformationType(0) { }
75 virtual ~TVariable() { }
76 virtual bool isVariable() const { return true; }
77 TType& getType() { return type; }
78 const TType& getType() const { return type; }
79 bool isUserType() const { return userType; }
80 void setQualifier(TQualifier qualifier) { type.setQualifier(qualifier); }
81 void updateArrayInformationType(TType *t) { arrayInformationType = t; }
82 TType* getArrayInformationType() { return arrayInformationType; }
83
John Bauman66b8ab22014-05-06 15:57:45 -040084 ConstantUnion* getConstPointer()
85 {
86 if (!unionArray)
87 unionArray = new ConstantUnion[type.getObjectSize()];
88
89 return unionArray;
90 }
91
92 ConstantUnion* getConstPointer() const { return unionArray; }
93
94 void shareConstPointer( ConstantUnion *constArray)
95 {
96 if (unionArray == constArray)
97 return;
98
99 delete[] unionArray;
100 unionArray = constArray;
101 }
John Bauman66b8ab22014-05-06 15:57:45 -0400102
103protected:
104 TType type;
105 bool userType;
106 // we are assuming that Pool Allocator will free the memory allocated to unionArray
107 // when this object is destroyed
108 ConstantUnion *unionArray;
109 TType *arrayInformationType; // this is used for updating maxArraySize in all the references to a given symbol
110};
111
112//
113// The function sub-class of symbols and the parser will need to
114// share this definition of a function parameter.
115//
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500116struct TParameter
117{
John Bauman66b8ab22014-05-06 15:57:45 -0400118 TString *name;
John Baumand4ae8632014-05-06 16:18:33 -0400119 TType *type;
John Bauman66b8ab22014-05-06 15:57:45 -0400120};
121
122//
123// The function sub-class of a symbol.
124//
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500125class TFunction : public TSymbol
126{
John Bauman66b8ab22014-05-06 15:57:45 -0400127public:
128 TFunction(TOperator o) :
129 TSymbol(0),
130 returnType(TType(EbtVoid, EbpUndefined)),
131 op(o),
132 defined(false) { }
133 TFunction(const TString *name, TType& retType, TOperator tOp = EOpNull) :
134 TSymbol(name),
135 returnType(retType),
136 mangledName(TFunction::mangleName(*name)),
137 op(tOp),
138 defined(false) { }
139 virtual ~TFunction();
140 virtual bool isFunction() const { return true; }
141
142 static TString mangleName(const TString& name) { return name + '('; }
143 static TString unmangleName(const TString& mangledName)
144 {
145 return TString(mangledName.c_str(), mangledName.find_first_of('('));
146 }
147
148 void addParameter(TParameter& p)
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500149 {
John Bauman66b8ab22014-05-06 15:57:45 -0400150 parameters.push_back(p);
151 mangledName = mangledName + p.type->getMangledName();
152 }
153
154 const TString& getMangledName() const { return mangledName; }
155 const TType& getReturnType() const { return returnType; }
156
157 void relateToOperator(TOperator o) { op = o; }
158 TOperator getBuiltInOp() const { return op; }
159
160 void relateToExtension(const TString& ext) { extension = ext; }
161 const TString& getExtension() const { return extension; }
162
163 void setDefined() { defined = true; }
164 bool isDefined() { return defined; }
165
166 int getParamCount() const { return static_cast<int>(parameters.size()); }
167 const TParameter& getParam(int i) const { return parameters[i]; }
168
John Bauman66b8ab22014-05-06 15:57:45 -0400169protected:
170 typedef TVector<TParameter> TParamList;
171 TParamList parameters;
172 TType returnType;
173 TString mangledName;
174 TOperator op;
175 TString extension;
176 bool defined;
177};
178
179
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500180class TSymbolTableLevel
181{
John Bauman66b8ab22014-05-06 15:57:45 -0400182public:
183 typedef TMap<TString, TSymbol*> tLevel;
184 typedef tLevel::const_iterator const_iterator;
185 typedef const tLevel::value_type tLevelPair;
186 typedef std::pair<tLevel::iterator, bool> tInsertResult;
187
Nicolas Capens978ddc52014-11-11 12:42:08 -0500188 POOL_ALLOCATOR_NEW_DELETE();
John Bauman66b8ab22014-05-06 15:57:45 -0400189 TSymbolTableLevel() { }
190 ~TSymbolTableLevel();
191
John Baumand4ae8632014-05-06 16:18:33 -0400192 bool insert(TSymbol &symbol)
John Bauman66b8ab22014-05-06 15:57:45 -0400193 {
John Baumand4ae8632014-05-06 16:18:33 -0400194 symbol.setUniqueId(++uniqueId);
195
John Bauman66b8ab22014-05-06 15:57:45 -0400196 //
197 // returning true means symbol was added to the table
198 //
199 tInsertResult result;
200 result = level.insert(tLevelPair(symbol.getMangledName(), &symbol));
201
202 return result.second;
203 }
204
205 TSymbol* find(const TString& name) const
206 {
207 tLevel::const_iterator it = level.find(name);
208 if (it == level.end())
209 return 0;
210 else
211 return (*it).second;
212 }
213
John Bauman66b8ab22014-05-06 15:57:45 -0400214 void relateToOperator(const char* name, TOperator op);
215 void relateToExtension(const char* name, const TString& ext);
John Bauman66b8ab22014-05-06 15:57:45 -0400216
217protected:
218 tLevel level;
John Baumand4ae8632014-05-06 16:18:33 -0400219 static int uniqueId; // for unique identification in code generation
John Bauman66b8ab22014-05-06 15:57:45 -0400220};
221
Nicolas Capense2858652015-02-18 15:30:51 -0500222enum ESymbolLevel
223{
Nicolas Capens3d7f6ed2015-02-18 16:34:50 -0500224 COMMON_BUILTINS,
225 ESSL1_BUILTINS,
226 ESSL3_BUILTINS,
227 LAST_BUILTIN_LEVEL = ESSL3_BUILTINS,
228 GLOBAL_LEVEL
Nicolas Capense2858652015-02-18 15:30:51 -0500229};
230
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500231class TSymbolTable
232{
John Bauman66b8ab22014-05-06 15:57:45 -0400233public:
John Baumand4ae8632014-05-06 16:18:33 -0400234 TSymbolTable()
John Bauman66b8ab22014-05-06 15:57:45 -0400235 {
236 //
237 // The symbol table cannot be used until push() is called, but
238 // the lack of an initial call to push() can be used to detect
239 // that the symbol table has not been preloaded with built-ins.
240 //
241 }
242
243 ~TSymbolTable()
244 {
Nicolas Capense2858652015-02-18 15:30:51 -0500245 while(currentLevel() > LAST_BUILTIN_LEVEL)
246 {
247 pop();
248 }
John Bauman66b8ab22014-05-06 15:57:45 -0400249 }
250
Nicolas Capense2858652015-02-18 15:30:51 -0500251 bool isEmpty() { return table.empty(); }
252 bool atBuiltInLevel() { return currentLevel() <= LAST_BUILTIN_LEVEL; }
253 bool atGlobalLevel() { return currentLevel() <= GLOBAL_LEVEL; }
John Bauman66b8ab22014-05-06 15:57:45 -0400254 void push()
255 {
256 table.push_back(new TSymbolTableLevel);
257 precisionStack.push_back( PrecisionStackLevel() );
258 }
259
260 void pop()
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500261 {
262 delete table[currentLevel()];
263 table.pop_back();
John Bauman66b8ab22014-05-06 15:57:45 -0400264 precisionStack.pop_back();
265 }
266
Nicolas Capensd603ecd2015-02-18 14:52:21 -0500267 bool declare(TSymbol &symbol)
John Bauman66b8ab22014-05-06 15:57:45 -0400268 {
Nicolas Capensd603ecd2015-02-18 14:52:21 -0500269 return insert(currentLevel(), symbol);
270 }
271
Nicolas Capense2858652015-02-18 15:30:51 -0500272 bool insert(ESymbolLevel level, TSymbol &symbol)
Nicolas Capensd603ecd2015-02-18 14:52:21 -0500273 {
274 return table[level]->insert(symbol);
John Bauman66b8ab22014-05-06 15:57:45 -0400275 }
276
Nicolas Capense2858652015-02-18 15:30:51 -0500277 bool insertConstInt(ESymbolLevel level, const char *name, int value)
John Baumand4ae8632014-05-06 16:18:33 -0400278 {
279 TVariable *constant = new TVariable(NewPoolTString(name), TType(EbtInt, EbpUndefined, EvqConst, 1));
280 constant->getConstPointer()->setIConst(value);
Nicolas Capense2858652015-02-18 15:30:51 -0500281 return insert(level, *constant);
John Baumand4ae8632014-05-06 16:18:33 -0400282 }
283
Nicolas Capensf8a4cba2015-02-18 17:30:46 -0500284 void insertBuiltIn(ESymbolLevel level, TType *rvalue, const char *name, TType *ptype1, TType *ptype2 = 0, TType *ptype3 = 0, TType *ptype4 = 0)
John Baumand4ae8632014-05-06 16:18:33 -0400285 {
Nicolas Capensf8a4cba2015-02-18 17:30:46 -0500286 if(ptype1->getBasicType() == EbtGSampler2D)
287 {
288 bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
289 insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2D), ptype2, ptype3, ptype4);
290 insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2D), ptype2, ptype3, ptype4);
291 insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2D), ptype2, ptype3, ptype4);
292 return;
293 }
294 else if(ptype1->getBasicType() == EbtGSampler3D)
295 {
296 bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
297 insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler3D), ptype2, ptype3, ptype4);
298 insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler3D), ptype2, ptype3, ptype4);
299 insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler3D), ptype2, ptype3, ptype4);
300 return;
301 }
302 else if(ptype1->getBasicType() == EbtGSamplerCube)
303 {
304 bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
305 insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSamplerCube), ptype2, ptype3, ptype4);
306 insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISamplerCube), ptype2, ptype3, ptype4);
307 insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSamplerCube), ptype2, ptype3, ptype4);
308 return;
309 }
310 else if(ptype1->getBasicType() == EbtGSampler2DArray)
311 {
312 bool gvec4 = (rvalue->getBasicType() == EbtGVec4);
313 insertBuiltIn(level, gvec4 ? new TType(EbtFloat, 4) : rvalue, name, new TType(EbtSampler2DArray), ptype2, ptype3, ptype4);
314 insertBuiltIn(level, gvec4 ? new TType(EbtInt, 4) : rvalue, name, new TType(EbtISampler2DArray), ptype2, ptype3, ptype4);
315 insertBuiltIn(level, gvec4 ? new TType(EbtUInt, 4) : rvalue, name, new TType(EbtUSampler2DArray), ptype2, ptype3, ptype4);
316 return;
317 }
318
John Baumand4ae8632014-05-06 16:18:33 -0400319 TFunction *function = new TFunction(NewPoolTString(name), *rvalue);
320
Nicolas Capens434311c2014-05-28 19:23:55 -0400321 TParameter param1 = {0, ptype1};
John Baumand4ae8632014-05-06 16:18:33 -0400322 function->addParameter(param1);
323
Nicolas Capens434311c2014-05-28 19:23:55 -0400324 if(ptype2)
John Baumand4ae8632014-05-06 16:18:33 -0400325 {
Nicolas Capens434311c2014-05-28 19:23:55 -0400326 TParameter param2 = {0, ptype2};
John Baumand4ae8632014-05-06 16:18:33 -0400327 function->addParameter(param2);
328 }
329
Nicolas Capens434311c2014-05-28 19:23:55 -0400330 if(ptype3)
John Baumand4ae8632014-05-06 16:18:33 -0400331 {
Nicolas Capens434311c2014-05-28 19:23:55 -0400332 TParameter param3 = {0, ptype3};
John Baumand4ae8632014-05-06 16:18:33 -0400333 function->addParameter(param3);
334 }
335
Nicolas Capensf8a4cba2015-02-18 17:30:46 -0500336 insert(level, *function);
John Bauman66b8ab22014-05-06 15:57:45 -0400337 }
338
Nicolas Capense2858652015-02-18 15:30:51 -0500339 TSymbol *find(const TString &name, int shaderVersion, bool *builtIn = false, bool *sameScope = false) const;
340 TSymbol *findBuiltIn(const TString &name, int shaderVersion) const;
John Bauman66b8ab22014-05-06 15:57:45 -0400341
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500342 TSymbolTableLevel *getOuterLevel() const
343 {
Nicolas Capense2858652015-02-18 15:30:51 -0500344 assert(currentLevel() >= 1);
John Bauman66b8ab22014-05-06 15:57:45 -0400345 return table[currentLevel() - 1];
346 }
347
Nicolas Capense2858652015-02-18 15:30:51 -0500348 void relateToOperator(ESymbolLevel level, const char *name, TOperator op)
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500349 {
Nicolas Capense2858652015-02-18 15:30:51 -0500350 table[level]->relateToOperator(name, op);
John Bauman66b8ab22014-05-06 15:57:45 -0400351 }
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500352
Nicolas Capense2858652015-02-18 15:30:51 -0500353 void relateToExtension(ESymbolLevel level, const char *name, const TString &ext)
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500354 {
Nicolas Capense2858652015-02-18 15:30:51 -0500355 table[level]->relateToExtension(name, ext);
John Bauman66b8ab22014-05-06 15:57:45 -0400356 }
John Bauman66b8ab22014-05-06 15:57:45 -0400357
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500358 bool setDefaultPrecision(const TPublicType &type, TPrecision prec)
359 {
John Baumand4ae8632014-05-06 16:18:33 -0400360 if (IsSampler(type.type))
361 return true; // Skip sampler types for the time being
362 if (type.type != EbtFloat && type.type != EbtInt)
363 return false; // Only set default precision for int/float
364 if (type.size != 1 || type.matrix || type.array)
365 return false; // Not allowed to set for aggregate types
John Bauman66b8ab22014-05-06 15:57:45 -0400366 int indexOfLastElement = static_cast<int>(precisionStack.size()) - 1;
John Baumand4ae8632014-05-06 16:18:33 -0400367 precisionStack[indexOfLastElement][type.type] = prec; // Uses map operator [], overwrites the current value
368 return true;
John Bauman66b8ab22014-05-06 15:57:45 -0400369 }
370
371 // Searches down the precisionStack for a precision qualifier for the specified TBasicType
Nicolas Capens3c20f802015-02-17 17:17:20 -0500372 TPrecision getDefaultPrecision( TBasicType type)
373 {
374 // unsigned integers use the same precision as signed
375 if (type == EbtUInt) type = EbtInt;
376
John Bauman66b8ab22014-05-06 15:57:45 -0400377 if( type != EbtFloat && type != EbtInt ) return EbpUndefined;
378 int level = static_cast<int>(precisionStack.size()) - 1;
379 assert( level >= 0); // Just to be safe. Should not happen.
380 PrecisionStackLevel::iterator it;
381 TPrecision prec = EbpUndefined; // If we dont find anything we return this. Should we error check this?
382 while( level >= 0 ){
383 it = precisionStack[level].find( type );
384 if( it != precisionStack[level].end() ){
385 prec = (*it).second;
386 break;
387 }
388 level--;
389 }
390 return prec;
391 }
392
Nicolas Capens0a7f0c22015-02-18 14:47:31 -0500393protected:
Nicolas Capense2858652015-02-18 15:30:51 -0500394 ESymbolLevel currentLevel() const { return static_cast<ESymbolLevel>(table.size() - 1); }
John Bauman66b8ab22014-05-06 15:57:45 -0400395
396 std::vector<TSymbolTableLevel*> table;
397 typedef std::map< TBasicType, TPrecision > PrecisionStackLevel;
398 std::vector< PrecisionStackLevel > precisionStack;
John Bauman66b8ab22014-05-06 15:57:45 -0400399};
400
401#endif // _SYMBOL_TABLE_INCLUDED_