src/OpenGL/compiler/OutputASM.cpp

   1 // SwiftShader Software Renderer\r
   2 //\r
   3 // Copyright(c) 2005-2013 TransGaming Inc.\r
   4 //\r
   5 // All rights reserved. No part of this software may be copied, distributed, transmitted,\r
   6 // transcribed, stored in a retrieval system, translated into any human or computer\r
   7 // language by any means, or disclosed to third parties without the explicit written\r
   8 // agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express\r
   9 // or implied, including but not limited to any patent rights, are granted to you.\r
  10 //\r
  11 \r
  12 #include "OutputASM.h"\r
  13 \r
  14 #include "common/debug.h"\r
  15 #include "InfoSink.h"\r
  16 \r
  17 #include "libGLESv2/Shader.h"\r
  18 \r
  19 #include <GLES2/gl2.h>\r
  20 #include <GLES2/gl2ext.h>\r
  21 #include <GLES3/gl3.h>\r
  22 \r
  23 namespace glsl\r
  24 {\r
  25         // Integer to TString conversion\r
  26         TString str(int i)\r
  27         {\r
  28                 char buffer[20];\r
  29                 sprintf(buffer, "%d", i);\r
  30                 return buffer;\r
  31         }\r
  32 \r
  33         class Temporary : public TIntermSymbol\r
  34         {\r
  35         public:\r
  36                 Temporary(OutputASM *assembler) : TIntermSymbol(0, "tmp", TType(EbtFloat, EbpHigh, EvqTemporary, 4, 1, false)), assembler(assembler)\r
  37                 {\r
  38                 }\r
  39 \r
  40                 ~Temporary()\r
  41                 {\r
  42                         assembler->freeTemporary(this);\r
  43                 }\r
  44 \r
  45         private:\r
  46                 OutputASM *const assembler;\r
  47         };\r
  48 \r
  49         class Constant : public TIntermConstantUnion\r
  50         {\r
  51         public:\r
  52                 Constant(float x, float y, float z, float w) : TIntermConstantUnion(constants, TType(EbtFloat, EbpHigh, EvqConstExpr, 4, 1, false))\r
  53                 {\r
  54                         constants[0].setFConst(x);\r
  55                         constants[1].setFConst(y);\r
  56                         constants[2].setFConst(z);\r
  57                         constants[3].setFConst(w);\r
  58                 }\r
  59 \r
  60                 Constant(bool b) : TIntermConstantUnion(constants, TType(EbtBool, EbpHigh, EvqConstExpr, 1, 1, false))\r
  61                 {\r
  62                         constants[0].setBConst(b);\r
  63                 }\r
  64 \r
  65                 Constant(int i) : TIntermConstantUnion(constants, TType(EbtInt, EbpHigh, EvqConstExpr, 1, 1, false))\r
  66                 {\r
  67                         constants[0].setIConst(i);\r
  68                 }\r
  69 \r
  70                 ~Constant()\r
  71                 {\r
  72                 }\r
  73 \r
  74         private:\r
  75                 ConstantUnion constants[4];\r
  76         };\r
  77 \r
  78         Uniform::Uniform(GLenum type, GLenum precision, const std::string &name, int arraySize, int registerIndex)\r
  79         {\r
  80                 this->type = type;\r
  81                 this->precision = precision;\r
  82                 this->name = name;\r
  83                 this->arraySize = arraySize;\r
  84                 this->registerIndex = registerIndex;\r
  85         }\r
  86 \r
  87         Attribute::Attribute()\r
  88         {\r
  89                 type = GL_NONE;\r
  90                 arraySize = 0;\r
  91                 registerIndex = 0;\r
  92         }\r
  93 \r
  94         Attribute::Attribute(GLenum type, const std::string &name, int arraySize, int registerIndex)\r
  95         {\r
  96                 this->type = type;\r
  97                 this->name = name;\r
  98                 this->arraySize = arraySize;\r
  99                 this->registerIndex = registerIndex;\r
 100         }\r
 101 \r
 102         sw::PixelShader *Shader::getPixelShader() const\r
 103         {\r
 104                 return 0;\r
 105         }\r
 106 \r
 107         sw::VertexShader *Shader::getVertexShader() const\r
 108         {\r
 109                 return 0;\r
 110         }\r
 111 \r
 112         OutputASM::OutputASM(TParseContext &context, Shader *shaderObject) : TIntermTraverser(true, true, true), mContext(context), shaderObject(shaderObject)\r
 113         {\r
 114                 shader = 0;\r
 115                 pixelShader = 0;\r
 116                 vertexShader = 0;\r
 117 \r
 118                 if(shaderObject)\r
 119                 {\r
 120                         shader = shaderObject->getShader();\r
 121                         pixelShader = shaderObject->getPixelShader();\r
 122                         vertexShader = shaderObject->getVertexShader();\r
 123                 }\r
 124 \r
 125                 functionArray.push_back(Function(0, "main(", 0, 0));\r
 126                 currentFunction = 0;\r
 127                 outputQualifier = EvqOutput; // Set outputQualifier to any value other than EvqFragColor or EvqFragData\r
 128         }\r
 129 \r
 130         OutputASM::~OutputASM()\r
 131         {\r
 132         }\r
 133 \r
 134         void OutputASM::output()\r
 135         {\r
 136                 if(shader)\r
 137                 {\r
 138                         emitShader(GLOBAL);\r
 139 \r
 140                         if(functionArray.size() > 1)   // Only call main() when there are other functions\r
 141                         {\r
 142                                 Instruction *callMain = emit(sw::Shader::OPCODE_CALL);\r
 143                                 callMain->dst.type = sw::Shader::PARAMETER_LABEL;\r
 144                                 callMain->dst.index = 0;   // main()\r
 145 \r
 146                                 emit(sw::Shader::OPCODE_RET);\r
 147                         }\r
 148 \r
 149                         emitShader(FUNCTION);\r
 150                 }\r
 151         }\r
 152 \r
 153         void OutputASM::emitShader(Scope scope)\r
 154         {\r
 155                 emitScope = scope;\r
 156                 currentScope = GLOBAL;\r
 157                 mContext.getTreeRoot()->traverse(this);\r
 158         }\r
 159 \r
 160         void OutputASM::freeTemporary(Temporary *temporary)\r
 161         {\r
 162                 free(temporaries, temporary);\r
 163         }\r
 164 \r
 165         void OutputASM::visitSymbol(TIntermSymbol *symbol)\r
 166         {\r
 167                 // Vertex varyings don't have to be actively used to successfully link\r
 168                 // against pixel shaders that use them. So make sure they're declared.\r
 169                 if(symbol->getQualifier() == EvqVaryingOut || symbol->getQualifier() == EvqInvariantVaryingOut || symbol->getQualifier() == EvqVertexOut)\r
 170                 {\r
 171                         if(symbol->getBasicType() != EbtInvariant)   // Typeless declarations are not new varyings\r
 172                         {\r
 173                                 declareVarying(symbol, -1);\r
 174                         }\r
 175                 }\r
 176         }\r
 177 \r
 178         bool OutputASM::visitBinary(Visit visit, TIntermBinary *node)\r
 179         {\r
 180                 if(currentScope != emitScope)\r
 181                 {\r
 182                         return false;\r
 183                 }\r
 184 \r
 185                 TIntermTyped *result = node;\r
 186                 TIntermTyped *left = node->getLeft();\r
 187                 TIntermTyped *right = node->getRight();\r
 188                 const TType &leftType = left->getType();\r
 189                 const TType &rightType = right->getType();\r
 190                 const TType &resultType = node->getType();\r
 191                 \r
 192                 switch(node->getOp())\r
 193                 {\r
 194                 case EOpAssign:\r
 195                         if(visit == PostVisit)\r
 196                         {\r
 197                                 assignLvalue(left, right);\r
 198                                 copy(result, right);\r
 199                         }\r
 200                         break;\r
 201                 case EOpInitialize:\r
 202                         if(visit == PostVisit)\r
 203                         {\r
 204                                 copy(left, right);\r
 205                         }\r
 206                         break;\r
 207                 case EOpMatrixTimesScalarAssign:\r
 208                         if(visit == PostVisit)\r
 209                         {\r
 210                                 for(int i = 0; i < leftType.getNominalSize(); i++)\r
 211                                 {\r
 212                                         Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
 213                                         mul->dst.index += i;\r
 214                                         argument(mul->src[0], left, i);\r
 215                                 }\r
 216 \r
 217                                 assignLvalue(left, result);\r
 218                         }\r
 219                         break;\r
 220                 case EOpVectorTimesMatrixAssign:\r
 221                         if(visit == PostVisit)\r
 222                         {\r
 223                                 int size = leftType.getNominalSize();\r
 224 \r
 225                                 for(int i = 0; i < size; i++)\r
 226                                 {\r
 227                                         Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, left, right);\r
 228                                         dot->dst.mask = 1 << i;\r
 229                                         argument(dot->src[1], right, i);\r
 230                                 }\r
 231 \r
 232                                 assignLvalue(left, result);\r
 233                         }\r
 234                         break;\r
 235                 case EOpMatrixTimesMatrixAssign:\r
 236                         if(visit == PostVisit)\r
 237                         {\r
 238                                 int dim = leftType.getNominalSize();\r
 239 \r
 240                                 for(int i = 0; i < dim; i++)\r
 241                                 {\r
 242                                         Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
 243                                         mul->dst.index += i;\r
 244                                         argument(mul->src[1], right, i);\r
 245                                         mul->src[1].swizzle = 0x00;\r
 246 \r
 247                                         for(int j = 1; j < dim; j++)\r
 248                                         {\r
 249                                                 Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);\r
 250                                                 mad->dst.index += i;\r
 251                                                 argument(mad->src[0], left, j);\r
 252                                                 argument(mad->src[1], right, i);\r
 253                                                 mad->src[1].swizzle = j * 0x55;\r
 254                                                 argument(mad->src[2], result, i);\r
 255                                         }\r
 256                                 }\r
 257 \r
 258                                 assignLvalue(left, result);\r
 259                         }\r
 260                         break;\r
 261                 case EOpIndexDirect:\r
 262                         if(visit == PostVisit)\r
 263                         {\r
 264                                 int index = right->getAsConstantUnion()->getIConst(0);\r
 265 \r
 266                                 if(result->isMatrix() || result->isStruct())\r
 267                                 {\r
 268                                         ASSERT(left->isArray());\r
 269                                         copy(result, left, index * left->elementRegisterCount());\r
 270                                 }\r
 271                                 else if(result->isRegister())\r
 272                                 {\r
 273                                         Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);\r
 274 \r
 275                                         if(left->isRegister())\r
 276                                         {\r
 277                                                 mov->src[0].swizzle = index;\r
 278                                         }\r
 279                                         else if(left->isArray())\r
 280                                         {\r
 281                                                 argument(mov->src[0], left, index * left->elementRegisterCount());\r
 282                                         }\r
 283                                         else if(left->isMatrix())\r
 284                                         {\r
 285                                                 ASSERT(index < left->getNominalSize());   // FIXME: Report semantic error\r
 286                                                 argument(mov->src[0], left, index);\r
 287                                         }\r
 288                                         else UNREACHABLE(0);\r
 289                                 }\r
 290                                 else UNREACHABLE(0);\r
 291                         }\r
 292                         break;\r
 293                 case EOpIndexIndirect:\r
 294                         if(visit == PostVisit)\r
 295                         {\r
 296                                 if(left->isArray() || left->isMatrix())\r
 297                                 {\r
 298                                         for(int index = 0; index < result->totalRegisterCount(); index++)\r
 299                                         {\r
 300                                                 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);\r
 301                                                 mov->dst.index += index;\r
 302                                                 mov->dst.mask = writeMask(result, index);\r
 303                                                 argument(mov->src[0], left, index);\r
 304 \r
 305                                                 if(left->totalRegisterCount() > 1)\r
 306                                                 {\r
 307                                                         sw::Shader::SourceParameter relativeRegister;\r
 308                                                         argument(relativeRegister, right);\r
 309 \r
 310                                                         mov->src[0].rel.type = relativeRegister.type;\r
 311                                                         mov->src[0].rel.index = relativeRegister.index;\r
 312                                                         mov->src[0].rel.scale = result->totalRegisterCount();\r
 313                                                         mov->src[0].rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);\r
 314                                                 }\r
 315                                         }\r
 316                                 }\r
 317                                 else if(left->isRegister())\r
 318                                 {\r
 319                                         emit(sw::Shader::OPCODE_EXTRACT, result, left, right);\r
 320                                 }\r
 321                                 else UNREACHABLE(0);\r
 322                         }\r
 323                         break;\r
 324                 case EOpIndexDirectStruct:\r
 325                 case EOpIndexDirectInterfaceBlock:\r
 326                         if(visit == PostVisit)\r
 327                         {\r
 328                                 ASSERT(leftType.isStruct() || (leftType.isInterfaceBlock()));\r
 329 \r
 330                                 const TFieldList& fields = (node->getOp() == EOpIndexDirectStruct) ?\r
 331                                                            leftType.getStruct()->fields() :\r
 332                                                            leftType.getInterfaceBlock()->fields();\r
 333                                 int index = right->getAsConstantUnion()->getIConst(0);\r
 334                                 int fieldOffset = 0;\r
 335 \r
 336                                 for(int i = 0; i < index; i++)\r
 337                                 {\r
 338                                         fieldOffset += fields[i]->type()->totalRegisterCount();\r
 339                                 }\r
 340 \r
 341                                 copy(result, left, fieldOffset);\r
 342                         }\r
 343                         break;\r
 344                 case EOpVectorSwizzle:\r
 345                         if(visit == PostVisit)\r
 346                         {\r
 347                                 int swizzle = 0;\r
 348                                 TIntermAggregate *components = right->getAsAggregate();\r
 349 \r
 350                                 if(components)\r
 351                                 {\r
 352                                         TIntermSequence &sequence = components->getSequence();\r
 353                                         int component = 0;\r
 354 \r
 355                                         for(TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++)\r
 356                                         {\r
 357                                                 TIntermConstantUnion *element = (*sit)->getAsConstantUnion();\r
 358 \r
 359                                                 if(element)\r
 360                                                 {\r
 361                                                         int i = element->getUnionArrayPointer()[0].getIConst();\r
 362                                                         swizzle |= i << (component * 2);\r
 363                                                         component++;\r
 364                                                 }\r
 365                                                 else UNREACHABLE(0);\r
 366                                         }\r
 367                                 }\r
 368                                 else UNREACHABLE(0);\r
 369 \r
 370                                 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);\r
 371                                 mov->src[0].swizzle = swizzle;\r
 372                         }\r
 373                         break;\r
 374                 case EOpAddAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_ADD, result, left, left, right); break;\r
 375                 case EOpAdd:       if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_ADD, result, left, right);       break;\r
 376                 case EOpSubAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_SUB, result, left, left, right); break;\r
 377                 case EOpSub:       if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_SUB, result, left, right);       break;\r
 378                 case EOpMulAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_MUL, result, left, left, right); break;\r
 379                 case EOpMul:       if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_MUL, result, left, right);       break;\r
 380                 case EOpDivAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_DIV, result, left, left, right); break;\r
 381                 case EOpDiv:       if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_DIV, result, left, right);       break;\r
 382                 case EOpEqual:\r
 383                         if(visit == PostVisit)\r
 384                         {\r
 385                                 emitCmp(sw::Shader::CONTROL_EQ, result, left, right);\r
 386 \r
 387                                 for(int index = 1; index < left->totalRegisterCount(); index++)\r
 388                                 {\r
 389                                         Temporary equal(this);\r
 390                                         emitCmp(sw::Shader::CONTROL_EQ, &equal, left, right, index);\r
 391                                         emit(sw::Shader::OPCODE_AND, result, result, &equal);\r
 392                                 }\r
 393                         }\r
 394                         break;\r
 395                 case EOpNotEqual:\r
 396                         if(visit == PostVisit)\r
 397                         {\r
 398                                 emitCmp(sw::Shader::CONTROL_NE, result, left, right);\r
 399 \r
 400                                 for(int index = 1; index < left->totalRegisterCount(); index++)\r
 401                                 {\r
 402                                         Temporary notEqual(this);\r
 403                                         emitCmp(sw::Shader::CONTROL_NE, &notEqual, left, right, index);\r
 404                                         emit(sw::Shader::OPCODE_OR, result, result, &notEqual);\r
 405                                 }\r
 406                         }\r
 407                         break;\r
 408                 case EOpLessThan:                if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, left, right); break;\r
 409                 case EOpGreaterThan:             if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, left, right); break;\r
 410                 case EOpLessThanEqual:           if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, left, right); break;\r
 411                 case EOpGreaterThanEqual:        if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, left, right); break;\r
 412                 case EOpVectorTimesScalarAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_MUL, result, left, left, right); break;\r
 413                 case EOpVectorTimesScalar:       if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, left, right); break;\r
 414                 case EOpMatrixTimesScalar:\r
 415                         if(visit == PostVisit)\r
 416                         {\r
 417                                 for(int i = 0; i < leftType.getNominalSize(); i++)\r
 418                                 {\r
 419                                         Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
 420                                         mul->dst.index += i;\r
 421                                         argument(mul->src[0], left, i);\r
 422                                 }\r
 423                         }\r
 424                         break;\r
 425                 case EOpVectorTimesMatrix:\r
 426                         if(visit == PostVisit)\r
 427                         {\r
 428                                 int size = leftType.getNominalSize();\r
 429 \r
 430                                 for(int i = 0; i < size; i++)\r
 431                                 {\r
 432                                         Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, left, right);\r
 433                                         dot->dst.mask = 1 << i;\r
 434                                         argument(dot->src[1], right, i);\r
 435                                 }\r
 436                         }\r
 437                         break;\r
 438                 case EOpMatrixTimesVector:\r
 439                         if(visit == PostVisit)\r
 440                         {\r
 441                                 Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
 442                                 mul->src[1].swizzle = 0x00;\r
 443 \r
 444                                 for(int i = 1; i < leftType.getNominalSize(); i++)\r
 445                                 {\r
 446                                         Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);\r
 447                                         argument(mad->src[0], left, i);\r
 448                                         mad->src[1].swizzle = i * 0x55;\r
 449                                 }\r
 450                         }\r
 451                         break;\r
 452                 case EOpMatrixTimesMatrix:\r
 453                         if(visit == PostVisit)\r
 454                         {\r
 455                                 int dim = leftType.getNominalSize();\r
 456 \r
 457                                 for(int i = 0; i < dim; i++)\r
 458                                 {\r
 459                                         Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
 460                                         mul->dst.index += i;\r
 461                                         argument(mul->src[1], right, i);\r
 462                                         mul->src[1].swizzle = 0x00;\r
 463 \r
 464                                         for(int j = 1; j < dim; j++)\r
 465                                         {\r
 466                                                 Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);\r
 467                                                 mad->dst.index += i;\r
 468                                                 argument(mad->src[0], left, j);\r
 469                                                 argument(mad->src[1], right, i);\r
 470                                                 mad->src[1].swizzle = j * 0x55;\r
 471                                                 argument(mad->src[2], result, i);\r
 472                                         }\r
 473                                 }\r
 474                         }\r
 475                         break;\r
 476                 case EOpLogicalOr:\r
 477                         if(trivial(right, 6))\r
 478                         {\r
 479                                 if(visit == PostVisit)\r
 480                                 {\r
 481                                         emit(sw::Shader::OPCODE_OR, result, left, right);\r
 482                                 }\r
 483                         }\r
 484                         else   // Short-circuit evaluation\r
 485                         {\r
 486                                 if(visit == InVisit)\r
 487                                 {\r
 488                                         emit(sw::Shader::OPCODE_MOV, result, left);\r
 489                                         Instruction *ifnot = emit(sw::Shader::OPCODE_IF, 0, result);\r
 490                                         ifnot->src[0].modifier = sw::Shader::MODIFIER_NOT;\r
 491                                 }\r
 492                                 else if(visit == PostVisit)\r
 493                                 {\r
 494                                         emit(sw::Shader::OPCODE_MOV, result, right);\r
 495                                         emit(sw::Shader::OPCODE_ENDIF);\r
 496                                 }\r
 497                         }\r
 498                         break;\r
 499                 case EOpLogicalXor:        if(visit == PostVisit) emit(sw::Shader::OPCODE_XOR, result, left, right); break;\r
 500                 case EOpLogicalAnd:\r
 501                         if(trivial(right, 6))\r
 502                         {\r
 503                                 if(visit == PostVisit)\r
 504                                 {\r
 505                                         emit(sw::Shader::OPCODE_AND, result, left, right);\r
 506                                 }\r
 507                         }\r
 508                         else   // Short-circuit evaluation\r
 509                         {\r
 510                                 if(visit == InVisit)\r
 511                                 {\r
 512                                         emit(sw::Shader::OPCODE_MOV, result, left);\r
 513                                         emit(sw::Shader::OPCODE_IF, 0, result);\r
 514                                 }\r
 515                                 else if(visit == PostVisit)\r
 516                                 {\r
 517                                         emit(sw::Shader::OPCODE_MOV, result, right);\r
 518                                         emit(sw::Shader::OPCODE_ENDIF);\r
 519                                 }\r
 520                         }\r
 521                         break;\r
 522                 default: UNREACHABLE(node->getOp());\r
 523                 }\r
 524 \r
 525                 return true;\r
 526         }\r
 527 \r
 528         bool OutputASM::visitUnary(Visit visit, TIntermUnary *node)\r
 529         {\r
 530                 if(currentScope != emitScope)\r
 531                 {\r
 532                         return false;\r
 533                 }\r
 534 \r
 535                 Constant one(1.0f, 1.0f, 1.0f, 1.0f);\r
 536                 Constant rad(1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f);\r
 537                 Constant deg(5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f);\r
 538 \r
 539                 TIntermTyped *result = node;\r
 540                 TIntermTyped *arg = node->getOperand();\r
 541 \r
 542                 switch(node->getOp())\r
 543                 {\r
 544                 case EOpNegative:\r
 545                         if(visit == PostVisit)\r
 546                         {\r
 547                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 548                                 {\r
 549                                         Instruction *neg = emit(sw::Shader::OPCODE_MOV, result, arg);\r
 550                                         neg->dst.index += index;\r
 551                                         argument(neg->src[0], arg, index);\r
 552                                         neg->src[0].modifier = sw::Shader::MODIFIER_NEGATE;\r
 553                                 }\r
 554                         }\r
 555                         break;\r
 556                 case EOpVectorLogicalNot: if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;\r
 557                 case EOpLogicalNot:       if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;\r
 558                 case EOpPostIncrement:\r
 559                         if(visit == PostVisit)\r
 560                         {\r
 561                                 copy(result, arg);\r
 562 \r
 563                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 564                                 {\r
 565                                         Instruction *add = emit(sw::Shader::OPCODE_ADD, arg, arg, &one);\r
 566                                         add->dst.index += index;\r
 567                                         argument(add->src[0], arg, index);\r
 568                                 }\r
 569 \r
 570                                 assignLvalue(arg, arg);\r
 571                         }\r
 572                         break;\r
 573                 case EOpPostDecrement:\r
 574                         if(visit == PostVisit)\r
 575                         {\r
 576                                 copy(result, arg);\r
 577 \r
 578                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 579                                 {\r
 580                                         Instruction *sub = emit(sw::Shader::OPCODE_SUB, arg, arg, &one);\r
 581                                         sub->dst.index += index;\r
 582                                         argument(sub->src[0], arg, index);\r
 583                                 }\r
 584 \r
 585                                 assignLvalue(arg, arg);\r
 586                         }\r
 587                         break;\r
 588                 case EOpPreIncrement:\r
 589                         if(visit == PostVisit)\r
 590                         {\r
 591                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 592                                 {\r
 593                                         Instruction *add = emit(sw::Shader::OPCODE_ADD, result, arg, &one);\r
 594                                         add->dst.index += index;\r
 595                                         argument(add->src[0], arg, index);\r
 596                                 }\r
 597 \r
 598                                 assignLvalue(arg, result);\r
 599                         }\r
 600                         break;\r
 601                 case EOpPreDecrement:\r
 602                         if(visit == PostVisit)\r
 603                         {\r
 604                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 605                                 {\r
 606                                         Instruction *sub = emit(sw::Shader::OPCODE_SUB, result, arg, &one);\r
 607                                         sub->dst.index += index;\r
 608                                         argument(sub->src[0], arg, index);\r
 609                                 }\r
 610 \r
 611                                 assignLvalue(arg, result);\r
 612                         }\r
 613                         break;\r
 614                 case EOpRadians:          if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, &rad); break;\r
 615                 case EOpDegrees:          if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, &deg); break;\r
 616                 case EOpSin:              if(visit == PostVisit) emit(sw::Shader::OPCODE_SIN, result, arg); break;\r
 617                 case EOpCos:              if(visit == PostVisit) emit(sw::Shader::OPCODE_COS, result, arg); break;\r
 618                 case EOpTan:              if(visit == PostVisit) emit(sw::Shader::OPCODE_TAN, result, arg); break;\r
 619                 case EOpAsin:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ASIN, result, arg); break;\r
 620                 case EOpAcos:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOS, result, arg); break;\r
 621                 case EOpAtan:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN, result, arg); break;\r
 622                 case EOpSinh:             if(visit == PostVisit) emit(sw::Shader::OPCODE_SINH, result, arg); break;\r
 623                 case EOpCosh:             if(visit == PostVisit) emit(sw::Shader::OPCODE_COSH, result, arg); break;\r
 624                 case EOpTanh:             if(visit == PostVisit) emit(sw::Shader::OPCODE_TANH, result, arg); break;\r
 625                 case EOpAsinh:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ASINH, result, arg); break;\r
 626                 case EOpAcosh:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOSH, result, arg); break;\r
 627                 case EOpAtanh:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ATANH, result, arg); break;\r
 628                 case EOpExp:              if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP, result, arg); break;\r
 629                 case EOpLog:              if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG, result, arg); break;\r
 630                 case EOpExp2:             if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP2, result, arg); break;\r
 631                 case EOpLog2:             if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG2, result, arg); break;\r
 632                 case EOpSqrt:             if(visit == PostVisit) emit(sw::Shader::OPCODE_SQRT, result, arg); break;\r
 633                 case EOpInverseSqrt:      if(visit == PostVisit) emit(sw::Shader::OPCODE_RSQ, result, arg); break;\r
 634                 case EOpAbs:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ABS, result, arg); break;\r
 635                 case EOpSign:             if(visit == PostVisit) emit(sw::Shader::OPCODE_SGN, result, arg); break;\r
 636                 case EOpFloor:            if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOOR, result, arg); break;\r
 637                 case EOpTrunc:            if(visit == PostVisit) emit(sw::Shader::OPCODE_TRUNC, result, arg); break;\r
 638                 case EOpRound:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ROUND, result, arg); break;\r
 639                 case EOpRoundEven:        if(visit == PostVisit) emit(sw::Shader::OPCODE_ROUNDEVEN, result, arg); break;\r
 640                 case EOpCeil:             if(visit == PostVisit) emit(sw::Shader::OPCODE_CEIL, result, arg, result); break;\r
 641                 case EOpFract:            if(visit == PostVisit) emit(sw::Shader::OPCODE_FRC, result, arg); break;\r
 642                 case EOpIsNan:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ISNAN, result, arg); break;\r
 643                 case EOpIsInf:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ISINF, result, arg); break;\r
 644                 case EOpLength:           if(visit == PostVisit) emit(sw::Shader::OPCODE_LEN(dim(arg)), result, arg); break;\r
 645                 case EOpNormalize:        if(visit == PostVisit) emit(sw::Shader::OPCODE_NRM(dim(arg)), result, arg); break;\r
 646                 case EOpDFdx:             if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDX, result, arg); break;\r
 647                 case EOpDFdy:             if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDY, result, arg); break;\r
 648                 case EOpFwidth:           if(visit == PostVisit) emit(sw::Shader::OPCODE_FWIDTH, result, arg); break;\r
 649                 case EOpAny:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ANY, result, arg); break;\r
 650                 case EOpAll:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ALL, result, arg); break;\r
 651                 case EOpFloatBitsToInt:   if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOATBITSTOINT, result, arg); break;\r
 652                 case EOpFloatBitsToUint:  if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOATBITSTOUINT, result, arg); break;\r
 653                 case EOpIntBitsToFloat:   if(visit == PostVisit) emit(sw::Shader::OPCODE_INTBITSTOFLOAT, result, arg); break;\r
 654                 case EOpUintBitsToFloat:  if(visit == PostVisit) emit(sw::Shader::OPCODE_UINTBITSTOFLOAT, result, arg); break;\r
 655                 case EOpPackSnorm2x16:    if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKSNORM2x16, result, arg); break;\r
 656                 case EOpPackUnorm2x16:    if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKUNORM2x16, result, arg); break;\r
 657                 case EOpPackHalf2x16:     if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKHALF2x16, result, arg); break;\r
 658                 case EOpUnpackSnorm2x16:  if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKSNORM2x16, result, arg); break;\r
 659                 case EOpUnpackUnorm2x16:  if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKUNORM2x16, result, arg); break;\r
 660                 case EOpUnpackHalf2x16:   if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKHALF2x16, result, arg); break;\r
 661                 case EOpTranspose:\r
 662                         if(visit == PostVisit)\r
 663                         {\r
 664                                 int numCols = arg->getNominalSize();\r
 665                                 int numRows = arg->getSecondarySize();\r
 666                                 for(int i = 0; i < numCols; ++i)\r
 667                                 {\r
 668                                         for(int j = 0; j < numRows; ++j)\r
 669                                         {\r
 670                                                 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, arg);\r
 671                                                 mov->src[0].index += i;\r
 672                                                 mov->src[0].swizzle = 0x55 * j;\r
 673                                                 mov->dst.index += j;\r
 674                                                 mov->dst.mask = 1 << i;\r
 675                                         }\r
 676                                 }\r
 677                         }\r
 678                         break;\r
 679                 default: UNREACHABLE(node->getOp());\r
 680                 }\r
 681 \r
 682                 return true;\r
 683         }\r
 684 \r
 685         bool OutputASM::visitAggregate(Visit visit, TIntermAggregate *node)\r
 686         {\r
 687                 if(currentScope != emitScope && node->getOp() != EOpFunction && node->getOp() != EOpSequence)\r
 688                 {\r
 689                         return false;\r
 690                 }\r
 691 \r
 692                 Constant zero(0.0f, 0.0f, 0.0f, 0.0f);\r
 693 \r
 694                 TIntermTyped *result = node;\r
 695                 const TType &resultType = node->getType();\r
 696                 TIntermSequence &arg = node->getSequence();\r
 697                 int argumentCount = arg.size();\r
 698 \r
 699                 switch(node->getOp())\r
 700                 {\r
 701                 case EOpSequence:           break;\r
 702                 case EOpDeclaration:        break;\r
 703                 case EOpPrototype:          break;\r
 704                 case EOpComma:\r
 705                         if(visit == PostVisit)\r
 706                         {\r
 707                                 copy(result, arg[1]);\r
 708                         }\r
 709                         break;\r
 710                 case EOpFunction:\r
 711                         if(visit == PreVisit)\r
 712                         {\r
 713                                 const TString &name = node->getName();\r
 714 \r
 715                                 if(emitScope == FUNCTION)\r
 716                                 {\r
 717                                         if(functionArray.size() > 1)   // No need for a label when there's only main()\r
 718                                         {\r
 719                                                 Instruction *label = emit(sw::Shader::OPCODE_LABEL);\r
 720                                                 label->dst.type = sw::Shader::PARAMETER_LABEL;\r
 721 \r
 722                                                 const Function *function = findFunction(name);\r
 723                                                 ASSERT(function);   // Should have been added during global pass\r
 724                                                 label->dst.index = function->label;\r
 725                                                 currentFunction = function->label;\r
 726                                         }\r
 727                                 }\r
 728                                 else if(emitScope == GLOBAL)\r
 729                                 {\r
 730                                         if(name != "main(")\r
 731                                         {\r
 732                                                 TIntermSequence &arguments = node->getSequence()[0]->getAsAggregate()->getSequence();\r
 733                                                 functionArray.push_back(Function(functionArray.size(), name, &arguments, node));\r
 734                                         }\r
 735                                 }\r
 736                                 else UNREACHABLE(emitScope);\r
 737 \r
 738                                 currentScope = FUNCTION;\r
 739                         }\r
 740                         else if(visit == PostVisit)\r
 741                         {\r
 742                                 if(emitScope == FUNCTION)\r
 743                                 {\r
 744                                         if(functionArray.size() > 1)   // No need to return when there's only main()\r
 745                                         {\r
 746                                                 emit(sw::Shader::OPCODE_RET);\r
 747                                         }\r
 748                                 }\r
 749 \r
 750                                 currentScope = GLOBAL;\r
 751                         }\r
 752                         break;\r
 753                 case EOpFunctionCall:\r
 754                         if(visit == PostVisit)\r
 755                         {\r
 756                                 if(node->isUserDefined())\r
 757                                 {\r
 758                                         const TString &name = node->getName();\r
 759                                         const Function *function = findFunction(name);\r
 760 \r
 761                                         if(!function)\r
 762                                         {\r
 763                                                 mContext.error(node->getLine(), "function definition not found", name.c_str());\r
 764                                                 return false;\r
 765                                         }\r
 766 \r
 767                                         TIntermSequence &arguments = *function->arg;\r
 768 \r
 769                                         for(int i = 0; i < argumentCount; i++)\r
 770                                         {\r
 771                                                 TIntermTyped *in = arguments[i]->getAsTyped();\r
 772 \r
 773                                                 if(in->getQualifier() == EvqIn ||\r
 774                                                    in->getQualifier() == EvqInOut ||\r
 775                                                    in->getQualifier() == EvqConstReadOnly)\r
 776                                                 {\r
 777                                                         copy(in, arg[i]);\r
 778                                                 }\r
 779                                         }\r
 780 \r
 781                                         Instruction *call = emit(sw::Shader::OPCODE_CALL);\r
 782                                         call->dst.type = sw::Shader::PARAMETER_LABEL;\r
 783                                         call->dst.index = function->label;\r
 784 \r
 785                                         if(function->ret && function->ret->getType().getBasicType() != EbtVoid)\r
 786                                         {\r
 787                                                 copy(result, function->ret);\r
 788                                         }\r
 789 \r
 790                                         for(int i = 0; i < argumentCount; i++)\r
 791                                         {\r
 792                                                 TIntermTyped *argument = arguments[i]->getAsTyped();\r
 793                                                 TIntermTyped *out = arg[i]->getAsTyped();\r
 794                                                                 \r
 795                                                 if(argument->getQualifier() == EvqOut ||\r
 796                                                    argument->getQualifier() == EvqInOut)\r
 797                                                 {\r
 798                                                         copy(out, argument);\r
 799                                                 }\r
 800                                         }\r
 801                                 }\r
 802                                 else\r
 803                                 {\r
 804                                         TString name = TFunction::unmangleName(node->getName());\r
 805 \r
 806                                         if(name == "texture" || name == "texture2D" || name == "textureCube" || name == "texture3D")\r
 807                                         {\r
 808                                                 if(argumentCount == 2)\r
 809                                                 {\r
 810                                                         emit(sw::Shader::OPCODE_TEX, result, arg[1], arg[0]);\r
 811                                                 }\r
 812                                                 else if(argumentCount == 3)   // bias\r
 813                                                 {\r
 814                                                         Temporary uvwb(this);\r
 815                                                         emit(sw::Shader::OPCODE_MOV, &uvwb, arg[1]);\r
 816                                                         Instruction *bias = emit(sw::Shader::OPCODE_MOV, &uvwb, arg[2]);\r
 817                                                         bias->dst.mask = 0x8;\r
 818 \r
 819                                                         Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, &uvwb, arg[0]);   // FIXME: Implement an efficient TEXLDB instruction\r
 820                                                         tex->bias = true;\r
 821                                                 }\r
 822                                                 else UNREACHABLE(argumentCount);\r
 823                                         }\r
 824                                         else if(name == "texture2DProj")\r
 825                                         {\r
 826                                                 TIntermTyped *t = arg[1]->getAsTyped();\r
 827 \r
 828                                                 if(argumentCount == 2)\r
 829                                                 {\r
 830                                                         Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, arg[1], arg[0]);\r
 831                                                         tex->project = true;\r
 832 \r
 833                                                         if(t->getNominalSize() == 3)\r
 834                                                         {\r
 835                                                                 tex->src[0].swizzle = 0xA4;\r
 836                                                         }\r
 837                                                         else ASSERT(t->getNominalSize() == 4);\r
 838                                                 }\r
 839                                                 else if(argumentCount == 3)   // bias\r
 840                                                 {\r
 841                                                         Temporary proj(this);\r
 842 \r
 843                                                         if(t->getNominalSize() == 3)\r
 844                                                         {\r
 845                                                                 Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);\r
 846                                                                 div->src[1].swizzle = 0xAA;\r
 847                                                                 div->dst.mask = 0x3;\r
 848                                                         }\r
 849                                                         else if(t->getNominalSize() == 4)\r
 850                                                         {\r
 851                                                                 Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);\r
 852                                                                 div->src[1].swizzle = 0xFF;\r
 853                                                                 div->dst.mask = 0x3;\r
 854                                                         }\r
 855                                                         else UNREACHABLE(t->getNominalSize());\r
 856 \r
 857                                                         Instruction *bias = emit(sw::Shader::OPCODE_MOV, &proj, arg[2]);\r
 858                                                         bias->dst.mask = 0x8;\r
 859 \r
 860                                                         Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, &proj, arg[0]);\r
 861                                                         tex->bias = true;\r
 862                                                 }\r
 863                                                 else UNREACHABLE(argumentCount);\r
 864                                         }\r
 865                                         else if(name == "texture2DLod" || name == "textureCubeLod")\r
 866                                         {\r
 867                                                 Temporary uvwb(this);\r
 868                                                 emit(sw::Shader::OPCODE_MOV, &uvwb, arg[1]);\r
 869                                                 Instruction *lod = emit(sw::Shader::OPCODE_MOV, &uvwb, arg[2]);\r
 870                                                 lod->dst.mask = 0x8;\r
 871 \r
 872                                                 emit(sw::Shader::OPCODE_TEXLDL, result, &uvwb, arg[0]);\r
 873                                         }\r
 874                                         else if(name == "texture2DProjLod")\r
 875                                         {\r
 876                                                 TIntermTyped *t = arg[1]->getAsTyped();\r
 877                                                 Temporary proj(this);\r
 878 \r
 879                                                 if(t->getNominalSize() == 3)\r
 880                                                 {\r
 881                                                         Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);\r
 882                                                         div->src[1].swizzle = 0xAA;\r
 883                                                         div->dst.mask = 0x3;\r
 884                                                 }\r
 885                                                 else if(t->getNominalSize() == 4)\r
 886                                                 {\r
 887                                                         Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);\r
 888                                                         div->src[1].swizzle = 0xFF;\r
 889                                                         div->dst.mask = 0x3;\r
 890                                                 }\r
 891                                                 else UNREACHABLE(t->getNominalSize());\r
 892 \r
 893                                                 Instruction *lod = emit(sw::Shader::OPCODE_MOV, &proj, arg[2]);\r
 894                                                 lod->dst.mask = 0x8;\r
 895 \r
 896                                                 emit(sw::Shader::OPCODE_TEXLDL, result, &proj, arg[0]);\r
 897                                         }\r
 898                                         else UNREACHABLE(0);\r
 899                                 }\r
 900                         }\r
 901                         break;\r
 902                 case EOpParameters:\r
 903                         break;\r
 904                 case EOpConstructFloat:\r
 905                 case EOpConstructVec2:\r
 906                 case EOpConstructVec3:\r
 907                 case EOpConstructVec4:\r
 908                 case EOpConstructBool:\r
 909                 case EOpConstructBVec2:\r
 910                 case EOpConstructBVec3:\r
 911                 case EOpConstructBVec4:\r
 912                 case EOpConstructInt:\r
 913                 case EOpConstructIVec2:\r
 914                 case EOpConstructIVec3:\r
 915                 case EOpConstructIVec4:\r
 916                 case EOpConstructUInt:\r
 917                 case EOpConstructUVec2:\r
 918                 case EOpConstructUVec3:\r
 919                 case EOpConstructUVec4:\r
 920                         if(visit == PostVisit)\r
 921                         {\r
 922                                 int component = 0;\r
 923 \r
 924                                 for(int i = 0; i < argumentCount; i++)\r
 925                                 {\r
 926                                         TIntermTyped *argi = arg[i]->getAsTyped();\r
 927                                         int size = argi->getNominalSize();\r
 928 \r
 929                                         if(!argi->isMatrix())\r
 930                                         {\r
 931                                                 Instruction *mov = emitCast(result, argi);\r
 932                                                 mov->dst.mask = (0xF << component) & 0xF;\r
 933                                                 mov->src[0].swizzle = readSwizzle(argi, size) << (component * 2);\r
 934 \r
 935                                                 component += size;\r
 936                                         }\r
 937                                         else   // Matrix\r
 938                                         {\r
 939                                                 int column = 0;\r
 940 \r
 941                                                 while(component < resultType.getNominalSize())\r
 942                                                 {\r
 943                                                         Instruction *mov = emitCast(result, argi);\r
 944                                                         mov->dst.mask = (0xF << component) & 0xF;\r
 945                                                         mov->src[0].index += column;\r
 946                                                         mov->src[0].swizzle = readSwizzle(argi, size) << (component * 2);\r
 947 \r
 948                                                         column++;\r
 949                                                         component += size;\r
 950                                                 }\r
 951                                         }\r
 952                                 }\r
 953                         }\r
 954                         break;\r
 955                 case EOpConstructMat2:\r
 956                 case EOpConstructMat2x3:\r
 957                 case EOpConstructMat2x4:\r
 958                 case EOpConstructMat3x2:\r
 959                 case EOpConstructMat3:\r
 960                 case EOpConstructMat3x4:\r
 961                 case EOpConstructMat4x2:\r
 962                 case EOpConstructMat4x3:\r
 963                 case EOpConstructMat4:\r
 964                         if(visit == PostVisit)\r
 965                         {\r
 966                                 TIntermTyped *arg0 = arg[0]->getAsTyped();\r
 967                                 const int outCols = result->getNominalSize();\r
 968                                 const int outRows = result->getSecondarySize();\r
 969 \r
 970                                 if(arg0->isScalar() && arg.size() == 1)   // Construct scale matrix\r
 971                                 {\r
 972                                         for(int i = 0; i < outCols; i++)\r
 973                                         {\r
 974                                                 Instruction *init = emit(sw::Shader::OPCODE_MOV, result, &zero);\r
 975                                                 init->dst.index += i;\r
 976                                                 Instruction *mov = emitCast(result, arg0);\r
 977                                                 mov->dst.index += i;\r
 978                                                 mov->dst.mask = 1 << i;\r
 979                                                 ASSERT(mov->src[0].swizzle == 0x00);\r
 980                                         }\r
 981                                 }\r
 982                                 else if(arg0->isMatrix())\r
 983                                 {\r
 984                                         const int inCols = arg0->getNominalSize();\r
 985                                         const int inRows = arg0->getSecondarySize();\r
 986 \r
 987                                         for(int i = 0; i < outCols; i++)\r
 988                                         {\r
 989                                                 if(i >= inCols || outRows > inRows)\r
 990                                                 {\r
 991                                                         // Initialize to identity matrix\r
 992                                                         Constant col((i == 0 ? 1.0f : 0.0f), (i == 1 ? 1.0f : 0.0f), (i == 2 ? 1.0f : 0.0f), (i == 3 ? 1.0f : 0.0f));\r
 993                                                         Instruction *mov = emitCast(result, &col);\r
 994                                                         mov->dst.index += i;\r
 995                                                 }\r
 996 \r
 997                                                 if(i < inCols)\r
 998                                                 {\r
 999                                                         Instruction *mov = emitCast(result, arg0);\r
1000                                                         mov->dst.index += i;\r
1001                                                         mov->dst.mask = 0xF >> (4 - inRows);\r
1002                                                         argument(mov->src[0], arg0, i);\r
1003                                                 }\r
1004                                         }\r
1005                                 }\r
1006                                 else\r
1007                                 {\r
1008                                         int column = 0;\r
1009                                         int row = 0;\r
1010 \r
1011                                         for(int i = 0; i < argumentCount; i++)\r
1012                                         {\r
1013                                                 TIntermTyped *argi = arg[i]->getAsTyped();\r
1014                                                 int size = argi->getNominalSize();\r
1015                                                 int element = 0;\r
1016 \r
1017                                                 while(element < size)\r
1018                                                 {\r
1019                                                         Instruction *mov = emitCast(result, argi);\r
1020                                                         mov->dst.index += column;\r
1021                                                         mov->dst.mask = (0xF << row) & 0xF;\r
1022                                                         mov->src[0].swizzle = (readSwizzle(argi, size) << (row * 2)) + 0x55 * element;\r
1023 \r
1024                                                         int end = row + size - element;\r
1025                                                         column = end >= outRows ? column + 1 : column;\r
1026                                                         element = element + outRows - row;\r
1027                                                         row = end >= outRows ? 0 : end;\r
1028                                                 }\r
1029                                         }\r
1030                                 }\r
1031                         }\r
1032                         break;\r
1033                 case EOpConstructStruct:\r
1034                         if(visit == PostVisit)\r
1035                         {\r
1036                                 int offset = 0;\r
1037                                 for(int i = 0; i < argumentCount; i++)\r
1038                                 {\r
1039                                         TIntermTyped *argi = arg[i]->getAsTyped();\r
1040                                         int size = argi->totalRegisterCount();\r
1041 \r
1042                                         for(int index = 0; index < size; index++)\r
1043                                         {\r
1044                                                 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, argi);\r
1045                                                 mov->dst.index += index + offset;\r
1046                                                 mov->dst.mask = writeMask(result, offset + index);\r
1047                                                 argument(mov->src[0], argi, index);\r
1048                                         }\r
1049 \r
1050                                         offset += size;\r
1051                                 }\r
1052                         }\r
1053                         break;\r
1054                 case EOpLessThan:         if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, arg[0], arg[1]); break;\r
1055                 case EOpGreaterThan:      if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, arg[0], arg[1]); break;\r
1056                 case EOpLessThanEqual:    if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, arg[0], arg[1]); break;\r
1057                 case EOpGreaterThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, arg[0], arg[1]); break;\r
1058                 case EOpVectorEqual:      if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_EQ, result, arg[0], arg[1]); break;\r
1059                 case EOpVectorNotEqual:   if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_NE, result, arg[0], arg[1]); break;\r
1060                 case EOpMod:              if(visit == PostVisit) emit(sw::Shader::OPCODE_MOD, result, arg[0], arg[1]); break;\r
1061                 case EOpPow:              if(visit == PostVisit) emit(sw::Shader::OPCODE_POW, result, arg[0], arg[1]); break;\r
1062                 case EOpAtan:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN2, result, arg[0], arg[1]); break;\r
1063                 case EOpMin:              if(visit == PostVisit) emit(sw::Shader::OPCODE_MIN, result, arg[0], arg[1]); break;\r
1064                 case EOpMax:              if(visit == PostVisit) emit(sw::Shader::OPCODE_MAX, result, arg[0], arg[1]); break;\r
1065                 case EOpClamp:\r
1066                         if(visit == PostVisit)\r
1067                         {\r
1068                                 emit(sw::Shader::OPCODE_MAX, result, arg[0], arg[1]);\r
1069                                 emit(sw::Shader::OPCODE_MIN, result, result, arg[2]);\r
1070                         }\r
1071                         break;\r
1072                 case EOpMix:         if(visit == PostVisit) emit(sw::Shader::OPCODE_LRP, result, arg[2], arg[1], arg[0]); break;\r
1073                 case EOpStep:        if(visit == PostVisit) emit(sw::Shader::OPCODE_STEP, result, arg[0], arg[1]); break;\r
1074                 case EOpSmoothStep:  if(visit == PostVisit) emit(sw::Shader::OPCODE_SMOOTH, result, arg[0], arg[1], arg[2]); break;\r
1075                 case EOpDistance:    if(visit == PostVisit) emit(sw::Shader::OPCODE_DIST(dim(arg[0])), result, arg[0], arg[1]); break;\r
1076                 case EOpDot:         if(visit == PostVisit) emit(sw::Shader::OPCODE_DP(dim(arg[0])), result, arg[0], arg[1]); break;\r
1077                 case EOpCross:       if(visit == PostVisit) emit(sw::Shader::OPCODE_CRS, result, arg[0], arg[1]); break;\r
1078                 case EOpFaceForward: if(visit == PostVisit) emit(sw::Shader::OPCODE_FORWARD(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;\r
1079                 case EOpReflect:     if(visit == PostVisit) emit(sw::Shader::OPCODE_REFLECT(dim(arg[0])), result, arg[0], arg[1]); break;\r
1080                 case EOpRefract:     if(visit == PostVisit) emit(sw::Shader::OPCODE_REFRACT(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;\r
1081                 case EOpMul:\r
1082                         if(visit == PostVisit)\r
1083                         {\r
1084                                 ASSERT(dim2(arg[0]) == dim2(arg[1]));\r
1085 \r
1086                                 for(int i = 0; i < dim2(arg[0]); i++)\r
1087                                 {\r
1088                                         Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, arg[0], arg[1]);\r
1089                                         mul->dst.index += i;\r
1090                                         argument(mul->src[0], arg[0], i);\r
1091                                         argument(mul->src[1], arg[1], i);\r
1092                                 }\r
1093                         }\r
1094                         break;\r
1095                 case EOpOuterProduct:\r
1096                         if(visit == PostVisit)\r
1097                         {\r
1098                                 for(int i = 0; i < dim(arg[1]); i++)\r
1099                                 {\r
1100                                         Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, arg[0], arg[1]);\r
1101                                         mul->dst.index += i;\r
1102                                         mul->src[1].swizzle = 0x55 * i;\r
1103                                 }\r
1104                         }\r
1105                         break;\r
1106                 default: UNREACHABLE(node->getOp());\r
1107                 }\r
1108 \r
1109                 return true;\r
1110         }\r
1111 \r
1112         bool OutputASM::visitSelection(Visit visit, TIntermSelection *node)\r
1113         {\r
1114                 if(currentScope != emitScope)\r
1115                 {\r
1116                         return false;\r
1117                 }\r
1118 \r
1119                 TIntermTyped *condition = node->getCondition();\r
1120                 TIntermNode *trueBlock = node->getTrueBlock();\r
1121                 TIntermNode *falseBlock = node->getFalseBlock();\r
1122                 TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();\r
1123 \r
1124                 condition->traverse(this);\r
1125 \r
1126                 if(node->usesTernaryOperator())\r
1127                 {\r
1128                         if(constantCondition)\r
1129                         {\r
1130                                 bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();\r
1131 \r
1132                                 if(trueCondition)\r
1133                                 {\r
1134                                         trueBlock->traverse(this);\r
1135                                         copy(node, trueBlock);\r
1136                                 }\r
1137                                 else\r
1138                                 {\r
1139                                         falseBlock->traverse(this);\r
1140                                         copy(node, falseBlock);\r
1141                                 }\r
1142                         }\r
1143                         else if(trivial(node, 6))   // Fast to compute both potential results and no side effects\r
1144                         {\r
1145                                 trueBlock->traverse(this);\r
1146                                 falseBlock->traverse(this);\r
1147                                 emit(sw::Shader::OPCODE_SELECT, node, condition, trueBlock, falseBlock);\r
1148                         }\r
1149                         else\r
1150                         {\r
1151                                 emit(sw::Shader::OPCODE_IF, 0, condition);\r
1152 \r
1153                                 if(trueBlock)\r
1154                                 {\r
1155                                         trueBlock->traverse(this);\r
1156                                         copy(node, trueBlock);\r
1157                                 }\r
1158 \r
1159                                 if(falseBlock)\r
1160                                 {\r
1161                                         emit(sw::Shader::OPCODE_ELSE);\r
1162                                         falseBlock->traverse(this);\r
1163                                         copy(node, falseBlock);\r
1164                                 }\r
1165 \r
1166                                 emit(sw::Shader::OPCODE_ENDIF);\r
1167                         }\r
1168                 }\r
1169                 else  // if/else statement\r
1170                 {\r
1171                         if(constantCondition)\r
1172                         {\r
1173                                 bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();\r
1174 \r
1175                                 if(trueCondition)\r
1176                                 {\r
1177                                         if(trueBlock)\r
1178                                         {\r
1179                                                 trueBlock->traverse(this);\r
1180                                         }\r
1181                                 }\r
1182                                 else\r
1183                                 {\r
1184                                         if(falseBlock)\r
1185                                         {\r
1186                                                 falseBlock->traverse(this);\r
1187                                         }\r
1188                                 }\r
1189                         }\r
1190                         else\r
1191                         {\r
1192                                 emit(sw::Shader::OPCODE_IF, 0, condition);\r
1193 \r
1194                                 if(trueBlock)\r
1195                                 {\r
1196                                         trueBlock->traverse(this);\r
1197                                 }\r
1198 \r
1199                                 if(falseBlock)\r
1200                                 {\r
1201                                         emit(sw::Shader::OPCODE_ELSE);\r
1202                                         falseBlock->traverse(this);\r
1203                                 }\r
1204 \r
1205                                 emit(sw::Shader::OPCODE_ENDIF);\r
1206                         }\r
1207                 }\r
1208 \r
1209                 return false;\r
1210         }\r
1211 \r
1212         bool OutputASM::visitLoop(Visit visit, TIntermLoop *node)\r
1213         {\r
1214                 if(currentScope != emitScope)\r
1215                 {\r
1216                         return false;\r
1217                 }\r
1218 \r
1219                 unsigned int iterations = loopCount(node);\r
1220 \r
1221                 if(iterations == 0)\r
1222                 {\r
1223                         return false;\r
1224                 }\r
1225 \r
1226                 bool unroll = (iterations <= 4);\r
1227 \r
1228                 if(unroll)\r
1229                 {\r
1230                         DetectLoopDiscontinuity detectLoopDiscontinuity;\r
1231                         unroll = !detectLoopDiscontinuity.traverse(node);\r
1232                 }\r
1233 \r
1234                 TIntermNode *init = node->getInit();\r
1235                 TIntermTyped *condition = node->getCondition();\r
1236                 TIntermTyped *expression = node->getExpression();\r
1237                 TIntermNode *body = node->getBody();\r
1238 \r
1239                 if(node->getType() == ELoopDoWhile)\r
1240                 {\r
1241                         Temporary iterate(this);\r
1242                         Constant True(true);\r
1243                         emit(sw::Shader::OPCODE_MOV, &iterate, &True);\r
1244 \r
1245                         emit(sw::Shader::OPCODE_WHILE, 0, &iterate);   // FIXME: Implement real do-while\r
1246 \r
1247                         if(body)\r
1248                         {\r
1249                                 body->traverse(this);\r
1250                         }\r
1251 \r
1252                         emit(sw::Shader::OPCODE_TEST);\r
1253 \r
1254                         condition->traverse(this);\r
1255                         emit(sw::Shader::OPCODE_MOV, &iterate, condition);\r
1256 \r
1257                         emit(sw::Shader::OPCODE_ENDWHILE);\r
1258                 }\r
1259                 else\r
1260                 {\r
1261                         if(init)\r
1262                         {\r
1263                                 init->traverse(this);\r
1264                         }\r
1265 \r
1266                         if(unroll)\r
1267                         {\r
1268                                 for(unsigned int i = 0; i < iterations; i++)\r
1269                                 {\r
1270                                 //      condition->traverse(this);   // Condition could contain statements, but not in an unrollable loop\r
1271 \r
1272                                         if(body)\r
1273                                         {\r
1274                                                 body->traverse(this);\r
1275                                         }\r
1276 \r
1277                                         if(expression)\r
1278                                         {\r
1279                                                 expression->traverse(this);\r
1280                                         }\r
1281                                 }\r
1282                         }\r
1283                         else\r
1284                         {\r
1285                                 if(condition)\r
1286                                 {\r
1287                                         condition->traverse(this);\r
1288                                 }\r
1289 \r
1290                                 emit(sw::Shader::OPCODE_WHILE, 0, condition);\r
1291 \r
1292                                 if(body)\r
1293                                 {\r
1294                                         body->traverse(this);\r
1295                                 }\r
1296 \r
1297                                 emit(sw::Shader::OPCODE_TEST);\r
1298 \r
1299                                 if(expression)\r
1300                                 {\r
1301                                         expression->traverse(this);\r
1302                                 }\r
1303 \r
1304                                 if(condition)\r
1305                                 {\r
1306                                         condition->traverse(this);\r
1307                                 }\r
1308 \r
1309                                 emit(sw::Shader::OPCODE_ENDWHILE);\r
1310                         }\r
1311                 }\r
1312 \r
1313                 return false;\r
1314         }\r
1315 \r
1316         bool OutputASM::visitBranch(Visit visit, TIntermBranch *node)\r
1317         {\r
1318                 if(currentScope != emitScope)\r
1319                 {\r
1320                         return false;\r
1321                 }\r
1322 \r
1323                 switch(node->getFlowOp())\r
1324                 {\r
1325                 case EOpKill:      if(visit == PostVisit) emit(sw::Shader::OPCODE_DISCARD);  break;\r
1326                 case EOpBreak:     if(visit == PostVisit) emit(sw::Shader::OPCODE_BREAK);    break;\r
1327                 case EOpContinue:  if(visit == PostVisit) emit(sw::Shader::OPCODE_CONTINUE); break;\r
1328                 case EOpReturn:\r
1329                         if(visit == PostVisit)\r
1330                         {\r
1331                                 TIntermTyped *value = node->getExpression();\r
1332 \r
1333                                 if(value)\r
1334                                 {\r
1335                                         copy(functionArray[currentFunction].ret, value);\r
1336                                 }\r
1337 \r
1338                                 emit(sw::Shader::OPCODE_LEAVE);\r
1339                         }\r
1340                         break;\r
1341                 default: UNREACHABLE(node->getFlowOp());\r
1342                 }\r
1343 \r
1344                 return true;\r
1345         }\r
1346 \r
1347         bool OutputASM::isSamplerRegister(TIntermTyped *operand)\r
1348         {\r
1349                 return operand && isSamplerRegister(operand->getType());\r
1350         }\r
1351 \r
1352         bool OutputASM::isSamplerRegister(const TType &type)\r
1353         {\r
1354                 // A sampler register's qualifiers can be:\r
1355                 // - EvqUniform: The sampler uniform is used as is in the code (default case).\r
1356                 // - EvqTemporary: The sampler is indexed. It's still a sampler register.\r
1357                 // - EvqIn (and other similar types): The sampler has been passed as a function argument. At this point,\r
1358                 //                                    the sampler has been copied and is no longer a sampler register.\r
1359                 return IsSampler(type.getBasicType()) && (type.getQualifier() == EvqUniform || type.getQualifier() == EvqTemporary);\r
1360         }\r
1361 \r
1362         Instruction *OutputASM::emit(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2, int index)\r
1363         {\r
1364                 if(isSamplerRegister(dst))\r
1365                 {\r
1366                         op = sw::Shader::OPCODE_NULL;   // Can't assign to a sampler, but this is hit when indexing sampler arrays\r
1367                 }\r
1368 \r
1369                 Instruction *instruction = new Instruction(op);\r
1370 \r
1371                 if(dst)\r
1372                 {\r
1373                         instruction->dst.type = registerType(dst);\r
1374                         instruction->dst.index = registerIndex(dst) + index;\r
1375                         instruction->dst.mask = writeMask(dst);\r
1376                         instruction->dst.integer = (dst->getBasicType() == EbtInt);\r
1377                 }\r
1378 \r
1379                 argument(instruction->src[0], src0, index);\r
1380                 argument(instruction->src[1], src1, index);\r
1381                 argument(instruction->src[2], src2, index);\r
1382 \r
1383                 shader->append(instruction);\r
1384 \r
1385                 return instruction;\r
1386         }\r
1387 \r
1388         Instruction *OutputASM::emitCast(TIntermTyped *dst, TIntermTyped *src)\r
1389         {\r
1390                 // Integers are implemented as float\r
1391                 if((dst->getBasicType() == EbtFloat || dst->getBasicType() == EbtInt) && src->getBasicType() == EbtBool)\r
1392                 {\r
1393                         return emit(sw::Shader::OPCODE_B2F, dst, src);\r
1394                 }\r
1395                 if(dst->getBasicType() == EbtBool && (src->getBasicType() == EbtFloat || src->getBasicType() == EbtInt))\r
1396                 {\r
1397                         return emit(sw::Shader::OPCODE_F2B, dst, src);\r
1398                 }\r
1399                 if(dst->getBasicType() == EbtInt && src->getBasicType() == EbtFloat)\r
1400                 {\r
1401                         return emit(sw::Shader::OPCODE_TRUNC, dst, src);\r
1402                 }\r
1403 \r
1404                 return emit(sw::Shader::OPCODE_MOV, dst, src);\r
1405         }\r
1406 \r
1407         void OutputASM::emitBinary(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2)\r
1408         {\r
1409                 for(int index = 0; index < dst->elementRegisterCount(); index++)\r
1410                 {\r
1411                         emit(op, dst, src0, src1, src2, index);\r
1412                 }\r
1413         }\r
1414 \r
1415         void OutputASM::emitAssign(sw::Shader::Opcode op, TIntermTyped *result, TIntermTyped *lhs, TIntermTyped *src0, TIntermTyped *src1)\r
1416         {\r
1417                 emitBinary(op, result, src0, src1);\r
1418                 assignLvalue(lhs, result);\r
1419         }\r
1420 \r
1421         void OutputASM::emitCmp(sw::Shader::Control cmpOp, TIntermTyped *dst, TIntermNode *left, TIntermNode *right, int index)\r
1422         {\r
1423                 bool boolean = (left->getAsTyped()->getBasicType() == EbtBool);\r
1424                 sw::Shader::Opcode opcode = boolean ? sw::Shader::OPCODE_ICMP : sw::Shader::OPCODE_CMP;\r
1425 \r
1426                 Instruction *cmp = emit(opcode, dst, left, right);\r
1427                 cmp->control = cmpOp;\r
1428                 argument(cmp->src[0], left, index);\r
1429                 argument(cmp->src[1], right, index);\r
1430         }\r
1431 \r
1432         int componentCount(const TType &type, int registers)\r
1433         {\r
1434                 if(registers == 0)\r
1435                 {\r
1436                         return 0;\r
1437                 }\r
1438 \r
1439                 if(type.isArray() && registers >= type.elementRegisterCount())\r
1440                 {\r
1441                         int index = registers / type.elementRegisterCount();\r
1442                         registers -= index * type.elementRegisterCount();\r
1443                         return index * type.getElementSize() + componentCount(type, registers);\r
1444                 }\r
1445 \r
1446                 if(type.isStruct() || type.isInterfaceBlock())\r
1447                 {\r
1448                         const TFieldList& fields = type.getStruct() ? type.getStruct()->fields() : type.getInterfaceBlock()->fields();\r
1449                         int elements = 0;\r
1450 \r
1451                         for(TFieldList::const_iterator field = fields.begin(); field != fields.end(); field++)\r
1452                         {\r
1453                                 const TType &fieldType = *((*field)->type());\r
1454 \r
1455                                 if(fieldType.totalRegisterCount() <= registers)\r
1456                                 {\r
1457                                         registers -= fieldType.totalRegisterCount();\r
1458                                         elements += fieldType.getObjectSize();\r
1459                                 }\r
1460                                 else   // Register within this field\r
1461                                 {\r
1462                                         return elements + componentCount(fieldType, registers);\r
1463                                 }\r
1464                         }\r
1465                 }\r
1466                 else if(type.isMatrix())\r
1467                 {\r
1468                         return registers * type.registerSize();\r
1469                 }\r
1470                 \r
1471                 UNREACHABLE(0);\r
1472                 return 0;\r
1473         }\r
1474 \r
1475         int registerSize(const TType &type, int registers)\r
1476         {\r
1477                 if(registers == 0)\r
1478                 {\r
1479                         if(type.isStruct())\r
1480                         {\r
1481                                 return registerSize(*((*(type.getStruct()->fields().begin()))->type()), 0);\r
1482                         }\r
1483 \r
1484                         return type.registerSize();\r
1485                 }\r
1486 \r
1487                 if(type.isArray() && registers >= type.elementRegisterCount())\r
1488                 {\r
1489                         int index = registers / type.elementRegisterCount();\r
1490                         registers -= index * type.elementRegisterCount();\r
1491                         return registerSize(type, registers);\r
1492                 }\r
1493 \r
1494                 if(type.isStruct() || type.isInterfaceBlock())\r
1495                 {\r
1496                         const TFieldList& fields = type.getStruct() ? type.getStruct()->fields() : type.getInterfaceBlock()->fields();\r
1497                         int elements = 0;\r
1498 \r
1499                         for(TFieldList::const_iterator field = fields.begin(); field != fields.end(); field++)\r
1500                         {\r
1501                                 const TType &fieldType = *((*field)->type());\r
1502                                 \r
1503                                 if(fieldType.totalRegisterCount() <= registers)\r
1504                                 {\r
1505                                         registers -= fieldType.totalRegisterCount();\r
1506                                         elements += fieldType.getObjectSize();\r
1507                                 }\r
1508                                 else   // Register within this field\r
1509                                 {\r
1510                                         return registerSize(fieldType, registers);\r
1511                                 }\r
1512                         }\r
1513                 }\r
1514                 else if(type.isMatrix())\r
1515                 {\r
1516                         return registerSize(type, 0);\r
1517                 }\r
1518                 \r
1519                 UNREACHABLE(0);\r
1520                 return 0;\r
1521         }\r
1522 \r
1523         void OutputASM::argument(sw::Shader::SourceParameter &parameter, TIntermNode *argument, int index)\r
1524         {\r
1525                 if(argument)\r
1526                 {\r
1527                         TIntermTyped *arg = argument->getAsTyped();\r
1528                         const TType &type = arg->getType();\r
1529                         index = (index >= arg->totalRegisterCount()) ? arg->totalRegisterCount() - 1 : index;\r
1530 \r
1531                         int size = registerSize(type, index);\r
1532 \r
1533                         parameter.type = registerType(arg);\r
1534 \r
1535                         if(arg->getQualifier() == EvqConstExpr)\r
1536                         {\r
1537                                 int component = componentCount(type, index);\r
1538                                 ConstantUnion *constants = arg->getAsConstantUnion()->getUnionArrayPointer();\r
1539 \r
1540                                 for(int i = 0; i < 4; i++)\r
1541                                 {\r
1542                                         if(size == 1)   // Replicate\r
1543                                         {\r
1544                                                 parameter.value[i] = constants[component + 0].getAsFloat();\r
1545                                         }\r
1546                                         else if(i < size)\r
1547                                         {\r
1548                                                 parameter.value[i] = constants[component + i].getAsFloat();\r
1549                                         }\r
1550                                         else\r
1551                                         {\r
1552                                                 parameter.value[i] = 0.0f;\r
1553                                         }\r
1554                                 }\r
1555                         }\r
1556                         else\r
1557                         {\r
1558                                 parameter.index = registerIndex(arg) + index;\r
1559 \r
1560                                 if(isSamplerRegister(arg))\r
1561                                 {\r
1562                                         TIntermBinary *binary = argument->getAsBinaryNode();\r
1563 \r
1564                                         if(binary)\r
1565                                         {\r
1566                                                 TIntermTyped *left = binary->getLeft();\r
1567                                                 TIntermTyped *right = binary->getRight();\r
1568 \r
1569                                                 switch(binary->getOp())\r
1570                                                 {\r
1571                                                 case EOpIndexDirect:\r
1572                                                         parameter.index += right->getAsConstantUnion()->getIConst(0);\r
1573                                                         break;\r
1574                                                 case EOpIndexIndirect:\r
1575                                                         if(left->getArraySize() > 1)\r
1576                                                         {\r
1577                                                                 parameter.rel.type = registerType(binary->getRight());\r
1578                                                                 parameter.rel.index = registerIndex(binary->getRight());\r
1579                                                                 parameter.rel.scale = 1;\r
1580                                                                 parameter.rel.deterministic = true;\r
1581                                                         }\r
1582                                                         break;\r
1583                                                 case EOpIndexDirectStruct:\r
1584                                                 case EOpIndexDirectInterfaceBlock:\r
1585                                                         parameter.index += right->getAsConstantUnion()->getIConst(0);\r
1586                                                         break;\r
1587                                                 default:\r
1588                                                         UNREACHABLE(binary->getOp());\r
1589                                                 }\r
1590                                         }\r
1591                                 }\r
1592                         }\r
1593 \r
1594                         if(!IsSampler(arg->getBasicType()))\r
1595                         {\r
1596                                 parameter.swizzle = readSwizzle(arg, size);\r
1597                         }\r
1598                 }\r
1599         }\r
1600 \r
1601         void OutputASM::copy(TIntermTyped *dst, TIntermNode *src, int offset)\r
1602         {\r
1603                 for(int index = 0; index < dst->totalRegisterCount(); index++)\r
1604                 {\r
1605                         Instruction *mov = emit(sw::Shader::OPCODE_MOV, dst, src);\r
1606                         mov->dst.index += index;\r
1607                         mov->dst.mask = writeMask(dst, index);\r
1608                         argument(mov->src[0], src, offset + index);\r
1609                 }\r
1610         }\r
1611 \r
1612         int swizzleElement(int swizzle, int index)\r
1613         {\r
1614                 return (swizzle >> (index * 2)) & 0x03;\r
1615         }\r
1616 \r
1617         int swizzleSwizzle(int leftSwizzle, int rightSwizzle)\r
1618         {\r
1619                 return (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 0)) << 0) |\r
1620                        (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 1)) << 2) |\r
1621                        (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 2)) << 4) |\r
1622                        (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 3)) << 6);\r
1623         }\r
1624 \r
1625         void OutputASM::assignLvalue(TIntermTyped *dst, TIntermTyped *src)\r
1626         {\r
1627                 if(src &&\r
1628                         ((src->isVector() && (!dst->isVector() || (dst->getNominalSize() != dst->getNominalSize()))) ||\r
1629                          (src->isMatrix() && (!dst->isMatrix() || (src->getNominalSize() != dst->getNominalSize()) || (src->getSecondarySize() != dst->getSecondarySize())))))\r
1630                 {\r
1631                         return mContext.error(src->getLine(), "Result type should match the l-value type in compound assignment", src->isVector() ? "vector" : "matrix");\r
1632                 }\r
1633 \r
1634                 TIntermBinary *binary = dst->getAsBinaryNode();\r
1635 \r
1636                 if(binary && binary->getOp() == EOpIndexIndirect && dst->isScalar())\r
1637                 {\r
1638                         Instruction *insert = new Instruction(sw::Shader::OPCODE_INSERT);\r
1639                         \r
1640                         Temporary address(this);\r
1641                         lvalue(insert->dst, address, dst);\r
1642 \r
1643                         insert->src[0].type = insert->dst.type;\r
1644                         insert->src[0].index = insert->dst.index;\r
1645                         insert->src[0].rel = insert->dst.rel;\r
1646                         argument(insert->src[1], src);\r
1647                         argument(insert->src[2], binary->getRight());\r
1648 \r
1649                         shader->append(insert);\r
1650                 }\r
1651                 else\r
1652                 {\r
1653                         for(int offset = 0; offset < dst->totalRegisterCount(); offset++)\r
1654                         {\r
1655                                 Instruction *mov = new Instruction(sw::Shader::OPCODE_MOV);\r
1656                         \r
1657                                 Temporary address(this);\r
1658                                 int swizzle = lvalue(mov->dst, address, dst);\r
1659                                 mov->dst.index += offset;\r
1660 \r
1661                                 if(offset > 0)\r
1662                                 {\r
1663                                         mov->dst.mask = writeMask(dst, offset);\r
1664                                 }\r
1665 \r
1666                                 argument(mov->src[0], src, offset);\r
1667                                 mov->src[0].swizzle = swizzleSwizzle(mov->src[0].swizzle, swizzle);\r
1668 \r
1669                                 shader->append(mov);\r
1670                         }\r
1671                 }\r
1672         }\r
1673 \r
1674         int OutputASM::lvalue(sw::Shader::DestinationParameter &dst, Temporary &address, TIntermTyped *node)\r
1675         {\r
1676                 TIntermTyped *result = node;\r
1677                 TIntermBinary *binary = node->getAsBinaryNode();\r
1678                 TIntermSymbol *symbol = node->getAsSymbolNode();\r
1679 \r
1680                 if(binary)\r
1681                 {\r
1682                         TIntermTyped *left = binary->getLeft();\r
1683                         TIntermTyped *right = binary->getRight();\r
1684 \r
1685                         int leftSwizzle = lvalue(dst, address, left);   // Resolve the l-value of the left side\r
1686 \r
1687                         switch(binary->getOp())\r
1688                         {\r
1689                         case EOpIndexDirect:\r
1690                                 {\r
1691                                         int rightIndex = right->getAsConstantUnion()->getIConst(0);\r
1692 \r
1693                                         if(left->isRegister())\r
1694                                         {\r
1695                                                 int leftMask = dst.mask;\r
1696                                                 \r
1697                                                 dst.mask = 1;\r
1698                                                 while((leftMask & dst.mask) == 0)\r
1699                                                 {\r
1700                                                         dst.mask = dst.mask << 1;\r
1701                                                 }\r
1702 \r
1703                                                 int element = swizzleElement(leftSwizzle, rightIndex);\r
1704                                                 dst.mask = 1 << element;\r
1705                                                 \r
1706                                                 return element;\r
1707                                         }\r
1708                                         else if(left->isArray() || left->isMatrix())\r
1709                                         {\r
1710                                                 dst.index += rightIndex * result->totalRegisterCount();\r
1711                                                 return 0xE4;\r
1712                                         }\r
1713                                         else UNREACHABLE(0);\r
1714                                 }\r
1715                                 break;\r
1716                         case EOpIndexIndirect:\r
1717                                 {\r
1718                                         if(left->isRegister())\r
1719                                         {\r
1720                                                 // Requires INSERT instruction (handled by calling function)\r
1721                                         }\r
1722                                         else if(left->isArray() || left->isMatrix())\r
1723                                         {\r
1724                                                 int scale = result->totalRegisterCount();\r
1725 \r
1726                                                 if(dst.rel.type == sw::Shader::PARAMETER_VOID)   // Use the index register as the relative address directly\r
1727                                                 {\r
1728                                                         if(left->totalRegisterCount() > 1)\r
1729                                                         {\r
1730                                                                 sw::Shader::SourceParameter relativeRegister;\r
1731                                                                 argument(relativeRegister, right);\r
1732 \r
1733                                                                 dst.rel.index = relativeRegister.index;\r
1734                                                                 dst.rel.type = relativeRegister.type;\r
1735                                                                 dst.rel.scale = scale;\r
1736                                                                 dst.rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);\r
1737                                                         }\r
1738                                                 }\r
1739                                                 else if(dst.rel.index != registerIndex(&address))   // Move the previous index register to the address register\r
1740                                                 {\r
1741                                                         if(scale == 1)\r
1742                                                         {\r
1743                                                                 Constant oldScale((int)dst.rel.scale);\r
1744                                                                 Instruction *mad = emit(sw::Shader::OPCODE_MAD, &address, &address, &oldScale, right);\r
1745                                                                 mad->src[0].index = dst.rel.index;\r
1746                                                                 mad->src[0].type = dst.rel.type;\r
1747                                                         }\r
1748                                                         else\r
1749                                                         {\r
1750                                                                 Constant oldScale((int)dst.rel.scale);\r
1751                                                                 Instruction *mul = emit(sw::Shader::OPCODE_MUL, &address, &address, &oldScale);\r
1752                                                                 mul->src[0].index = dst.rel.index;\r
1753                                                                 mul->src[0].type = dst.rel.type;\r
1754 \r
1755                                                                 Constant newScale(scale);\r
1756                                                                 emit(sw::Shader::OPCODE_MAD, &address, right, &newScale, &address);\r
1757                                                         }\r
1758 \r
1759                                                         dst.rel.type = sw::Shader::PARAMETER_TEMP;\r
1760                                                         dst.rel.index = registerIndex(&address);\r
1761                                                         dst.rel.scale = 1;\r
1762                                                 }\r
1763                                                 else   // Just add the new index to the address register\r
1764                                                 {\r
1765                                                         if(scale == 1)\r
1766                                                         {\r
1767                                                                 emit(sw::Shader::OPCODE_ADD, &address, &address, right);\r
1768                                                         }\r
1769                                                         else\r
1770                                                         {\r
1771                                                                 Constant newScale(scale);\r
1772                                                                 emit(sw::Shader::OPCODE_MAD, &address, right, &newScale, &address);\r
1773                                                         }\r
1774                                                 }\r
1775                                         }\r
1776                                         else UNREACHABLE(0);\r
1777                                 }\r
1778                                 break;\r
1779                         case EOpIndexDirectStruct:\r
1780                         case EOpIndexDirectInterfaceBlock:\r
1781                                 {\r
1782                                         const TFieldList& fields = (binary->getOp() == EOpIndexDirectStruct) ?\r
1783                                                                left->getType().getStruct()->fields() :\r
1784                                                                left->getType().getInterfaceBlock()->fields();\r
1785                                         int index = right->getAsConstantUnion()->getIConst(0);\r
1786                                         int fieldOffset = 0;\r
1787 \r
1788                                         for(int i = 0; i < index; i++)\r
1789                                         {\r
1790                                                 fieldOffset += fields[i]->type()->totalRegisterCount();\r
1791                                         }\r
1792 \r
1793                                         dst.type = registerType(left);\r
1794                                         dst.index += fieldOffset;\r
1795                                         dst.mask = writeMask(right);\r
1796 \r
1797                                         return 0xE4;\r
1798                                 }\r
1799                                 break;\r
1800                         case EOpVectorSwizzle:\r
1801                                 {\r
1802                                         ASSERT(left->isRegister());\r
1803 \r
1804                                         int leftMask = dst.mask;\r
1805 \r
1806                                         int swizzle = 0;\r
1807                                         int rightMask = 0;\r
1808 \r
1809                                         TIntermSequence &sequence = right->getAsAggregate()->getSequence();\r
1810 \r
1811                                         for(unsigned int i = 0; i < sequence.size(); i++)\r
1812                                         {\r
1813                                                 int index = sequence[i]->getAsConstantUnion()->getIConst(0);\r
1814 \r
1815                                                 int element = swizzleElement(leftSwizzle, index);\r
1816                                                 rightMask = rightMask | (1 << element);\r
1817                                                 swizzle = swizzle | swizzleElement(leftSwizzle, i) << (element * 2);\r
1818                                         }\r
1819                                         \r
1820                                         dst.mask = leftMask & rightMask;\r
1821 \r
1822                                         return swizzle;\r
1823                                 }\r
1824                                 break;\r
1825                         default:\r
1826                                 UNREACHABLE(binary->getOp());   // Not an l-value operator\r
1827                                 break;\r
1828                         }\r
1829                 }\r
1830                 else if(symbol)\r
1831                 {\r
1832                         dst.type = registerType(symbol);\r
1833                         dst.index = registerIndex(symbol);\r
1834                         dst.mask = writeMask(symbol);\r
1835                         return 0xE4;\r
1836                 }\r
1837 \r
1838                 return 0xE4;\r
1839         }\r
1840 \r
1841         sw::Shader::ParameterType OutputASM::registerType(TIntermTyped *operand)\r
1842         {\r
1843                 if(isSamplerRegister(operand))\r
1844                 {\r
1845                         return sw::Shader::PARAMETER_SAMPLER;\r
1846                 }\r
1847 \r
1848                 const TQualifier qualifier = operand->getQualifier();\r
1849                 if((EvqFragColor == qualifier) || (EvqFragData == qualifier))\r
1850                 {\r
1851                         if(((EvqFragData == qualifier) && (EvqFragColor == outputQualifier)) ||\r
1852                            ((EvqFragColor == qualifier) && (EvqFragData == outputQualifier)))\r
1853                         {\r
1854                                 mContext.error(operand->getLine(), "static assignment to both gl_FragData and gl_FragColor", "");\r
1855                         }\r
1856                         outputQualifier = qualifier;\r
1857                 }\r
1858 \r
1859                 switch(qualifier)\r
1860                 {\r
1861                 case EvqTemporary:           return sw::Shader::PARAMETER_TEMP;\r
1862                 case EvqGlobal:              return sw::Shader::PARAMETER_TEMP;\r
1863                 case EvqConstExpr:           return sw::Shader::PARAMETER_FLOAT4LITERAL;   // All converted to float\r
1864                 case EvqAttribute:           return sw::Shader::PARAMETER_INPUT;\r
1865                 case EvqVaryingIn:           return sw::Shader::PARAMETER_INPUT;\r
1866                 case EvqVaryingOut:          return sw::Shader::PARAMETER_OUTPUT;\r
1867                 case EvqVertexIn:            return sw::Shader::PARAMETER_INPUT;\r
1868                 case EvqFragmentOut:         return sw::Shader::PARAMETER_COLOROUT;\r
1869                 case EvqVertexOut:           return sw::Shader::PARAMETER_OUTPUT;\r
1870                 case EvqFragmentIn:          return sw::Shader::PARAMETER_INPUT;\r
1871                 case EvqInvariantVaryingIn:  return sw::Shader::PARAMETER_INPUT;    // FIXME: Guarantee invariance at the backend\r
1872                 case EvqInvariantVaryingOut: return sw::Shader::PARAMETER_OUTPUT;   // FIXME: Guarantee invariance at the backend \r
1873                 case EvqSmooth:              return sw::Shader::PARAMETER_OUTPUT;\r
1874                 case EvqFlat:                return sw::Shader::PARAMETER_OUTPUT;\r
1875                 case EvqCentroidOut:         return sw::Shader::PARAMETER_OUTPUT;\r
1876                 case EvqSmoothIn:            return sw::Shader::PARAMETER_INPUT;\r
1877                 case EvqFlatIn:              return sw::Shader::PARAMETER_INPUT;\r
1878                 case EvqCentroidIn:          return sw::Shader::PARAMETER_INPUT;\r
1879                 case EvqUniform:             return sw::Shader::PARAMETER_CONST;\r
1880                 case EvqIn:                  return sw::Shader::PARAMETER_TEMP;\r
1881                 case EvqOut:                 return sw::Shader::PARAMETER_TEMP;\r
1882                 case EvqInOut:               return sw::Shader::PARAMETER_TEMP;\r
1883                 case EvqConstReadOnly:       return sw::Shader::PARAMETER_TEMP;\r
1884                 case EvqPosition:            return sw::Shader::PARAMETER_OUTPUT;\r
1885                 case EvqPointSize:           return sw::Shader::PARAMETER_OUTPUT;\r
1886                 case EvqInstanceID:          return sw::Shader::PARAMETER_MISCTYPE;\r
1887                 case EvqFragCoord:           return sw::Shader::PARAMETER_MISCTYPE;\r
1888                 case EvqFrontFacing:         return sw::Shader::PARAMETER_MISCTYPE;\r
1889                 case EvqPointCoord:          return sw::Shader::PARAMETER_INPUT;\r
1890                 case EvqFragColor:           return sw::Shader::PARAMETER_COLOROUT;\r
1891                 case EvqFragData:            return sw::Shader::PARAMETER_COLOROUT;\r
1892                 default: UNREACHABLE(qualifier);\r
1893                 }\r
1894 \r
1895                 return sw::Shader::PARAMETER_VOID;\r
1896         }\r
1897 \r
1898         int OutputASM::registerIndex(TIntermTyped *operand)\r
1899         {\r
1900                 if(isSamplerRegister(operand))\r
1901                 {\r
1902                         return samplerRegister(operand);\r
1903                 }\r
1904 \r
1905                 switch(operand->getQualifier())\r
1906                 {\r
1907                 case EvqTemporary:           return temporaryRegister(operand);\r
1908                 case EvqGlobal:              return temporaryRegister(operand);\r
1909                 case EvqConstExpr:           UNREACHABLE(EvqConstExpr);\r
1910                 case EvqAttribute:           return attributeRegister(operand);\r
1911                 case EvqVaryingIn:           return varyingRegister(operand);\r
1912                 case EvqVaryingOut:          return varyingRegister(operand);\r
1913                 case EvqVertexIn:            return attributeRegister(operand);\r
1914                 case EvqFragmentOut:         return 0;\r
1915                 case EvqVertexOut:           return varyingRegister(operand);\r
1916                 case EvqFragmentIn:          return varyingRegister(operand);\r
1917                 case EvqInvariantVaryingIn:  return varyingRegister(operand);\r
1918                 case EvqInvariantVaryingOut: return varyingRegister(operand);\r
1919                 case EvqSmooth:              return varyingRegister(operand);\r
1920                 case EvqFlat:                return varyingRegister(operand);\r
1921                 case EvqCentroidOut:         return varyingRegister(operand);\r
1922                 case EvqSmoothIn:            return varyingRegister(operand);\r
1923                 case EvqFlatIn:              return varyingRegister(operand);\r
1924                 case EvqCentroidIn:          return varyingRegister(operand);\r
1925                 case EvqUniform:             return uniformRegister(operand);\r
1926                 case EvqIn:                  return temporaryRegister(operand);\r
1927                 case EvqOut:                 return temporaryRegister(operand);\r
1928                 case EvqInOut:               return temporaryRegister(operand);\r
1929                 case EvqConstReadOnly:       return temporaryRegister(operand);\r
1930                 case EvqPosition:            return varyingRegister(operand);\r
1931                 case EvqPointSize:           return varyingRegister(operand);\r
1932                 case EvqInstanceID:          vertexShader->instanceIdDeclared = true; return 0;\r
1933                 case EvqFragCoord:           pixelShader->vPosDeclared = true;  return 0;\r
1934                 case EvqFrontFacing:         pixelShader->vFaceDeclared = true; return 1;\r
1935                 case EvqPointCoord:          return varyingRegister(operand);\r
1936                 case EvqFragColor:           return 0;\r
1937                 case EvqFragData:            return 0;\r
1938                 default: UNREACHABLE(operand->getQualifier());\r
1939                 }\r
1940 \r
1941                 return 0;\r
1942         }\r
1943 \r
1944         int OutputASM::writeMask(TIntermTyped *destination, int index)\r
1945         {\r
1946                 if(destination->getQualifier() == EvqPointSize)\r
1947                 {\r
1948                         return 0x2;   // Point size stored in the y component\r
1949                 }\r
1950 \r
1951                 return 0xF >> (4 - registerSize(destination->getType(), index));\r
1952         }\r
1953 \r
1954         int OutputASM::readSwizzle(TIntermTyped *argument, int size)\r
1955         {\r
1956                 if(argument->getQualifier() == EvqPointSize)\r
1957                 {\r
1958                         return 0x55;   // Point size stored in the y component\r
1959                 }\r
1960 \r
1961                 static const unsigned char swizzleSize[5] = {0x00, 0x00, 0x54, 0xA4, 0xE4};   // (void), xxxx, xyyy, xyzz, xyzw\r
1962 \r
1963                 return swizzleSize[size];\r
1964         }\r
1965 \r
1966         // Conservatively checks whether an expression is fast to compute and has no side effects\r
1967         bool OutputASM::trivial(TIntermTyped *expression, int budget)\r
1968         {\r
1969                 if(!expression->isRegister())\r
1970                 {\r
1971                         return false;\r
1972                 }\r
1973 \r
1974                 return cost(expression, budget) >= 0;\r
1975         }\r
1976 \r
1977         // Returns the remaining computing budget (if < 0 the expression is too expensive or has side effects)\r
1978         int OutputASM::cost(TIntermNode *expression, int budget)\r
1979         {\r
1980                 if(budget < 0)\r
1981                 {\r
1982                         return budget;\r
1983                 }\r
1984 \r
1985                 if(expression->getAsSymbolNode())\r
1986                 {\r
1987                         return budget;\r
1988                 }\r
1989                 else if(expression->getAsConstantUnion())\r
1990                 {\r
1991                         return budget;\r
1992                 }\r
1993                 else if(expression->getAsBinaryNode())\r
1994                 {\r
1995                         TIntermBinary *binary = expression->getAsBinaryNode();\r
1996 \r
1997                         switch(binary->getOp())\r
1998                         {\r
1999                         case EOpVectorSwizzle:\r
2000                         case EOpIndexDirect:\r
2001                         case EOpIndexDirectStruct:\r
2002                         case EOpIndexDirectInterfaceBlock:\r
2003                                 return cost(binary->getLeft(), budget - 0);\r
2004                         case EOpAdd:\r
2005                         case EOpSub:\r
2006                         case EOpMul:\r
2007                                 return cost(binary->getLeft(), cost(binary->getRight(), budget - 1));\r
2008                         default:\r
2009                                 return -1;\r
2010                         }\r
2011                 }\r
2012                 else if(expression->getAsUnaryNode())\r
2013                 {\r
2014                         TIntermUnary *unary = expression->getAsUnaryNode();\r
2015 \r
2016                         switch(unary->getOp())\r
2017                         {\r
2018                         case EOpAbs:\r
2019                         case EOpNegative:\r
2020                                 return cost(unary->getOperand(), budget - 1);\r
2021                         default:\r
2022                                 return -1;\r
2023                         }\r
2024                 }\r
2025                 else if(expression->getAsSelectionNode())\r
2026                 {\r
2027                         TIntermSelection *selection = expression->getAsSelectionNode();\r
2028 \r
2029                         if(selection->usesTernaryOperator())\r
2030                         {\r
2031                                 TIntermTyped *condition = selection->getCondition();\r
2032                                 TIntermNode *trueBlock = selection->getTrueBlock();\r
2033                                 TIntermNode *falseBlock = selection->getFalseBlock();\r
2034                                 TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();\r
2035 \r
2036                                 if(constantCondition)\r
2037                                 {\r
2038                                         bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();\r
2039 \r
2040                                         if(trueCondition)\r
2041                                         {\r
2042                                                 return cost(trueBlock, budget - 0);\r
2043                                         }\r
2044                                         else\r
2045                                         {\r
2046                                                 return cost(falseBlock, budget - 0);\r
2047                                         }\r
2048                                 }\r
2049                                 else\r
2050                                 {\r
2051                                         return cost(trueBlock, cost(falseBlock, budget - 2));\r
2052                                 }\r
2053                         }\r
2054                 }\r
2055 \r
2056                 return -1;\r
2057         }\r
2058 \r
2059         const Function *OutputASM::findFunction(const TString &name)\r
2060         {\r
2061                 for(unsigned int f = 0; f < functionArray.size(); f++)\r
2062                 {\r
2063                         if(functionArray[f].name == name)\r
2064                         {\r
2065                                 return &functionArray[f];\r
2066                         }\r
2067                 }\r
2068 \r
2069                 return 0;\r
2070         }\r
2071         \r
2072         int OutputASM::temporaryRegister(TIntermTyped *temporary)\r
2073         {\r
2074                 return allocate(temporaries, temporary);\r
2075         }\r
2076 \r
2077         int OutputASM::varyingRegister(TIntermTyped *varying)\r
2078         {\r
2079                 int var = lookup(varyings, varying);\r
2080 \r
2081                 if(var == -1)\r
2082                 {\r
2083                         var = allocate(varyings, varying);\r
2084                         int componentCount = varying->registerSize();\r
2085                         int registerCount = varying->totalRegisterCount();\r
2086 \r
2087                         if(pixelShader)\r
2088                         {\r
2089                                 if((var + registerCount) > sw::PixelShader::MAX_INPUT_VARYINGS)\r
2090                                 {\r
2091                                         mContext.error(varying->getLine(), "Varyings packing failed: Too many varyings", "fragment shader");\r
2092                                         return 0;\r
2093                                 }\r
2094 \r
2095                                 if(varying->getQualifier() == EvqPointCoord)\r
2096                                 {\r
2097                                         ASSERT(varying->isRegister());\r
2098                                         if(componentCount >= 1) pixelShader->semantic[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);\r
2099                                         if(componentCount >= 2) pixelShader->semantic[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);\r
2100                                         if(componentCount >= 3) pixelShader->semantic[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);\r
2101                                         if(componentCount >= 4) pixelShader->semantic[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);\r
2102                                 }\r
2103                                 else\r
2104                                 {\r
2105                                         for(int i = 0; i < varying->totalRegisterCount(); i++)\r
2106                                         {\r
2107                                                 if(componentCount >= 1) pixelShader->semantic[var + i][0] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);\r
2108                                                 if(componentCount >= 2) pixelShader->semantic[var + i][1] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);\r
2109                                                 if(componentCount >= 3) pixelShader->semantic[var + i][2] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);\r
2110                                                 if(componentCount >= 4) pixelShader->semantic[var + i][3] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);\r
2111                                         }\r
2112                                 }\r
2113                         }\r
2114                         else if(vertexShader)\r
2115                         {\r
2116                                 if((var + registerCount) > sw::VertexShader::MAX_OUTPUT_VARYINGS)\r
2117                                 {\r
2118                                         mContext.error(varying->getLine(), "Varyings packing failed: Too many varyings", "vertex shader");\r
2119                                         return 0;\r
2120                                 }\r
2121 \r
2122                                 if(varying->getQualifier() == EvqPosition)\r
2123                                 {\r
2124                                         ASSERT(varying->isRegister());\r
2125                                         vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);\r
2126                                         vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);\r
2127                                         vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);\r
2128                                         vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);\r
2129                                         vertexShader->positionRegister = var;\r
2130                                 }\r
2131                                 else if(varying->getQualifier() == EvqPointSize)\r
2132                                 {\r
2133                                         ASSERT(varying->isRegister());\r
2134                                         vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);\r
2135                                         vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);\r
2136                                         vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);\r
2137                                         vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);\r
2138                                         vertexShader->pointSizeRegister = var;\r
2139                                 }\r
2140                                 else\r
2141                                 {\r
2142                                         // Semantic indexes for user varyings will be assigned during program link to match the pixel shader\r
2143                                 }\r
2144                         }\r
2145                         else UNREACHABLE(0);\r
2146 \r
2147                         declareVarying(varying, var);\r
2148                 }\r
2149 \r
2150                 return var;\r
2151         }\r
2152 \r
2153         void OutputASM::declareVarying(TIntermTyped *varying, int reg)\r
2154         {\r
2155                 if(varying->getQualifier() != EvqPointCoord)   // gl_PointCoord does not need linking\r
2156                 {\r
2157                         const TType &type = varying->getType();\r
2158                         const char *name = varying->getAsSymbolNode()->getSymbol().c_str();\r
2159                         VaryingList &activeVaryings = shaderObject->varyings;\r
2160                         \r
2161                         // Check if this varying has been declared before without having a register assigned\r
2162                         for(VaryingList::iterator v = activeVaryings.begin(); v != activeVaryings.end(); v++)\r
2163                         {\r
2164                                 if(v->name == name)\r
2165                                 {\r
2166                                         if(reg >= 0)\r
2167                                         {\r
2168                                                 ASSERT(v->reg < 0 || v->reg == reg);\r
2169                                                 v->reg = reg;\r
2170                                         }\r
2171 \r
2172                                         return;\r
2173                                 }\r
2174                         }\r
2175                         \r
2176                         activeVaryings.push_back(glsl::Varying(glVariableType(type), name, varying->getArraySize(), reg, 0));\r
2177                 }\r
2178         }\r
2179 \r
2180         int OutputASM::uniformRegister(TIntermTyped *uniform)\r
2181         {\r
2182                 const TType &type = uniform->getType();\r
2183                 ASSERT(!IsSampler(type.getBasicType()));\r
2184                 TInterfaceBlock *block = type.getAsInterfaceBlock();\r
2185                 TIntermSymbol *symbol = uniform->getAsSymbolNode();\r
2186                 ASSERT(symbol || block);\r
2187 \r
2188                 if(symbol || block)\r
2189                 {\r
2190                         int index = lookup(uniforms, uniform);\r
2191 \r
2192                         if(index == -1)\r
2193                         {\r
2194                                 index = allocate(uniforms, uniform);\r
2195                                 const TString &name = symbol ? symbol->getSymbol() : block->name();\r
2196 \r
2197                                 declareUniform(type, name, index);\r
2198                         }\r
2199 \r
2200                         return index;\r
2201                 }\r
2202 \r
2203                 return 0;\r
2204         }\r
2205 \r
2206         int OutputASM::attributeRegister(TIntermTyped *attribute)\r
2207         {\r
2208                 ASSERT(!attribute->isArray());\r
2209                 ASSERT(attribute->getBasicType() == EbtFloat);\r
2210 \r
2211                 int index = lookup(attributes, attribute);\r
2212 \r
2213                 if(index == -1)\r
2214                 {\r
2215                         TIntermSymbol *symbol = attribute->getAsSymbolNode();\r
2216                         ASSERT(symbol);\r
2217 \r
2218                         if(symbol)\r
2219                         {\r
2220                                 index = allocate(attributes, attribute);\r
2221                                 const TType &type = attribute->getType();\r
2222                                 int registerCount = attribute->totalRegisterCount();\r
2223 \r
2224                                 if(vertexShader && (index + registerCount) <= sw::VertexShader::MAX_INPUT_ATTRIBUTES)\r
2225                                 {\r
2226                                         for(int i = 0; i < registerCount; i++)\r
2227                                         {\r
2228                                                 vertexShader->input[index + i] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, index + i);\r
2229                                         }\r
2230                                 }\r
2231 \r
2232                                 ActiveAttributes &activeAttributes = shaderObject->activeAttributes;\r
2233 \r
2234                                 const char *name = symbol->getSymbol().c_str();\r
2235                                 activeAttributes.push_back(Attribute(glVariableType(type), name, 0, index));\r
2236                         }\r
2237                 }\r
2238 \r
2239                 return index;\r
2240         }\r
2241 \r
2242         int OutputASM::samplerRegister(TIntermTyped *sampler)\r
2243         {\r
2244                 ASSERT(IsSampler(sampler->getType().getBasicType()));\r
2245                 TIntermSymbol *symbol = sampler->getAsSymbolNode();\r
2246                 TIntermBinary *binary = sampler->getAsBinaryNode();\r
2247 \r
2248                 if(symbol)\r
2249                 {\r
2250                         return samplerRegister(symbol);\r
2251                 }\r
2252                 else if(binary)\r
2253                 {\r
2254                         ASSERT(binary->getOp() == EOpIndexDirect || binary->getOp() == EOpIndexIndirect ||\r
2255                                    binary->getOp() == EOpIndexDirectStruct || binary->getOp() == EOpIndexDirectInterfaceBlock);\r
2256 \r
2257                         return samplerRegister(binary->getLeft());   // Index added later\r
2258                 }\r
2259                 else UNREACHABLE(0);\r
2260 \r
2261                 return 0;\r
2262         }\r
2263 \r
2264         int OutputASM::samplerRegister(TIntermSymbol *sampler)\r
2265         {\r
2266                 const TType &type = sampler->getType();\r
2267                 ASSERT(IsSampler(type.getBasicType()) || type.getStruct());   // Structures can contain samplers\r
2268 \r
2269                 int index = lookup(samplers, sampler);\r
2270 \r
2271                 if(index == -1)\r
2272                 {\r
2273                         index = allocate(samplers, sampler);\r
2274 \r
2275                         if(sampler->getQualifier() == EvqUniform)\r
2276                         {\r
2277                                 const char *name = sampler->getSymbol().c_str();\r
2278                                 declareUniform(type, name, index);\r
2279                         }\r
2280                 }\r
2281 \r
2282                 return index;\r
2283         }\r
2284 \r
2285         int OutputASM::lookup(VariableArray &list, TIntermTyped *variable)\r
2286         {\r
2287                 for(unsigned int i = 0; i < list.size(); i++)\r
2288                 {\r
2289                         if(list[i] == variable)\r
2290                         {\r
2291                                 return i;   // Pointer match\r
2292                         }\r
2293                 }\r
2294 \r
2295                 TIntermSymbol *varSymbol = variable->getAsSymbolNode();\r
2296                 TInterfaceBlock *varBlock = variable->getType().getAsInterfaceBlock();\r
2297 \r
2298                 if(varSymbol)\r
2299                 {\r
2300                         for(unsigned int i = 0; i < list.size(); i++)\r
2301                         {\r
2302                                 if(list[i])\r
2303                                 {\r
2304                                         TIntermSymbol *listSymbol = list[i]->getAsSymbolNode();\r
2305 \r
2306                                         if(listSymbol)\r
2307                                         {\r
2308                                                 if(listSymbol->getId() == varSymbol->getId())\r
2309                                                 {\r
2310                                                         ASSERT(listSymbol->getSymbol() == varSymbol->getSymbol());\r
2311                                                         ASSERT(listSymbol->getType() == varSymbol->getType());\r
2312                                                         ASSERT(listSymbol->getQualifier() == varSymbol->getQualifier());\r
2313 \r
2314                                                         return i;\r
2315                                                 }\r
2316                                         }\r
2317                                 }\r
2318                         }\r
2319                 }\r
2320                 else if(varBlock)\r
2321                 {\r
2322                         for(unsigned int i = 0; i < list.size(); i++)\r
2323                         {\r
2324                                 if(list[i])\r
2325                                 {\r
2326                                         TInterfaceBlock *listBlock = list[i]->getType().getAsInterfaceBlock();\r
2327 \r
2328                                         if(listBlock)\r
2329                                         {\r
2330                                                 if(listBlock->name() == varBlock->name())\r
2331                                                 {\r
2332                                                         ASSERT(listBlock->arraySize() == varBlock->arraySize());\r
2333                                                         ASSERT(listBlock->fields() == varBlock->fields());\r
2334                                                         ASSERT(listBlock->blockStorage() == varBlock->blockStorage());\r
2335                                                         ASSERT(listBlock->matrixPacking() == varBlock->matrixPacking());\r
2336 \r
2337                                                         return i;\r
2338                                                 }\r
2339                                         }\r
2340                                 }\r
2341                         }\r
2342                 }\r
2343 \r
2344                 return -1;\r
2345         }\r
2346 \r
2347         int OutputASM::allocate(VariableArray &list, TIntermTyped *variable)\r
2348         {\r
2349                 int index = lookup(list, variable);\r
2350 \r
2351                 if(index == -1)\r
2352                 {\r
2353                         unsigned int registerCount = variable->totalRegisterCount();\r
2354 \r
2355                         for(unsigned int i = 0; i < list.size(); i++)\r
2356                         {\r
2357                                 if(list[i] == 0)\r
2358                                 {\r
2359                                         unsigned int j = 1;\r
2360                                         for( ; j < registerCount && (i + j) < list.size(); j++)\r
2361                                         {\r
2362                                                 if(list[i + j] != 0)\r
2363                                                 {\r
2364                                                         break;\r
2365                                                 }\r
2366                                         }\r
2367 \r
2368                                         if(j == registerCount)   // Found free slots\r
2369                                         {\r
2370                                                 for(unsigned int j = 0; j < registerCount; j++)\r
2371                                                 {\r
2372                                                         list[i + j] = variable;\r
2373                                                 }\r
2374 \r
2375                                                 return i;\r
2376                                         }\r
2377                                 }\r
2378                         }\r
2379 \r
2380                         index = list.size();\r
2381 \r
2382                         for(unsigned int i = 0; i < registerCount; i++)\r
2383                         {\r
2384                                 list.push_back(variable);\r
2385                         }\r
2386                 }\r
2387 \r
2388                 return index;\r
2389         }\r
2390 \r
2391         void OutputASM::free(VariableArray &list, TIntermTyped *variable)\r
2392         {\r
2393                 int index = lookup(list, variable);\r
2394 \r
2395                 if(index >= 0)\r
2396                 {\r
2397                         list[index] = 0;\r
2398                 }\r
2399         }\r
2400 \r
2401         void OutputASM::declareUniform(const TType &type, const TString &name, int index)\r
2402         {\r
2403                 const TStructure *structure = type.getStruct();\r
2404                 ActiveUniforms &activeUniforms = shaderObject->activeUniforms;\r
2405 \r
2406                 if(!structure)\r
2407                 {\r
2408                         activeUniforms.push_back(Uniform(glVariableType(type), glVariablePrecision(type), name.c_str(), type.getArraySize(), index));\r
2409 \r
2410                         if(isSamplerRegister(type))\r
2411                         {\r
2412                                 for(int i = 0; i < type.totalRegisterCount(); i++)\r
2413                                 {\r
2414                                         shader->declareSampler(index + i);\r
2415                                 }\r
2416                         }\r
2417                 }\r
2418                 else\r
2419                 {\r
2420                         const TFieldList& fields = structure->fields();\r
2421                         if(type.isArray())\r
2422                         {\r
2423                                 int elementIndex = index;\r
2424 \r
2425                                 for(int i = 0; i < type.getArraySize(); i++)\r
2426                                 {\r
2427                                         for(size_t j = 0; j < fields.size(); j++)\r
2428                                         {\r
2429                                                 const TType &fieldType = *(fields[j]->type());\r
2430                                                 const TString &fieldName = fields[j]->name();\r
2431 \r
2432                                                 const TString uniformName = name + "[" + str(i) + "]." + fieldName;\r
2433                                                 declareUniform(fieldType, uniformName, elementIndex);\r
2434                                                 elementIndex += fieldType.totalRegisterCount();\r
2435                                         }\r
2436                                 }\r
2437                         }\r
2438                         else\r
2439                         {\r
2440                                 int fieldIndex = index;\r
2441 \r
2442                                 for(size_t i = 0; i < fields.size(); i++)\r
2443                                 {\r
2444                                         const TType &fieldType = *(fields[i]->type());\r
2445                                         const TString &fieldName = fields[i]->name();\r
2446 \r
2447                                         const TString uniformName = name + "." + fieldName;\r
2448                                         declareUniform(fieldType, uniformName, fieldIndex);\r
2449                                         fieldIndex += fieldType.totalRegisterCount();\r
2450                                 }\r
2451                         }\r
2452                 }\r
2453         }\r
2454 \r
2455         GLenum OutputASM::glVariableType(const TType &type)\r
2456         {\r
2457                 switch(type.getBasicType())\r
2458                 {\r
2459                 case EbtFloat:\r
2460                         if(type.isScalar())\r
2461                         {\r
2462                                 return GL_FLOAT;\r
2463                         }\r
2464                         else if(type.isVector())\r
2465                         {\r
2466                                 switch(type.getNominalSize())\r
2467                                 {\r
2468                                 case 2: return GL_FLOAT_VEC2;\r
2469                                 case 3: return GL_FLOAT_VEC3;\r
2470                                 case 4: return GL_FLOAT_VEC4;\r
2471                                 default: UNREACHABLE(type.getNominalSize());\r
2472                                 }\r
2473                         }\r
2474                         else if(type.isMatrix())\r
2475                         {\r
2476                                 switch(type.getNominalSize())\r
2477                                 {\r
2478                                 case 2:\r
2479                                         switch(type.getSecondarySize())\r
2480                                         {\r
2481                                         case 2: return GL_FLOAT_MAT2;\r
2482                                         case 3: return GL_FLOAT_MAT2x3;\r
2483                                         case 4: return GL_FLOAT_MAT2x4;\r
2484                                         default: UNREACHABLE(type.getSecondarySize());\r
2485                                         }\r
2486                                 case 3:\r
2487                                         switch(type.getSecondarySize())\r
2488                                         {\r
2489                                         case 2: return GL_FLOAT_MAT3x2;\r
2490                                         case 3: return GL_FLOAT_MAT3;\r
2491                                         case 4: return GL_FLOAT_MAT3x4;\r
2492                                         default: UNREACHABLE(type.getSecondarySize());\r
2493                                         }\r
2494                                 case 4:\r
2495                                         switch(type.getSecondarySize())\r
2496                                         {\r
2497                                         case 2: return GL_FLOAT_MAT4x2;\r
2498                                         case 3: return GL_FLOAT_MAT4x3;\r
2499                                         case 4: return GL_FLOAT_MAT4;\r
2500                                         default: UNREACHABLE(type.getSecondarySize());\r
2501                                         }\r
2502                                 default: UNREACHABLE(type.getNominalSize());\r
2503                                 }\r
2504                         }\r
2505                         else UNREACHABLE(0);\r
2506                         break;\r
2507                 case EbtInt:\r
2508                         if(type.isScalar())\r
2509                         {\r
2510                                 return GL_INT;\r
2511                         }\r
2512                         else if(type.isVector())\r
2513                         {\r
2514                                 switch(type.getNominalSize())\r
2515                                 {\r
2516                                 case 2: return GL_INT_VEC2;\r
2517                                 case 3: return GL_INT_VEC3;\r
2518                                 case 4: return GL_INT_VEC4;\r
2519                                 default: UNREACHABLE(type.getNominalSize());\r
2520                                 }\r
2521                         }\r
2522                         else UNREACHABLE(0);\r
2523                         break;\r
2524                 case EbtUInt:\r
2525                         if(type.isScalar())\r
2526                         {\r
2527                                 return GL_UNSIGNED_INT;\r
2528                         }\r
2529                         else if(type.isVector())\r
2530                         {\r
2531                                 switch(type.getNominalSize())\r
2532                                 {\r
2533                                 case 2: return GL_UNSIGNED_INT_VEC2;\r
2534                                 case 3: return GL_UNSIGNED_INT_VEC3;\r
2535                                 case 4: return GL_UNSIGNED_INT_VEC4;\r
2536                                 default: UNREACHABLE(type.getNominalSize());\r
2537                                 }\r
2538                         }\r
2539                         else UNREACHABLE(0);\r
2540                         break;\r
2541                 case EbtBool:\r
2542                         if(type.isScalar())\r
2543                         {\r
2544                                 return GL_BOOL;\r
2545                         }\r
2546                         else if(type.isVector())\r
2547                         {\r
2548                                 switch(type.getNominalSize())\r
2549                                 {\r
2550                                 case 2: return GL_BOOL_VEC2;\r
2551                                 case 3: return GL_BOOL_VEC3;\r
2552                                 case 4: return GL_BOOL_VEC4;\r
2553                                 default: UNREACHABLE(type.getNominalSize());\r
2554                                 }\r
2555                         }\r
2556                         else UNREACHABLE(0);\r
2557                         break;\r
2558                 case EbtSampler2D:\r
2559                         return GL_SAMPLER_2D;\r
2560                 case EbtISampler2D:\r
2561                         return GL_INT_SAMPLER_2D;\r
2562                 case EbtUSampler2D:\r
2563                         return GL_UNSIGNED_INT_SAMPLER_2D;\r
2564                 case EbtSamplerCube:\r
2565                         return GL_SAMPLER_CUBE;\r
2566                 case EbtISamplerCube:\r
2567                         return GL_INT_SAMPLER_CUBE;\r
2568                 case EbtUSamplerCube:\r
2569                         return GL_UNSIGNED_INT_SAMPLER_CUBE;\r
2570                 case EbtSamplerExternalOES:\r
2571                         return GL_SAMPLER_EXTERNAL_OES;\r
2572                 case EbtSampler3D:\r
2573                         return GL_SAMPLER_3D_OES;\r
2574                 case EbtISampler3D:\r
2575                         return GL_INT_SAMPLER_3D;\r
2576                 case EbtUSampler3D:\r
2577                         return GL_UNSIGNED_INT_SAMPLER_3D;\r
2578                 case EbtSampler2DArray:\r
2579                         return GL_SAMPLER_2D_ARRAY;\r
2580                 case EbtISampler2DArray:\r
2581                         return GL_INT_SAMPLER_2D_ARRAY;\r
2582                 case EbtUSampler2DArray:\r
2583                         return GL_UNSIGNED_INT_SAMPLER_2D_ARRAY;\r
2584                 case EbtSampler2DShadow:\r
2585                         return GL_SAMPLER_2D_SHADOW;\r
2586                 case EbtSamplerCubeShadow:\r
2587                         return GL_SAMPLER_CUBE_SHADOW;\r
2588                 case EbtSampler2DArrayShadow:\r
2589                         return GL_SAMPLER_2D_ARRAY_SHADOW;\r
2590                 default:\r
2591                         UNREACHABLE(type.getBasicType());\r
2592                         break;\r
2593                 }\r
2594 \r
2595                 return GL_NONE;\r
2596         }\r
2597 \r
2598         GLenum OutputASM::glVariablePrecision(const TType &type)\r
2599         {\r
2600                 if(type.getBasicType() == EbtFloat)\r
2601                 {\r
2602                         switch(type.getPrecision())\r
2603                         {\r
2604                         case EbpHigh:   return GL_HIGH_FLOAT;\r
2605                         case EbpMedium: return GL_MEDIUM_FLOAT;\r
2606                         case EbpLow:    return GL_LOW_FLOAT;\r
2607                         case EbpUndefined:\r
2608                                 // Should be defined as the default precision by the parser\r
2609                         default: UNREACHABLE(type.getPrecision());\r
2610                         }\r
2611                 }\r
2612                 else if(type.getBasicType() == EbtInt)\r
2613                 {\r
2614                         switch(type.getPrecision())\r
2615                         {\r
2616                         case EbpHigh:   return GL_HIGH_INT;\r
2617                         case EbpMedium: return GL_MEDIUM_INT;\r
2618                         case EbpLow:    return GL_LOW_INT;\r
2619                         case EbpUndefined:\r
2620                                 // Should be defined as the default precision by the parser\r
2621                         default: UNREACHABLE(type.getPrecision());\r
2622                         }\r
2623                 }\r
2624 \r
2625                 // Other types (boolean, sampler) don't have a precision\r
2626                 return GL_NONE;\r
2627         }\r
2628 \r
2629         int OutputASM::dim(TIntermNode *v)\r
2630         {\r
2631                 TIntermTyped *vector = v->getAsTyped();\r
2632                 ASSERT(vector && vector->isRegister());\r
2633                 return vector->getNominalSize();\r
2634         }\r
2635 \r
2636         int OutputASM::dim2(TIntermNode *m)\r
2637         {\r
2638                 TIntermTyped *matrix = m->getAsTyped();\r
2639                 ASSERT(matrix && matrix->isMatrix() && !matrix->isArray());\r
2640                 return matrix->getSecondarySize();\r
2641         }\r
2642 \r
2643         // Returns ~0 if no loop count could be determined\r
2644         unsigned int OutputASM::loopCount(TIntermLoop *node)\r
2645         {\r
2646                 // Parse loops of the form:\r
2647                 // for(int index = initial; index [comparator] limit; index += increment)\r
2648                 TIntermSymbol *index = 0;\r
2649                 TOperator comparator = EOpNull;\r
2650                 int initial = 0;\r
2651                 int limit = 0;\r
2652                 int increment = 0;\r
2653 \r
2654                 // Parse index name and intial value\r
2655                 if(node->getInit())\r
2656                 {\r
2657                         TIntermAggregate *init = node->getInit()->getAsAggregate();\r
2658 \r
2659                         if(init)\r
2660                         {\r
2661                                 TIntermSequence &sequence = init->getSequence();\r
2662                                 TIntermTyped *variable = sequence[0]->getAsTyped();\r
2663 \r
2664                                 if(variable && variable->getQualifier() == EvqTemporary)\r
2665                                 {\r
2666                                         TIntermBinary *assign = variable->getAsBinaryNode();\r
2667 \r
2668                                         if(assign->getOp() == EOpInitialize)\r
2669                                         {\r
2670                                                 TIntermSymbol *symbol = assign->getLeft()->getAsSymbolNode();\r
2671                                                 TIntermConstantUnion *constant = assign->getRight()->getAsConstantUnion();\r
2672 \r
2673                                                 if(symbol && constant)\r
2674                                                 {\r
2675                                                         if(constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)\r
2676                                                         {\r
2677                                                                 index = symbol;\r
2678                                                                 initial = constant->getUnionArrayPointer()[0].getIConst();\r
2679                                                         }\r
2680                                                 }\r
2681                                         }\r
2682                                 }\r
2683                         }\r
2684                 }\r
2685 \r
2686                 // Parse comparator and limit value\r
2687                 if(index && node->getCondition())\r
2688                 {\r
2689                         TIntermBinary *test = node->getCondition()->getAsBinaryNode();\r
2690 \r
2691                         if(test && test->getLeft()->getAsSymbolNode()->getId() == index->getId())\r
2692                         {\r
2693                                 TIntermConstantUnion *constant = test->getRight()->getAsConstantUnion();\r
2694 \r
2695                                 if(constant)\r
2696                                 {\r
2697                                         if(constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)\r
2698                                         {\r
2699                                                 comparator = test->getOp();\r
2700                                                 limit = constant->getUnionArrayPointer()[0].getIConst();\r
2701                                         }\r
2702                                 }\r
2703                         }\r
2704                 }\r
2705 \r
2706                 // Parse increment\r
2707                 if(index && comparator != EOpNull && node->getExpression())\r
2708                 {\r
2709                         TIntermBinary *binaryTerminal = node->getExpression()->getAsBinaryNode();\r
2710                         TIntermUnary *unaryTerminal = node->getExpression()->getAsUnaryNode();\r
2711 \r
2712                         if(binaryTerminal)\r
2713                         {\r
2714                                 TOperator op = binaryTerminal->getOp();\r
2715                                 TIntermConstantUnion *constant = binaryTerminal->getRight()->getAsConstantUnion();\r
2716 \r
2717                                 if(constant)\r
2718                                 {\r
2719                                         if(constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)\r
2720                                         {\r
2721                                                 int value = constant->getUnionArrayPointer()[0].getIConst();\r
2722 \r
2723                                                 switch(op)\r
2724                                                 {\r
2725                                                 case EOpAddAssign: increment = value;  break;\r
2726                                                 case EOpSubAssign: increment = -value; break;\r
2727                                                 default: UNIMPLEMENTED();\r
2728                                                 }\r
2729                                         }\r
2730                                 }\r
2731                         }\r
2732                         else if(unaryTerminal)\r
2733                         {\r
2734                                 TOperator op = unaryTerminal->getOp();\r
2735 \r
2736                                 switch(op)\r
2737                                 {\r
2738                                 case EOpPostIncrement: increment = 1;  break;\r
2739                                 case EOpPostDecrement: increment = -1; break;\r
2740                                 case EOpPreIncrement:  increment = 1;  break;\r
2741                                 case EOpPreDecrement:  increment = -1; break;\r
2742                                 default: UNIMPLEMENTED();\r
2743                                 }\r
2744                         }\r
2745                 }\r
2746 \r
2747                 if(index && comparator != EOpNull && increment != 0)\r
2748                 {\r
2749                         if(comparator == EOpLessThanEqual)\r
2750                         {\r
2751                                 comparator = EOpLessThan;\r
2752                                 limit += 1;\r
2753                         }\r
2754 \r
2755                         if(comparator == EOpLessThan)\r
2756                         {\r
2757                                 int iterations = (limit - initial) / increment;\r
2758 \r
2759                                 if(iterations <= 0)\r
2760                                 {\r
2761                                         iterations = 0;\r
2762                                 }\r
2763 \r
2764                                 return iterations;\r
2765                         }\r
2766                         else UNIMPLEMENTED();   // Falls through\r
2767                 }\r
2768 \r
2769                 return ~0;\r
2770         }\r
2771 \r
2772         bool DetectLoopDiscontinuity::traverse(TIntermNode *node)\r
2773         {\r
2774                 loopDepth = 0;\r
2775                 loopDiscontinuity = false;\r
2776                 \r
2777                 node->traverse(this);\r
2778                 \r
2779                 return loopDiscontinuity;\r
2780         }\r
2781 \r
2782         bool DetectLoopDiscontinuity::visitLoop(Visit visit, TIntermLoop *loop)\r
2783         {\r
2784                 if(visit == PreVisit)\r
2785                 {\r
2786                         loopDepth++;\r
2787                 }\r
2788                 else if(visit == PostVisit)\r
2789                 {\r
2790                         loopDepth++;\r
2791                 }\r
2792 \r
2793                 return true;\r
2794         }\r
2795 \r
2796         bool DetectLoopDiscontinuity::visitBranch(Visit visit, TIntermBranch *node)\r
2797         {\r
2798                 if(loopDiscontinuity)\r
2799                 {\r
2800                         return false;\r
2801                 }\r
2802 \r
2803                 if(!loopDepth)\r
2804                 {\r
2805                         return true;\r
2806                 }\r
2807         \r
2808                 switch(node->getFlowOp())\r
2809                 {\r
2810                 case EOpKill:\r
2811                         break;\r
2812                 case EOpBreak:\r
2813                 case EOpContinue:\r
2814                 case EOpReturn:\r
2815                         loopDiscontinuity = true;\r
2816                         break;\r
2817                 default: UNREACHABLE(node->getFlowOp());\r
2818                 }\r
2819 \r
2820                 return !loopDiscontinuity;\r
2821         }\r
2822 \r
2823         bool DetectLoopDiscontinuity::visitAggregate(Visit visit, TIntermAggregate *node)\r
2824         {\r
2825                 return !loopDiscontinuity;\r
2826         }\r
2827 }\r