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