daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1 | // |
shannon.woods%transgaming.com@gtempaccount.com | c0d0c22 | 2013-04-13 03:29:36 +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 | // |
| 6 | |
| 7 | // |
| 8 | // Build the intermediate representation. |
| 9 | // |
| 10 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 11 | #include <float.h> |
alokp@chromium.org | 1bcc3fd | 2010-05-19 17:08:44 +0000 | [diff] [blame] | 12 | #include <limits.h> |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 13 | #include <algorithm> |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 14 | |
Geoff Lang | 1773282 | 2013-08-29 13:46:49 -0400 | [diff] [blame] | 15 | #include "compiler/translator/HashNames.h" |
| 16 | #include "compiler/translator/localintermediate.h" |
| 17 | #include "compiler/translator/QualifierAlive.h" |
| 18 | #include "compiler/translator/RemoveTree.h" |
| 19 | #include "compiler/translator/SymbolTable.h" |
daniel@transgaming.com | bbf56f7 | 2010-04-20 18:52:13 +0000 | [diff] [blame] | 20 | |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 21 | bool CompareStructure(const TType& leftNodeType, ConstantUnion* rightUnionArray, ConstantUnion* leftUnionArray); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 22 | |
Zhenyao Mo | 7cab38b | 2013-10-15 12:59:30 -0700 | [diff] [blame] | 23 | static TPrecision GetHigherPrecision(TPrecision left, TPrecision right) |
| 24 | { |
daniel@transgaming.com | 9abe956 | 2010-06-24 13:02:21 +0000 | [diff] [blame] | 25 | return left > right ? left : right; |
daniel@transgaming.com | a5d7623 | 2010-05-17 09:58:47 +0000 | [diff] [blame] | 26 | } |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 27 | |
Zhenyao Mo | 7cab38b | 2013-10-15 12:59:30 -0700 | [diff] [blame] | 28 | const char* getOperatorString(TOperator op) |
| 29 | { |
alokp@chromium.org | b59a778 | 2010-11-24 18:38:33 +0000 | [diff] [blame] | 30 | switch (op) { |
| 31 | case EOpInitialize: return "="; |
| 32 | case EOpAssign: return "="; |
| 33 | case EOpAddAssign: return "+="; |
| 34 | case EOpSubAssign: return "-="; |
| 35 | case EOpDivAssign: return "/="; |
| 36 | |
| 37 | // Fall-through. |
| 38 | case EOpMulAssign: |
| 39 | case EOpVectorTimesMatrixAssign: |
| 40 | case EOpVectorTimesScalarAssign: |
| 41 | case EOpMatrixTimesScalarAssign: |
| 42 | case EOpMatrixTimesMatrixAssign: return "*="; |
| 43 | |
| 44 | // Fall-through. |
| 45 | case EOpIndexDirect: |
| 46 | case EOpIndexIndirect: return "[]"; |
| 47 | |
shannonwoods@chromium.org | 4430b0d | 2013-05-30 00:12:34 +0000 | [diff] [blame] | 48 | case EOpIndexDirectStruct: |
| 49 | case EOpIndexDirectInterfaceBlock: return "."; |
alokp@chromium.org | b59a778 | 2010-11-24 18:38:33 +0000 | [diff] [blame] | 50 | case EOpVectorSwizzle: return "."; |
| 51 | case EOpAdd: return "+"; |
| 52 | case EOpSub: return "-"; |
| 53 | case EOpMul: return "*"; |
| 54 | case EOpDiv: return "/"; |
| 55 | case EOpMod: UNIMPLEMENTED(); break; |
| 56 | case EOpEqual: return "=="; |
| 57 | case EOpNotEqual: return "!="; |
| 58 | case EOpLessThan: return "<"; |
| 59 | case EOpGreaterThan: return ">"; |
| 60 | case EOpLessThanEqual: return "<="; |
| 61 | case EOpGreaterThanEqual: return ">="; |
| 62 | |
| 63 | // Fall-through. |
| 64 | case EOpVectorTimesScalar: |
| 65 | case EOpVectorTimesMatrix: |
| 66 | case EOpMatrixTimesVector: |
| 67 | case EOpMatrixTimesScalar: |
| 68 | case EOpMatrixTimesMatrix: return "*"; |
| 69 | |
| 70 | case EOpLogicalOr: return "||"; |
| 71 | case EOpLogicalXor: return "^^"; |
| 72 | case EOpLogicalAnd: return "&&"; |
| 73 | case EOpNegative: return "-"; |
| 74 | case EOpVectorLogicalNot: return "not"; |
| 75 | case EOpLogicalNot: return "!"; |
| 76 | case EOpPostIncrement: return "++"; |
| 77 | case EOpPostDecrement: return "--"; |
| 78 | case EOpPreIncrement: return "++"; |
| 79 | case EOpPreDecrement: return "--"; |
| 80 | |
| 81 | // Fall-through. |
| 82 | case EOpConvIntToBool: |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 83 | case EOpConvUIntToBool: |
alokp@chromium.org | b59a778 | 2010-11-24 18:38:33 +0000 | [diff] [blame] | 84 | case EOpConvFloatToBool: return "bool"; |
| 85 | |
| 86 | // Fall-through. |
| 87 | case EOpConvBoolToFloat: |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 88 | case EOpConvUIntToFloat: |
alokp@chromium.org | b59a778 | 2010-11-24 18:38:33 +0000 | [diff] [blame] | 89 | case EOpConvIntToFloat: return "float"; |
| 90 | |
| 91 | // Fall-through. |
| 92 | case EOpConvFloatToInt: |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 93 | case EOpConvUIntToInt: |
alokp@chromium.org | b59a778 | 2010-11-24 18:38:33 +0000 | [diff] [blame] | 94 | case EOpConvBoolToInt: return "int"; |
| 95 | |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 96 | // Fall-through. |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 97 | case EOpConvIntToUInt: |
| 98 | case EOpConvFloatToUInt: |
| 99 | case EOpConvBoolToUInt: return "uint"; |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 100 | |
alokp@chromium.org | b59a778 | 2010-11-24 18:38:33 +0000 | [diff] [blame] | 101 | case EOpRadians: return "radians"; |
| 102 | case EOpDegrees: return "degrees"; |
| 103 | case EOpSin: return "sin"; |
| 104 | case EOpCos: return "cos"; |
| 105 | case EOpTan: return "tan"; |
| 106 | case EOpAsin: return "asin"; |
| 107 | case EOpAcos: return "acos"; |
| 108 | case EOpAtan: return "atan"; |
| 109 | case EOpExp: return "exp"; |
| 110 | case EOpLog: return "log"; |
| 111 | case EOpExp2: return "exp2"; |
| 112 | case EOpLog2: return "log2"; |
| 113 | case EOpSqrt: return "sqrt"; |
| 114 | case EOpInverseSqrt: return "inversesqrt"; |
| 115 | case EOpAbs: return "abs"; |
| 116 | case EOpSign: return "sign"; |
| 117 | case EOpFloor: return "floor"; |
| 118 | case EOpCeil: return "ceil"; |
| 119 | case EOpFract: return "fract"; |
| 120 | case EOpLength: return "length"; |
| 121 | case EOpNormalize: return "normalize"; |
| 122 | case EOpDFdx: return "dFdx"; |
| 123 | case EOpDFdy: return "dFdy"; |
| 124 | case EOpFwidth: return "fwidth"; |
| 125 | case EOpAny: return "any"; |
| 126 | case EOpAll: return "all"; |
| 127 | |
| 128 | default: break; |
| 129 | } |
| 130 | return ""; |
| 131 | } |
| 132 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 133 | //////////////////////////////////////////////////////////////////////////// |
| 134 | // |
| 135 | // First set of functions are to help build the intermediate representation. |
| 136 | // These functions are not member functions of the nodes. |
| 137 | // They are called from parser productions. |
| 138 | // |
| 139 | ///////////////////////////////////////////////////////////////////////////// |
| 140 | |
| 141 | // |
| 142 | // Add a terminal node for an identifier in an expression. |
| 143 | // |
| 144 | // Returns the added node. |
| 145 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 146 | TIntermSymbol* TIntermediate::addSymbol(int id, const TString& name, const TType& type, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 147 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 148 | TIntermSymbol* node = new TIntermSymbol(id, name, type); |
| 149 | node->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 150 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 151 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 152 | } |
| 153 | |
| 154 | // |
| 155 | // Connect two nodes with a new parent that does a binary operation on the nodes. |
| 156 | // |
| 157 | // Returns the added node. |
| 158 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 159 | TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIntermTyped* right, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 160 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 161 | switch (op) { |
alokp@chromium.org | 8f0f24a | 2010-09-01 21:06:24 +0000 | [diff] [blame] | 162 | case EOpEqual: |
| 163 | case EOpNotEqual: |
| 164 | if (left->isArray()) |
| 165 | return 0; |
| 166 | break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 167 | case EOpLessThan: |
| 168 | case EOpGreaterThan: |
| 169 | case EOpLessThanEqual: |
| 170 | case EOpGreaterThanEqual: |
alokp@chromium.org | 8f0f24a | 2010-09-01 21:06:24 +0000 | [diff] [blame] | 171 | if (left->isMatrix() || left->isArray() || left->isVector() || left->getBasicType() == EbtStruct) { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 172 | return 0; |
| 173 | } |
| 174 | break; |
| 175 | case EOpLogicalOr: |
| 176 | case EOpLogicalXor: |
| 177 | case EOpLogicalAnd: |
alokp@chromium.org | 8f0f24a | 2010-09-01 21:06:24 +0000 | [diff] [blame] | 178 | if (left->getBasicType() != EbtBool || left->isMatrix() || left->isArray() || left->isVector()) { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 179 | return 0; |
| 180 | } |
| 181 | break; |
| 182 | case EOpAdd: |
| 183 | case EOpSub: |
| 184 | case EOpDiv: |
| 185 | case EOpMul: |
alokp@chromium.org | 8f0f24a | 2010-09-01 21:06:24 +0000 | [diff] [blame] | 186 | if (left->getBasicType() == EbtStruct || left->getBasicType() == EbtBool) |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 187 | return 0; |
| 188 | default: break; |
| 189 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 190 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 191 | // |
| 192 | // First try converting the children to compatible types. |
| 193 | // |
alokp@chromium.org | 8f0f24a | 2010-09-01 21:06:24 +0000 | [diff] [blame] | 194 | if (left->getType().getStruct() && right->getType().getStruct()) { |
| 195 | if (left->getType() != right->getType()) |
| 196 | return 0; |
| 197 | } else { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 198 | TIntermTyped* child = addConversion(op, left->getType(), right); |
| 199 | if (child) |
| 200 | right = child; |
| 201 | else { |
| 202 | child = addConversion(op, right->getType(), left); |
| 203 | if (child) |
| 204 | left = child; |
| 205 | else |
| 206 | return 0; |
| 207 | } |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 208 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 209 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 210 | // |
| 211 | // Need a new node holding things together then. Make |
| 212 | // one and promote it to the right type. |
| 213 | // |
| 214 | TIntermBinary* node = new TIntermBinary(op); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 215 | node->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 216 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 217 | node->setLeft(left); |
| 218 | node->setRight(right); |
alokp@chromium.org | 8f0f24a | 2010-09-01 21:06:24 +0000 | [diff] [blame] | 219 | if (!node->promote(infoSink)) |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 220 | return 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 221 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 222 | // |
| 223 | // See if we can fold constants. |
| 224 | // |
alokp@chromium.org | 8f0f24a | 2010-09-01 21:06:24 +0000 | [diff] [blame] | 225 | TIntermConstantUnion *leftTempConstant = left->getAsConstantUnion(); |
| 226 | TIntermConstantUnion *rightTempConstant = right->getAsConstantUnion(); |
| 227 | if (leftTempConstant && rightTempConstant) { |
Nicolas Capens | bd0ea9c | 2014-03-04 13:53:29 -0500 | [diff] [blame] | 228 | TIntermTyped *typedReturnNode = leftTempConstant->fold(node->getOp(), rightTempConstant, infoSink); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 229 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 230 | if (typedReturnNode) |
| 231 | return typedReturnNode; |
| 232 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 233 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 234 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 235 | } |
| 236 | |
| 237 | // |
| 238 | // Connect two nodes through an assignment. |
| 239 | // |
| 240 | // Returns the added node. |
| 241 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 242 | TIntermTyped* TIntermediate::addAssign(TOperator op, TIntermTyped* left, TIntermTyped* right, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 243 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 244 | // |
| 245 | // Like adding binary math, except the conversion can only go |
| 246 | // from right to left. |
| 247 | // |
| 248 | TIntermBinary* node = new TIntermBinary(op); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 249 | node->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 250 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 251 | TIntermTyped* child = addConversion(op, left->getType(), right); |
| 252 | if (child == 0) |
| 253 | return 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 254 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 255 | node->setLeft(left); |
| 256 | node->setRight(child); |
| 257 | if (! node->promote(infoSink)) |
| 258 | return 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 259 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 260 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 261 | } |
| 262 | |
| 263 | // |
| 264 | // Connect two nodes through an index operator, where the left node is the base |
| 265 | // of an array or struct, and the right node is a direct or indirect offset. |
| 266 | // |
| 267 | // Returns the added node. |
| 268 | // The caller should set the type of the returned node. |
| 269 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 270 | TIntermTyped* TIntermediate::addIndex(TOperator op, TIntermTyped* base, TIntermTyped* index, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 271 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 272 | TIntermBinary* node = new TIntermBinary(op); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 273 | node->setLine(line); |
| 274 | node->setLeft(base); |
| 275 | node->setRight(index); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 276 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 277 | // caller should set the type |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 278 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 279 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | // |
| 283 | // Add one node as the parent of another that it operates on. |
| 284 | // |
| 285 | // Returns the added node. |
| 286 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 287 | TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 288 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 289 | TIntermUnary* node; |
| 290 | TIntermTyped* child = childNode->getAsTyped(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 291 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 292 | if (child == 0) { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 293 | infoSink.info.message(EPrefixInternalError, line, "Bad type in AddUnaryMath"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 294 | return 0; |
| 295 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 296 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 297 | switch (op) { |
| 298 | case EOpLogicalNot: |
| 299 | if (child->getType().getBasicType() != EbtBool || child->getType().isMatrix() || child->getType().isArray() || child->getType().isVector()) { |
| 300 | return 0; |
| 301 | } |
| 302 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 303 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 304 | case EOpPostIncrement: |
| 305 | case EOpPreIncrement: |
| 306 | case EOpPostDecrement: |
| 307 | case EOpPreDecrement: |
| 308 | case EOpNegative: |
| 309 | if (child->getType().getBasicType() == EbtStruct || child->getType().isArray()) |
| 310 | return 0; |
| 311 | default: break; |
| 312 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 313 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 314 | // |
| 315 | // Do we need to promote the operand? |
| 316 | // |
| 317 | // Note: Implicit promotions were removed from the language. |
| 318 | // |
| 319 | TBasicType newType = EbtVoid; |
| 320 | switch (op) { |
| 321 | case EOpConstructInt: newType = EbtInt; break; |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 322 | case EOpConstructUInt: newType = EbtUInt; break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 323 | case EOpConstructBool: newType = EbtBool; break; |
| 324 | case EOpConstructFloat: newType = EbtFloat; break; |
| 325 | default: break; |
| 326 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 327 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 328 | if (newType != EbtVoid) { |
daniel@transgaming.com | a5d7623 | 2010-05-17 09:58:47 +0000 | [diff] [blame] | 329 | child = addConversion(op, TType(newType, child->getPrecision(), EvqTemporary, |
| 330 | child->getNominalSize(), |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 331 | child->getSecondarySize(), |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 332 | child->isArray()), |
| 333 | child); |
| 334 | if (child == 0) |
| 335 | return 0; |
| 336 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 337 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 338 | // |
| 339 | // For constructors, we are now done, it's all in the conversion. |
| 340 | // |
| 341 | switch (op) { |
| 342 | case EOpConstructInt: |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 343 | case EOpConstructUInt: |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 344 | case EOpConstructBool: |
| 345 | case EOpConstructFloat: |
| 346 | return child; |
| 347 | default: break; |
| 348 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 349 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 350 | TIntermConstantUnion *childTempConstant = 0; |
| 351 | if (child->getAsConstantUnion()) |
| 352 | childTempConstant = child->getAsConstantUnion(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 353 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 354 | // |
| 355 | // Make a new node for the operator. |
| 356 | // |
| 357 | node = new TIntermUnary(op); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 358 | node->setLine(line); |
| 359 | node->setOperand(child); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 360 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 361 | if (! node->promote(infoSink)) |
| 362 | return 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 363 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 364 | if (childTempConstant) { |
| 365 | TIntermTyped* newChild = childTempConstant->fold(op, 0, infoSink); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 366 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 367 | if (newChild) |
| 368 | return newChild; |
| 369 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 370 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 371 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 372 | } |
| 373 | |
| 374 | // |
| 375 | // This is the safe way to change the operator on an aggregate, as it |
| 376 | // does lots of error checking and fixing. Especially for establishing |
| 377 | // a function call's operation on it's set of parameters. Sequences |
| 378 | // of instructions are also aggregates, but they just direnctly set |
| 379 | // their operator to EOpSequence. |
| 380 | // |
| 381 | // Returns an aggregate node, which could be the one passed in if |
daniel@transgaming.com | 978702d | 2012-04-04 15:05:58 +0000 | [diff] [blame] | 382 | // it was already an aggregate but no operator was set. |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 383 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 384 | TIntermAggregate* TIntermediate::setAggregateOperator(TIntermNode* node, TOperator op, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 385 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 386 | TIntermAggregate* aggNode; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 387 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 388 | // |
| 389 | // Make sure we have an aggregate. If not turn it into one. |
| 390 | // |
| 391 | if (node) { |
| 392 | aggNode = node->getAsAggregate(); |
| 393 | if (aggNode == 0 || aggNode->getOp() != EOpNull) { |
| 394 | // |
| 395 | // Make an aggregate containing this node. |
| 396 | // |
| 397 | aggNode = new TIntermAggregate(); |
| 398 | aggNode->getSequence().push_back(node); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 399 | } |
| 400 | } else |
| 401 | aggNode = new TIntermAggregate(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 402 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 403 | // |
| 404 | // Set the operator. |
| 405 | // |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 406 | aggNode->setOp(op); |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 407 | aggNode->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 408 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 409 | return aggNode; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 410 | } |
| 411 | |
| 412 | // |
| 413 | // Convert one type to another. |
| 414 | // |
| 415 | // Returns the node representing the conversion, which could be the same |
| 416 | // node passed in if no conversion was needed. |
| 417 | // |
| 418 | // Return 0 if a conversion can't be done. |
| 419 | // |
| 420 | TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TIntermTyped* node) |
| 421 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 422 | // |
| 423 | // Does the base type allow operation? |
| 424 | // |
Nicolas Capens | 344e714 | 2013-06-24 15:39:21 -0400 | [diff] [blame] | 425 | if (node->getBasicType() == EbtVoid || |
| 426 | IsSampler(node->getBasicType())) |
| 427 | { |
| 428 | return 0; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 429 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 430 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 431 | // |
| 432 | // Otherwise, if types are identical, no problem |
| 433 | // |
| 434 | if (type == node->getType()) |
| 435 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 436 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 437 | // |
| 438 | // If one's a structure, then no conversions. |
| 439 | // |
| 440 | if (type.getStruct() || node->getType().getStruct()) |
| 441 | return 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 442 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 443 | // |
| 444 | // If one's an array, then no conversions. |
| 445 | // |
| 446 | if (type.isArray() || node->getType().isArray()) |
| 447 | return 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 448 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 449 | TBasicType promoteTo; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 450 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 451 | switch (op) { |
| 452 | // |
| 453 | // Explicit conversions |
| 454 | // |
| 455 | case EOpConstructBool: |
| 456 | promoteTo = EbtBool; |
| 457 | break; |
| 458 | case EOpConstructFloat: |
| 459 | promoteTo = EbtFloat; |
| 460 | break; |
| 461 | case EOpConstructInt: |
| 462 | promoteTo = EbtInt; |
| 463 | break; |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 464 | case EOpConstructUInt: |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 465 | promoteTo = EbtUInt; |
| 466 | break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 467 | default: |
| 468 | // |
| 469 | // implicit conversions were removed from the language. |
| 470 | // |
| 471 | if (type.getBasicType() != node->getType().getBasicType()) |
| 472 | return 0; |
| 473 | // |
| 474 | // Size and structure could still differ, but that's |
| 475 | // handled by operator promotion. |
| 476 | // |
| 477 | return node; |
| 478 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 479 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 480 | if (node->getAsConstantUnion()) { |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 481 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 482 | return (promoteConstantUnion(promoteTo, node->getAsConstantUnion())); |
| 483 | } else { |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 484 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 485 | // |
| 486 | // Add a new newNode for the conversion. |
| 487 | // |
| 488 | TIntermUnary* newNode = 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 489 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 490 | TOperator newOp = EOpNull; |
| 491 | switch (promoteTo) { |
| 492 | case EbtFloat: |
| 493 | switch (node->getBasicType()) { |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 494 | case EbtInt: newOp = EOpConvIntToFloat; break; |
| 495 | case EbtUInt: newOp = EOpConvFloatToUInt; break; |
| 496 | case EbtBool: newOp = EOpConvBoolToFloat; break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 497 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 498 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Bad promotion node"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 499 | return 0; |
| 500 | } |
| 501 | break; |
| 502 | case EbtBool: |
| 503 | switch (node->getBasicType()) { |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 504 | case EbtInt: newOp = EOpConvIntToBool; break; |
| 505 | case EbtUInt: newOp = EOpConvBoolToUInt; break; |
| 506 | case EbtFloat: newOp = EOpConvFloatToBool; break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 507 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 508 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Bad promotion node"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 509 | return 0; |
| 510 | } |
| 511 | break; |
| 512 | case EbtInt: |
| 513 | switch (node->getBasicType()) { |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 514 | case EbtUInt: newOp = EOpConvUIntToInt; break; |
| 515 | case EbtBool: newOp = EOpConvBoolToInt; break; |
| 516 | case EbtFloat: newOp = EOpConvFloatToInt; break; |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 517 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 518 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Bad promotion node"); |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 519 | return 0; |
| 520 | } |
| 521 | break; |
| 522 | case EbtUInt: |
| 523 | switch (node->getBasicType()) { |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 524 | case EbtInt: newOp = EOpConvIntToUInt; break; |
| 525 | case EbtBool: newOp = EOpConvBoolToUInt; break; |
| 526 | case EbtFloat: newOp = EOpConvFloatToUInt; break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 527 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 528 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Bad promotion node"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 529 | return 0; |
| 530 | } |
| 531 | break; |
| 532 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 533 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Bad promotion type"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 534 | return 0; |
| 535 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 536 | |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 537 | TType type(promoteTo, node->getPrecision(), EvqTemporary, node->getNominalSize(), node->getSecondarySize(), node->isArray()); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 538 | newNode = new TIntermUnary(newOp, type); |
| 539 | newNode->setLine(node->getLine()); |
| 540 | newNode->setOperand(node); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 541 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 542 | return newNode; |
| 543 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 544 | } |
| 545 | |
| 546 | // |
| 547 | // Safe way to combine two nodes into an aggregate. Works with null pointers, |
| 548 | // a node that's not a aggregate yet, etc. |
| 549 | // |
| 550 | // Returns the resulting aggregate, unless 0 was passed in for |
| 551 | // both existing nodes. |
| 552 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 553 | TIntermAggregate* TIntermediate::growAggregate(TIntermNode* left, TIntermNode* right, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 554 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 555 | if (left == 0 && right == 0) |
| 556 | return 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 557 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 558 | TIntermAggregate* aggNode = 0; |
| 559 | if (left) |
| 560 | aggNode = left->getAsAggregate(); |
| 561 | if (!aggNode || aggNode->getOp() != EOpNull) { |
| 562 | aggNode = new TIntermAggregate; |
| 563 | if (left) |
| 564 | aggNode->getSequence().push_back(left); |
| 565 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 566 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 567 | if (right) |
| 568 | aggNode->getSequence().push_back(right); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 569 | |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 570 | aggNode->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 571 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 572 | return aggNode; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 573 | } |
| 574 | |
| 575 | // |
| 576 | // Turn an existing node into an aggregate. |
| 577 | // |
| 578 | // Returns an aggregate, unless 0 was passed in for the existing node. |
| 579 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 580 | TIntermAggregate* TIntermediate::makeAggregate(TIntermNode* node, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 581 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 582 | if (node == 0) |
| 583 | return 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 584 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 585 | TIntermAggregate* aggNode = new TIntermAggregate; |
| 586 | aggNode->getSequence().push_back(node); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 587 | |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 588 | aggNode->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 589 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 590 | return aggNode; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 591 | } |
| 592 | |
| 593 | // |
| 594 | // For "if" test nodes. There are three children; a condition, |
| 595 | // a true path, and a false path. The two paths are in the |
| 596 | // nodePair. |
| 597 | // |
| 598 | // Returns the selection node created. |
| 599 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 600 | TIntermNode* TIntermediate::addSelection(TIntermTyped* cond, TIntermNodePair nodePair, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 601 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 602 | // |
| 603 | // For compile time constant selections, prune the code and |
| 604 | // test now. |
| 605 | // |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 606 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 607 | if (cond->getAsTyped() && cond->getAsTyped()->getAsConstantUnion()) { |
shannon.woods%transgaming.com@gtempaccount.com | c0d0c22 | 2013-04-13 03:29:36 +0000 | [diff] [blame] | 608 | if (cond->getAsConstantUnion()->getBConst(0) == true) |
daniel@transgaming.com | 978702d | 2012-04-04 15:05:58 +0000 | [diff] [blame] | 609 | return nodePair.node1 ? setAggregateOperator(nodePair.node1, EOpSequence, nodePair.node1->getLine()) : NULL; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 610 | else |
daniel@transgaming.com | 978702d | 2012-04-04 15:05:58 +0000 | [diff] [blame] | 611 | return nodePair.node2 ? setAggregateOperator(nodePair.node2, EOpSequence, nodePair.node2->getLine()) : NULL; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 612 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 613 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 614 | TIntermSelection* node = new TIntermSelection(cond, nodePair.node1, nodePair.node2); |
| 615 | node->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 616 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 617 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 618 | } |
| 619 | |
| 620 | |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 621 | TIntermTyped* TIntermediate::addComma(TIntermTyped* left, TIntermTyped* right, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 622 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 623 | if (left->getType().getQualifier() == EvqConst && right->getType().getQualifier() == EvqConst) { |
| 624 | return right; |
| 625 | } else { |
| 626 | TIntermTyped *commaAggregate = growAggregate(left, right, line); |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 627 | commaAggregate->getAsAggregate()->setOp(EOpComma); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 628 | commaAggregate->setType(right->getType()); |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 629 | commaAggregate->getTypePointer()->setQualifier(EvqTemporary); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 630 | return commaAggregate; |
| 631 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 632 | } |
| 633 | |
| 634 | // |
| 635 | // For "?:" test nodes. There are three children; a condition, |
| 636 | // a true path, and a false path. The two paths are specified |
| 637 | // as separate parameters. |
| 638 | // |
| 639 | // Returns the selection node created, or 0 if one could not be. |
| 640 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 641 | TIntermTyped* TIntermediate::addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 642 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 643 | // |
| 644 | // Get compatible types. |
| 645 | // |
| 646 | TIntermTyped* child = addConversion(EOpSequence, trueBlock->getType(), falseBlock); |
| 647 | if (child) |
| 648 | falseBlock = child; |
| 649 | else { |
| 650 | child = addConversion(EOpSequence, falseBlock->getType(), trueBlock); |
| 651 | if (child) |
| 652 | trueBlock = child; |
| 653 | else |
| 654 | return 0; |
| 655 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 656 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 657 | // |
| 658 | // See if all the operands are constant, then fold it otherwise not. |
| 659 | // |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 660 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 661 | if (cond->getAsConstantUnion() && trueBlock->getAsConstantUnion() && falseBlock->getAsConstantUnion()) { |
shannon.woods%transgaming.com@gtempaccount.com | c0d0c22 | 2013-04-13 03:29:36 +0000 | [diff] [blame] | 662 | if (cond->getAsConstantUnion()->getBConst(0)) |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 663 | return trueBlock; |
| 664 | else |
| 665 | return falseBlock; |
| 666 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 667 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 668 | // |
| 669 | // Make a selection node. |
| 670 | // |
| 671 | TIntermSelection* node = new TIntermSelection(cond, trueBlock, falseBlock, trueBlock->getType()); |
daniel@transgaming.com | 43affc5 | 2012-03-28 14:55:39 +0000 | [diff] [blame] | 672 | node->getTypePointer()->setQualifier(EvqTemporary); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 673 | node->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 674 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 675 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 676 | } |
| 677 | |
| 678 | // |
| 679 | // Constant terminal nodes. Has a union that contains bool, float or int constants |
| 680 | // |
| 681 | // Returns the constant union node created. |
| 682 | // |
| 683 | |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 684 | TIntermConstantUnion* TIntermediate::addConstantUnion(ConstantUnion* unionArrayPointer, const TType& t, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 685 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 686 | TIntermConstantUnion* node = new TIntermConstantUnion(unionArrayPointer, t); |
| 687 | node->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 688 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 689 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 690 | } |
| 691 | |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 692 | TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 693 | { |
| 694 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 695 | TIntermAggregate* node = new TIntermAggregate(EOpSequence); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 696 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 697 | node->setLine(line); |
| 698 | TIntermConstantUnion* constIntNode; |
| 699 | TIntermSequence &sequenceVector = node->getSequence(); |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 700 | ConstantUnion* unionArray; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 701 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 702 | for (int i = 0; i < fields.num; i++) { |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 703 | unionArray = new ConstantUnion[1]; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 704 | unionArray->setIConst(fields.offsets[i]); |
daniel@transgaming.com | a5d7623 | 2010-05-17 09:58:47 +0000 | [diff] [blame] | 705 | constIntNode = addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), line); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 706 | sequenceVector.push_back(constIntNode); |
| 707 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 708 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 709 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 710 | } |
| 711 | |
| 712 | // |
| 713 | // Create loop nodes. |
| 714 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 715 | TIntermNode* TIntermediate::addLoop(TLoopType type, TIntermNode* init, TIntermTyped* cond, TIntermTyped* expr, TIntermNode* body, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 716 | { |
alokp@chromium.org | 5281355 | 2010-11-16 18:36:09 +0000 | [diff] [blame] | 717 | TIntermNode* node = new TIntermLoop(type, init, cond, expr, body); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 718 | node->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 719 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 720 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 721 | } |
| 722 | |
| 723 | // |
| 724 | // Add branches. |
| 725 | // |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 726 | TIntermBranch* TIntermediate::addBranch(TOperator branchOp, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 727 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 728 | return addBranch(branchOp, 0, line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 729 | } |
| 730 | |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 731 | TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TIntermTyped* expression, const TSourceLoc& line) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 732 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 733 | TIntermBranch* node = new TIntermBranch(branchOp, expression); |
| 734 | node->setLine(line); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 735 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 736 | return node; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 737 | } |
| 738 | |
| 739 | // |
| 740 | // This is to be executed once the final root is put on top by the parsing |
| 741 | // process. |
| 742 | // |
alokp@chromium.org | 07620a5 | 2010-09-23 17:53:56 +0000 | [diff] [blame] | 743 | bool TIntermediate::postProcess(TIntermNode* root) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 744 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 745 | if (root == 0) |
| 746 | return true; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 747 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 748 | // |
| 749 | // First, finish off the top level sequence, if any |
| 750 | // |
| 751 | TIntermAggregate* aggRoot = root->getAsAggregate(); |
| 752 | if (aggRoot && aggRoot->getOp() == EOpNull) |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 753 | aggRoot->setOp(EOpSequence); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 754 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 755 | return true; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 756 | } |
| 757 | |
| 758 | // |
| 759 | // This deletes the tree. |
| 760 | // |
| 761 | void TIntermediate::remove(TIntermNode* root) |
| 762 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 763 | if (root) |
| 764 | RemoveAllTreeNodes(root); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 765 | } |
| 766 | |
| 767 | //////////////////////////////////////////////////////////////// |
| 768 | // |
| 769 | // Member functions of the nodes used for building the tree. |
| 770 | // |
| 771 | //////////////////////////////////////////////////////////////// |
| 772 | |
Zhenyao Mo | 7cab38b | 2013-10-15 12:59:30 -0700 | [diff] [blame] | 773 | #define REPLACE_IF_IS(node, type, original, replacement) \ |
| 774 | if (node == original) { \ |
| 775 | node = static_cast<type *>(replacement); \ |
| 776 | return true; \ |
| 777 | } |
| 778 | |
| 779 | bool TIntermLoop::replaceChildNode( |
| 780 | TIntermNode *original, TIntermNode *replacement) |
| 781 | { |
| 782 | REPLACE_IF_IS(init, TIntermNode, original, replacement); |
| 783 | REPLACE_IF_IS(cond, TIntermTyped, original, replacement); |
| 784 | REPLACE_IF_IS(expr, TIntermTyped, original, replacement); |
| 785 | REPLACE_IF_IS(body, TIntermNode, original, replacement); |
| 786 | return false; |
| 787 | } |
| 788 | |
Jamie Madill | dd0d342 | 2014-03-26 14:01:56 -0400 | [diff] [blame] | 789 | void TIntermLoop::enqueueChildren(std::queue<TIntermNode*> *nodeQueue) const |
| 790 | { |
| 791 | if (init) |
| 792 | { |
| 793 | nodeQueue->push(init); |
| 794 | } |
| 795 | if (cond) |
| 796 | { |
| 797 | nodeQueue->push(cond); |
| 798 | } |
| 799 | if (expr) |
| 800 | { |
| 801 | nodeQueue->push(expr); |
| 802 | } |
| 803 | if (body) |
| 804 | { |
| 805 | nodeQueue->push(body); |
| 806 | } |
| 807 | } |
| 808 | |
Zhenyao Mo | 7cab38b | 2013-10-15 12:59:30 -0700 | [diff] [blame] | 809 | bool TIntermBranch::replaceChildNode( |
| 810 | TIntermNode *original, TIntermNode *replacement) |
| 811 | { |
| 812 | REPLACE_IF_IS(expression, TIntermTyped, original, replacement); |
| 813 | return false; |
| 814 | } |
| 815 | |
Jamie Madill | dd0d342 | 2014-03-26 14:01:56 -0400 | [diff] [blame] | 816 | void TIntermBranch::enqueueChildren(std::queue<TIntermNode*> *nodeQueue) const |
| 817 | { |
| 818 | if (expression) |
| 819 | { |
| 820 | nodeQueue->push(expression); |
| 821 | } |
| 822 | } |
| 823 | |
Zhenyao Mo | 7cab38b | 2013-10-15 12:59:30 -0700 | [diff] [blame] | 824 | bool TIntermBinary::replaceChildNode( |
| 825 | TIntermNode *original, TIntermNode *replacement) |
| 826 | { |
| 827 | REPLACE_IF_IS(left, TIntermTyped, original, replacement); |
| 828 | REPLACE_IF_IS(right, TIntermTyped, original, replacement); |
| 829 | return false; |
| 830 | } |
| 831 | |
Jamie Madill | dd0d342 | 2014-03-26 14:01:56 -0400 | [diff] [blame] | 832 | void TIntermBinary::enqueueChildren(std::queue<TIntermNode*> *nodeQueue) const |
| 833 | { |
| 834 | if (left) |
| 835 | { |
| 836 | nodeQueue->push(left); |
| 837 | } |
| 838 | if (right) |
| 839 | { |
| 840 | nodeQueue->push(right); |
| 841 | } |
| 842 | } |
| 843 | |
Zhenyao Mo | 7cab38b | 2013-10-15 12:59:30 -0700 | [diff] [blame] | 844 | bool TIntermUnary::replaceChildNode( |
| 845 | TIntermNode *original, TIntermNode *replacement) |
| 846 | { |
| 847 | REPLACE_IF_IS(operand, TIntermTyped, original, replacement); |
| 848 | return false; |
| 849 | } |
| 850 | |
Jamie Madill | dd0d342 | 2014-03-26 14:01:56 -0400 | [diff] [blame] | 851 | void TIntermUnary::enqueueChildren(std::queue<TIntermNode*> *nodeQueue) const |
| 852 | { |
| 853 | if (operand) |
| 854 | { |
| 855 | nodeQueue->push(operand); |
| 856 | } |
| 857 | } |
| 858 | |
Zhenyao Mo | 7cab38b | 2013-10-15 12:59:30 -0700 | [diff] [blame] | 859 | bool TIntermAggregate::replaceChildNode( |
| 860 | TIntermNode *original, TIntermNode *replacement) |
| 861 | { |
| 862 | for (size_t ii = 0; ii < sequence.size(); ++ii) |
| 863 | { |
| 864 | REPLACE_IF_IS(sequence[ii], TIntermNode, original, replacement); |
| 865 | } |
| 866 | return false; |
| 867 | } |
| 868 | |
Jamie Madill | dd0d342 | 2014-03-26 14:01:56 -0400 | [diff] [blame] | 869 | void TIntermAggregate::enqueueChildren(std::queue<TIntermNode*> *nodeQueue) const |
| 870 | { |
| 871 | for (size_t childIndex = 0; childIndex < sequence.size(); childIndex++) |
| 872 | { |
| 873 | nodeQueue->push(sequence[childIndex]); |
| 874 | } |
| 875 | } |
| 876 | |
Zhenyao Mo | 7cab38b | 2013-10-15 12:59:30 -0700 | [diff] [blame] | 877 | bool TIntermSelection::replaceChildNode( |
| 878 | TIntermNode *original, TIntermNode *replacement) |
| 879 | { |
| 880 | REPLACE_IF_IS(condition, TIntermTyped, original, replacement); |
| 881 | REPLACE_IF_IS(trueBlock, TIntermNode, original, replacement); |
| 882 | REPLACE_IF_IS(falseBlock, TIntermNode, original, replacement); |
| 883 | return false; |
| 884 | } |
| 885 | |
Jamie Madill | dd0d342 | 2014-03-26 14:01:56 -0400 | [diff] [blame] | 886 | void TIntermSelection::enqueueChildren(std::queue<TIntermNode*> *nodeQueue) const |
| 887 | { |
| 888 | if (condition) |
| 889 | { |
| 890 | nodeQueue->push(condition); |
| 891 | } |
| 892 | if (trueBlock) |
| 893 | { |
| 894 | nodeQueue->push(trueBlock); |
| 895 | } |
| 896 | if (falseBlock) |
| 897 | { |
| 898 | nodeQueue->push(falseBlock); |
| 899 | } |
| 900 | } |
| 901 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 902 | // |
| 903 | // Say whether or not an operation node changes the value of a variable. |
| 904 | // |
Jamie Madill | f4b79ba | 2013-11-26 10:38:18 -0500 | [diff] [blame] | 905 | bool TIntermOperator::isAssignment() const |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 906 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 907 | switch (op) { |
| 908 | case EOpPostIncrement: |
| 909 | case EOpPostDecrement: |
| 910 | case EOpPreIncrement: |
| 911 | case EOpPreDecrement: |
| 912 | case EOpAssign: |
| 913 | case EOpAddAssign: |
| 914 | case EOpSubAssign: |
| 915 | case EOpMulAssign: |
| 916 | case EOpVectorTimesMatrixAssign: |
| 917 | case EOpVectorTimesScalarAssign: |
| 918 | case EOpMatrixTimesScalarAssign: |
| 919 | case EOpMatrixTimesMatrixAssign: |
| 920 | case EOpDivAssign: |
| 921 | return true; |
| 922 | default: |
| 923 | return false; |
| 924 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 925 | } |
| 926 | |
| 927 | // |
| 928 | // returns true if the operator is for one of the constructors |
| 929 | // |
| 930 | bool TIntermOperator::isConstructor() const |
| 931 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 932 | switch (op) { |
| 933 | case EOpConstructVec2: |
| 934 | case EOpConstructVec3: |
| 935 | case EOpConstructVec4: |
| 936 | case EOpConstructMat2: |
| 937 | case EOpConstructMat3: |
| 938 | case EOpConstructMat4: |
| 939 | case EOpConstructFloat: |
| 940 | case EOpConstructIVec2: |
| 941 | case EOpConstructIVec3: |
| 942 | case EOpConstructIVec4: |
| 943 | case EOpConstructInt: |
shannonwoods@chromium.org | 8c788e8 | 2013-05-30 00:20:21 +0000 | [diff] [blame] | 944 | case EOpConstructUVec2: |
| 945 | case EOpConstructUVec3: |
| 946 | case EOpConstructUVec4: |
Nicolas Capens | ab60b93 | 2013-06-05 10:31:21 -0400 | [diff] [blame] | 947 | case EOpConstructUInt: |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 948 | case EOpConstructBVec2: |
| 949 | case EOpConstructBVec3: |
| 950 | case EOpConstructBVec4: |
| 951 | case EOpConstructBool: |
| 952 | case EOpConstructStruct: |
| 953 | return true; |
| 954 | default: |
| 955 | return false; |
| 956 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 957 | } |
Zhenyao Mo | 7cab38b | 2013-10-15 12:59:30 -0700 | [diff] [blame] | 958 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 959 | // |
| 960 | // Make sure the type of a unary operator is appropriate for its |
| 961 | // combination of operation and operand type. |
| 962 | // |
| 963 | // Returns false in nothing makes sense. |
| 964 | // |
| 965 | bool TIntermUnary::promote(TInfoSink&) |
| 966 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 967 | switch (op) { |
| 968 | case EOpLogicalNot: |
| 969 | if (operand->getBasicType() != EbtBool) |
| 970 | return false; |
| 971 | break; |
| 972 | case EOpNegative: |
| 973 | case EOpPostIncrement: |
| 974 | case EOpPostDecrement: |
| 975 | case EOpPreIncrement: |
| 976 | case EOpPreDecrement: |
| 977 | if (operand->getBasicType() == EbtBool) |
| 978 | return false; |
| 979 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 980 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 981 | // operators for built-ins are already type checked against their prototype |
| 982 | case EOpAny: |
| 983 | case EOpAll: |
| 984 | case EOpVectorLogicalNot: |
| 985 | return true; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 986 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 987 | default: |
| 988 | if (operand->getBasicType() != EbtFloat) |
| 989 | return false; |
| 990 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 991 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 992 | setType(operand->getType()); |
shannon.woods%transgaming.com@gtempaccount.com | ac1fc75 | 2013-04-13 03:29:52 +0000 | [diff] [blame] | 993 | type.setQualifier(EvqTemporary); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 994 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 995 | return true; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 996 | } |
| 997 | |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 998 | bool validateMultiplication(TOperator op, const TType &left, const TType &right) |
| 999 | { |
| 1000 | switch (op) |
| 1001 | { |
| 1002 | case EOpMul: |
| 1003 | case EOpMulAssign: |
| 1004 | return left.getNominalSize() == right.getNominalSize() && left.getSecondarySize() == right.getSecondarySize(); |
| 1005 | case EOpVectorTimesScalar: |
| 1006 | case EOpVectorTimesScalarAssign: |
| 1007 | return true; |
| 1008 | case EOpVectorTimesMatrix: |
| 1009 | return left.getNominalSize() == right.getRows(); |
| 1010 | case EOpVectorTimesMatrixAssign: |
| 1011 | return left.getNominalSize() == right.getRows() && left.getNominalSize() == right.getCols(); |
| 1012 | case EOpMatrixTimesVector: |
| 1013 | return left.getCols() == right.getNominalSize(); |
| 1014 | case EOpMatrixTimesScalar: |
| 1015 | case EOpMatrixTimesScalarAssign: |
| 1016 | return true; |
| 1017 | case EOpMatrixTimesMatrix: |
| 1018 | return left.getCols() == right.getRows(); |
| 1019 | case EOpMatrixTimesMatrixAssign: |
| 1020 | return left.getCols() == right.getCols() && left.getRows() == right.getRows(); |
| 1021 | |
| 1022 | default: |
| 1023 | UNREACHABLE(); |
| 1024 | return false; |
| 1025 | } |
| 1026 | } |
| 1027 | |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1028 | // |
| 1029 | // Establishes the type of the resultant operation, as well as |
| 1030 | // makes the operator the correct one for the operands. |
| 1031 | // |
| 1032 | // Returns false if operator can't work on operands. |
| 1033 | // |
| 1034 | bool TIntermBinary::promote(TInfoSink& infoSink) |
| 1035 | { |
alokp@chromium.org | 8f0f24a | 2010-09-01 21:06:24 +0000 | [diff] [blame] | 1036 | // This function only handles scalars, vectors, and matrices. |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1037 | if (left->isArray() || right->isArray()) |
| 1038 | { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1039 | infoSink.info.message(EPrefixInternalError, getLine(), "Invalid operation for arrays"); |
alokp@chromium.org | 8f0f24a | 2010-09-01 21:06:24 +0000 | [diff] [blame] | 1040 | return false; |
| 1041 | } |
| 1042 | |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1043 | // GLSL ES 2.0 does not support implicit type casting. |
| 1044 | // So the basic type should always match. |
| 1045 | if (left->getBasicType() != right->getBasicType()) |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1046 | return false; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1047 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1048 | // |
| 1049 | // Base assumption: just make the type the same as the left |
| 1050 | // operand. Then only deviations from this need be coded. |
| 1051 | // |
daniel@transgaming.com | fe56515 | 2010-04-10 05:29:07 +0000 | [diff] [blame] | 1052 | setType(left->getType()); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1053 | |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1054 | // The result gets promoted to the highest precision. |
| 1055 | TPrecision higherPrecision = GetHigherPrecision(left->getPrecision(), right->getPrecision()); |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 1056 | getTypePointer()->setPrecision(higherPrecision); |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1057 | |
| 1058 | // Binary operations results in temporary variables unless both |
| 1059 | // operands are const. |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1060 | if (left->getQualifier() != EvqConst || right->getQualifier() != EvqConst) |
| 1061 | { |
alokp@chromium.org | 58e5429 | 2010-08-24 21:40:03 +0000 | [diff] [blame] | 1062 | getTypePointer()->setQualifier(EvqTemporary); |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1063 | } |
daniel@transgaming.com | a5d7623 | 2010-05-17 09:58:47 +0000 | [diff] [blame] | 1064 | |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1065 | const int nominalSize = std::max(left->getNominalSize(), right->getNominalSize()); |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1066 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1067 | // |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1068 | // All scalars or structs. Code after this test assumes this case is removed! |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1069 | // |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1070 | if (nominalSize == 1) |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1071 | { |
| 1072 | switch (op) |
| 1073 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1074 | // |
| 1075 | // Promote to conditional |
| 1076 | // |
| 1077 | case EOpEqual: |
| 1078 | case EOpNotEqual: |
| 1079 | case EOpLessThan: |
| 1080 | case EOpGreaterThan: |
| 1081 | case EOpLessThanEqual: |
| 1082 | case EOpGreaterThanEqual: |
daniel@transgaming.com | a5d7623 | 2010-05-17 09:58:47 +0000 | [diff] [blame] | 1083 | setType(TType(EbtBool, EbpUndefined)); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1084 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1085 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1086 | // |
| 1087 | // And and Or operate on conditionals |
| 1088 | // |
| 1089 | case EOpLogicalAnd: |
| 1090 | case EOpLogicalOr: |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1091 | // Both operands must be of type bool. |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1092 | if (left->getBasicType() != EbtBool || right->getBasicType() != EbtBool) |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1093 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1094 | return false; |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1095 | } |
daniel@transgaming.com | a5d7623 | 2010-05-17 09:58:47 +0000 | [diff] [blame] | 1096 | setType(TType(EbtBool, EbpUndefined)); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1097 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1098 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1099 | default: |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1100 | break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1101 | } |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1102 | return true; |
| 1103 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1104 | |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1105 | // If we reach here, at least one of the operands is vector or matrix. |
| 1106 | // The other operand could be a scalar, vector, or matrix. |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1107 | // Can these two operands be combined? |
| 1108 | // |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1109 | TBasicType basicType = left->getBasicType(); |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1110 | switch (op) |
| 1111 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1112 | case EOpMul: |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1113 | if (!left->isMatrix() && right->isMatrix()) |
| 1114 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1115 | if (left->isVector()) |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1116 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1117 | op = EOpVectorTimesMatrix; |
shannonwoods@chromium.org | 9bd22fa | 2013-05-30 00:18:47 +0000 | [diff] [blame] | 1118 | setType(TType(basicType, higherPrecision, EvqTemporary, right->getCols(), 1)); |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1119 | } |
| 1120 | else |
| 1121 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1122 | op = EOpMatrixTimesScalar; |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1123 | setType(TType(basicType, higherPrecision, EvqTemporary, right->getCols(), right->getRows())); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1124 | } |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1125 | } |
| 1126 | else if (left->isMatrix() && !right->isMatrix()) |
| 1127 | { |
| 1128 | if (right->isVector()) |
| 1129 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1130 | op = EOpMatrixTimesVector; |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1131 | setType(TType(basicType, higherPrecision, EvqTemporary, left->getRows(), 1)); |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1132 | } |
| 1133 | else |
| 1134 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1135 | op = EOpMatrixTimesScalar; |
| 1136 | } |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1137 | } |
| 1138 | else if (left->isMatrix() && right->isMatrix()) |
| 1139 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1140 | op = EOpMatrixTimesMatrix; |
shannonwoods@chromium.org | 9bd22fa | 2013-05-30 00:18:47 +0000 | [diff] [blame] | 1141 | setType(TType(basicType, higherPrecision, EvqTemporary, right->getCols(), left->getRows())); |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1142 | } |
| 1143 | else if (!left->isMatrix() && !right->isMatrix()) |
| 1144 | { |
| 1145 | if (left->isVector() && right->isVector()) |
| 1146 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1147 | // leave as component product |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1148 | } |
| 1149 | else if (left->isVector() || right->isVector()) |
| 1150 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1151 | op = EOpVectorTimesScalar; |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1152 | setType(TType(basicType, higherPrecision, EvqTemporary, nominalSize, 1)); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1153 | } |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1154 | } |
| 1155 | else |
| 1156 | { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1157 | infoSink.info.message(EPrefixInternalError, getLine(), "Missing elses"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1158 | return false; |
| 1159 | } |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1160 | |
| 1161 | if (!validateMultiplication(op, left->getType(), right->getType())) |
| 1162 | { |
| 1163 | return false; |
| 1164 | } |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1165 | break; |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1166 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1167 | case EOpMulAssign: |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1168 | if (!left->isMatrix() && right->isMatrix()) |
| 1169 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1170 | if (left->isVector()) |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1171 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1172 | op = EOpVectorTimesMatrixAssign; |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1173 | } |
| 1174 | else |
| 1175 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1176 | return false; |
| 1177 | } |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1178 | } |
| 1179 | else if (left->isMatrix() && !right->isMatrix()) |
| 1180 | { |
| 1181 | if (right->isVector()) |
| 1182 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1183 | return false; |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1184 | } |
| 1185 | else |
| 1186 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1187 | op = EOpMatrixTimesScalarAssign; |
| 1188 | } |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1189 | } |
| 1190 | else if (left->isMatrix() && right->isMatrix()) |
| 1191 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1192 | op = EOpMatrixTimesMatrixAssign; |
shannonwoods@chromium.org | 9bd22fa | 2013-05-30 00:18:47 +0000 | [diff] [blame] | 1193 | setType(TType(basicType, higherPrecision, EvqTemporary, right->getCols(), left->getRows())); |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1194 | } |
| 1195 | else if (!left->isMatrix() && !right->isMatrix()) |
| 1196 | { |
| 1197 | if (left->isVector() && right->isVector()) |
| 1198 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1199 | // leave as component product |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1200 | } |
| 1201 | else if (left->isVector() || right->isVector()) |
| 1202 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1203 | if (! left->isVector()) |
| 1204 | return false; |
| 1205 | op = EOpVectorTimesScalarAssign; |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1206 | setType(TType(basicType, higherPrecision, EvqTemporary, left->getNominalSize(), 1)); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1207 | } |
shannonwoods@chromium.org | b7dc403 | 2013-05-30 00:18:18 +0000 | [diff] [blame] | 1208 | } |
| 1209 | else |
| 1210 | { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1211 | infoSink.info.message(EPrefixInternalError, getLine(), "Missing elses"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1212 | return false; |
| 1213 | } |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1214 | |
| 1215 | if (!validateMultiplication(op, left->getType(), right->getType())) |
| 1216 | { |
| 1217 | return false; |
| 1218 | } |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1219 | break; |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1220 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1221 | case EOpAssign: |
| 1222 | case EOpInitialize: |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1223 | case EOpAdd: |
| 1224 | case EOpSub: |
| 1225 | case EOpDiv: |
| 1226 | case EOpAddAssign: |
| 1227 | case EOpSubAssign: |
| 1228 | case EOpDivAssign: |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1229 | { |
| 1230 | if ((left->isMatrix() && right->isVector()) || |
| 1231 | (left->isVector() && right->isMatrix())) |
| 1232 | return false; |
| 1233 | |
| 1234 | // Are the sizes compatible? |
| 1235 | if (left->getNominalSize() != right->getNominalSize() || left->getSecondarySize() != right->getSecondarySize()) |
| 1236 | { |
| 1237 | // If the nominal size of operands do not match: |
| 1238 | // One of them must be scalar. |
| 1239 | if (!left->isScalar() && !right->isScalar()) |
| 1240 | return false; |
| 1241 | |
| 1242 | // Operator cannot be of type pure assignment. |
| 1243 | if (op == EOpAssign || op == EOpInitialize) |
| 1244 | return false; |
| 1245 | } |
| 1246 | |
| 1247 | const int secondarySize = std::max(left->getSecondarySize(), right->getSecondarySize()); |
| 1248 | |
| 1249 | setType(TType(basicType, higherPrecision, EvqTemporary, nominalSize, secondarySize)); |
| 1250 | } |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1251 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1252 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1253 | case EOpEqual: |
| 1254 | case EOpNotEqual: |
| 1255 | case EOpLessThan: |
| 1256 | case EOpGreaterThan: |
| 1257 | case EOpLessThanEqual: |
| 1258 | case EOpGreaterThanEqual: |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1259 | if ((left->getNominalSize() != right->getNominalSize()) || |
| 1260 | (left->getSecondarySize() != right->getSecondarySize())) |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1261 | return false; |
daniel@transgaming.com | a5d7623 | 2010-05-17 09:58:47 +0000 | [diff] [blame] | 1262 | setType(TType(EbtBool, EbpUndefined)); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1263 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1264 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1265 | default: |
| 1266 | return false; |
| 1267 | } |
alokp@chromium.org | 32cfaf4 | 2010-08-23 21:01:13 +0000 | [diff] [blame] | 1268 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1269 | return true; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1270 | } |
| 1271 | |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1272 | bool CompareStruct(const TType& leftNodeType, ConstantUnion* rightUnionArray, ConstantUnion* leftUnionArray) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1273 | { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 1274 | const TFieldList& fields = leftNodeType.getStruct()->fields(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1275 | |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 1276 | size_t structSize = fields.size(); |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1277 | size_t index = 0; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1278 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1279 | for (size_t j = 0; j < structSize; j++) { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 1280 | size_t size = fields[j]->type()->getObjectSize(); |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1281 | for (size_t i = 0; i < size; i++) { |
Jamie Madill | 98493dd | 2013-07-08 14:39:03 -0400 | [diff] [blame] | 1282 | if (fields[j]->type()->getBasicType() == EbtStruct) { |
| 1283 | if (!CompareStructure(*fields[j]->type(), &rightUnionArray[index], &leftUnionArray[index])) |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1284 | return false; |
| 1285 | } else { |
| 1286 | if (leftUnionArray[index] != rightUnionArray[index]) |
| 1287 | return false; |
| 1288 | index++; |
| 1289 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1290 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1291 | } |
| 1292 | } |
| 1293 | return true; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1294 | } |
| 1295 | |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1296 | bool CompareStructure(const TType& leftNodeType, ConstantUnion* rightUnionArray, ConstantUnion* leftUnionArray) |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1297 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1298 | if (leftNodeType.isArray()) { |
| 1299 | TType typeWithoutArrayness = leftNodeType; |
| 1300 | typeWithoutArrayness.clearArrayness(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1301 | |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1302 | size_t arraySize = leftNodeType.getArraySize(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1303 | |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1304 | for (size_t i = 0; i < arraySize; ++i) { |
| 1305 | size_t offset = typeWithoutArrayness.getObjectSize() * i; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1306 | if (!CompareStruct(typeWithoutArrayness, &rightUnionArray[offset], &leftUnionArray[offset])) |
| 1307 | return false; |
| 1308 | } |
| 1309 | } else |
| 1310 | return CompareStruct(leftNodeType, rightUnionArray, leftUnionArray); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1311 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1312 | return true; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1313 | } |
| 1314 | |
| 1315 | // |
| 1316 | // The fold functions see if an operation on a constant can be done in place, |
| 1317 | // without generating run-time code. |
| 1318 | // |
| 1319 | // Returns the node to keep using, which may or may not be the node passed in. |
| 1320 | // |
| 1321 | |
| 1322 | TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNode, TInfoSink& infoSink) |
| 1323 | { |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1324 | ConstantUnion *unionArray = getUnionArrayPointer(); |
Nicolas Capens | bd0ea9c | 2014-03-04 13:53:29 -0500 | [diff] [blame] | 1325 | |
| 1326 | if (!unionArray) |
| 1327 | return 0; |
| 1328 | |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1329 | size_t objectSize = getType().getObjectSize(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1330 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1331 | if (constantNode) |
| 1332 | { |
| 1333 | // binary operations |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1334 | TIntermConstantUnion *node = constantNode->getAsConstantUnion(); |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1335 | ConstantUnion *rightUnionArray = node->getUnionArrayPointer(); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1336 | TType returnType = getType(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1337 | |
Nicolas Capens | bd0ea9c | 2014-03-04 13:53:29 -0500 | [diff] [blame] | 1338 | if (!rightUnionArray) |
| 1339 | return 0; |
| 1340 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1341 | // for a case like float f = 1.2 + vec4(2,3,4,5); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1342 | if (constantNode->getType().getObjectSize() == 1 && objectSize > 1) |
| 1343 | { |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1344 | rightUnionArray = new ConstantUnion[objectSize]; |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1345 | for (size_t i = 0; i < objectSize; ++i) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1346 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1347 | rightUnionArray[i] = *node->getUnionArrayPointer(); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1348 | } |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1349 | returnType = getType(); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1350 | } |
| 1351 | else if (constantNode->getType().getObjectSize() > 1 && objectSize == 1) |
| 1352 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1353 | // for a case like float f = vec4(2,3,4,5) + 1.2; |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1354 | unionArray = new ConstantUnion[constantNode->getType().getObjectSize()]; |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1355 | for (size_t i = 0; i < constantNode->getType().getObjectSize(); ++i) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1356 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1357 | unionArray[i] = *getUnionArrayPointer(); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1358 | } |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1359 | returnType = node->getType(); |
| 1360 | objectSize = constantNode->getType().getObjectSize(); |
| 1361 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1362 | |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1363 | ConstantUnion* tempConstArray = 0; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1364 | TIntermConstantUnion *tempNode; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1365 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1366 | bool boolNodeFlag = false; |
| 1367 | switch(op) { |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1368 | case EOpAdd: |
| 1369 | tempConstArray = new ConstantUnion[objectSize]; |
| 1370 | { |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1371 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1372 | tempConstArray[i] = unionArray[i] + rightUnionArray[i]; |
| 1373 | } |
| 1374 | break; |
| 1375 | case EOpSub: |
| 1376 | tempConstArray = new ConstantUnion[objectSize]; |
| 1377 | { |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1378 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1379 | tempConstArray[i] = unionArray[i] - rightUnionArray[i]; |
| 1380 | } |
| 1381 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1382 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1383 | case EOpMul: |
| 1384 | case EOpVectorTimesScalar: |
| 1385 | case EOpMatrixTimesScalar: |
| 1386 | tempConstArray = new ConstantUnion[objectSize]; |
| 1387 | { |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1388 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1389 | tempConstArray[i] = unionArray[i] * rightUnionArray[i]; |
| 1390 | } |
| 1391 | break; |
| 1392 | |
| 1393 | case EOpMatrixTimesMatrix: |
| 1394 | { |
| 1395 | if (getType().getBasicType() != EbtFloat || node->getBasicType() != EbtFloat) |
| 1396 | { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1397 | infoSink.info.message(EPrefixInternalError, getLine(), "Constant Folding cannot be done for matrix multiply"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1398 | return 0; |
| 1399 | } |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1400 | |
Shannon Woods | 3841b8e | 2013-09-10 18:23:12 -0400 | [diff] [blame] | 1401 | const int leftCols = getCols(); |
| 1402 | const int leftRows = getRows(); |
| 1403 | const int rightCols = constantNode->getType().getCols(); |
| 1404 | const int rightRows = constantNode->getType().getRows(); |
| 1405 | const int resultCols = rightCols; |
| 1406 | const int resultRows = leftRows; |
shannonwoods@chromium.org | 5073333 | 2013-05-30 00:19:07 +0000 | [diff] [blame] | 1407 | |
| 1408 | tempConstArray = new ConstantUnion[resultCols*resultRows]; |
| 1409 | for (int row = 0; row < resultRows; row++) |
| 1410 | { |
| 1411 | for (int column = 0; column < resultCols; column++) |
| 1412 | { |
| 1413 | tempConstArray[resultRows * column + row].setFConst(0.0f); |
| 1414 | for (int i = 0; i < leftCols; i++) |
| 1415 | { |
| 1416 | tempConstArray[resultRows * column + row].setFConst(tempConstArray[resultRows * column + row].getFConst() + unionArray[i * leftRows + row].getFConst() * (rightUnionArray[column * rightRows + i].getFConst())); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1417 | } |
| 1418 | } |
| 1419 | } |
shannonwoods@chromium.org | 5073333 | 2013-05-30 00:19:07 +0000 | [diff] [blame] | 1420 | |
| 1421 | // update return type for matrix product |
| 1422 | returnType.setPrimarySize(resultCols); |
| 1423 | returnType.setSecondarySize(resultRows); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1424 | } |
| 1425 | break; |
| 1426 | |
| 1427 | case EOpDiv: |
| 1428 | { |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1429 | tempConstArray = new ConstantUnion[objectSize]; |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1430 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1431 | { |
| 1432 | switch (getType().getBasicType()) |
| 1433 | { |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 1434 | case EbtFloat: |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1435 | if (rightUnionArray[i] == 0.0f) |
| 1436 | { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1437 | infoSink.info.message(EPrefixWarning, getLine(), "Divide by zero error during constant folding"); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1438 | tempConstArray[i].setFConst(unionArray[i].getFConst() < 0 ? -FLT_MAX : FLT_MAX); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1439 | } |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1440 | else |
| 1441 | { |
| 1442 | tempConstArray[i].setFConst(unionArray[i].getFConst() / rightUnionArray[i].getFConst()); |
| 1443 | } |
| 1444 | break; |
| 1445 | |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 1446 | case EbtInt: |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1447 | if (rightUnionArray[i] == 0) |
| 1448 | { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1449 | infoSink.info.message(EPrefixWarning, getLine(), "Divide by zero error during constant folding"); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1450 | tempConstArray[i].setIConst(INT_MAX); |
| 1451 | } |
| 1452 | else |
| 1453 | { |
| 1454 | tempConstArray[i].setIConst(unionArray[i].getIConst() / rightUnionArray[i].getIConst()); |
| 1455 | } |
| 1456 | break; |
| 1457 | |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 1458 | case EbtUInt: |
| 1459 | if (rightUnionArray[i] == 0) |
| 1460 | { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1461 | infoSink.info.message(EPrefixWarning, getLine(), "Divide by zero error during constant folding"); |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 1462 | tempConstArray[i].setUConst(UINT_MAX); |
| 1463 | } |
| 1464 | else |
| 1465 | { |
| 1466 | tempConstArray[i].setUConst(unionArray[i].getUConst() / rightUnionArray[i].getUConst()); |
| 1467 | } |
| 1468 | break; |
| 1469 | |
| 1470 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1471 | infoSink.info.message(EPrefixInternalError, getLine(), "Constant folding cannot be done for \"/\""); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1472 | return 0; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1473 | } |
| 1474 | } |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1475 | } |
| 1476 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1477 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1478 | case EOpMatrixTimesVector: |
| 1479 | { |
| 1480 | if (node->getBasicType() != EbtFloat) |
| 1481 | { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1482 | infoSink.info.message(EPrefixInternalError, getLine(), "Constant Folding cannot be done for matrix times vector"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1483 | return 0; |
| 1484 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1485 | |
Shannon Woods | 3841b8e | 2013-09-10 18:23:12 -0400 | [diff] [blame] | 1486 | const int matrixCols = getCols(); |
| 1487 | const int matrixRows = getRows(); |
shannonwoods@chromium.org | 5073333 | 2013-05-30 00:19:07 +0000 | [diff] [blame] | 1488 | |
| 1489 | tempConstArray = new ConstantUnion[matrixRows]; |
| 1490 | |
| 1491 | for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++) |
| 1492 | { |
| 1493 | tempConstArray[matrixRow].setFConst(0.0f); |
| 1494 | for (int col = 0; col < matrixCols; col++) |
| 1495 | { |
| 1496 | tempConstArray[matrixRow].setFConst(tempConstArray[matrixRow].getFConst() + ((unionArray[col * matrixRows + matrixRow].getFConst()) * rightUnionArray[col].getFConst())); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1497 | } |
| 1498 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1499 | |
shannonwoods@chromium.org | 5073333 | 2013-05-30 00:19:07 +0000 | [diff] [blame] | 1500 | returnType = node->getType(); |
| 1501 | returnType.setPrimarySize(matrixRows); |
| 1502 | |
| 1503 | tempNode = new TIntermConstantUnion(tempConstArray, returnType); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1504 | tempNode->setLine(getLine()); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1505 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1506 | return tempNode; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1507 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1508 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1509 | case EOpVectorTimesMatrix: |
| 1510 | { |
| 1511 | if (getType().getBasicType() != EbtFloat) |
| 1512 | { |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1513 | infoSink.info.message(EPrefixInternalError, getLine(), "Constant Folding cannot be done for vector times matrix"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1514 | return 0; |
| 1515 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1516 | |
Shannon Woods | 3841b8e | 2013-09-10 18:23:12 -0400 | [diff] [blame] | 1517 | const int matrixCols = constantNode->getType().getCols(); |
| 1518 | const int matrixRows = constantNode->getType().getRows(); |
shannonwoods@chromium.org | 5073333 | 2013-05-30 00:19:07 +0000 | [diff] [blame] | 1519 | |
| 1520 | tempConstArray = new ConstantUnion[matrixCols]; |
| 1521 | |
| 1522 | for (int matrixCol = 0; matrixCol < matrixCols; matrixCol++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1523 | { |
shannonwoods@chromium.org | 5073333 | 2013-05-30 00:19:07 +0000 | [diff] [blame] | 1524 | tempConstArray[matrixCol].setFConst(0.0f); |
| 1525 | for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1526 | { |
shannonwoods@chromium.org | 5073333 | 2013-05-30 00:19:07 +0000 | [diff] [blame] | 1527 | tempConstArray[matrixCol].setFConst(tempConstArray[matrixCol].getFConst() + ((unionArray[matrixRow].getFConst()) * rightUnionArray[matrixCol * matrixRows + matrixRow].getFConst())); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1528 | } |
| 1529 | } |
shannonwoods@chromium.org | 5073333 | 2013-05-30 00:19:07 +0000 | [diff] [blame] | 1530 | |
| 1531 | returnType.setPrimarySize(matrixCols); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1532 | } |
| 1533 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1534 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1535 | case EOpLogicalAnd: // this code is written for possible future use, will not get executed currently |
| 1536 | { |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1537 | tempConstArray = new ConstantUnion[objectSize]; |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1538 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1539 | { |
| 1540 | tempConstArray[i] = unionArray[i] && rightUnionArray[i]; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1541 | } |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1542 | } |
| 1543 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1544 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1545 | case EOpLogicalOr: // this code is written for possible future use, will not get executed currently |
| 1546 | { |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1547 | tempConstArray = new ConstantUnion[objectSize]; |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1548 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1549 | { |
| 1550 | tempConstArray[i] = unionArray[i] || rightUnionArray[i]; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1551 | } |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1552 | } |
| 1553 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1554 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1555 | case EOpLogicalXor: |
| 1556 | { |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1557 | tempConstArray = new ConstantUnion[objectSize]; |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1558 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1559 | { |
| 1560 | switch (getType().getBasicType()) |
| 1561 | { |
| 1562 | case EbtBool: |
| 1563 | tempConstArray[i].setBConst((unionArray[i] == rightUnionArray[i]) ? false : true); |
| 1564 | break; |
| 1565 | default: |
| 1566 | UNREACHABLE(); |
| 1567 | break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1568 | } |
| 1569 | } |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1570 | } |
| 1571 | break; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1572 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1573 | case EOpLessThan: |
| 1574 | assert(objectSize == 1); |
| 1575 | tempConstArray = new ConstantUnion[1]; |
| 1576 | tempConstArray->setBConst(*unionArray < *rightUnionArray); |
| 1577 | returnType = TType(EbtBool, EbpUndefined, EvqConst); |
| 1578 | break; |
| 1579 | |
| 1580 | case EOpGreaterThan: |
| 1581 | assert(objectSize == 1); |
| 1582 | tempConstArray = new ConstantUnion[1]; |
| 1583 | tempConstArray->setBConst(*unionArray > *rightUnionArray); |
| 1584 | returnType = TType(EbtBool, EbpUndefined, EvqConst); |
| 1585 | break; |
| 1586 | |
| 1587 | case EOpLessThanEqual: |
| 1588 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1589 | assert(objectSize == 1); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1590 | ConstantUnion constant; |
| 1591 | constant.setBConst(*unionArray > *rightUnionArray); |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1592 | tempConstArray = new ConstantUnion[1]; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1593 | tempConstArray->setBConst(!constant.getBConst()); |
daniel@transgaming.com | a5d7623 | 2010-05-17 09:58:47 +0000 | [diff] [blame] | 1594 | returnType = TType(EbtBool, EbpUndefined, EvqConst); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1595 | break; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1596 | } |
| 1597 | |
| 1598 | case EOpGreaterThanEqual: |
| 1599 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1600 | assert(objectSize == 1); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1601 | ConstantUnion constant; |
| 1602 | constant.setBConst(*unionArray < *rightUnionArray); |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1603 | tempConstArray = new ConstantUnion[1]; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1604 | tempConstArray->setBConst(!constant.getBConst()); |
daniel@transgaming.com | a5d7623 | 2010-05-17 09:58:47 +0000 | [diff] [blame] | 1605 | returnType = TType(EbtBool, EbpUndefined, EvqConst); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1606 | break; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1607 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1608 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1609 | case EOpEqual: |
| 1610 | if (getType().getBasicType() == EbtStruct) |
| 1611 | { |
| 1612 | if (!CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray)) |
| 1613 | boolNodeFlag = true; |
| 1614 | } |
| 1615 | else |
| 1616 | { |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1617 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1618 | { |
| 1619 | if (unionArray[i] != rightUnionArray[i]) |
| 1620 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1621 | boolNodeFlag = true; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1622 | break; // break out of for loop |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1623 | } |
| 1624 | } |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1625 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1626 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1627 | tempConstArray = new ConstantUnion[1]; |
| 1628 | if (!boolNodeFlag) |
| 1629 | { |
| 1630 | tempConstArray->setBConst(true); |
| 1631 | } |
| 1632 | else |
| 1633 | { |
| 1634 | tempConstArray->setBConst(false); |
| 1635 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1636 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1637 | tempNode = new TIntermConstantUnion(tempConstArray, TType(EbtBool, EbpUndefined, EvqConst)); |
| 1638 | tempNode->setLine(getLine()); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1639 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1640 | return tempNode; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1641 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1642 | case EOpNotEqual: |
| 1643 | if (getType().getBasicType() == EbtStruct) |
| 1644 | { |
| 1645 | if (CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray)) |
| 1646 | boolNodeFlag = true; |
| 1647 | } |
| 1648 | else |
| 1649 | { |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1650 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1651 | { |
| 1652 | if (unionArray[i] == rightUnionArray[i]) |
| 1653 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1654 | boolNodeFlag = true; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1655 | break; // break out of for loop |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1656 | } |
| 1657 | } |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1658 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1659 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1660 | tempConstArray = new ConstantUnion[1]; |
| 1661 | if (!boolNodeFlag) |
| 1662 | { |
| 1663 | tempConstArray->setBConst(true); |
| 1664 | } |
| 1665 | else |
| 1666 | { |
| 1667 | tempConstArray->setBConst(false); |
| 1668 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1669 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1670 | tempNode = new TIntermConstantUnion(tempConstArray, TType(EbtBool, EbpUndefined, EvqConst)); |
| 1671 | tempNode->setLine(getLine()); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1672 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1673 | return tempNode; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1674 | |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1675 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1676 | infoSink.info.message(EPrefixInternalError, getLine(), "Invalid operator for constant folding"); |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1677 | return 0; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1678 | } |
| 1679 | tempNode = new TIntermConstantUnion(tempConstArray, returnType); |
| 1680 | tempNode->setLine(getLine()); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1681 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1682 | return tempNode; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1683 | } |
| 1684 | else |
| 1685 | { |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1686 | // |
| 1687 | // Do unary operations |
| 1688 | // |
| 1689 | TIntermConstantUnion *newNode = 0; |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1690 | ConstantUnion* tempConstArray = new ConstantUnion[objectSize]; |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1691 | for (size_t i = 0; i < objectSize; i++) |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1692 | { |
| 1693 | switch(op) |
| 1694 | { |
| 1695 | case EOpNegative: |
| 1696 | switch (getType().getBasicType()) |
| 1697 | { |
Nicolas Capens | c0f7c61 | 2013-06-05 11:46:09 -0400 | [diff] [blame] | 1698 | case EbtFloat: tempConstArray[i].setFConst(-unionArray[i].getFConst()); break; |
| 1699 | case EbtInt: tempConstArray[i].setIConst(-unionArray[i].getIConst()); break; |
| 1700 | case EbtUInt: tempConstArray[i].setUConst(static_cast<unsigned int>(-static_cast<int>(unionArray[i].getUConst()))); break; |
| 1701 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1702 | infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant"); |
Nicolas Capens | c0f7c61 | 2013-06-05 11:46:09 -0400 | [diff] [blame] | 1703 | return 0; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1704 | } |
| 1705 | break; |
| 1706 | |
| 1707 | case EOpLogicalNot: // this code is written for possible future use, will not get executed currently |
| 1708 | switch (getType().getBasicType()) |
| 1709 | { |
Nicolas Capens | c0f7c61 | 2013-06-05 11:46:09 -0400 | [diff] [blame] | 1710 | case EbtBool: tempConstArray[i].setBConst(!unionArray[i].getBConst()); break; |
| 1711 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1712 | infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant"); |
Nicolas Capens | c0f7c61 | 2013-06-05 11:46:09 -0400 | [diff] [blame] | 1713 | return 0; |
shannonwoods@chromium.org | 9fc85b1 | 2013-05-30 00:19:00 +0000 | [diff] [blame] | 1714 | } |
| 1715 | break; |
| 1716 | |
| 1717 | default: |
| 1718 | return 0; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1719 | } |
| 1720 | } |
| 1721 | newNode = new TIntermConstantUnion(tempConstArray, getType()); |
| 1722 | newNode->setLine(getLine()); |
| 1723 | return newNode; |
| 1724 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1725 | } |
| 1726 | |
| 1727 | TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermConstantUnion* node) |
| 1728 | { |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1729 | size_t size = node->getType().getObjectSize(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1730 | |
alokp@chromium.org | 6ff56fd | 2010-05-05 16:37:50 +0000 | [diff] [blame] | 1731 | ConstantUnion *leftUnionArray = new ConstantUnion[size]; |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1732 | |
Jamie Madill | 94bf7f2 | 2013-07-08 13:31:15 -0400 | [diff] [blame] | 1733 | for (size_t i=0; i < size; i++) { |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1734 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1735 | switch (promoteTo) { |
| 1736 | case EbtFloat: |
| 1737 | switch (node->getType().getBasicType()) { |
| 1738 | case EbtInt: |
shannon.woods%transgaming.com@gtempaccount.com | 812c3f1 | 2013-04-13 03:30:01 +0000 | [diff] [blame] | 1739 | leftUnionArray[i].setFConst(static_cast<float>(node->getIConst(i))); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1740 | break; |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 1741 | case EbtUInt: |
| 1742 | leftUnionArray[i].setFConst(static_cast<float>(node->getUConst(i))); |
| 1743 | break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1744 | case EbtBool: |
shannon.woods%transgaming.com@gtempaccount.com | 812c3f1 | 2013-04-13 03:30:01 +0000 | [diff] [blame] | 1745 | leftUnionArray[i].setFConst(static_cast<float>(node->getBConst(i))); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1746 | break; |
| 1747 | case EbtFloat: |
shannon.woods%transgaming.com@gtempaccount.com | 812c3f1 | 2013-04-13 03:30:01 +0000 | [diff] [blame] | 1748 | leftUnionArray[i].setFConst(static_cast<float>(node->getFConst(i))); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1749 | break; |
| 1750 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1751 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Cannot promote"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1752 | return 0; |
| 1753 | } |
| 1754 | break; |
| 1755 | case EbtInt: |
| 1756 | switch (node->getType().getBasicType()) { |
| 1757 | case EbtInt: |
shannon.woods%transgaming.com@gtempaccount.com | 812c3f1 | 2013-04-13 03:30:01 +0000 | [diff] [blame] | 1758 | leftUnionArray[i].setIConst(static_cast<int>(node->getIConst(i))); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1759 | break; |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 1760 | case EbtUInt: |
| 1761 | leftUnionArray[i].setIConst(static_cast<int>(node->getUConst(i))); |
| 1762 | break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1763 | case EbtBool: |
shannon.woods%transgaming.com@gtempaccount.com | 812c3f1 | 2013-04-13 03:30:01 +0000 | [diff] [blame] | 1764 | leftUnionArray[i].setIConst(static_cast<int>(node->getBConst(i))); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1765 | break; |
| 1766 | case EbtFloat: |
shannon.woods%transgaming.com@gtempaccount.com | 812c3f1 | 2013-04-13 03:30:01 +0000 | [diff] [blame] | 1767 | leftUnionArray[i].setIConst(static_cast<int>(node->getFConst(i))); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1768 | break; |
| 1769 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1770 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Cannot promote"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1771 | return 0; |
| 1772 | } |
| 1773 | break; |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 1774 | case EbtUInt: |
| 1775 | switch (node->getType().getBasicType()) { |
| 1776 | case EbtInt: |
| 1777 | leftUnionArray[i].setUConst(static_cast<unsigned int>(node->getIConst(i))); |
| 1778 | break; |
| 1779 | case EbtUInt: |
| 1780 | leftUnionArray[i].setUConst(static_cast<unsigned int>(node->getUConst(i))); |
| 1781 | break; |
| 1782 | case EbtBool: |
| 1783 | leftUnionArray[i].setUConst(static_cast<unsigned int>(node->getBConst(i))); |
| 1784 | break; |
| 1785 | case EbtFloat: |
| 1786 | leftUnionArray[i].setUConst(static_cast<unsigned int>(node->getFConst(i))); |
| 1787 | break; |
| 1788 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1789 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Cannot promote"); |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 1790 | return 0; |
| 1791 | } |
| 1792 | break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1793 | case EbtBool: |
| 1794 | switch (node->getType().getBasicType()) { |
| 1795 | case EbtInt: |
shannon.woods%transgaming.com@gtempaccount.com | 812c3f1 | 2013-04-13 03:30:01 +0000 | [diff] [blame] | 1796 | leftUnionArray[i].setBConst(node->getIConst(i) != 0); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1797 | break; |
shannonwoods@chromium.org | 6b70991 | 2013-05-30 00:20:04 +0000 | [diff] [blame] | 1798 | case EbtUInt: |
| 1799 | leftUnionArray[i].setBConst(node->getUConst(i) != 0); |
| 1800 | break; |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1801 | case EbtBool: |
shannon.woods%transgaming.com@gtempaccount.com | 812c3f1 | 2013-04-13 03:30:01 +0000 | [diff] [blame] | 1802 | leftUnionArray[i].setBConst(node->getBConst(i)); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1803 | break; |
| 1804 | case EbtFloat: |
shannon.woods%transgaming.com@gtempaccount.com | 812c3f1 | 2013-04-13 03:30:01 +0000 | [diff] [blame] | 1805 | leftUnionArray[i].setBConst(node->getFConst(i) != 0.0f); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1806 | break; |
| 1807 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1808 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Cannot promote"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1809 | return 0; |
| 1810 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1811 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1812 | break; |
| 1813 | default: |
Jamie Madill | 075edd8 | 2013-07-08 13:30:19 -0400 | [diff] [blame] | 1814 | infoSink.info.message(EPrefixInternalError, node->getLine(), "Incorrect data type found"); |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1815 | return 0; |
| 1816 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1817 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1818 | } |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1819 | |
alokp@chromium.org | 2cf1771 | 2010-03-30 20:33:18 +0000 | [diff] [blame] | 1820 | const TType& t = node->getType(); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1821 | |
shannonwoods@chromium.org | 09e0988 | 2013-05-30 00:18:25 +0000 | [diff] [blame] | 1822 | return addConstantUnion(leftUnionArray, TType(promoteTo, t.getPrecision(), t.getQualifier(), t.getNominalSize(), t.getSecondarySize(), t.isArray()), node->getLine()); |
daniel@transgaming.com | 4f39fd9 | 2010-03-08 20:26:45 +0000 | [diff] [blame] | 1823 | } |
| 1824 | |
daniel@transgaming.com | 0aa3b5a | 2012-11-28 19:43:24 +0000 | [diff] [blame] | 1825 | // static |
| 1826 | TString TIntermTraverser::hash(const TString& name, ShHashFunction64 hashFunction) |
| 1827 | { |
| 1828 | if (hashFunction == NULL || name.empty()) |
| 1829 | return name; |
| 1830 | khronos_uint64_t number = (*hashFunction)(name.c_str(), name.length()); |
| 1831 | TStringStream stream; |
| 1832 | stream << HASHED_NAME_PREFIX << std::hex << number; |
| 1833 | TString hashedName = stream.str(); |
| 1834 | return hashedName; |
| 1835 | } |