daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1 | // |
shannonwoods@chromium.org | 96e7ba1 | 2013-05-30 00:02:41 +0000 | [diff] [blame] | 2 | // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved. |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 3 | // Use of this source code is governed by a BSD-style license that can be |
| 4 | // found in the LICENSE file. |
| 5 | // |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 6 | // Symbol table for parsing. The design principles and most of the functionality are documented in |
| 7 | // the header file. |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 8 | // |
| 9 | |
apatrick@chromium.org | e057c5d | 2012-01-26 19:18:24 +0000 | [diff] [blame] | 10 | #if defined(_MSC_VER) |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 11 | #pragma warning(disable : 4718) |
apatrick@chromium.org | e057c5d | 2012-01-26 19:18:24 +0000 | [diff] [blame] | 12 | #endif |
| 13 | |
Geoff Lang | 1773282 | 2013-08-29 13:46:49 -0400 | [diff] [blame] | 14 | #include "compiler/translator/SymbolTable.h" |
Olli Etuaho | 01d0ad0 | 2017-01-22 14:51:23 -0800 | [diff] [blame] | 15 | |
Olli Etuaho | 01d0ad0 | 2017-01-22 14:51:23 -0800 | [diff] [blame] | 16 | #include "compiler/translator/IntermNode.h" |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 17 | #include "compiler/translator/StaticType.h" |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 18 | |
apatrick@chromium.org | 8187fa8 | 2010-06-15 22:09:28 +0000 | [diff] [blame] | 19 | #include <stdio.h> |
kbr@chromium.org | 476541f | 2011-10-27 21:14:51 +0000 | [diff] [blame] | 20 | #include <algorithm> |
| 21 | |
Jamie Madill | 45bcc78 | 2016-11-07 13:58:48 -0500 | [diff] [blame] | 22 | namespace sh |
| 23 | { |
| 24 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 25 | // |
| 26 | // Symbol table levels are a map of pointers to symbols that have to be deleted. |
| 27 | // |
| 28 | TSymbolTableLevel::~TSymbolTableLevel() |
| 29 | { |
daniel@transgaming.com | 0578f81 | 2010-05-17 09:58:39 +0000 | [diff] [blame] | 30 | for (tLevel::iterator it = level.begin(); it != level.end(); ++it) |
| 31 | delete (*it).second; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 32 | } |
| 33 | |
Nicolas Capens | adfffe4 | 2014-06-17 02:13:36 -0400 | [diff] [blame] | 34 | bool TSymbolTableLevel::insert(TSymbol *symbol) |
Jamie Madill | bfa91f4 | 2014-06-05 15:45:18 -0400 | [diff] [blame] | 35 | { |
Jamie Madill | bfa91f4 | 2014-06-05 15:45:18 -0400 | [diff] [blame] | 36 | // returning true means symbol was added to the table |
Nicolas Capens | adfffe4 | 2014-06-17 02:13:36 -0400 | [diff] [blame] | 37 | tInsertResult result = level.insert(tLevelPair(symbol->getMangledName(), symbol)); |
Jamie Madill | bfa91f4 | 2014-06-05 15:45:18 -0400 | [diff] [blame] | 38 | |
| 39 | return result.second; |
| 40 | } |
| 41 | |
Olli Etuaho | b2983c9 | 2015-03-18 14:02:46 +0200 | [diff] [blame] | 42 | bool TSymbolTableLevel::insertUnmangled(TFunction *function) |
| 43 | { |
Olli Etuaho | b2983c9 | 2015-03-18 14:02:46 +0200 | [diff] [blame] | 44 | // returning true means symbol was added to the table |
Olli Etuaho | bed35d7 | 2017-12-20 16:36:26 +0200 | [diff] [blame^] | 45 | tInsertResult result = level.insert(tLevelPair(function->name(), function)); |
Olli Etuaho | b2983c9 | 2015-03-18 14:02:46 +0200 | [diff] [blame] | 46 | |
| 47 | return result.second; |
| 48 | } |
| 49 | |
Jamie Madill | bfa91f4 | 2014-06-05 15:45:18 -0400 | [diff] [blame] | 50 | TSymbol *TSymbolTableLevel::find(const TString &name) const |
| 51 | { |
| 52 | tLevel::const_iterator it = level.find(name); |
| 53 | if (it == level.end()) |
| 54 | return 0; |
| 55 | else |
| 56 | return (*it).second; |
| 57 | } |
| 58 | |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 59 | TSymbol *TSymbolTable::find(const TString &name, |
| 60 | int shaderVersion, |
| 61 | bool *builtIn, |
| 62 | bool *sameScope) const |
shannonwoods@chromium.org | 96e7ba1 | 2013-05-30 00:02:41 +0000 | [diff] [blame] | 63 | { |
| 64 | int level = currentLevel(); |
| 65 | TSymbol *symbol; |
| 66 | |
| 67 | do |
| 68 | { |
Olli Etuaho | 977ee7e | 2017-07-21 11:38:27 +0300 | [diff] [blame] | 69 | if (level == GLSL_BUILTINS) |
| 70 | level--; |
Martin Radev | e93d24e | 2016-07-28 12:06:05 +0300 | [diff] [blame] | 71 | if (level == ESSL3_1_BUILTINS && shaderVersion != 310) |
| 72 | level--; |
| 73 | if (level == ESSL3_BUILTINS && shaderVersion < 300) |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 74 | level--; |
| 75 | if (level == ESSL1_BUILTINS && shaderVersion != 100) |
| 76 | level--; |
shannonwoods@chromium.org | 96e7ba1 | 2013-05-30 00:02:41 +0000 | [diff] [blame] | 77 | |
| 78 | symbol = table[level]->find(name); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 79 | } while (symbol == 0 && --level >= 0); |
shannonwoods@chromium.org | 96e7ba1 | 2013-05-30 00:02:41 +0000 | [diff] [blame] | 80 | |
| 81 | if (builtIn) |
| 82 | *builtIn = (level <= LAST_BUILTIN_LEVEL); |
| 83 | if (sameScope) |
| 84 | *sameScope = (level == currentLevel()); |
| 85 | |
| 86 | return symbol; |
| 87 | } |
| 88 | |
Zhenyao Mo | d749096 | 2016-11-09 15:49:51 -0800 | [diff] [blame] | 89 | TSymbol *TSymbolTable::findGlobal(const TString &name) const |
| 90 | { |
| 91 | ASSERT(table.size() > GLOBAL_LEVEL); |
| 92 | return table[GLOBAL_LEVEL]->find(name); |
| 93 | } |
| 94 | |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 95 | TSymbol *TSymbolTable::findBuiltIn(const TString &name, int shaderVersion) const |
shannonwoods@chromium.org | 96e7ba1 | 2013-05-30 00:02:41 +0000 | [diff] [blame] | 96 | { |
Olli Etuaho | 977ee7e | 2017-07-21 11:38:27 +0300 | [diff] [blame] | 97 | return findBuiltIn(name, shaderVersion, false); |
| 98 | } |
| 99 | |
| 100 | TSymbol *TSymbolTable::findBuiltIn(const TString &name, |
| 101 | int shaderVersion, |
| 102 | bool includeGLSLBuiltins) const |
| 103 | { |
shannonwoods@chromium.org | 96e7ba1 | 2013-05-30 00:02:41 +0000 | [diff] [blame] | 104 | for (int level = LAST_BUILTIN_LEVEL; level >= 0; level--) |
| 105 | { |
Olli Etuaho | 977ee7e | 2017-07-21 11:38:27 +0300 | [diff] [blame] | 106 | if (level == GLSL_BUILTINS && !includeGLSLBuiltins) |
| 107 | level--; |
Martin Radev | e93d24e | 2016-07-28 12:06:05 +0300 | [diff] [blame] | 108 | if (level == ESSL3_1_BUILTINS && shaderVersion != 310) |
| 109 | level--; |
| 110 | if (level == ESSL3_BUILTINS && shaderVersion < 300) |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 111 | level--; |
| 112 | if (level == ESSL1_BUILTINS && shaderVersion != 100) |
| 113 | level--; |
shannonwoods@chromium.org | 96e7ba1 | 2013-05-30 00:02:41 +0000 | [diff] [blame] | 114 | |
| 115 | TSymbol *symbol = table[level]->find(name); |
| 116 | |
| 117 | if (symbol) |
| 118 | return symbol; |
| 119 | } |
| 120 | |
Olli Etuaho | 977ee7e | 2017-07-21 11:38:27 +0300 | [diff] [blame] | 121 | return nullptr; |
shannonwoods@chromium.org | 96e7ba1 | 2013-05-30 00:02:41 +0000 | [diff] [blame] | 122 | } |
Alok Priyadarshi | bc3f1ac | 2013-09-23 14:57:02 -0400 | [diff] [blame] | 123 | |
| 124 | TSymbolTable::~TSymbolTable() |
| 125 | { |
| 126 | while (table.size() > 0) |
| 127 | pop(); |
| 128 | } |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 129 | |
Kai Ninomiya | 030017a | 2017-12-06 14:06:53 -0800 | [diff] [blame] | 130 | constexpr bool IsGenType(const TType *type) |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 131 | { |
| 132 | if (type) |
| 133 | { |
| 134 | TBasicType basicType = type->getBasicType(); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 135 | return basicType == EbtGenType || basicType == EbtGenIType || basicType == EbtGenUType || |
| 136 | basicType == EbtGenBType; |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 137 | } |
| 138 | |
| 139 | return false; |
| 140 | } |
| 141 | |
Kai Ninomiya | 030017a | 2017-12-06 14:06:53 -0800 | [diff] [blame] | 142 | constexpr bool IsVecType(const TType *type) |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 143 | { |
| 144 | if (type) |
| 145 | { |
| 146 | TBasicType basicType = type->getBasicType(); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 147 | return basicType == EbtVec || basicType == EbtIVec || basicType == EbtUVec || |
| 148 | basicType == EbtBVec; |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 149 | } |
| 150 | |
| 151 | return false; |
| 152 | } |
| 153 | |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 154 | constexpr const TType *SpecificType(const TType *type, int size) |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 155 | { |
| 156 | ASSERT(size >= 1 && size <= 4); |
| 157 | |
| 158 | if (!type) |
| 159 | { |
| 160 | return nullptr; |
| 161 | } |
| 162 | |
| 163 | ASSERT(!IsVecType(type)); |
| 164 | |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 165 | switch (type->getBasicType()) |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 166 | { |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 167 | case EbtGenType: |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 168 | return StaticType::GetForVec<EbtFloat>(type->getQualifier(), |
| 169 | static_cast<unsigned char>(size)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 170 | case EbtGenIType: |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 171 | return StaticType::GetForVec<EbtInt>(type->getQualifier(), |
| 172 | static_cast<unsigned char>(size)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 173 | case EbtGenUType: |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 174 | return StaticType::GetForVec<EbtUInt>(type->getQualifier(), |
| 175 | static_cast<unsigned char>(size)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 176 | case EbtGenBType: |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 177 | return StaticType::GetForVec<EbtBool>(type->getQualifier(), |
| 178 | static_cast<unsigned char>(size)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 179 | default: |
| 180 | return type; |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 181 | } |
| 182 | } |
| 183 | |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 184 | constexpr const TType *VectorType(const TType *type, int size) |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 185 | { |
| 186 | ASSERT(size >= 2 && size <= 4); |
| 187 | |
| 188 | if (!type) |
| 189 | { |
| 190 | return nullptr; |
| 191 | } |
| 192 | |
| 193 | ASSERT(!IsGenType(type)); |
| 194 | |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 195 | switch (type->getBasicType()) |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 196 | { |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 197 | case EbtVec: |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 198 | return StaticType::GetForVecMat<EbtFloat>(static_cast<unsigned char>(size)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 199 | case EbtIVec: |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 200 | return StaticType::GetForVecMat<EbtInt>(static_cast<unsigned char>(size)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 201 | case EbtUVec: |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 202 | return StaticType::GetForVecMat<EbtUInt>(static_cast<unsigned char>(size)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 203 | case EbtBVec: |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 204 | return StaticType::GetForVecMat<EbtBool>(static_cast<unsigned char>(size)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 205 | default: |
| 206 | return type; |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 207 | } |
| 208 | } |
| 209 | |
Olli Etuaho | 195be94 | 2017-12-04 23:40:14 +0200 | [diff] [blame] | 210 | bool TSymbolTable::declareVariable(TVariable *variable) |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 211 | { |
Olli Etuaho | 195be94 | 2017-12-04 23:40:14 +0200 | [diff] [blame] | 212 | ASSERT(variable->symbolType() == SymbolType::UserDefined); |
| 213 | return insertVariable(currentLevel(), variable); |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 214 | } |
| 215 | |
Olli Etuaho | 035419f | 2017-11-28 14:27:15 +0200 | [diff] [blame] | 216 | bool TSymbolTable::declareStructType(TStructure *str) |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 217 | { |
| 218 | return insertStructType(currentLevel(), str); |
| 219 | } |
| 220 | |
Olli Etuaho | 378c3a5 | 2017-12-04 11:32:13 +0200 | [diff] [blame] | 221 | bool TSymbolTable::declareInterfaceBlock(TInterfaceBlock *interfaceBlock) |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 222 | { |
Olli Etuaho | 378c3a5 | 2017-12-04 11:32:13 +0200 | [diff] [blame] | 223 | return insert(currentLevel(), interfaceBlock); |
Jiawei Shao | d8105a0 | 2017-08-08 09:54:36 +0800 | [diff] [blame] | 224 | } |
| 225 | |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 226 | TVariable *TSymbolTable::insertVariable(ESymbolLevel level, const char *name, const TType &type) |
| 227 | { |
Olli Etuaho | 9d4d7f0 | 2017-12-07 17:11:41 +0100 | [diff] [blame] | 228 | ASSERT(level <= LAST_BUILTIN_LEVEL); |
| 229 | return insertVariable(level, NewPoolTString(name), type, SymbolType::BuiltIn); |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 230 | } |
| 231 | |
Olli Etuaho | 9d4d7f0 | 2017-12-07 17:11:41 +0100 | [diff] [blame] | 232 | TVariable *TSymbolTable::insertVariable(ESymbolLevel level, |
| 233 | const TString *name, |
| 234 | const TType &type, |
| 235 | SymbolType symbolType) |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 236 | { |
Olli Etuaho | 9d4d7f0 | 2017-12-07 17:11:41 +0100 | [diff] [blame] | 237 | TVariable *var = new TVariable(this, name, type, symbolType); |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 238 | if (insert(level, var)) |
| 239 | { |
| 240 | // Do lazy initialization for struct types, so we allocate to the current scope. |
| 241 | if (var->getType().getBasicType() == EbtStruct) |
| 242 | { |
| 243 | var->getType().realize(); |
| 244 | } |
| 245 | return var; |
| 246 | } |
| 247 | return nullptr; |
| 248 | } |
| 249 | |
| 250 | TVariable *TSymbolTable::insertVariableExt(ESymbolLevel level, |
Olli Etuaho | 2a1e8f9 | 2017-07-14 11:49:36 +0300 | [diff] [blame] | 251 | TExtension ext, |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 252 | const char *name, |
| 253 | const TType &type) |
| 254 | { |
Olli Etuaho | 9d4d7f0 | 2017-12-07 17:11:41 +0100 | [diff] [blame] | 255 | TVariable *var = new TVariable(this, NewPoolTString(name), type, SymbolType::BuiltIn, ext); |
Olli Etuaho | 5d69db1 | 2017-11-24 16:51:15 +0200 | [diff] [blame] | 256 | if (insert(level, var)) |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 257 | { |
| 258 | if (var->getType().getBasicType() == EbtStruct) |
| 259 | { |
| 260 | var->getType().realize(); |
| 261 | } |
| 262 | return var; |
| 263 | } |
| 264 | return nullptr; |
| 265 | } |
| 266 | |
Olli Etuaho | 195be94 | 2017-12-04 23:40:14 +0200 | [diff] [blame] | 267 | bool TSymbolTable::insertVariable(ESymbolLevel level, TVariable *variable) |
| 268 | { |
| 269 | ASSERT(variable); |
| 270 | return insert(level, variable); |
| 271 | } |
| 272 | |
Olli Etuaho | 035419f | 2017-11-28 14:27:15 +0200 | [diff] [blame] | 273 | bool TSymbolTable::insertStructType(ESymbolLevel level, TStructure *str) |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 274 | { |
Olli Etuaho | 035419f | 2017-11-28 14:27:15 +0200 | [diff] [blame] | 275 | ASSERT(str); |
Olli Etuaho | 378c3a5 | 2017-12-04 11:32:13 +0200 | [diff] [blame] | 276 | return insert(level, str); |
| 277 | } |
| 278 | |
| 279 | bool TSymbolTable::insertInterfaceBlock(ESymbolLevel level, TInterfaceBlock *interfaceBlock) |
| 280 | { |
| 281 | ASSERT(interfaceBlock); |
| 282 | return insert(level, interfaceBlock); |
Olli Etuaho | 0f68463 | 2017-07-13 12:42:15 +0300 | [diff] [blame] | 283 | } |
| 284 | |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 285 | void TSymbolTable::insertBuiltIn(ESymbolLevel level, |
| 286 | TOperator op, |
Olli Etuaho | 2a1e8f9 | 2017-07-14 11:49:36 +0300 | [diff] [blame] | 287 | TExtension ext, |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 288 | const TType *rvalue, |
| 289 | const char *name, |
| 290 | const TType *ptype1, |
| 291 | const TType *ptype2, |
| 292 | const TType *ptype3, |
| 293 | const TType *ptype4, |
| 294 | const TType *ptype5) |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 295 | { |
| 296 | if (ptype1->getBasicType() == EbtGSampler2D) |
| 297 | { |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 298 | insertUnmangledBuiltInName(name, level); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 299 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 300 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtFloat, 4>() : rvalue, name, |
| 301 | StaticType::GetBasic<EbtSampler2D>(), ptype2, ptype3, ptype4, ptype5); |
| 302 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtInt, 4>() : rvalue, name, |
| 303 | StaticType::GetBasic<EbtISampler2D>(), ptype2, ptype3, ptype4, ptype5); |
| 304 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtUInt, 4>() : rvalue, name, |
| 305 | StaticType::GetBasic<EbtUSampler2D>(), ptype2, ptype3, ptype4, ptype5); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 306 | } |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 307 | else if (ptype1->getBasicType() == EbtGSampler3D) |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 308 | { |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 309 | insertUnmangledBuiltInName(name, level); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 310 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 311 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtFloat, 4>() : rvalue, name, |
| 312 | StaticType::GetBasic<EbtSampler3D>(), ptype2, ptype3, ptype4, ptype5); |
| 313 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtInt, 4>() : rvalue, name, |
| 314 | StaticType::GetBasic<EbtISampler3D>(), ptype2, ptype3, ptype4, ptype5); |
| 315 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtUInt, 4>() : rvalue, name, |
| 316 | StaticType::GetBasic<EbtUSampler3D>(), ptype2, ptype3, ptype4, ptype5); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 317 | } |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 318 | else if (ptype1->getBasicType() == EbtGSamplerCube) |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 319 | { |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 320 | insertUnmangledBuiltInName(name, level); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 321 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 322 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtFloat, 4>() : rvalue, name, |
| 323 | StaticType::GetBasic<EbtSamplerCube>(), ptype2, ptype3, ptype4, ptype5); |
| 324 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtInt, 4>() : rvalue, name, |
| 325 | StaticType::GetBasic<EbtISamplerCube>(), ptype2, ptype3, ptype4, ptype5); |
| 326 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtUInt, 4>() : rvalue, name, |
| 327 | StaticType::GetBasic<EbtUSamplerCube>(), ptype2, ptype3, ptype4, ptype5); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 328 | } |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 329 | else if (ptype1->getBasicType() == EbtGSampler2DArray) |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 330 | { |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 331 | insertUnmangledBuiltInName(name, level); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 332 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 333 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtFloat, 4>() : rvalue, name, |
| 334 | StaticType::GetBasic<EbtSampler2DArray>(), ptype2, ptype3, ptype4, |
| 335 | ptype5); |
| 336 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtInt, 4>() : rvalue, name, |
| 337 | StaticType::GetBasic<EbtISampler2DArray>(), ptype2, ptype3, ptype4, |
| 338 | ptype5); |
| 339 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtUInt, 4>() : rvalue, name, |
| 340 | StaticType::GetBasic<EbtUSampler2DArray>(), ptype2, ptype3, ptype4, |
| 341 | ptype5); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 342 | } |
JiangYizhou | 4021932 | 2016-12-09 09:50:51 +0800 | [diff] [blame] | 343 | else if (ptype1->getBasicType() == EbtGSampler2DMS) |
| 344 | { |
| 345 | insertUnmangledBuiltInName(name, level); |
| 346 | bool gvec4 = (rvalue->getBasicType() == EbtGVec4); |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 347 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtFloat, 4>() : rvalue, name, |
| 348 | StaticType::GetBasic<EbtSampler2DMS>(), ptype2, ptype3, ptype4, ptype5); |
| 349 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtInt, 4>() : rvalue, name, |
| 350 | StaticType::GetBasic<EbtISampler2DMS>(), ptype2, ptype3, ptype4, ptype5); |
| 351 | insertBuiltIn(level, gvec4 ? StaticType::GetBasic<EbtUInt, 4>() : rvalue, name, |
| 352 | StaticType::GetBasic<EbtUSampler2DMS>(), ptype2, ptype3, ptype4, ptype5); |
JiangYizhou | 4021932 | 2016-12-09 09:50:51 +0800 | [diff] [blame] | 353 | } |
Martin Radev | 2cc85b3 | 2016-08-05 16:22:53 +0300 | [diff] [blame] | 354 | else if (IsGImage(ptype1->getBasicType())) |
| 355 | { |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 356 | insertUnmangledBuiltInName(name, level); |
Martin Radev | 2cc85b3 | 2016-08-05 16:22:53 +0300 | [diff] [blame] | 357 | |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 358 | const TType *floatType = StaticType::GetBasic<EbtFloat, 4>(); |
| 359 | const TType *intType = StaticType::GetBasic<EbtInt, 4>(); |
| 360 | const TType *unsignedType = StaticType::GetBasic<EbtUInt, 4>(); |
Martin Radev | 2cc85b3 | 2016-08-05 16:22:53 +0300 | [diff] [blame] | 361 | |
Kai Ninomiya | 614dd0f | 2017-11-22 14:04:48 -0800 | [diff] [blame] | 362 | const TType *floatImage = StaticType::GetForFloatImage(ptype1->getBasicType()); |
| 363 | const TType *intImage = StaticType::GetForIntImage(ptype1->getBasicType()); |
| 364 | const TType *unsignedImage = StaticType::GetForUintImage(ptype1->getBasicType()); |
Martin Radev | 2cc85b3 | 2016-08-05 16:22:53 +0300 | [diff] [blame] | 365 | |
| 366 | // GLSL ES 3.10, Revision 4, 8.12 Image Functions |
| 367 | if (rvalue->getBasicType() == EbtGVec4) |
| 368 | { |
| 369 | // imageLoad |
| 370 | insertBuiltIn(level, floatType, name, floatImage, ptype2, ptype3, ptype4, ptype5); |
| 371 | insertBuiltIn(level, intType, name, intImage, ptype2, ptype3, ptype4, ptype5); |
| 372 | insertBuiltIn(level, unsignedType, name, unsignedImage, ptype2, ptype3, ptype4, ptype5); |
| 373 | } |
| 374 | else if (rvalue->getBasicType() == EbtVoid) |
| 375 | { |
| 376 | // imageStore |
| 377 | insertBuiltIn(level, rvalue, name, floatImage, ptype2, floatType, ptype4, ptype5); |
| 378 | insertBuiltIn(level, rvalue, name, intImage, ptype2, intType, ptype4, ptype5); |
| 379 | insertBuiltIn(level, rvalue, name, unsignedImage, ptype2, unsignedType, ptype4, ptype5); |
| 380 | } |
| 381 | else |
| 382 | { |
| 383 | // imageSize |
| 384 | insertBuiltIn(level, rvalue, name, floatImage, ptype2, ptype3, ptype4, ptype5); |
| 385 | insertBuiltIn(level, rvalue, name, intImage, ptype2, ptype3, ptype4, ptype5); |
| 386 | insertBuiltIn(level, rvalue, name, unsignedImage, ptype2, ptype3, ptype4, ptype5); |
| 387 | } |
| 388 | } |
Olli Etuaho | 9250cb2 | 2017-01-21 10:51:27 +0000 | [diff] [blame] | 389 | else if (IsGenType(rvalue) || IsGenType(ptype1) || IsGenType(ptype2) || IsGenType(ptype3) || |
| 390 | IsGenType(ptype4)) |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 391 | { |
Olli Etuaho | 9250cb2 | 2017-01-21 10:51:27 +0000 | [diff] [blame] | 392 | ASSERT(!ptype5); |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 393 | insertUnmangledBuiltInName(name, level); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 394 | insertBuiltIn(level, op, ext, SpecificType(rvalue, 1), name, SpecificType(ptype1, 1), |
Olli Etuaho | 9250cb2 | 2017-01-21 10:51:27 +0000 | [diff] [blame] | 395 | SpecificType(ptype2, 1), SpecificType(ptype3, 1), SpecificType(ptype4, 1)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 396 | insertBuiltIn(level, op, ext, SpecificType(rvalue, 2), name, SpecificType(ptype1, 2), |
Olli Etuaho | 9250cb2 | 2017-01-21 10:51:27 +0000 | [diff] [blame] | 397 | SpecificType(ptype2, 2), SpecificType(ptype3, 2), SpecificType(ptype4, 2)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 398 | insertBuiltIn(level, op, ext, SpecificType(rvalue, 3), name, SpecificType(ptype1, 3), |
Olli Etuaho | 9250cb2 | 2017-01-21 10:51:27 +0000 | [diff] [blame] | 399 | SpecificType(ptype2, 3), SpecificType(ptype3, 3), SpecificType(ptype4, 3)); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 400 | insertBuiltIn(level, op, ext, SpecificType(rvalue, 4), name, SpecificType(ptype1, 4), |
Olli Etuaho | 9250cb2 | 2017-01-21 10:51:27 +0000 | [diff] [blame] | 401 | SpecificType(ptype2, 4), SpecificType(ptype3, 4), SpecificType(ptype4, 4)); |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 402 | } |
| 403 | else if (IsVecType(rvalue) || IsVecType(ptype1) || IsVecType(ptype2) || IsVecType(ptype3)) |
| 404 | { |
| 405 | ASSERT(!ptype4 && !ptype5); |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 406 | insertUnmangledBuiltInName(name, level); |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 407 | insertBuiltIn(level, op, ext, VectorType(rvalue, 2), name, VectorType(ptype1, 2), |
| 408 | VectorType(ptype2, 2), VectorType(ptype3, 2)); |
| 409 | insertBuiltIn(level, op, ext, VectorType(rvalue, 3), name, VectorType(ptype1, 3), |
| 410 | VectorType(ptype2, 3), VectorType(ptype3, 3)); |
| 411 | insertBuiltIn(level, op, ext, VectorType(rvalue, 4), name, VectorType(ptype1, 4), |
| 412 | VectorType(ptype2, 4), VectorType(ptype3, 4)); |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 413 | } |
| 414 | else |
| 415 | { |
Olli Etuaho | 9d4d7f0 | 2017-12-07 17:11:41 +0100 | [diff] [blame] | 416 | TFunction *function = |
Olli Etuaho | 0c37100 | 2017-12-13 17:00:25 +0400 | [diff] [blame] | 417 | new TFunction(this, NewPoolTString(name), rvalue, SymbolType::BuiltIn, false, op, ext); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 418 | |
Dmitry Skiba | efa3d8e | 2015-06-22 14:52:10 -0700 | [diff] [blame] | 419 | function->addParameter(TConstParameter(ptype1)); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 420 | |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 421 | if (ptype2) |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 422 | { |
Dmitry Skiba | efa3d8e | 2015-06-22 14:52:10 -0700 | [diff] [blame] | 423 | function->addParameter(TConstParameter(ptype2)); |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 424 | } |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 425 | |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 426 | if (ptype3) |
| 427 | { |
Dmitry Skiba | efa3d8e | 2015-06-22 14:52:10 -0700 | [diff] [blame] | 428 | function->addParameter(TConstParameter(ptype3)); |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 429 | } |
| 430 | |
| 431 | if (ptype4) |
| 432 | { |
Dmitry Skiba | efa3d8e | 2015-06-22 14:52:10 -0700 | [diff] [blame] | 433 | function->addParameter(TConstParameter(ptype4)); |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 434 | } |
| 435 | |
| 436 | if (ptype5) |
| 437 | { |
Dmitry Skiba | efa3d8e | 2015-06-22 14:52:10 -0700 | [diff] [blame] | 438 | function->addParameter(TConstParameter(ptype5)); |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 439 | } |
| 440 | |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 441 | ASSERT(hasUnmangledBuiltInAtLevel(name, level)); |
Nicolas Capens | f3cc4ae | 2015-02-23 13:51:25 -0500 | [diff] [blame] | 442 | insert(level, function); |
| 443 | } |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 444 | } |
| 445 | |
Olli Etuaho | 492cfab | 2017-01-20 21:18:29 +0000 | [diff] [blame] | 446 | void TSymbolTable::insertBuiltInOp(ESymbolLevel level, |
| 447 | TOperator op, |
| 448 | const TType *rvalue, |
| 449 | const TType *ptype1, |
| 450 | const TType *ptype2, |
| 451 | const TType *ptype3, |
| 452 | const TType *ptype4, |
| 453 | const TType *ptype5) |
| 454 | { |
| 455 | const char *name = GetOperatorString(op); |
| 456 | ASSERT(strlen(name) > 0); |
| 457 | insertUnmangledBuiltInName(name, level); |
Olli Etuaho | 2a1e8f9 | 2017-07-14 11:49:36 +0300 | [diff] [blame] | 458 | insertBuiltIn(level, op, TExtension::UNDEFINED, rvalue, name, ptype1, ptype2, ptype3, ptype4, |
| 459 | ptype5); |
Olli Etuaho | 492cfab | 2017-01-20 21:18:29 +0000 | [diff] [blame] | 460 | } |
| 461 | |
| 462 | void TSymbolTable::insertBuiltInOp(ESymbolLevel level, |
| 463 | TOperator op, |
Olli Etuaho | 2a1e8f9 | 2017-07-14 11:49:36 +0300 | [diff] [blame] | 464 | TExtension ext, |
Olli Etuaho | 492cfab | 2017-01-20 21:18:29 +0000 | [diff] [blame] | 465 | const TType *rvalue, |
| 466 | const TType *ptype1, |
| 467 | const TType *ptype2, |
| 468 | const TType *ptype3, |
| 469 | const TType *ptype4, |
| 470 | const TType *ptype5) |
| 471 | { |
| 472 | const char *name = GetOperatorString(op); |
| 473 | insertUnmangledBuiltInName(name, level); |
| 474 | insertBuiltIn(level, op, ext, rvalue, name, ptype1, ptype2, ptype3, ptype4, ptype5); |
| 475 | } |
| 476 | |
Martin Radev | d7c5b0a | 2016-07-27 14:04:43 +0300 | [diff] [blame] | 477 | void TSymbolTable::insertBuiltInFunctionNoParameters(ESymbolLevel level, |
| 478 | TOperator op, |
| 479 | const TType *rvalue, |
| 480 | const char *name) |
| 481 | { |
| 482 | insertUnmangledBuiltInName(name, level); |
Olli Etuaho | 0c37100 | 2017-12-13 17:00:25 +0400 | [diff] [blame] | 483 | insert(level, |
| 484 | new TFunction(this, NewPoolTString(name), rvalue, SymbolType::BuiltIn, false, op)); |
Martin Radev | d7c5b0a | 2016-07-27 14:04:43 +0300 | [diff] [blame] | 485 | } |
| 486 | |
Jiawei Shao | d27f5c8 | 2017-08-23 09:38:08 +0800 | [diff] [blame] | 487 | void TSymbolTable::insertBuiltInFunctionNoParametersExt(ESymbolLevel level, |
Olli Etuaho | 2a1e8f9 | 2017-07-14 11:49:36 +0300 | [diff] [blame] | 488 | TExtension ext, |
Jiawei Shao | d27f5c8 | 2017-08-23 09:38:08 +0800 | [diff] [blame] | 489 | TOperator op, |
| 490 | const TType *rvalue, |
| 491 | const char *name) |
| 492 | { |
| 493 | insertUnmangledBuiltInName(name, level); |
Olli Etuaho | 0c37100 | 2017-12-13 17:00:25 +0400 | [diff] [blame] | 494 | insert(level, |
| 495 | new TFunction(this, NewPoolTString(name), rvalue, SymbolType::BuiltIn, false, op, ext)); |
Jiawei Shao | d27f5c8 | 2017-08-23 09:38:08 +0800 | [diff] [blame] | 496 | } |
| 497 | |
Zhenyao Mo | e740add | 2014-07-18 17:01:01 -0700 | [diff] [blame] | 498 | TPrecision TSymbolTable::getDefaultPrecision(TBasicType type) const |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 499 | { |
| 500 | if (!SupportsPrecision(type)) |
| 501 | return EbpUndefined; |
| 502 | |
| 503 | // unsigned integers use the same precision as signed |
| 504 | TBasicType baseType = (type == EbtUInt) ? EbtInt : type; |
| 505 | |
| 506 | int level = static_cast<int>(precisionStack.size()) - 1; |
Jamie Madill | d7b1ab5 | 2016-12-12 14:42:19 -0500 | [diff] [blame] | 507 | assert(level >= 0); // Just to be safe. Should not happen. |
Olli Etuaho | 183d7e2 | 2015-11-20 15:59:09 +0200 | [diff] [blame] | 508 | // If we dont find anything we return this. Some types don't have predefined default precision. |
Zhenyao Mo | 9eedea0 | 2014-05-12 16:02:35 -0700 | [diff] [blame] | 509 | TPrecision prec = EbpUndefined; |
| 510 | while (level >= 0) |
| 511 | { |
| 512 | PrecisionStackLevel::iterator it = precisionStack[level]->find(baseType); |
| 513 | if (it != precisionStack[level]->end()) |
| 514 | { |
| 515 | prec = (*it).second; |
| 516 | break; |
| 517 | } |
| 518 | level--; |
| 519 | } |
| 520 | return prec; |
| 521 | } |
Jamie Madill | 45bcc78 | 2016-11-07 13:58:48 -0500 | [diff] [blame] | 522 | |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 523 | void TSymbolTable::insertUnmangledBuiltInName(const char *name, ESymbolLevel level) |
| 524 | { |
| 525 | ASSERT(level >= 0 && level < static_cast<ESymbolLevel>(table.size())); |
Olli Etuaho | 5d69db1 | 2017-11-24 16:51:15 +0200 | [diff] [blame] | 526 | ASSERT(mUserDefinedUniqueIdsStart == -1); |
Martin Radev | da6254b | 2016-12-14 17:00:36 +0200 | [diff] [blame] | 527 | table[level]->insertUnmangledBuiltInName(std::string(name)); |
| 528 | } |
| 529 | |
| 530 | bool TSymbolTable::hasUnmangledBuiltInAtLevel(const char *name, ESymbolLevel level) |
| 531 | { |
| 532 | ASSERT(level >= 0 && level < static_cast<ESymbolLevel>(table.size())); |
| 533 | return table[level]->hasUnmangledBuiltIn(std::string(name)); |
| 534 | } |
| 535 | |
| 536 | bool TSymbolTable::hasUnmangledBuiltInForShaderVersion(const char *name, int shaderVersion) |
| 537 | { |
| 538 | ASSERT(static_cast<ESymbolLevel>(table.size()) > LAST_BUILTIN_LEVEL); |
| 539 | |
| 540 | for (int level = LAST_BUILTIN_LEVEL; level >= 0; --level) |
| 541 | { |
| 542 | if (level == ESSL3_1_BUILTINS && shaderVersion != 310) |
| 543 | { |
| 544 | --level; |
| 545 | } |
| 546 | if (level == ESSL3_BUILTINS && shaderVersion < 300) |
| 547 | { |
| 548 | --level; |
| 549 | } |
| 550 | if (level == ESSL1_BUILTINS && shaderVersion != 100) |
| 551 | { |
| 552 | --level; |
| 553 | } |
| 554 | |
| 555 | if (table[level]->hasUnmangledBuiltIn(name)) |
| 556 | { |
| 557 | return true; |
| 558 | } |
| 559 | } |
| 560 | return false; |
| 561 | } |
| 562 | |
Olli Etuaho | 5d69db1 | 2017-11-24 16:51:15 +0200 | [diff] [blame] | 563 | void TSymbolTable::markBuiltInInitializationFinished() |
| 564 | { |
| 565 | mUserDefinedUniqueIdsStart = mUniqueIdCounter; |
| 566 | } |
| 567 | |
| 568 | void TSymbolTable::clearCompilationResults() |
| 569 | { |
| 570 | mUniqueIdCounter = mUserDefinedUniqueIdsStart; |
| 571 | |
| 572 | // User-defined scopes should have already been cleared when the compilation finished. |
| 573 | ASSERT(table.size() == LAST_BUILTIN_LEVEL + 1u); |
| 574 | } |
| 575 | |
| 576 | int TSymbolTable::nextUniqueIdValue() |
| 577 | { |
| 578 | ASSERT(mUniqueIdCounter < std::numeric_limits<int>::max()); |
| 579 | return ++mUniqueIdCounter; |
| 580 | } |
| 581 | |
Jamie Madill | 45bcc78 | 2016-11-07 13:58:48 -0500 | [diff] [blame] | 582 | } // namespace sh |