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 #include "Common/Math.hpp"\r
  14 \r
  15 #include "common/debug.h"\r
  16 #include "InfoSink.h"\r
  17 \r
  18 #include "libGLESv2/Shader.h"\r
  19 \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(TSymbolTableLevel::nextUniqueId(), "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, int blockId, const BlockMemberInfo& blockMemberInfo) :\r
  80                 type(type), precision(precision), name(name), arraySize(arraySize), registerIndex(registerIndex), blockId(blockId), blockInfo(blockMemberInfo)\r
  81         {\r
  82         }\r
  83 \r
  84         UniformBlock::UniformBlock(const std::string& name, unsigned int dataSize, unsigned int arraySize,\r
  85                                    TLayoutBlockStorage layout, bool isRowMajorLayout, int registerIndex, int blockId) :\r
  86                 name(name), dataSize(dataSize), arraySize(arraySize), layout(layout),\r
  87                 isRowMajorLayout(isRowMajorLayout), registerIndex(registerIndex), blockId(blockId)\r
  88         {\r
  89         }\r
  90 \r
  91         BlockLayoutEncoder::BlockLayoutEncoder(bool rowMajor)\r
  92                 : mCurrentOffset(0), isRowMajor(rowMajor)\r
  93         {\r
  94         }\r
  95 \r
  96         BlockMemberInfo BlockLayoutEncoder::encodeType(const TType &type)\r
  97         {\r
  98                 int arrayStride;\r
  99                 int matrixStride;\r
 100 \r
 101                 getBlockLayoutInfo(type, type.getArraySize(), isRowMajor, &arrayStride, &matrixStride);\r
 102 \r
 103                 const BlockMemberInfo memberInfo(static_cast<int>(mCurrentOffset * BytesPerComponent),\r
 104                                                  static_cast<int>(arrayStride * BytesPerComponent),\r
 105                                                  static_cast<int>(matrixStride * BytesPerComponent),\r
 106                                                  (matrixStride > 0) && isRowMajor);\r
 107 \r
 108                 advanceOffset(type, type.getArraySize(), isRowMajor, arrayStride, matrixStride);\r
 109 \r
 110                 return memberInfo;\r
 111         }\r
 112 \r
 113         // static\r
 114         size_t BlockLayoutEncoder::getBlockRegister(const BlockMemberInfo &info)\r
 115         {\r
 116                 return (info.offset / BytesPerComponent) / ComponentsPerRegister;\r
 117         }\r
 118 \r
 119         // static\r
 120         size_t BlockLayoutEncoder::getBlockRegisterElement(const BlockMemberInfo &info)\r
 121         {\r
 122                 return (info.offset / BytesPerComponent) % ComponentsPerRegister;\r
 123         }\r
 124 \r
 125         void BlockLayoutEncoder::nextRegister()\r
 126         {\r
 127                 mCurrentOffset = sw::align(mCurrentOffset, ComponentsPerRegister);\r
 128         }\r
 129 \r
 130         Std140BlockEncoder::Std140BlockEncoder(bool rowMajor) : BlockLayoutEncoder(rowMajor)\r
 131         {\r
 132         }\r
 133 \r
 134         void Std140BlockEncoder::enterAggregateType()\r
 135         {\r
 136                 nextRegister();\r
 137         }\r
 138 \r
 139         void Std140BlockEncoder::exitAggregateType()\r
 140         {\r
 141                 nextRegister();\r
 142         }\r
 143 \r
 144         void Std140BlockEncoder::getBlockLayoutInfo(const TType &type, unsigned int arraySize, bool isRowMajorMatrix, int *arrayStrideOut, int *matrixStrideOut)\r
 145         {\r
 146                 size_t baseAlignment = 0;\r
 147                 int matrixStride = 0;\r
 148                 int arrayStride = 0;\r
 149 \r
 150                 if(type.isMatrix())\r
 151                 {\r
 152                         baseAlignment = ComponentsPerRegister;\r
 153                         matrixStride = ComponentsPerRegister;\r
 154 \r
 155                         if(arraySize > 0)\r
 156                         {\r
 157                                 const int numRegisters = isRowMajorMatrix ? type.getSecondarySize() : type.getNominalSize();\r
 158                                 arrayStride = ComponentsPerRegister * numRegisters;\r
 159                         }\r
 160                 }\r
 161                 else if(arraySize > 0)\r
 162                 {\r
 163                         baseAlignment = ComponentsPerRegister;\r
 164                         arrayStride = ComponentsPerRegister;\r
 165                 }\r
 166                 else\r
 167                 {\r
 168                         const int numComponents = type.getElementSize();\r
 169                         baseAlignment = (numComponents == 3 ? 4u : static_cast<size_t>(numComponents));\r
 170                 }\r
 171 \r
 172                 mCurrentOffset = sw::align(mCurrentOffset, baseAlignment);\r
 173 \r
 174                 *matrixStrideOut = matrixStride;\r
 175                 *arrayStrideOut = arrayStride;\r
 176         }\r
 177 \r
 178         void Std140BlockEncoder::advanceOffset(const TType &type, unsigned int arraySize, bool isRowMajorMatrix, int arrayStride, int matrixStride)\r
 179         {\r
 180                 if(arraySize > 0)\r
 181                 {\r
 182                         mCurrentOffset += arrayStride * arraySize;\r
 183                 }\r
 184                 else if(type.isMatrix())\r
 185                 {\r
 186                         ASSERT(matrixStride == ComponentsPerRegister);\r
 187                         const int numRegisters = isRowMajorMatrix ? type.getSecondarySize() : type.getNominalSize();\r
 188                         mCurrentOffset += ComponentsPerRegister * numRegisters;\r
 189                 }\r
 190                 else\r
 191                 {\r
 192                         mCurrentOffset += type.getElementSize();\r
 193                 }\r
 194         }\r
 195 \r
 196         Attribute::Attribute()\r
 197         {\r
 198                 type = GL_NONE;\r
 199                 arraySize = 0;\r
 200                 registerIndex = 0;\r
 201         }\r
 202 \r
 203         Attribute::Attribute(GLenum type, const std::string &name, int arraySize, int location, int registerIndex)\r
 204         {\r
 205                 this->type = type;\r
 206                 this->name = name;\r
 207                 this->arraySize = arraySize;\r
 208                 this->location = location;\r
 209                 this->registerIndex = registerIndex;\r
 210         }\r
 211 \r
 212         sw::PixelShader *Shader::getPixelShader() const\r
 213         {\r
 214                 return 0;\r
 215         }\r
 216 \r
 217         sw::VertexShader *Shader::getVertexShader() const\r
 218         {\r
 219                 return 0;\r
 220         }\r
 221 \r
 222         OutputASM::TextureFunction::TextureFunction(const TString& nodeName) : method(IMPLICIT), proj(false), offset(false)\r
 223         {\r
 224                 TString name = TFunction::unmangleName(nodeName);\r
 225 \r
 226                 if(name == "texture2D" || name == "textureCube" || name == "texture" || name == "texture3D")\r
 227                 {\r
 228                         method = IMPLICIT;\r
 229                 }\r
 230                 else if(name == "texture2DProj" || name == "textureProj")\r
 231                 {\r
 232                         method = IMPLICIT;\r
 233                         proj = true;\r
 234                 }\r
 235                 else if(name == "texture2DLod" || name == "textureCubeLod" || name == "textureLod")\r
 236                 {\r
 237                         method = LOD;\r
 238                 }\r
 239                 else if(name == "texture2DProjLod" || name == "textureProjLod")\r
 240                 {\r
 241                         method = LOD;\r
 242                         proj = true;\r
 243                 }\r
 244                 else if(name == "textureSize")\r
 245                 {\r
 246                         method = SIZE;\r
 247                 }\r
 248                 else if(name == "textureOffset")\r
 249                 {\r
 250                         method = IMPLICIT;\r
 251                         offset = true;\r
 252                 }\r
 253                 else if(name == "textureProjOffset")\r
 254                 {\r
 255                         method = IMPLICIT;\r
 256                         offset = true;\r
 257                         proj = true;\r
 258                 }\r
 259                 else if(name == "textureLodOffset")\r
 260                 {\r
 261                         method = LOD;\r
 262                         offset = true;\r
 263                 }\r
 264                 else if(name == "textureProjLodOffset")\r
 265                 {\r
 266                         method = LOD;\r
 267                         proj = true;\r
 268                         offset = true;\r
 269                 }\r
 270                 else if(name == "texelFetch")\r
 271                 {\r
 272                         method = FETCH;\r
 273                 }\r
 274                 else if(name == "texelFetchOffset")\r
 275                 {\r
 276                         method = FETCH;\r
 277                         offset = true;\r
 278                 }\r
 279                 else if(name == "textureGrad")\r
 280                 {\r
 281                         method = GRAD;\r
 282                 }\r
 283                 else if(name == "textureGradOffset")\r
 284                 {\r
 285                         method = GRAD;\r
 286                         offset = true;\r
 287                 }\r
 288                 else if(name == "textureProjGrad")\r
 289                 {\r
 290                         method = GRAD;\r
 291                         proj = true;\r
 292                 }\r
 293                 else if(name == "textureProjGradOffset")\r
 294                 {\r
 295                         method = GRAD;\r
 296                         proj = true;\r
 297                         offset = true;\r
 298                 }\r
 299                 else UNREACHABLE(0);\r
 300         }\r
 301 \r
 302         OutputASM::OutputASM(TParseContext &context, Shader *shaderObject) : TIntermTraverser(true, true, true), shaderObject(shaderObject), mContext(context)\r
 303         {\r
 304                 shader = 0;\r
 305                 pixelShader = 0;\r
 306                 vertexShader = 0;\r
 307 \r
 308                 if(shaderObject)\r
 309                 {\r
 310                         shader = shaderObject->getShader();\r
 311                         pixelShader = shaderObject->getPixelShader();\r
 312                         vertexShader = shaderObject->getVertexShader();\r
 313                 }\r
 314 \r
 315                 functionArray.push_back(Function(0, "main(", 0, 0));\r
 316                 currentFunction = 0;\r
 317                 outputQualifier = EvqOutput; // Set outputQualifier to any value other than EvqFragColor or EvqFragData\r
 318         }\r
 319 \r
 320         OutputASM::~OutputASM()\r
 321         {\r
 322         }\r
 323 \r
 324         void OutputASM::output()\r
 325         {\r
 326                 if(shader)\r
 327                 {\r
 328                         emitShader(GLOBAL);\r
 329 \r
 330                         if(functionArray.size() > 1)   // Only call main() when there are other functions\r
 331                         {\r
 332                                 Instruction *callMain = emit(sw::Shader::OPCODE_CALL);\r
 333                                 callMain->dst.type = sw::Shader::PARAMETER_LABEL;\r
 334                                 callMain->dst.index = 0;   // main()\r
 335 \r
 336                                 emit(sw::Shader::OPCODE_RET);\r
 337                         }\r
 338 \r
 339                         emitShader(FUNCTION);\r
 340                 }\r
 341         }\r
 342 \r
 343         void OutputASM::emitShader(Scope scope)\r
 344         {\r
 345                 emitScope = scope;\r
 346                 currentScope = GLOBAL;\r
 347                 mContext.getTreeRoot()->traverse(this);\r
 348         }\r
 349 \r
 350         void OutputASM::freeTemporary(Temporary *temporary)\r
 351         {\r
 352                 free(temporaries, temporary);\r
 353         }\r
 354 \r
 355         sw::Shader::Opcode OutputASM::getOpcode(sw::Shader::Opcode op, TIntermTyped *in) const\r
 356         {\r
 357                 TBasicType baseType = in->getType().getBasicType();\r
 358 \r
 359                 switch(op)\r
 360                 {\r
 361                 case sw::Shader::OPCODE_NEG:\r
 362                         switch(baseType)\r
 363                         {\r
 364                         case EbtInt:\r
 365                         case EbtUInt:\r
 366                                 return sw::Shader::OPCODE_INEG;\r
 367                         case EbtFloat:\r
 368                         default:\r
 369                                 return op;\r
 370                         }\r
 371                 case sw::Shader::OPCODE_ABS:\r
 372                         switch(baseType)\r
 373                         {\r
 374                         case EbtInt:\r
 375                                 return sw::Shader::OPCODE_IABS;\r
 376                         case EbtFloat:\r
 377                         default:\r
 378                                 return op;\r
 379                         }\r
 380                 case sw::Shader::OPCODE_SGN:\r
 381                         switch(baseType)\r
 382                         {\r
 383                         case EbtInt:\r
 384                                 return sw::Shader::OPCODE_ISGN;\r
 385                         case EbtFloat:\r
 386                         default:\r
 387                                 return op;\r
 388                         }\r
 389                 case sw::Shader::OPCODE_ADD:\r
 390                         switch(baseType)\r
 391                         {\r
 392                         case EbtInt:\r
 393                         case EbtUInt:\r
 394                                 return sw::Shader::OPCODE_IADD;\r
 395                         case EbtFloat:\r
 396                         default:\r
 397                                 return op;\r
 398                         }\r
 399                 case sw::Shader::OPCODE_SUB:\r
 400                         switch(baseType)\r
 401                         {\r
 402                         case EbtInt:\r
 403                         case EbtUInt:\r
 404                                 return sw::Shader::OPCODE_ISUB;\r
 405                         case EbtFloat:\r
 406                         default:\r
 407                                 return op;\r
 408                         }\r
 409                 case sw::Shader::OPCODE_MUL:\r
 410                         switch(baseType)\r
 411                         {\r
 412                         case EbtInt:\r
 413                         case EbtUInt:\r
 414                                 return sw::Shader::OPCODE_IMUL;\r
 415                         case EbtFloat:\r
 416                         default:\r
 417                                 return op;\r
 418                         }\r
 419                 case sw::Shader::OPCODE_DIV:\r
 420                         switch(baseType)\r
 421                         {\r
 422                         case EbtInt:\r
 423                                 return sw::Shader::OPCODE_IDIV;\r
 424                         case EbtUInt:\r
 425                                 return sw::Shader::OPCODE_UDIV;\r
 426                         case EbtFloat:\r
 427                         default:\r
 428                                 return op;\r
 429                         }\r
 430                 case sw::Shader::OPCODE_IMOD:\r
 431                         return baseType == EbtUInt ? sw::Shader::OPCODE_UMOD : op;\r
 432                 case sw::Shader::OPCODE_ISHR:\r
 433                         return baseType == EbtUInt ? sw::Shader::OPCODE_USHR : op;\r
 434                 case sw::Shader::OPCODE_MIN:\r
 435                         switch(baseType)\r
 436                         {\r
 437                         case EbtInt:\r
 438                                 return sw::Shader::OPCODE_IMIN;\r
 439                         case EbtUInt:\r
 440                                 return sw::Shader::OPCODE_UMIN;\r
 441                         case EbtFloat:\r
 442                         default:\r
 443                                 return op;\r
 444                         }\r
 445                 case sw::Shader::OPCODE_MAX:\r
 446                         switch(baseType)\r
 447                         {\r
 448                         case EbtInt:\r
 449                                 return sw::Shader::OPCODE_IMAX;\r
 450                         case EbtUInt:\r
 451                                 return sw::Shader::OPCODE_UMAX;\r
 452                         case EbtFloat:\r
 453                         default:\r
 454                                 return op;\r
 455                         }\r
 456                 default:\r
 457                         return op;\r
 458                 }\r
 459         }\r
 460 \r
 461         void OutputASM::visitSymbol(TIntermSymbol *symbol)\r
 462         {\r
 463                 // Vertex varyings don't have to be actively used to successfully link\r
 464                 // against pixel shaders that use them. So make sure they're declared.\r
 465                 if(symbol->getQualifier() == EvqVaryingOut || symbol->getQualifier() == EvqInvariantVaryingOut || symbol->getQualifier() == EvqVertexOut)\r
 466                 {\r
 467                         if(symbol->getBasicType() != EbtInvariant)   // Typeless declarations are not new varyings\r
 468                         {\r
 469                                 declareVarying(symbol, -1);\r
 470                         }\r
 471                 }\r
 472 \r
 473                 TInterfaceBlock* block = symbol->getType().getInterfaceBlock();\r
 474                 // OpenGL ES 3.0.4 spec, section 2.12.6 Uniform Variables:\r
 475                 // "All members of a named uniform block declared with a shared or std140 layout qualifier\r
 476                 // are considered active, even if they are not referenced in any shader in the program.\r
 477                 // The uniform block itself is also considered active, even if no member of the block is referenced."\r
 478                 if(block && ((block->blockStorage() == EbsShared) || (block->blockStorage() == EbsStd140)))\r
 479                 {\r
 480                         uniformRegister(symbol);\r
 481                 }\r
 482         }\r
 483 \r
 484         bool OutputASM::visitBinary(Visit visit, TIntermBinary *node)\r
 485         {\r
 486                 if(currentScope != emitScope)\r
 487                 {\r
 488                         return false;\r
 489                 }\r
 490 \r
 491                 TIntermTyped *result = node;\r
 492                 TIntermTyped *left = node->getLeft();\r
 493                 TIntermTyped *right = node->getRight();\r
 494                 const TType &leftType = left->getType();\r
 495                 const TType &rightType = right->getType();\r
 496                 const TType &resultType = node->getType();\r
 497 \r
 498                 switch(node->getOp())\r
 499                 {\r
 500                 case EOpAssign:\r
 501                         if(visit == PostVisit)\r
 502                         {\r
 503                                 assignLvalue(left, right);\r
 504                                 copy(result, right);\r
 505                         }\r
 506                         break;\r
 507                 case EOpInitialize:\r
 508                         if(visit == PostVisit)\r
 509                         {\r
 510                                 copy(left, right);\r
 511                         }\r
 512                         break;\r
 513                 case EOpMatrixTimesScalarAssign:\r
 514                         if(visit == PostVisit)\r
 515                         {\r
 516                                 for(int i = 0; i < leftType.getNominalSize(); i++)\r
 517                                 {\r
 518                                         emit(sw::Shader::OPCODE_MUL, result, i, left, i, right);\r
 519                                 }\r
 520 \r
 521                                 assignLvalue(left, result);\r
 522                         }\r
 523                         break;\r
 524                 case EOpVectorTimesMatrixAssign:\r
 525                         if(visit == PostVisit)\r
 526                         {\r
 527                                 int size = leftType.getNominalSize();\r
 528 \r
 529                                 for(int i = 0; i < size; i++)\r
 530                                 {\r
 531                                         Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, 0, left, 0, right, i);\r
 532                                         dot->dst.mask = 1 << i;\r
 533                                 }\r
 534 \r
 535                                 assignLvalue(left, result);\r
 536                         }\r
 537                         break;\r
 538                 case EOpMatrixTimesMatrixAssign:\r
 539                         if(visit == PostVisit)\r
 540                         {\r
 541                                 int dim = leftType.getNominalSize();\r
 542 \r
 543                                 for(int i = 0; i < dim; i++)\r
 544                                 {\r
 545                                         Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, i, left, 0, right, i);\r
 546                                         mul->src[1].swizzle = 0x00;\r
 547 \r
 548                                         for(int j = 1; j < dim; j++)\r
 549                                         {\r
 550                                                 Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, i, left, j, right, i, result, i);\r
 551                                                 mad->src[1].swizzle = j * 0x55;\r
 552                                         }\r
 553                                 }\r
 554 \r
 555                                 assignLvalue(left, result);\r
 556                         }\r
 557                         break;\r
 558                 case EOpIndexDirect:\r
 559                         if(visit == PostVisit)\r
 560                         {\r
 561                                 int index = right->getAsConstantUnion()->getIConst(0);\r
 562 \r
 563                                 if(result->isMatrix() || result->isStruct() || result->isInterfaceBlock())\r
 564                                 {\r
 565                                         ASSERT(left->isArray());\r
 566                                         copy(result, left, index * left->elementRegisterCount());\r
 567                                 }\r
 568                                 else if(result->isRegister())\r
 569                                 {\r
 570                                         int srcIndex = 0;\r
 571                                         if(left->isRegister())\r
 572                                         {\r
 573                                                 srcIndex = 0;\r
 574                                         }\r
 575                                         else if(left->isArray())\r
 576                                         {\r
 577                                                 srcIndex = index * left->elementRegisterCount();\r
 578                                         }\r
 579                                         else if(left->isMatrix())\r
 580                                         {\r
 581                                                 ASSERT(index < left->getNominalSize());   // FIXME: Report semantic error\r
 582                                                 srcIndex = index;\r
 583                                         }\r
 584                                         else UNREACHABLE(0);\r
 585 \r
 586                                         Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, 0, left, srcIndex);\r
 587 \r
 588                                         if(left->isRegister())\r
 589                                         {\r
 590                                                 mov->src[0].swizzle = index;\r
 591                                         }\r
 592                                 }\r
 593                                 else UNREACHABLE(0);\r
 594                         }\r
 595                         break;\r
 596                 case EOpIndexIndirect:\r
 597                         if(visit == PostVisit)\r
 598                         {\r
 599                                 if(left->isArray() || left->isMatrix())\r
 600                                 {\r
 601                                         for(int index = 0; index < result->totalRegisterCount(); index++)\r
 602                                         {\r
 603                                                 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, index, left, index);\r
 604                                                 mov->dst.mask = writeMask(result, index);\r
 605 \r
 606                                                 if(left->totalRegisterCount() > 1)\r
 607                                                 {\r
 608                                                         sw::Shader::SourceParameter relativeRegister;\r
 609                                                         argument(relativeRegister, right);\r
 610 \r
 611                                                         mov->src[0].rel.type = relativeRegister.type;\r
 612                                                         mov->src[0].rel.index = relativeRegister.index;\r
 613                                                         mov->src[0].rel.scale = result->totalRegisterCount();\r
 614                                                         mov->src[0].rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);\r
 615                                                 }\r
 616                                         }\r
 617                                 }\r
 618                                 else if(left->isRegister())\r
 619                                 {\r
 620                                         emit(sw::Shader::OPCODE_EXTRACT, result, left, right);\r
 621                                 }\r
 622                                 else UNREACHABLE(0);\r
 623                         }\r
 624                         break;\r
 625                 case EOpIndexDirectStruct:\r
 626                 case EOpIndexDirectInterfaceBlock:\r
 627                         if(visit == PostVisit)\r
 628                         {\r
 629                                 ASSERT(leftType.isStruct() || (leftType.isInterfaceBlock()));\r
 630 \r
 631                                 const TFieldList& fields = (node->getOp() == EOpIndexDirectStruct) ?\r
 632                                                            leftType.getStruct()->fields() :\r
 633                                                            leftType.getInterfaceBlock()->fields();\r
 634                                 int index = right->getAsConstantUnion()->getIConst(0);\r
 635                                 int fieldOffset = 0;\r
 636 \r
 637                                 for(int i = 0; i < index; i++)\r
 638                                 {\r
 639                                         fieldOffset += fields[i]->type()->totalRegisterCount();\r
 640                                 }\r
 641 \r
 642                                 copy(result, left, fieldOffset);\r
 643                         }\r
 644                         break;\r
 645                 case EOpVectorSwizzle:\r
 646                         if(visit == PostVisit)\r
 647                         {\r
 648                                 int swizzle = 0;\r
 649                                 TIntermAggregate *components = right->getAsAggregate();\r
 650 \r
 651                                 if(components)\r
 652                                 {\r
 653                                         TIntermSequence &sequence = components->getSequence();\r
 654                                         int component = 0;\r
 655 \r
 656                                         for(TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++)\r
 657                                         {\r
 658                                                 TIntermConstantUnion *element = (*sit)->getAsConstantUnion();\r
 659 \r
 660                                                 if(element)\r
 661                                                 {\r
 662                                                         int i = element->getUnionArrayPointer()[0].getIConst();\r
 663                                                         swizzle |= i << (component * 2);\r
 664                                                         component++;\r
 665                                                 }\r
 666                                                 else UNREACHABLE(0);\r
 667                                         }\r
 668                                 }\r
 669                                 else UNREACHABLE(0);\r
 670 \r
 671                                 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);\r
 672                                 mov->src[0].swizzle = swizzle;\r
 673                         }\r
 674                         break;\r
 675                 case EOpAddAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_ADD, result), result, left, left, right); break;\r
 676                 case EOpAdd:       if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_ADD, result), result, left, right);       break;\r
 677                 case EOpSubAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_SUB, result), result, left, left, right); break;\r
 678                 case EOpSub:       if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_SUB, result), result, left, right);       break;\r
 679                 case EOpMulAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_MUL, result), result, left, left, right); break;\r
 680                 case EOpMul:       if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_MUL, result), result, left, right);       break;\r
 681                 case EOpDivAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_DIV, result), result, left, left, right); break;\r
 682                 case EOpDiv:       if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_DIV, result), result, left, right);       break;\r
 683                 case EOpIModAssign:          if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_IMOD, result), result, left, left, right); break;\r
 684                 case EOpIMod:                if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_IMOD, result), result, left, right);       break;\r
 685                 case EOpBitShiftLeftAssign:  if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_SHL, result, left, left, right); break;\r
 686                 case EOpBitShiftLeft:        if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_SHL, result, left, right);       break;\r
 687                 case EOpBitShiftRightAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_ISHR, result), result, left, left, right); break;\r
 688                 case EOpBitShiftRight:       if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_ISHR, result), result, left, right);       break;\r
 689                 case EOpBitwiseAndAssign:    if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_AND, result, left, left, right); break;\r
 690                 case EOpBitwiseAnd:          if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_AND, result, left, right);       break;\r
 691                 case EOpBitwiseXorAssign:    if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_XOR, result, left, left, right); break;\r
 692                 case EOpBitwiseXor:          if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_XOR, result, left, right);       break;\r
 693                 case EOpBitwiseOrAssign:     if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_OR, result, left, left, right);  break;\r
 694                 case EOpBitwiseOr:           if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_OR, result, left, right);        break;\r
 695                 case EOpEqual:\r
 696                         if(visit == PostVisit)\r
 697                         {\r
 698                                 emitBinary(sw::Shader::OPCODE_EQ, result, left, right);\r
 699 \r
 700                                 for(int index = 1; index < left->totalRegisterCount(); index++)\r
 701                                 {\r
 702                                         Temporary equal(this);\r
 703                                         emit(sw::Shader::OPCODE_EQ, &equal, 0, left, index, right, index);\r
 704                                         emit(sw::Shader::OPCODE_AND, result, result, &equal);\r
 705                                 }\r
 706                         }\r
 707                         break;\r
 708                 case EOpNotEqual:\r
 709                         if(visit == PostVisit)\r
 710                         {\r
 711                                 emitBinary(sw::Shader::OPCODE_NE, result, left, right);\r
 712 \r
 713                                 for(int index = 1; index < left->totalRegisterCount(); index++)\r
 714                                 {\r
 715                                         Temporary notEqual(this);\r
 716                                         emit(sw::Shader::OPCODE_NE, &notEqual, 0, left, index, right, index);\r
 717                                         emit(sw::Shader::OPCODE_OR, result, result, &notEqual);\r
 718                                 }\r
 719                         }\r
 720                         break;\r
 721                 case EOpLessThan:                if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, left, right); break;\r
 722                 case EOpGreaterThan:             if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, left, right); break;\r
 723                 case EOpLessThanEqual:           if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, left, right); break;\r
 724                 case EOpGreaterThanEqual:        if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, left, right); break;\r
 725                 case EOpVectorTimesScalarAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_MUL, left), result, left, left, right); break;\r
 726                 case EOpVectorTimesScalar:       if(visit == PostVisit) emit(getOpcode(sw::Shader::OPCODE_MUL, left), result, left, right); break;\r
 727                 case EOpMatrixTimesScalar:\r
 728                         if(visit == PostVisit)\r
 729                         {\r
 730                                 if(left->isMatrix())\r
 731                                 {\r
 732                                         for(int i = 0; i < leftType.getNominalSize(); i++)\r
 733                                         {\r
 734                                                 emit(sw::Shader::OPCODE_MUL, result, i, left, i, right, 0);\r
 735                                         }\r
 736                                 }\r
 737                                 else if(right->isMatrix())\r
 738                                 {\r
 739                                         for(int i = 0; i < rightType.getNominalSize(); i++)\r
 740                                         {\r
 741                                                 emit(sw::Shader::OPCODE_MUL, result, i, left, 0, right, i);\r
 742                                         }\r
 743                                 }\r
 744                                 else UNREACHABLE(0);\r
 745                         }\r
 746                         break;\r
 747                 case EOpVectorTimesMatrix:\r
 748                         if(visit == PostVisit)\r
 749                         {\r
 750                                 sw::Shader::Opcode dpOpcode = sw::Shader::OPCODE_DP(leftType.getNominalSize());\r
 751 \r
 752                                 int size = rightType.getNominalSize();\r
 753                                 for(int i = 0; i < size; i++)\r
 754                                 {\r
 755                                         Instruction *dot = emit(dpOpcode, result, 0, left, 0, right, i);\r
 756                                         dot->dst.mask = 1 << i;\r
 757                                 }\r
 758                         }\r
 759                         break;\r
 760                 case EOpMatrixTimesVector:\r
 761                         if(visit == PostVisit)\r
 762                         {\r
 763                                 Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
 764                                 mul->src[1].swizzle = 0x00;\r
 765 \r
 766                                 int size = rightType.getNominalSize();\r
 767                                 for(int i = 1; i < size; i++)\r
 768                                 {\r
 769                                         Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, 0, left, i, right, 0, result);\r
 770                                         mad->src[1].swizzle = i * 0x55;\r
 771                                 }\r
 772                         }\r
 773                         break;\r
 774                 case EOpMatrixTimesMatrix:\r
 775                         if(visit == PostVisit)\r
 776                         {\r
 777                                 int dim = leftType.getNominalSize();\r
 778 \r
 779                                 int size = rightType.getNominalSize();\r
 780                                 for(int i = 0; i < size; i++)\r
 781                                 {\r
 782                                         Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, i, left, 0, right, i);\r
 783                                         mul->src[1].swizzle = 0x00;\r
 784 \r
 785                                         for(int j = 1; j < dim; j++)\r
 786                                         {\r
 787                                                 Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, i, left, j, right, i, result, i);\r
 788                                                 mad->src[1].swizzle = j * 0x55;\r
 789                                         }\r
 790                                 }\r
 791                         }\r
 792                         break;\r
 793                 case EOpLogicalOr:\r
 794                         if(trivial(right, 6))\r
 795                         {\r
 796                                 if(visit == PostVisit)\r
 797                                 {\r
 798                                         emit(sw::Shader::OPCODE_OR, result, left, right);\r
 799                                 }\r
 800                         }\r
 801                         else   // Short-circuit evaluation\r
 802                         {\r
 803                                 if(visit == InVisit)\r
 804                                 {\r
 805                                         emit(sw::Shader::OPCODE_MOV, result, left);\r
 806                                         Instruction *ifnot = emit(sw::Shader::OPCODE_IF, 0, result);\r
 807                                         ifnot->src[0].modifier = sw::Shader::MODIFIER_NOT;\r
 808                                 }\r
 809                                 else if(visit == PostVisit)\r
 810                                 {\r
 811                                         emit(sw::Shader::OPCODE_MOV, result, right);\r
 812                                         emit(sw::Shader::OPCODE_ENDIF);\r
 813                                 }\r
 814                         }\r
 815                         break;\r
 816                 case EOpLogicalXor:        if(visit == PostVisit) emit(sw::Shader::OPCODE_XOR, result, left, right); break;\r
 817                 case EOpLogicalAnd:\r
 818                         if(trivial(right, 6))\r
 819                         {\r
 820                                 if(visit == PostVisit)\r
 821                                 {\r
 822                                         emit(sw::Shader::OPCODE_AND, result, left, right);\r
 823                                 }\r
 824                         }\r
 825                         else   // Short-circuit evaluation\r
 826                         {\r
 827                                 if(visit == InVisit)\r
 828                                 {\r
 829                                         emit(sw::Shader::OPCODE_MOV, result, left);\r
 830                                         emit(sw::Shader::OPCODE_IF, 0, result);\r
 831                                 }\r
 832                                 else if(visit == PostVisit)\r
 833                                 {\r
 834                                         emit(sw::Shader::OPCODE_MOV, result, right);\r
 835                                         emit(sw::Shader::OPCODE_ENDIF);\r
 836                                 }\r
 837                         }\r
 838                         break;\r
 839                 default: UNREACHABLE(node->getOp());\r
 840                 }\r
 841 \r
 842                 return true;\r
 843         }\r
 844 \r
 845         void OutputASM::emitDeterminant(TIntermTyped *result, TIntermTyped *arg, int size, int col, int row, int outCol, int outRow)\r
 846         {\r
 847                 switch(size)\r
 848                 {\r
 849                 case 1: // Used for cofactor computation only\r
 850                         {\r
 851                                 // For a 2x2 matrix, the cofactor is simply a transposed move or negate\r
 852                                 bool isMov = (row == col);\r
 853                                 sw::Shader::Opcode op = isMov ? sw::Shader::OPCODE_MOV : sw::Shader::OPCODE_NEG;\r
 854                                 Instruction *mov = emit(op, result, outCol, arg, isMov ? 1 - row : row);\r
 855                                 mov->src[0].swizzle = 0x55 * (isMov ? 1 - col : col);\r
 856                                 mov->dst.mask = 1 << outRow;\r
 857                         }\r
 858                         break;\r
 859                 case 2:\r
 860                         {\r
 861                                 static const unsigned int swizzle[3] = { 0x99, 0x88, 0x44 }; // xy?? : yzyz, xzxz, xyxy\r
 862 \r
 863                                 bool isCofactor = (col >= 0) && (row >= 0);\r
 864                                 int col0 = (isCofactor && (col <= 0)) ? 1 : 0;\r
 865                                 int col1 = (isCofactor && (col <= 1)) ? 2 : 1;\r
 866                                 bool negate = isCofactor && ((col & 0x01) ^ (row & 0x01));\r
 867 \r
 868                                 Instruction *det = emit(sw::Shader::OPCODE_DET2, result, outCol, arg, negate ? col1 : col0, arg, negate ? col0 : col1);\r
 869                                 det->src[0].swizzle = det->src[1].swizzle = swizzle[isCofactor ? row : 2];\r
 870                                 det->dst.mask = 1 << outRow;\r
 871                         }\r
 872                         break;\r
 873                 case 3:\r
 874                         {\r
 875                                 static const unsigned int swizzle[4] = { 0xF9, 0xF8, 0xF4, 0xE4 }; // xyz? : yzww, xzww, xyww, xyzw\r
 876 \r
 877                                 bool isCofactor = (col >= 0) && (row >= 0);\r
 878                                 int col0 = (isCofactor && (col <= 0)) ? 1 : 0;\r
 879                                 int col1 = (isCofactor && (col <= 1)) ? 2 : 1;\r
 880                                 int col2 = (isCofactor && (col <= 2)) ? 3 : 2;\r
 881                                 bool negate = isCofactor && ((col & 0x01) ^ (row & 0x01));\r
 882 \r
 883                                 Instruction *det = emit(sw::Shader::OPCODE_DET3, result, outCol, arg, col0, arg, negate ? col2 : col1, arg, negate ? col1 : col2);\r
 884                                 det->src[0].swizzle = det->src[1].swizzle = det->src[2].swizzle = swizzle[isCofactor ? row : 3];\r
 885                                 det->dst.mask = 1 << outRow;\r
 886                         }\r
 887                         break;\r
 888                 case 4:\r
 889                         {\r
 890                                 Instruction *det = emit(sw::Shader::OPCODE_DET4, result, outCol, arg, 0, arg, 1, arg, 2, arg, 3);\r
 891                                 det->dst.mask = 1 << outRow;\r
 892                         }\r
 893                         break;\r
 894                 default:\r
 895                         UNREACHABLE(size);\r
 896                         break;\r
 897                 }\r
 898         }\r
 899 \r
 900         bool OutputASM::visitUnary(Visit visit, TIntermUnary *node)\r
 901         {\r
 902                 if(currentScope != emitScope)\r
 903                 {\r
 904                         return false;\r
 905                 }\r
 906 \r
 907                 TIntermTyped *result = node;\r
 908                 TIntermTyped *arg = node->getOperand();\r
 909                 TBasicType basicType = arg->getType().getBasicType();\r
 910 \r
 911                 union\r
 912                 {\r
 913                         float f;\r
 914                         int i;\r
 915                 } one_value;\r
 916 \r
 917                 if(basicType == EbtInt || basicType == EbtUInt)\r
 918                 {\r
 919                         one_value.i = 1;\r
 920                 }\r
 921                 else\r
 922                 {\r
 923                         one_value.f = 1.0f;\r
 924                 }\r
 925 \r
 926                 Constant one(one_value.f, one_value.f, one_value.f, one_value.f);\r
 927                 Constant rad(1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f);\r
 928                 Constant deg(5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f);\r
 929 \r
 930                 switch(node->getOp())\r
 931                 {\r
 932                 case EOpNegative:\r
 933                         if(visit == PostVisit)\r
 934                         {\r
 935                                 sw::Shader::Opcode negOpcode = getOpcode(sw::Shader::OPCODE_NEG, arg);\r
 936                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 937                                 {\r
 938                                         emit(negOpcode, result, index, arg, index);\r
 939                                 }\r
 940                         }\r
 941                         break;\r
 942                 case EOpVectorLogicalNot: if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;\r
 943                 case EOpLogicalNot:       if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;\r
 944                 case EOpPostIncrement:\r
 945                         if(visit == PostVisit)\r
 946                         {\r
 947                                 copy(result, arg);\r
 948 \r
 949                                 sw::Shader::Opcode addOpcode = getOpcode(sw::Shader::OPCODE_ADD, arg);\r
 950                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 951                                 {\r
 952                                         emit(addOpcode, arg, index, arg, index, &one);\r
 953                                 }\r
 954 \r
 955                                 assignLvalue(arg, arg);\r
 956                         }\r
 957                         break;\r
 958                 case EOpPostDecrement:\r
 959                         if(visit == PostVisit)\r
 960                         {\r
 961                                 copy(result, arg);\r
 962 \r
 963                                 sw::Shader::Opcode subOpcode = getOpcode(sw::Shader::OPCODE_SUB, arg);\r
 964                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 965                                 {\r
 966                                         emit(subOpcode, arg, index, arg, index, &one);\r
 967                                 }\r
 968 \r
 969                                 assignLvalue(arg, arg);\r
 970                         }\r
 971                         break;\r
 972                 case EOpPreIncrement:\r
 973                         if(visit == PostVisit)\r
 974                         {\r
 975                                 sw::Shader::Opcode addOpcode = getOpcode(sw::Shader::OPCODE_ADD, arg);\r
 976                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 977                                 {\r
 978                                         emit(addOpcode, result, index, arg, index, &one);\r
 979                                 }\r
 980 \r
 981                                 assignLvalue(arg, result);\r
 982                         }\r
 983                         break;\r
 984                 case EOpPreDecrement:\r
 985                         if(visit == PostVisit)\r
 986                         {\r
 987                                 sw::Shader::Opcode subOpcode = getOpcode(sw::Shader::OPCODE_SUB, arg);\r
 988                                 for(int index = 0; index < arg->totalRegisterCount(); index++)\r
 989                                 {\r
 990                                         emit(subOpcode, result, index, arg, index, &one);\r
 991                                 }\r
 992 \r
 993                                 assignLvalue(arg, result);\r
 994                         }\r
 995                         break;\r
 996                 case EOpRadians:          if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, &rad); break;\r
 997                 case EOpDegrees:          if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, &deg); break;\r
 998                 case EOpSin:              if(visit == PostVisit) emit(sw::Shader::OPCODE_SIN, result, arg); break;\r
 999                 case EOpCos:              if(visit == PostVisit) emit(sw::Shader::OPCODE_COS, result, arg); break;\r
1000                 case EOpTan:              if(visit == PostVisit) emit(sw::Shader::OPCODE_TAN, result, arg); break;\r
1001                 case EOpAsin:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ASIN, result, arg); break;\r
1002                 case EOpAcos:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOS, result, arg); break;\r
1003                 case EOpAtan:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN, result, arg); break;\r
1004                 case EOpSinh:             if(visit == PostVisit) emit(sw::Shader::OPCODE_SINH, result, arg); break;\r
1005                 case EOpCosh:             if(visit == PostVisit) emit(sw::Shader::OPCODE_COSH, result, arg); break;\r
1006                 case EOpTanh:             if(visit == PostVisit) emit(sw::Shader::OPCODE_TANH, result, arg); break;\r
1007                 case EOpAsinh:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ASINH, result, arg); break;\r
1008                 case EOpAcosh:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOSH, result, arg); break;\r
1009                 case EOpAtanh:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ATANH, result, arg); break;\r
1010                 case EOpExp:              if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP, result, arg); break;\r
1011                 case EOpLog:              if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG, result, arg); break;\r
1012                 case EOpExp2:             if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP2, result, arg); break;\r
1013                 case EOpLog2:             if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG2, result, arg); break;\r
1014                 case EOpSqrt:             if(visit == PostVisit) emit(sw::Shader::OPCODE_SQRT, result, arg); break;\r
1015                 case EOpInverseSqrt:      if(visit == PostVisit) emit(sw::Shader::OPCODE_RSQ, result, arg); break;\r
1016                 case EOpAbs:              if(visit == PostVisit) emit(getOpcode(sw::Shader::OPCODE_ABS, result), result, arg); break;\r
1017                 case EOpSign:             if(visit == PostVisit) emit(getOpcode(sw::Shader::OPCODE_SGN, result), result, arg); break;\r
1018                 case EOpFloor:            if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOOR, result, arg); break;\r
1019                 case EOpTrunc:            if(visit == PostVisit) emit(sw::Shader::OPCODE_TRUNC, result, arg); break;\r
1020                 case EOpRound:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ROUND, result, arg); break;\r
1021                 case EOpRoundEven:        if(visit == PostVisit) emit(sw::Shader::OPCODE_ROUNDEVEN, result, arg); break;\r
1022                 case EOpCeil:             if(visit == PostVisit) emit(sw::Shader::OPCODE_CEIL, result, arg, result); break;\r
1023                 case EOpFract:            if(visit == PostVisit) emit(sw::Shader::OPCODE_FRC, result, arg); break;\r
1024                 case EOpIsNan:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ISNAN, result, arg); break;\r
1025                 case EOpIsInf:            if(visit == PostVisit) emit(sw::Shader::OPCODE_ISINF, result, arg); break;\r
1026                 case EOpLength:           if(visit == PostVisit) emit(sw::Shader::OPCODE_LEN(dim(arg)), result, arg); break;\r
1027                 case EOpNormalize:        if(visit == PostVisit) emit(sw::Shader::OPCODE_NRM(dim(arg)), result, arg); break;\r
1028                 case EOpDFdx:             if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDX, result, arg); break;\r
1029                 case EOpDFdy:             if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDY, result, arg); break;\r
1030                 case EOpFwidth:           if(visit == PostVisit) emit(sw::Shader::OPCODE_FWIDTH, result, arg); break;\r
1031                 case EOpAny:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ANY, result, arg); break;\r
1032                 case EOpAll:              if(visit == PostVisit) emit(sw::Shader::OPCODE_ALL, result, arg); break;\r
1033                 case EOpFloatBitsToInt:   if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOATBITSTOINT, result, arg); break;\r
1034                 case EOpFloatBitsToUint:  if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOATBITSTOUINT, result, arg); break;\r
1035                 case EOpIntBitsToFloat:   if(visit == PostVisit) emit(sw::Shader::OPCODE_INTBITSTOFLOAT, result, arg); break;\r
1036                 case EOpUintBitsToFloat:  if(visit == PostVisit) emit(sw::Shader::OPCODE_UINTBITSTOFLOAT, result, arg); break;\r
1037                 case EOpPackSnorm2x16:    if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKSNORM2x16, result, arg); break;\r
1038                 case EOpPackUnorm2x16:    if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKUNORM2x16, result, arg); break;\r
1039                 case EOpPackHalf2x16:     if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKHALF2x16, result, arg); break;\r
1040                 case EOpUnpackSnorm2x16:  if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKSNORM2x16, result, arg); break;\r
1041                 case EOpUnpackUnorm2x16:  if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKUNORM2x16, result, arg); break;\r
1042                 case EOpUnpackHalf2x16:   if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKHALF2x16, result, arg); break;\r
1043                 case EOpTranspose:\r
1044                         if(visit == PostVisit)\r
1045                         {\r
1046                                 int numCols = arg->getNominalSize();\r
1047                                 int numRows = arg->getSecondarySize();\r
1048                                 for(int i = 0; i < numCols; ++i)\r
1049                                 {\r
1050                                         for(int j = 0; j < numRows; ++j)\r
1051                                         {\r
1052                                                 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, j, arg, i);\r
1053                                                 mov->src[0].swizzle = 0x55 * j;\r
1054                                                 mov->dst.mask = 1 << i;\r
1055                                         }\r
1056                                 }\r
1057                         }\r
1058                         break;\r
1059                 case EOpDeterminant:\r
1060                         if(visit == PostVisit)\r
1061                         {\r
1062                                 int size = arg->getNominalSize();\r
1063                                 ASSERT(size == arg->getSecondarySize());\r
1064 \r
1065                                 emitDeterminant(result, arg, size);\r
1066                         }\r
1067                         break;\r
1068                 case EOpInverse:\r
1069                         if(visit == PostVisit)\r
1070                         {\r
1071                                 int size = arg->getNominalSize();\r
1072                                 ASSERT(size == arg->getSecondarySize());\r
1073 \r
1074                                 // Compute transposed matrix of cofactors\r
1075                                 for(int i = 0; i < size; ++i)\r
1076                                 {\r
1077                                         for(int j = 0; j < size; ++j)\r
1078                                         {\r
1079                                                 // For a 2x2 matrix, the cofactor is simply a transposed move or negate\r
1080                                                 // For a 3x3 or 4x4 matrix, the cofactor is a transposed determinant\r
1081                                                 emitDeterminant(result, arg, size - 1, j, i, i, j);\r
1082                                         }\r
1083                                 }\r
1084 \r
1085                                 // Compute 1 / determinant\r
1086                                 Temporary invDet(this);\r
1087                                 emitDeterminant(&invDet, arg, size);\r
1088                                 Constant one(1.0f, 1.0f, 1.0f, 1.0f);\r
1089                                 Instruction *div = emit(sw::Shader::OPCODE_DIV, &invDet, &one, &invDet);\r
1090                                 div->src[1].swizzle = 0x00; // xxxx\r
1091 \r
1092                                 // Divide transposed matrix of cofactors by determinant\r
1093                                 for(int i = 0; i < size; ++i)\r
1094                                 {\r
1095                                         emit(sw::Shader::OPCODE_MUL, result, i, result, i, &invDet);\r
1096                                 }\r
1097                         }\r
1098                         break;\r
1099                 default: UNREACHABLE(node->getOp());\r
1100                 }\r
1101 \r
1102                 return true;\r
1103         }\r
1104 \r
1105         bool OutputASM::visitAggregate(Visit visit, TIntermAggregate *node)\r
1106         {\r
1107                 if(currentScope != emitScope && node->getOp() != EOpFunction && node->getOp() != EOpSequence)\r
1108                 {\r
1109                         return false;\r
1110                 }\r
1111 \r
1112                 Constant zero(0.0f, 0.0f, 0.0f, 0.0f);\r
1113 \r
1114                 TIntermTyped *result = node;\r
1115                 const TType &resultType = node->getType();\r
1116                 TIntermSequence &arg = node->getSequence();\r
1117                 int argumentCount = arg.size();\r
1118 \r
1119                 switch(node->getOp())\r
1120                 {\r
1121                 case EOpSequence:             break;\r
1122                 case EOpDeclaration:          break;\r
1123                 case EOpInvariantDeclaration: break;\r
1124                 case EOpPrototype:            break;\r
1125                 case EOpComma:\r
1126                         if(visit == PostVisit)\r
1127                         {\r
1128                                 copy(result, arg[1]);\r
1129                         }\r
1130                         break;\r
1131                 case EOpFunction:\r
1132                         if(visit == PreVisit)\r
1133                         {\r
1134                                 const TString &name = node->getName();\r
1135 \r
1136                                 if(emitScope == FUNCTION)\r
1137                                 {\r
1138                                         if(functionArray.size() > 1)   // No need for a label when there's only main()\r
1139                                         {\r
1140                                                 Instruction *label = emit(sw::Shader::OPCODE_LABEL);\r
1141                                                 label->dst.type = sw::Shader::PARAMETER_LABEL;\r
1142 \r
1143                                                 const Function *function = findFunction(name);\r
1144                                                 ASSERT(function);   // Should have been added during global pass\r
1145                                                 label->dst.index = function->label;\r
1146                                                 currentFunction = function->label;\r
1147                                         }\r
1148                                 }\r
1149                                 else if(emitScope == GLOBAL)\r
1150                                 {\r
1151                                         if(name != "main(")\r
1152                                         {\r
1153                                                 TIntermSequence &arguments = node->getSequence()[0]->getAsAggregate()->getSequence();\r
1154                                                 functionArray.push_back(Function(functionArray.size(), name, &arguments, node));\r
1155                                         }\r
1156                                 }\r
1157                                 else UNREACHABLE(emitScope);\r
1158 \r
1159                                 currentScope = FUNCTION;\r
1160                         }\r
1161                         else if(visit == PostVisit)\r
1162                         {\r
1163                                 if(emitScope == FUNCTION)\r
1164                                 {\r
1165                                         if(functionArray.size() > 1)   // No need to return when there's only main()\r
1166                                         {\r
1167                                                 emit(sw::Shader::OPCODE_RET);\r
1168                                         }\r
1169                                 }\r
1170 \r
1171                                 currentScope = GLOBAL;\r
1172                         }\r
1173                         break;\r
1174                 case EOpFunctionCall:\r
1175                         if(visit == PostVisit)\r
1176                         {\r
1177                                 if(node->isUserDefined())\r
1178                                 {\r
1179                                         const TString &name = node->getName();\r
1180                                         const Function *function = findFunction(name);\r
1181 \r
1182                                         if(!function)\r
1183                                         {\r
1184                                                 mContext.error(node->getLine(), "function definition not found", name.c_str());\r
1185                                                 return false;\r
1186                                         }\r
1187 \r
1188                                         TIntermSequence &arguments = *function->arg;\r
1189 \r
1190                                         for(int i = 0; i < argumentCount; i++)\r
1191                                         {\r
1192                                                 TIntermTyped *in = arguments[i]->getAsTyped();\r
1193 \r
1194                                                 if(in->getQualifier() == EvqIn ||\r
1195                                                    in->getQualifier() == EvqInOut ||\r
1196                                                    in->getQualifier() == EvqConstReadOnly)\r
1197                                                 {\r
1198                                                         copy(in, arg[i]);\r
1199                                                 }\r
1200                                         }\r
1201 \r
1202                                         Instruction *call = emit(sw::Shader::OPCODE_CALL);\r
1203                                         call->dst.type = sw::Shader::PARAMETER_LABEL;\r
1204                                         call->dst.index = function->label;\r
1205 \r
1206                                         if(function->ret && function->ret->getType().getBasicType() != EbtVoid)\r
1207                                         {\r
1208                                                 copy(result, function->ret);\r
1209                                         }\r
1210 \r
1211                                         for(int i = 0; i < argumentCount; i++)\r
1212                                         {\r
1213                                                 TIntermTyped *argument = arguments[i]->getAsTyped();\r
1214                                                 TIntermTyped *out = arg[i]->getAsTyped();\r
1215 \r
1216                                                 if(argument->getQualifier() == EvqOut ||\r
1217                                                    argument->getQualifier() == EvqInOut)\r
1218                                                 {\r
1219                                                         copy(out, argument);\r
1220                                                 }\r
1221                                         }\r
1222                                 }\r
1223                                 else\r
1224                                 {\r
1225                                         const TextureFunction textureFunction(node->getName());\r
1226                                         switch(textureFunction.method)\r
1227                                         {\r
1228                                         case TextureFunction::IMPLICIT:\r
1229                                                 {\r
1230                                                         TIntermTyped *t = arg[1]->getAsTyped();\r
1231 \r
1232                                                         TIntermNode* offset = textureFunction.offset ? arg[2] : 0;\r
1233 \r
1234                                                         if(argumentCount == 2 || (textureFunction.offset && argumentCount == 3))\r
1235                                                         {\r
1236                                                                 Instruction *tex = emit(textureFunction.offset ? sw::Shader::OPCODE_TEXOFFSET : sw::Shader::OPCODE_TEX,\r
1237                                                                                         result, arg[1], arg[0], offset);\r
1238                                                                 if(textureFunction.proj)\r
1239                                                                 {\r
1240                                                                         tex->project = true;\r
1241 \r
1242                                                                         switch(t->getNominalSize())\r
1243                                                                         {\r
1244                                                                         case 2: tex->src[0].swizzle = 0x54; break; // xyyy\r
1245                                                                         case 3: tex->src[0].swizzle = 0xA4; break; // xyzz\r
1246                                                                         case 4: break; // xyzw\r
1247                                                                         default:\r
1248                                                                                 UNREACHABLE(t->getNominalSize());\r
1249                                                                                 break;\r
1250                                                                         }\r
1251                                                                 }\r
1252                                                         }\r
1253                                                         else if(argumentCount == 3 || (textureFunction.offset && argumentCount == 4))   // bias\r
1254                                                         {\r
1255                                                                 Temporary proj(this);\r
1256                                                                 if(textureFunction.proj)\r
1257                                                                 {\r
1258                                                                         Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);\r
1259                                                                         div->dst.mask = 0x3;\r
1260 \r
1261                                                                         switch(t->getNominalSize())\r
1262                                                                         {\r
1263                                                                         case 2:\r
1264                                                                         case 3:\r
1265                                                                         case 4:\r
1266                                                                                 div->src[1].swizzle = 0x55 * (t->getNominalSize() - 1);\r
1267                                                                                 break;\r
1268                                                                         default:\r
1269                                                                                 UNREACHABLE(t->getNominalSize());\r
1270                                                                                 break;\r
1271                                                                         }\r
1272                                                                 }\r
1273                                                                 else\r
1274                                                                 {\r
1275                                                                         emit(sw::Shader::OPCODE_MOV, &proj, arg[1]);\r
1276                                                                 }\r
1277 \r
1278                                                                 Instruction *bias = emit(sw::Shader::OPCODE_MOV, &proj, arg[textureFunction.offset ? 3 : 2]);\r
1279                                                                 bias->dst.mask = 0x8;\r
1280 \r
1281                                                                 Instruction *tex = emit(textureFunction.offset ? sw::Shader::OPCODE_TEXOFFSET : sw::Shader::OPCODE_TEX,\r
1282                                                                                         result, &proj, arg[0], offset); // FIXME: Implement an efficient TEXLDB instruction\r
1283                                                                 tex->bias = true;\r
1284                                                         }\r
1285                                                         else UNREACHABLE(argumentCount);\r
1286                                                 }\r
1287                                                 break;\r
1288                                         case TextureFunction::LOD:\r
1289                                                 {\r
1290                                                         TIntermTyped *t = arg[1]->getAsTyped();\r
1291                                                         Temporary proj(this);\r
1292 \r
1293                                                         if(textureFunction.proj)\r
1294                                                         {\r
1295                                                                 Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);\r
1296                                                                 div->dst.mask = 0x3;\r
1297 \r
1298                                                                 switch(t->getNominalSize())\r
1299                                                                 {\r
1300                                                                 case 2:\r
1301                                                                 case 3:\r
1302                                                                 case 4:\r
1303                                                                         div->src[1].swizzle = 0x55 * (t->getNominalSize() - 1);\r
1304                                                                         break;\r
1305                                                                 default:\r
1306                                                                         UNREACHABLE(t->getNominalSize());\r
1307                                                                         break;\r
1308                                                                 }\r
1309                                                         }\r
1310                                                         else\r
1311                                                         {\r
1312                                                                 emit(sw::Shader::OPCODE_MOV, &proj, arg[1]);\r
1313                                                         }\r
1314 \r
1315                                                         Instruction *lod = emit(sw::Shader::OPCODE_MOV, &proj, arg[2]);\r
1316                                                         lod->dst.mask = 0x8;\r
1317 \r
1318                                                         emit(textureFunction.offset ? sw::Shader::OPCODE_TEXLDLOFFSET : sw::Shader::OPCODE_TEXLDL,\r
1319                                                              result, &proj, arg[0], textureFunction.offset ? arg[3] : 0);\r
1320                                                 }\r
1321                                                 break;\r
1322                                         case TextureFunction::FETCH:\r
1323                                                 {\r
1324                                                         TIntermTyped *t = arg[1]->getAsTyped();\r
1325 \r
1326                                                         if(argumentCount == 3 || (textureFunction.offset && argumentCount == 4))\r
1327                                                         {\r
1328                                                                 TIntermNode* offset = textureFunction.offset ? arg[3] : 0;\r
1329 \r
1330                                                                 emit(textureFunction.offset ? sw::Shader::OPCODE_TEXELFETCHOFFSET : sw::Shader::OPCODE_TEXELFETCH,\r
1331                                                                      result, arg[1], arg[0], arg[2], offset);\r
1332                                                         }\r
1333                                                         else UNREACHABLE(argumentCount);\r
1334                                                 }\r
1335                                                 break;\r
1336                                         case TextureFunction::GRAD:\r
1337                                                 {\r
1338                                                         TIntermTyped *t = arg[1]->getAsTyped();\r
1339 \r
1340                                                         if(argumentCount == 4 || (textureFunction.offset && argumentCount == 5))\r
1341                                                         {\r
1342                                                                 Temporary uvwb(this);\r
1343 \r
1344                                                                 if(textureFunction.proj)\r
1345                                                                 {\r
1346                                                                         Instruction *div = emit(sw::Shader::OPCODE_DIV, &uvwb, arg[1], arg[1]);\r
1347                                                                         div->dst.mask = 0x3;\r
1348 \r
1349                                                                         switch(t->getNominalSize())\r
1350                                                                         {\r
1351                                                                         case 2:\r
1352                                                                         case 3:\r
1353                                                                         case 4:\r
1354                                                                                 div->src[1].swizzle = 0x55 * (t->getNominalSize() - 1);\r
1355                                                                                 break;\r
1356                                                                         default:\r
1357                                                                                 UNREACHABLE(t->getNominalSize());\r
1358                                                                                 break;\r
1359                                                                         }\r
1360                                                                 }\r
1361                                                                 else\r
1362                                                                 {\r
1363                                                                         emit(sw::Shader::OPCODE_MOV, &uvwb, arg[1]);\r
1364                                                                 }\r
1365 \r
1366                                                                 TIntermNode* offset = textureFunction.offset ? arg[4] : 0;\r
1367 \r
1368                                                                 emit(textureFunction.offset ? sw::Shader::OPCODE_TEXGRADOFFSET : sw::Shader::OPCODE_TEXGRAD,\r
1369                                                                      result, &uvwb, arg[0], arg[2], arg[3], offset);\r
1370                                                         }\r
1371                                                         else UNREACHABLE(argumentCount);\r
1372                                                 }\r
1373                                                 break;\r
1374                                         case TextureFunction::SIZE:\r
1375                                                 emit(sw::Shader::OPCODE_TEXSIZE, result, arg[1], arg[0]);\r
1376                                                 break;\r
1377                                         default:\r
1378                                                 UNREACHABLE(textureFunction.method);\r
1379                                         }\r
1380                                 }\r
1381                         }\r
1382                         break;\r
1383                 case EOpParameters:\r
1384                         break;\r
1385                 case EOpConstructFloat:\r
1386                 case EOpConstructVec2:\r
1387                 case EOpConstructVec3:\r
1388                 case EOpConstructVec4:\r
1389                 case EOpConstructBool:\r
1390                 case EOpConstructBVec2:\r
1391                 case EOpConstructBVec3:\r
1392                 case EOpConstructBVec4:\r
1393                 case EOpConstructInt:\r
1394                 case EOpConstructIVec2:\r
1395                 case EOpConstructIVec3:\r
1396                 case EOpConstructIVec4:\r
1397                 case EOpConstructUInt:\r
1398                 case EOpConstructUVec2:\r
1399                 case EOpConstructUVec3:\r
1400                 case EOpConstructUVec4:\r
1401                         if(visit == PostVisit)\r
1402                         {\r
1403                                 int component = 0;\r
1404 \r
1405                                 for(int i = 0; i < argumentCount; i++)\r
1406                                 {\r
1407                                         TIntermTyped *argi = arg[i]->getAsTyped();\r
1408                                         int size = argi->getNominalSize();\r
1409 \r
1410                                         if(!argi->isMatrix())\r
1411                                         {\r
1412                                                 Instruction *mov = emitCast(result, argi);\r
1413                                                 mov->dst.mask = (0xF << component) & 0xF;\r
1414                                                 mov->src[0].swizzle = readSwizzle(argi, size) << (component * 2);\r
1415 \r
1416                                                 component += size;\r
1417                                         }\r
1418                                         else   // Matrix\r
1419                                         {\r
1420                                                 int column = 0;\r
1421 \r
1422                                                 while(component < resultType.getNominalSize())\r
1423                                                 {\r
1424                                                         Instruction *mov = emitCast(result, 0, argi, column);\r
1425                                                         mov->dst.mask = (0xF << component) & 0xF;\r
1426                                                         mov->src[0].swizzle = readSwizzle(argi, size) << (component * 2);\r
1427 \r
1428                                                         column++;\r
1429                                                         component += size;\r
1430                                                 }\r
1431                                         }\r
1432                                 }\r
1433                         }\r
1434                         break;\r
1435                 case EOpConstructMat2:\r
1436                 case EOpConstructMat2x3:\r
1437                 case EOpConstructMat2x4:\r
1438                 case EOpConstructMat3x2:\r
1439                 case EOpConstructMat3:\r
1440                 case EOpConstructMat3x4:\r
1441                 case EOpConstructMat4x2:\r
1442                 case EOpConstructMat4x3:\r
1443                 case EOpConstructMat4:\r
1444                         if(visit == PostVisit)\r
1445                         {\r
1446                                 TIntermTyped *arg0 = arg[0]->getAsTyped();\r
1447                                 const int outCols = result->getNominalSize();\r
1448                                 const int outRows = result->getSecondarySize();\r
1449 \r
1450                                 if(arg0->isScalar() && arg.size() == 1)   // Construct scale matrix\r
1451                                 {\r
1452                                         for(int i = 0; i < outCols; i++)\r
1453                                         {\r
1454                                                 Instruction *init = emit(sw::Shader::OPCODE_MOV, result, i, &zero);\r
1455                                                 Instruction *mov = emitCast(result, i, arg0, 0);\r
1456                                                 mov->dst.mask = 1 << i;\r
1457                                                 ASSERT(mov->src[0].swizzle == 0x00);\r
1458                                         }\r
1459                                 }\r
1460                                 else if(arg0->isMatrix())\r
1461                                 {\r
1462                                         const int inCols = arg0->getNominalSize();\r
1463                                         const int inRows = arg0->getSecondarySize();\r
1464 \r
1465                                         for(int i = 0; i < outCols; i++)\r
1466                                         {\r
1467                                                 if(i >= inCols || outRows > inRows)\r
1468                                                 {\r
1469                                                         // Initialize to identity matrix\r
1470                                                         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
1471                                                         Instruction *mov = emitCast(result, i, &col, 0);\r
1472                                                 }\r
1473 \r
1474                                                 if(i < inCols)\r
1475                                                 {\r
1476                                                         Instruction *mov = emitCast(result, i, arg0, i);\r
1477                                                         mov->dst.mask = 0xF >> (4 - inRows);\r
1478                                                 }\r
1479                                         }\r
1480                                 }\r
1481                                 else\r
1482                                 {\r
1483                                         int column = 0;\r
1484                                         int row = 0;\r
1485 \r
1486                                         for(int i = 0; i < argumentCount; i++)\r
1487                                         {\r
1488                                                 TIntermTyped *argi = arg[i]->getAsTyped();\r
1489                                                 int size = argi->getNominalSize();\r
1490                                                 int element = 0;\r
1491 \r
1492                                                 while(element < size)\r
1493                                                 {\r
1494                                                         Instruction *mov = emitCast(result, column, argi, 0);\r
1495                                                         mov->dst.mask = (0xF << row) & 0xF;\r
1496                                                         mov->src[0].swizzle = (readSwizzle(argi, size) << (row * 2)) + 0x55 * element;\r
1497 \r
1498                                                         int end = row + size - element;\r
1499                                                         column = end >= outRows ? column + 1 : column;\r
1500                                                         element = element + outRows - row;\r
1501                                                         row = end >= outRows ? 0 : end;\r
1502                                                 }\r
1503                                         }\r
1504                                 }\r
1505                         }\r
1506                         break;\r
1507                 case EOpConstructStruct:\r
1508                         if(visit == PostVisit)\r
1509                         {\r
1510                                 int offset = 0;\r
1511                                 for(int i = 0; i < argumentCount; i++)\r
1512                                 {\r
1513                                         TIntermTyped *argi = arg[i]->getAsTyped();\r
1514                                         int size = argi->totalRegisterCount();\r
1515 \r
1516                                         for(int index = 0; index < size; index++)\r
1517                                         {\r
1518                                                 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, index + offset, argi, index);\r
1519                                                 mov->dst.mask = writeMask(result, offset + index);\r
1520                                         }\r
1521 \r
1522                                         offset += size;\r
1523                                 }\r
1524                         }\r
1525                         break;\r
1526                 case EOpLessThan:         if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, arg[0], arg[1]); break;\r
1527                 case EOpGreaterThan:      if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, arg[0], arg[1]); break;\r
1528                 case EOpLessThanEqual:    if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, arg[0], arg[1]); break;\r
1529                 case EOpGreaterThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, arg[0], arg[1]); break;\r
1530                 case EOpVectorEqual:      if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_EQ, result, arg[0], arg[1]); break;\r
1531                 case EOpVectorNotEqual:   if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_NE, result, arg[0], arg[1]); break;\r
1532                 case EOpMod:              if(visit == PostVisit) emit(sw::Shader::OPCODE_MOD, result, arg[0], arg[1]); break;\r
1533                 case EOpPow:              if(visit == PostVisit) emit(sw::Shader::OPCODE_POW, result, arg[0], arg[1]); break;\r
1534                 case EOpAtan:             if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN2, result, arg[0], arg[1]); break;\r
1535                 case EOpMin:              if(visit == PostVisit) emit(getOpcode(sw::Shader::OPCODE_MIN, result), result, arg[0], arg[1]); break;\r
1536                 case EOpMax:              if(visit == PostVisit) emit(getOpcode(sw::Shader::OPCODE_MAX, result), result, arg[0], arg[1]); break;\r
1537                 case EOpClamp:\r
1538                         if(visit == PostVisit)\r
1539                         {\r
1540                                 emit(getOpcode(sw::Shader::OPCODE_MAX, result), result, arg[0], arg[1]);\r
1541                                 emit(getOpcode(sw::Shader::OPCODE_MIN, result), result, result, arg[2]);\r
1542                         }\r
1543                         break;\r
1544                 case EOpMix:         if(visit == PostVisit) emit(sw::Shader::OPCODE_LRP, result, arg[2], arg[1], arg[0]); break;\r
1545                 case EOpStep:        if(visit == PostVisit) emit(sw::Shader::OPCODE_STEP, result, arg[0], arg[1]); break;\r
1546                 case EOpSmoothStep:  if(visit == PostVisit) emit(sw::Shader::OPCODE_SMOOTH, result, arg[0], arg[1], arg[2]); break;\r
1547                 case EOpDistance:    if(visit == PostVisit) emit(sw::Shader::OPCODE_DIST(dim(arg[0])), result, arg[0], arg[1]); break;\r
1548                 case EOpDot:         if(visit == PostVisit) emit(sw::Shader::OPCODE_DP(dim(arg[0])), result, arg[0], arg[1]); break;\r
1549                 case EOpCross:       if(visit == PostVisit) emit(sw::Shader::OPCODE_CRS, result, arg[0], arg[1]); break;\r
1550                 case EOpFaceForward: if(visit == PostVisit) emit(sw::Shader::OPCODE_FORWARD(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;\r
1551                 case EOpReflect:     if(visit == PostVisit) emit(sw::Shader::OPCODE_REFLECT(dim(arg[0])), result, arg[0], arg[1]); break;\r
1552                 case EOpRefract:     if(visit == PostVisit) emit(sw::Shader::OPCODE_REFRACT(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;\r
1553                 case EOpMul:\r
1554                         if(visit == PostVisit)\r
1555                         {\r
1556                                 TIntermTyped *arg0 = arg[0]->getAsTyped();\r
1557                                 TIntermTyped *arg1 = arg[1]->getAsTyped();\r
1558                                 ASSERT((arg0->getNominalSize() == arg1->getNominalSize()) && (arg0->getSecondarySize() == arg1->getSecondarySize()));\r
1559 \r
1560                                 int size = arg0->getNominalSize();\r
1561                                 for(int i = 0; i < size; i++)\r
1562                                 {\r
1563                                         emit(sw::Shader::OPCODE_MUL, result, i, arg[0], i, arg[1], i);\r
1564                                 }\r
1565                         }\r
1566                         break;\r
1567                 case EOpOuterProduct:\r
1568                         if(visit == PostVisit)\r
1569                         {\r
1570                                 for(int i = 0; i < dim(arg[1]); i++)\r
1571                                 {\r
1572                                         Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, i, arg[0], 0, arg[1]);\r
1573                                         mul->src[1].swizzle = 0x55 * i;\r
1574                                 }\r
1575                         }\r
1576                         break;\r
1577                 default: UNREACHABLE(node->getOp());\r
1578                 }\r
1579 \r
1580                 return true;\r
1581         }\r
1582 \r
1583         bool OutputASM::visitSelection(Visit visit, TIntermSelection *node)\r
1584         {\r
1585                 if(currentScope != emitScope)\r
1586                 {\r
1587                         return false;\r
1588                 }\r
1589 \r
1590                 TIntermTyped *condition = node->getCondition();\r
1591                 TIntermNode *trueBlock = node->getTrueBlock();\r
1592                 TIntermNode *falseBlock = node->getFalseBlock();\r
1593                 TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();\r
1594 \r
1595                 condition->traverse(this);\r
1596 \r
1597                 if(node->usesTernaryOperator())\r
1598                 {\r
1599                         if(constantCondition)\r
1600                         {\r
1601                                 bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();\r
1602 \r
1603                                 if(trueCondition)\r
1604                                 {\r
1605                                         trueBlock->traverse(this);\r
1606                                         copy(node, trueBlock);\r
1607                                 }\r
1608                                 else\r
1609                                 {\r
1610                                         falseBlock->traverse(this);\r
1611                                         copy(node, falseBlock);\r
1612                                 }\r
1613                         }\r
1614                         else if(trivial(node, 6))   // Fast to compute both potential results and no side effects\r
1615                         {\r
1616                                 trueBlock->traverse(this);\r
1617                                 falseBlock->traverse(this);\r
1618                                 emit(sw::Shader::OPCODE_SELECT, node, condition, trueBlock, falseBlock);\r
1619                         }\r
1620                         else\r
1621                         {\r
1622                                 emit(sw::Shader::OPCODE_IF, 0, condition);\r
1623 \r
1624                                 if(trueBlock)\r
1625                                 {\r
1626                                         trueBlock->traverse(this);\r
1627                                         copy(node, trueBlock);\r
1628                                 }\r
1629 \r
1630                                 if(falseBlock)\r
1631                                 {\r
1632                                         emit(sw::Shader::OPCODE_ELSE);\r
1633                                         falseBlock->traverse(this);\r
1634                                         copy(node, falseBlock);\r
1635                                 }\r
1636 \r
1637                                 emit(sw::Shader::OPCODE_ENDIF);\r
1638                         }\r
1639                 }\r
1640                 else  // if/else statement\r
1641                 {\r
1642                         if(constantCondition)\r
1643                         {\r
1644                                 bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();\r
1645 \r
1646                                 if(trueCondition)\r
1647                                 {\r
1648                                         if(trueBlock)\r
1649                                         {\r
1650                                                 trueBlock->traverse(this);\r
1651                                         }\r
1652                                 }\r
1653                                 else\r
1654                                 {\r
1655                                         if(falseBlock)\r
1656                                         {\r
1657                                                 falseBlock->traverse(this);\r
1658                                         }\r
1659                                 }\r
1660                         }\r
1661                         else\r
1662                         {\r
1663                                 emit(sw::Shader::OPCODE_IF, 0, condition);\r
1664 \r
1665                                 if(trueBlock)\r
1666                                 {\r
1667                                         trueBlock->traverse(this);\r
1668                                 }\r
1669 \r
1670                                 if(falseBlock)\r
1671                                 {\r
1672                                         emit(sw::Shader::OPCODE_ELSE);\r
1673                                         falseBlock->traverse(this);\r
1674                                 }\r
1675 \r
1676                                 emit(sw::Shader::OPCODE_ENDIF);\r
1677                         }\r
1678                 }\r
1679 \r
1680                 return false;\r
1681         }\r
1682 \r
1683         bool OutputASM::visitLoop(Visit visit, TIntermLoop *node)\r
1684         {\r
1685                 if(currentScope != emitScope)\r
1686                 {\r
1687                         return false;\r
1688                 }\r
1689 \r
1690                 unsigned int iterations = loopCount(node);\r
1691 \r
1692                 if(iterations == 0)\r
1693                 {\r
1694                         return false;\r
1695                 }\r
1696 \r
1697                 bool unroll = (iterations <= 4);\r
1698 \r
1699                 if(unroll)\r
1700                 {\r
1701                         DetectLoopDiscontinuity detectLoopDiscontinuity;\r
1702                         unroll = !detectLoopDiscontinuity.traverse(node);\r
1703                 }\r
1704 \r
1705                 TIntermNode *init = node->getInit();\r
1706                 TIntermTyped *condition = node->getCondition();\r
1707                 TIntermTyped *expression = node->getExpression();\r
1708                 TIntermNode *body = node->getBody();\r
1709                 Constant True(true);\r
1710 \r
1711                 if(node->getType() == ELoopDoWhile)\r
1712                 {\r
1713                         Temporary iterate(this);\r
1714                         emit(sw::Shader::OPCODE_MOV, &iterate, &True);\r
1715 \r
1716                         emit(sw::Shader::OPCODE_WHILE, 0, &iterate);   // FIXME: Implement real do-while\r
1717 \r
1718                         if(body)\r
1719                         {\r
1720                                 body->traverse(this);\r
1721                         }\r
1722 \r
1723                         emit(sw::Shader::OPCODE_TEST);\r
1724 \r
1725                         condition->traverse(this);\r
1726                         emit(sw::Shader::OPCODE_MOV, &iterate, condition);\r
1727 \r
1728                         emit(sw::Shader::OPCODE_ENDWHILE);\r
1729                 }\r
1730                 else\r
1731                 {\r
1732                         if(init)\r
1733                         {\r
1734                                 init->traverse(this);\r
1735                         }\r
1736 \r
1737                         if(unroll)\r
1738                         {\r
1739                                 for(unsigned int i = 0; i < iterations; i++)\r
1740                                 {\r
1741                                 //      condition->traverse(this);   // Condition could contain statements, but not in an unrollable loop\r
1742 \r
1743                                         if(body)\r
1744                                         {\r
1745                                                 body->traverse(this);\r
1746                                         }\r
1747 \r
1748                                         if(expression)\r
1749                                         {\r
1750                                                 expression->traverse(this);\r
1751                                         }\r
1752                                 }\r
1753                         }\r
1754                         else\r
1755                         {\r
1756                                 if(condition)\r
1757                                 {\r
1758                                         condition->traverse(this);\r
1759                                 }\r
1760                                 else\r
1761                                 {\r
1762                                         condition = &True;\r
1763                                 }\r
1764 \r
1765                                 emit(sw::Shader::OPCODE_WHILE, 0, condition);\r
1766 \r
1767                                 if(body)\r
1768                                 {\r
1769                                         body->traverse(this);\r
1770                                 }\r
1771 \r
1772                                 emit(sw::Shader::OPCODE_TEST);\r
1773 \r
1774                                 if(expression)\r
1775                                 {\r
1776                                         expression->traverse(this);\r
1777                                 }\r
1778 \r
1779                                 if(condition)\r
1780                                 {\r
1781                                         condition->traverse(this);\r
1782                                 }\r
1783 \r
1784                                 emit(sw::Shader::OPCODE_ENDWHILE);\r
1785                         }\r
1786                 }\r
1787 \r
1788                 return false;\r
1789         }\r
1790 \r
1791         bool OutputASM::visitBranch(Visit visit, TIntermBranch *node)\r
1792         {\r
1793                 if(currentScope != emitScope)\r
1794                 {\r
1795                         return false;\r
1796                 }\r
1797 \r
1798                 switch(node->getFlowOp())\r
1799                 {\r
1800                 case EOpKill:      if(visit == PostVisit) emit(sw::Shader::OPCODE_DISCARD);  break;\r
1801                 case EOpBreak:     if(visit == PostVisit) emit(sw::Shader::OPCODE_BREAK);    break;\r
1802                 case EOpContinue:  if(visit == PostVisit) emit(sw::Shader::OPCODE_CONTINUE); break;\r
1803                 case EOpReturn:\r
1804                         if(visit == PostVisit)\r
1805                         {\r
1806                                 TIntermTyped *value = node->getExpression();\r
1807 \r
1808                                 if(value)\r
1809                                 {\r
1810                                         copy(functionArray[currentFunction].ret, value);\r
1811                                 }\r
1812 \r
1813                                 emit(sw::Shader::OPCODE_LEAVE);\r
1814                         }\r
1815                         break;\r
1816                 default: UNREACHABLE(node->getFlowOp());\r
1817                 }\r
1818 \r
1819                 return true;\r
1820         }\r
1821 \r
1822         bool OutputASM::isSamplerRegister(TIntermTyped *operand)\r
1823         {\r
1824                 return operand && isSamplerRegister(operand->getType());\r
1825         }\r
1826 \r
1827         bool OutputASM::isSamplerRegister(const TType &type)\r
1828         {\r
1829                 // A sampler register's qualifiers can be:\r
1830                 // - EvqUniform: The sampler uniform is used as is in the code (default case).\r
1831                 // - EvqTemporary: The sampler is indexed. It's still a sampler register.\r
1832                 // - EvqIn (and other similar types): The sampler has been passed as a function argument. At this point,\r
1833                 //                                    the sampler has been copied and is no longer a sampler register.\r
1834                 return IsSampler(type.getBasicType()) && (type.getQualifier() == EvqUniform || type.getQualifier() == EvqTemporary);\r
1835         }\r
1836 \r
1837         Instruction *OutputASM::emit(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2, TIntermNode *src3, TIntermNode *src4)\r
1838         {\r
1839                 return emit(op, dst, 0, src0, 0, src1, 0, src2, 0, src3, 0, src4, 0);\r
1840         }\r
1841 \r
1842         Instruction *OutputASM::emit(sw::Shader::Opcode op, TIntermTyped *dst, int dstIndex, TIntermNode *src0, int index0, TIntermNode *src1, int index1,\r
1843                                      TIntermNode *src2, int index2, TIntermNode *src3, int index3, TIntermNode *src4, int index4)\r
1844         {\r
1845                 if(isSamplerRegister(dst))\r
1846                 {\r
1847                         op = sw::Shader::OPCODE_NULL;   // Can't assign to a sampler, but this is hit when indexing sampler arrays\r
1848                 }\r
1849 \r
1850                 Instruction *instruction = new Instruction(op);\r
1851 \r
1852                 if(dst)\r
1853                 {\r
1854                         instruction->dst.type = registerType(dst);\r
1855                         instruction->dst.index = registerIndex(dst) + dstIndex;\r
1856                         instruction->dst.mask = writeMask(dst);\r
1857                         instruction->dst.integer = (dst->getBasicType() == EbtInt);\r
1858                 }\r
1859 \r
1860                 argument(instruction->src[0], src0, index0);\r
1861                 argument(instruction->src[1], src1, index1);\r
1862                 argument(instruction->src[2], src2, index2);\r
1863                 argument(instruction->src[3], src3, index3);\r
1864                 argument(instruction->src[4], src4, index4);\r
1865 \r
1866                 shader->append(instruction);\r
1867 \r
1868                 return instruction;\r
1869         }\r
1870 \r
1871         Instruction *OutputASM::emitCast(TIntermTyped *dst, TIntermTyped *src)\r
1872         {\r
1873                 return emitCast(dst, 0, src, 0);\r
1874         }\r
1875 \r
1876         Instruction *OutputASM::emitCast(TIntermTyped *dst, int dstIndex, TIntermTyped *src, int srcIndex)\r
1877         {\r
1878                 switch(src->getBasicType())\r
1879                 {\r
1880                 case EbtBool:\r
1881                         switch(dst->getBasicType())\r
1882                         {\r
1883                         case EbtInt:   return emit(sw::Shader::OPCODE_B2I, dst, dstIndex, src, srcIndex);\r
1884                         case EbtUInt:  return emit(sw::Shader::OPCODE_B2I, dst, dstIndex, src, srcIndex);\r
1885                         case EbtFloat: return emit(sw::Shader::OPCODE_B2F, dst, dstIndex, src, srcIndex);\r
1886                         default:       break;\r
1887                         }\r
1888                         break;\r
1889                 case EbtInt:\r
1890                         switch(dst->getBasicType())\r
1891                         {\r
1892                         case EbtBool:  return emit(sw::Shader::OPCODE_I2B, dst, dstIndex, src, srcIndex);\r
1893                         case EbtFloat: return emit(sw::Shader::OPCODE_I2F, dst, dstIndex, src, srcIndex);\r
1894                         default:       break;\r
1895                         }\r
1896                         break;\r
1897                 case EbtUInt:\r
1898                         switch(dst->getBasicType())\r
1899                         {\r
1900                         case EbtBool:  return emit(sw::Shader::OPCODE_I2B, dst, dstIndex, src, srcIndex);\r
1901                         case EbtFloat: return emit(sw::Shader::OPCODE_U2F, dst, dstIndex, src, srcIndex);\r
1902                         default:       break;\r
1903                         }\r
1904                         break;\r
1905                 case EbtFloat:\r
1906                         switch(dst->getBasicType())\r
1907                         {\r
1908                         case EbtBool: return emit(sw::Shader::OPCODE_F2B, dst, dstIndex, src, srcIndex);\r
1909                         case EbtInt:  return emit(sw::Shader::OPCODE_F2I, dst, dstIndex, src, srcIndex);\r
1910                         case EbtUInt: return emit(sw::Shader::OPCODE_F2U, dst, dstIndex, src, srcIndex);\r
1911                         default:      break;\r
1912                         }\r
1913                         break;\r
1914                 default:\r
1915                         break;\r
1916                 }\r
1917 \r
1918                 ASSERT(src->getBasicType() == dst->getBasicType());\r
1919 \r
1920                 return emit(sw::Shader::OPCODE_MOV, dst, dstIndex, src, srcIndex);\r
1921         }\r
1922 \r
1923         void OutputASM::emitBinary(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2)\r
1924         {\r
1925                 for(int index = 0; index < dst->elementRegisterCount(); index++)\r
1926                 {\r
1927                         emit(op, dst, index, src0, index, src1, index, src2, index);\r
1928                 }\r
1929         }\r
1930 \r
1931         void OutputASM::emitAssign(sw::Shader::Opcode op, TIntermTyped *result, TIntermTyped *lhs, TIntermTyped *src0, TIntermTyped *src1)\r
1932         {\r
1933                 emitBinary(op, result, src0, src1);\r
1934                 assignLvalue(lhs, result);\r
1935         }\r
1936 \r
1937         void OutputASM::emitCmp(sw::Shader::Control cmpOp, TIntermTyped *dst, TIntermNode *left, TIntermNode *right, int index)\r
1938         {\r
1939                 sw::Shader::Opcode opcode;\r
1940                 switch(left->getAsTyped()->getBasicType())\r
1941                 {\r
1942                 case EbtBool:\r
1943                 case EbtInt:\r
1944                         opcode = sw::Shader::OPCODE_ICMP;\r
1945                         break;\r
1946                 case EbtUInt:\r
1947                         opcode = sw::Shader::OPCODE_UCMP;\r
1948                         break;\r
1949                 default:\r
1950                         opcode = sw::Shader::OPCODE_CMP;\r
1951                         break;\r
1952                 }\r
1953 \r
1954                 Instruction *cmp = emit(opcode, dst, 0, left, index, right, index);\r
1955                 cmp->control = cmpOp;\r
1956         }\r
1957 \r
1958         int componentCount(const TType &type, int registers)\r
1959         {\r
1960                 if(registers == 0)\r
1961                 {\r
1962                         return 0;\r
1963                 }\r
1964 \r
1965                 if(type.isArray() && registers >= type.elementRegisterCount())\r
1966                 {\r
1967                         int index = registers / type.elementRegisterCount();\r
1968                         registers -= index * type.elementRegisterCount();\r
1969                         return index * type.getElementSize() + componentCount(type, registers);\r
1970                 }\r
1971 \r
1972                 if(type.isStruct() || type.isInterfaceBlock())\r
1973                 {\r
1974                         const TFieldList& fields = type.getStruct() ? type.getStruct()->fields() : type.getInterfaceBlock()->fields();\r
1975                         int elements = 0;\r
1976 \r
1977                         for(TFieldList::const_iterator field = fields.begin(); field != fields.end(); field++)\r
1978                         {\r
1979                                 const TType &fieldType = *((*field)->type());\r
1980 \r
1981                                 if(fieldType.totalRegisterCount() <= registers)\r
1982                                 {\r
1983                                         registers -= fieldType.totalRegisterCount();\r
1984                                         elements += fieldType.getObjectSize();\r
1985                                 }\r
1986                                 else   // Register within this field\r
1987                                 {\r
1988                                         return elements + componentCount(fieldType, registers);\r
1989                                 }\r
1990                         }\r
1991                 }\r
1992                 else if(type.isMatrix())\r
1993                 {\r
1994                         return registers * type.registerSize();\r
1995                 }\r
1996 \r
1997                 UNREACHABLE(0);\r
1998                 return 0;\r
1999         }\r
2000 \r
2001         int registerSize(const TType &type, int registers)\r
2002         {\r
2003                 if(registers == 0)\r
2004                 {\r
2005                         if(type.isStruct())\r
2006                         {\r
2007                                 return registerSize(*((*(type.getStruct()->fields().begin()))->type()), 0);\r
2008                         }\r
2009                         else if(type.isInterfaceBlock())\r
2010                         {\r
2011                                 return registerSize(*((*(type.getInterfaceBlock()->fields().begin()))->type()), 0);\r
2012                         }\r
2013 \r
2014                         return type.registerSize();\r
2015                 }\r
2016 \r
2017                 if(type.isArray() && registers >= type.elementRegisterCount())\r
2018                 {\r
2019                         int index = registers / type.elementRegisterCount();\r
2020                         registers -= index * type.elementRegisterCount();\r
2021                         return registerSize(type, registers);\r
2022                 }\r
2023 \r
2024                 if(type.isStruct() || type.isInterfaceBlock())\r
2025                 {\r
2026                         const TFieldList& fields = type.getStruct() ? type.getStruct()->fields() : type.getInterfaceBlock()->fields();\r
2027                         int elements = 0;\r
2028 \r
2029                         for(TFieldList::const_iterator field = fields.begin(); field != fields.end(); field++)\r
2030                         {\r
2031                                 const TType &fieldType = *((*field)->type());\r
2032 \r
2033                                 if(fieldType.totalRegisterCount() <= registers)\r
2034                                 {\r
2035                                         registers -= fieldType.totalRegisterCount();\r
2036                                         elements += fieldType.getObjectSize();\r
2037                                 }\r
2038                                 else   // Register within this field\r
2039                                 {\r
2040                                         return registerSize(fieldType, registers);\r
2041                                 }\r
2042                         }\r
2043                 }\r
2044                 else if(type.isMatrix())\r
2045                 {\r
2046                         return registerSize(type, 0);\r
2047                 }\r
2048 \r
2049                 UNREACHABLE(0);\r
2050                 return 0;\r
2051         }\r
2052 \r
2053         int OutputASM::getBlockId(TIntermTyped *arg)\r
2054         {\r
2055                 if(arg)\r
2056                 {\r
2057                         const TType &type = arg->getType();\r
2058                         TInterfaceBlock* block = type.getInterfaceBlock();\r
2059                         if(block && (type.getQualifier() == EvqUniform))\r
2060                         {\r
2061                                 // Make sure the uniform block is declared\r
2062                                 uniformRegister(arg);\r
2063 \r
2064                                 const char* blockName = block->name().c_str();\r
2065 \r
2066                                 // Fetch uniform block index from array of blocks\r
2067                                 for(ActiveUniformBlocks::const_iterator it = shaderObject->activeUniformBlocks.begin(); it != shaderObject->activeUniformBlocks.end(); ++it)\r
2068                                 {\r
2069                                         if(blockName == it->name)\r
2070                                         {\r
2071                                                 return it->blockId;\r
2072                                         }\r
2073                                 }\r
2074 \r
2075                                 ASSERT(false);\r
2076                         }\r
2077                 }\r
2078 \r
2079                 return -1;\r
2080         }\r
2081 \r
2082         OutputASM::ArgumentInfo OutputASM::getArgumentInfo(TIntermTyped *arg, int index)\r
2083         {\r
2084                 const TType &type = arg->getType();\r
2085                 int blockId = getBlockId(arg);\r
2086                 ArgumentInfo argumentInfo(BlockMemberInfo::getDefaultBlockInfo(), type, -1, -1);\r
2087                 if(blockId != -1)\r
2088                 {\r
2089                         argumentInfo.bufferIndex = 0;\r
2090                         for(int i = 0; i < blockId; ++i)\r
2091                         {\r
2092                                 int blockArraySize = shaderObject->activeUniformBlocks[i].arraySize;\r
2093                                 argumentInfo.bufferIndex += blockArraySize > 0 ? blockArraySize : 1;\r
2094                         }\r
2095 \r
2096                         const BlockDefinitionIndexMap& blockDefinition = blockDefinitions[blockId];\r
2097 \r
2098                         BlockDefinitionIndexMap::const_iterator itEnd = blockDefinition.end();\r
2099                         BlockDefinitionIndexMap::const_iterator it = itEnd;\r
2100 \r
2101                         argumentInfo.clampedIndex = index;\r
2102                         if(type.isInterfaceBlock())\r
2103                         {\r
2104                                 // Offset index to the beginning of the selected instance\r
2105                                 size_t blockRegisters = type.elementRegisterCount();\r
2106                                 size_t bufferOffset = argumentInfo.clampedIndex / blockRegisters;\r
2107                                 argumentInfo.bufferIndex += bufferOffset;\r
2108                                 argumentInfo.clampedIndex -= bufferOffset * blockRegisters;\r
2109                         }\r
2110 \r
2111                         int regIndex = registerIndex(arg);\r
2112                         for(int i = regIndex + argumentInfo.clampedIndex; i >= regIndex; --i)\r
2113                         {\r
2114                                 it = blockDefinition.find(i);\r
2115                                 if(it != itEnd)\r
2116                                 {\r
2117                                         argumentInfo.clampedIndex -= (i - regIndex);\r
2118                                         break;\r
2119                                 }\r
2120                         }\r
2121                         ASSERT(it != itEnd);\r
2122 \r
2123                         argumentInfo.typedMemberInfo = it->second;\r
2124 \r
2125                         int registerCount = argumentInfo.typedMemberInfo.type.totalRegisterCount();\r
2126                         argumentInfo.clampedIndex = (argumentInfo.clampedIndex >= registerCount) ? registerCount - 1 : argumentInfo.clampedIndex;\r
2127                 }\r
2128                 else\r
2129                 {\r
2130                         argumentInfo.clampedIndex = (index >= arg->totalRegisterCount()) ? arg->totalRegisterCount() - 1 : index;\r
2131                 }\r
2132 \r
2133                 return argumentInfo;\r
2134         }\r
2135 \r
2136         void OutputASM::argument(sw::Shader::SourceParameter &parameter, TIntermNode *argument, int index)\r
2137         {\r
2138                 if(argument)\r
2139                 {\r
2140                         TIntermTyped *arg = argument->getAsTyped();\r
2141                         const ArgumentInfo argumentInfo = getArgumentInfo(arg, index);\r
2142                         const TType &type = argumentInfo.typedMemberInfo.type;\r
2143 \r
2144                         int size = registerSize(type, argumentInfo.clampedIndex);\r
2145 \r
2146                         parameter.type = registerType(arg);\r
2147                         parameter.bufferIndex = argumentInfo.bufferIndex;\r
2148 \r
2149                         if(arg->getQualifier() == EvqConstExpr)\r
2150                         {\r
2151                                 int component = componentCount(type, argumentInfo.clampedIndex);\r
2152                                 ConstantUnion *constants = arg->getAsConstantUnion()->getUnionArrayPointer();\r
2153 \r
2154                                 for(int i = 0; i < 4; i++)\r
2155                                 {\r
2156                                         if(size == 1)   // Replicate\r
2157                                         {\r
2158                                                 parameter.value[i] = constants[component + 0].getAsFloat();\r
2159                                         }\r
2160                                         else if(i < size)\r
2161                                         {\r
2162                                                 parameter.value[i] = constants[component + i].getAsFloat();\r
2163                                         }\r
2164                                         else\r
2165                                         {\r
2166                                                 parameter.value[i] = 0.0f;\r
2167                                         }\r
2168                                 }\r
2169                         }\r
2170                         else\r
2171                         {\r
2172                                 parameter.index = registerIndex(arg) + argumentInfo.clampedIndex;\r
2173 \r
2174                                 if(isSamplerRegister(arg))\r
2175                                 {\r
2176                                         TIntermBinary *binary = argument->getAsBinaryNode();\r
2177 \r
2178                                         if(binary)\r
2179                                         {\r
2180                                                 TIntermTyped *left = binary->getLeft();\r
2181                                                 TIntermTyped *right = binary->getRight();\r
2182 \r
2183                                                 switch(binary->getOp())\r
2184                                                 {\r
2185                                                 case EOpIndexDirect:\r
2186                                                         parameter.index += right->getAsConstantUnion()->getIConst(0);\r
2187                                                         break;\r
2188                                                 case EOpIndexIndirect:\r
2189                                                         if(left->getArraySize() > 1)\r
2190                                                         {\r
2191                                                                 parameter.rel.type = registerType(binary->getRight());\r
2192                                                                 parameter.rel.index = registerIndex(binary->getRight());\r
2193                                                                 parameter.rel.scale = 1;\r
2194                                                                 parameter.rel.deterministic = true;\r
2195                                                         }\r
2196                                                         break;\r
2197                                                 case EOpIndexDirectStruct:\r
2198                                                 case EOpIndexDirectInterfaceBlock:\r
2199                                                         parameter.index += right->getAsConstantUnion()->getIConst(0);\r
2200                                                         break;\r
2201                                                 default:\r
2202                                                         UNREACHABLE(binary->getOp());\r
2203                                                 }\r
2204                                         }\r
2205                                 }\r
2206                                 else if(parameter.bufferIndex != -1)\r
2207                                 {\r
2208                                         int stride = (argumentInfo.typedMemberInfo.matrixStride > 0) ? argumentInfo.typedMemberInfo.matrixStride : argumentInfo.typedMemberInfo.arrayStride;\r
2209                                         parameter.index = argumentInfo.typedMemberInfo.offset + argumentInfo.clampedIndex * stride;\r
2210                                 }\r
2211                         }\r
2212 \r
2213                         if(!IsSampler(arg->getBasicType()))\r
2214                         {\r
2215                                 parameter.swizzle = readSwizzle(arg, size);\r
2216                         }\r
2217                 }\r
2218         }\r
2219 \r
2220         void OutputASM::copy(TIntermTyped *dst, TIntermNode *src, int offset)\r
2221         {\r
2222                 for(int index = 0; index < dst->totalRegisterCount(); index++)\r
2223                 {\r
2224                         Instruction *mov = emit(sw::Shader::OPCODE_MOV, dst, index, src, offset + index);\r
2225                         mov->dst.mask = writeMask(dst, index);\r
2226                 }\r
2227         }\r
2228 \r
2229         int swizzleElement(int swizzle, int index)\r
2230         {\r
2231                 return (swizzle >> (index * 2)) & 0x03;\r
2232         }\r
2233 \r
2234         int swizzleSwizzle(int leftSwizzle, int rightSwizzle)\r
2235         {\r
2236                 return (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 0)) << 0) |\r
2237                        (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 1)) << 2) |\r
2238                        (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 2)) << 4) |\r
2239                        (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 3)) << 6);\r
2240         }\r
2241 \r
2242         void OutputASM::assignLvalue(TIntermTyped *dst, TIntermTyped *src)\r
2243         {\r
2244                 if(src &&\r
2245                         ((src->isVector() && (!dst->isVector() || (dst->getNominalSize() != dst->getNominalSize()))) ||\r
2246                          (src->isMatrix() && (!dst->isMatrix() || (src->getNominalSize() != dst->getNominalSize()) || (src->getSecondarySize() != dst->getSecondarySize())))))\r
2247                 {\r
2248                         return mContext.error(src->getLine(), "Result type should match the l-value type in compound assignment", src->isVector() ? "vector" : "matrix");\r
2249                 }\r
2250 \r
2251                 TIntermBinary *binary = dst->getAsBinaryNode();\r
2252 \r
2253                 if(binary && binary->getOp() == EOpIndexIndirect && binary->getLeft()->isVector() && dst->isScalar())\r
2254                 {\r
2255                         Instruction *insert = new Instruction(sw::Shader::OPCODE_INSERT);\r
2256 \r
2257                         Temporary address(this);\r
2258                         lvalue(insert->dst, address, dst);\r
2259 \r
2260                         insert->src[0].type = insert->dst.type;\r
2261                         insert->src[0].index = insert->dst.index;\r
2262                         insert->src[0].rel = insert->dst.rel;\r
2263                         argument(insert->src[1], src);\r
2264                         argument(insert->src[2], binary->getRight());\r
2265 \r
2266                         shader->append(insert);\r
2267                 }\r
2268                 else\r
2269                 {\r
2270                         for(int offset = 0; offset < dst->totalRegisterCount(); offset++)\r
2271                         {\r
2272                                 Instruction *mov = new Instruction(sw::Shader::OPCODE_MOV);\r
2273 \r
2274                                 Temporary address(this);\r
2275                                 int swizzle = lvalue(mov->dst, address, dst);\r
2276                                 mov->dst.index += offset;\r
2277 \r
2278                                 if(offset > 0)\r
2279                                 {\r
2280                                         mov->dst.mask = writeMask(dst, offset);\r
2281                                 }\r
2282 \r
2283                                 argument(mov->src[0], src, offset);\r
2284                                 mov->src[0].swizzle = swizzleSwizzle(mov->src[0].swizzle, swizzle);\r
2285 \r
2286                                 shader->append(mov);\r
2287                         }\r
2288                 }\r
2289         }\r
2290 \r
2291         int OutputASM::lvalue(sw::Shader::DestinationParameter &dst, Temporary &address, TIntermTyped *node)\r
2292         {\r
2293                 TIntermTyped *result = node;\r
2294                 TIntermBinary *binary = node->getAsBinaryNode();\r
2295                 TIntermSymbol *symbol = node->getAsSymbolNode();\r
2296 \r
2297                 if(binary)\r
2298                 {\r
2299                         TIntermTyped *left = binary->getLeft();\r
2300                         TIntermTyped *right = binary->getRight();\r
2301 \r
2302                         int leftSwizzle = lvalue(dst, address, left);   // Resolve the l-value of the left side\r
2303 \r
2304                         switch(binary->getOp())\r
2305                         {\r
2306                         case EOpIndexDirect:\r
2307                                 {\r
2308                                         int rightIndex = right->getAsConstantUnion()->getIConst(0);\r
2309 \r
2310                                         if(left->isRegister())\r
2311                                         {\r
2312                                                 int leftMask = dst.mask;\r
2313 \r
2314                                                 dst.mask = 1;\r
2315                                                 while((leftMask & dst.mask) == 0)\r
2316                                                 {\r
2317                                                         dst.mask = dst.mask << 1;\r
2318                                                 }\r
2319 \r
2320                                                 int element = swizzleElement(leftSwizzle, rightIndex);\r
2321                                                 dst.mask = 1 << element;\r
2322 \r
2323                                                 return element;\r
2324                                         }\r
2325                                         else if(left->isArray() || left->isMatrix())\r
2326                                         {\r
2327                                                 dst.index += rightIndex * result->totalRegisterCount();\r
2328                                                 return 0xE4;\r
2329                                         }\r
2330                                         else UNREACHABLE(0);\r
2331                                 }\r
2332                                 break;\r
2333                         case EOpIndexIndirect:\r
2334                                 {\r
2335                                         if(left->isRegister())\r
2336                                         {\r
2337                                                 // Requires INSERT instruction (handled by calling function)\r
2338                                         }\r
2339                                         else if(left->isArray() || left->isMatrix())\r
2340                                         {\r
2341                                                 int scale = result->totalRegisterCount();\r
2342 \r
2343                                                 if(dst.rel.type == sw::Shader::PARAMETER_VOID)   // Use the index register as the relative address directly\r
2344                                                 {\r
2345                                                         if(left->totalRegisterCount() > 1)\r
2346                                                         {\r
2347                                                                 sw::Shader::SourceParameter relativeRegister;\r
2348                                                                 argument(relativeRegister, right);\r
2349 \r
2350                                                                 dst.rel.index = relativeRegister.index;\r
2351                                                                 dst.rel.type = relativeRegister.type;\r
2352                                                                 dst.rel.scale = scale;\r
2353                                                                 dst.rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);\r
2354                                                         }\r
2355                                                 }\r
2356                                                 else if(dst.rel.index != registerIndex(&address))   // Move the previous index register to the address register\r
2357                                                 {\r
2358                                                         if(scale == 1)\r
2359                                                         {\r
2360                                                                 Constant oldScale((int)dst.rel.scale);\r
2361                                                                 Instruction *mad = emit(sw::Shader::OPCODE_IMAD, &address, &address, &oldScale, right);\r
2362                                                                 mad->src[0].index = dst.rel.index;\r
2363                                                                 mad->src[0].type = dst.rel.type;\r
2364                                                         }\r
2365                                                         else\r
2366                                                         {\r
2367                                                                 Constant oldScale((int)dst.rel.scale);\r
2368                                                                 Instruction *mul = emit(sw::Shader::OPCODE_IMUL, &address, &address, &oldScale);\r
2369                                                                 mul->src[0].index = dst.rel.index;\r
2370                                                                 mul->src[0].type = dst.rel.type;\r
2371 \r
2372                                                                 Constant newScale(scale);\r
2373                                                                 emit(sw::Shader::OPCODE_IMAD, &address, right, &newScale, &address);\r
2374                                                         }\r
2375 \r
2376                                                         dst.rel.type = sw::Shader::PARAMETER_TEMP;\r
2377                                                         dst.rel.index = registerIndex(&address);\r
2378                                                         dst.rel.scale = 1;\r
2379                                                 }\r
2380                                                 else   // Just add the new index to the address register\r
2381                                                 {\r
2382                                                         if(scale == 1)\r
2383                                                         {\r
2384                                                                 emit(sw::Shader::OPCODE_IADD, &address, &address, right);\r
2385                                                         }\r
2386                                                         else\r
2387                                                         {\r
2388                                                                 Constant newScale(scale);\r
2389                                                                 emit(sw::Shader::OPCODE_IMAD, &address, right, &newScale, &address);\r
2390                                                         }\r
2391                                                 }\r
2392                                         }\r
2393                                         else UNREACHABLE(0);\r
2394                                 }\r
2395                                 break;\r
2396                         case EOpIndexDirectStruct:\r
2397                         case EOpIndexDirectInterfaceBlock:\r
2398                                 {\r
2399                                         const TFieldList& fields = (binary->getOp() == EOpIndexDirectStruct) ?\r
2400                                                                left->getType().getStruct()->fields() :\r
2401                                                                left->getType().getInterfaceBlock()->fields();\r
2402                                         int index = right->getAsConstantUnion()->getIConst(0);\r
2403                                         int fieldOffset = 0;\r
2404 \r
2405                                         for(int i = 0; i < index; i++)\r
2406                                         {\r
2407                                                 fieldOffset += fields[i]->type()->totalRegisterCount();\r
2408                                         }\r
2409 \r
2410                                         dst.type = registerType(left);\r
2411                                         dst.index += fieldOffset;\r
2412                                         dst.mask = writeMask(right);\r
2413 \r
2414                                         return 0xE4;\r
2415                                 }\r
2416                                 break;\r
2417                         case EOpVectorSwizzle:\r
2418                                 {\r
2419                                         ASSERT(left->isRegister());\r
2420 \r
2421                                         int leftMask = dst.mask;\r
2422 \r
2423                                         int swizzle = 0;\r
2424                                         int rightMask = 0;\r
2425 \r
2426                                         TIntermSequence &sequence = right->getAsAggregate()->getSequence();\r
2427 \r
2428                                         for(unsigned int i = 0; i < sequence.size(); i++)\r
2429                                         {\r
2430                                                 int index = sequence[i]->getAsConstantUnion()->getIConst(0);\r
2431 \r
2432                                                 int element = swizzleElement(leftSwizzle, index);\r
2433                                                 rightMask = rightMask | (1 << element);\r
2434                                                 swizzle = swizzle | swizzleElement(leftSwizzle, i) << (element * 2);\r
2435                                         }\r
2436 \r
2437                                         dst.mask = leftMask & rightMask;\r
2438 \r
2439                                         return swizzle;\r
2440                                 }\r
2441                                 break;\r
2442                         default:\r
2443                                 UNREACHABLE(binary->getOp());   // Not an l-value operator\r
2444                                 break;\r
2445                         }\r
2446                 }\r
2447                 else if(symbol)\r
2448                 {\r
2449                         dst.type = registerType(symbol);\r
2450                         dst.index = registerIndex(symbol);\r
2451                         dst.mask = writeMask(symbol);\r
2452                         return 0xE4;\r
2453                 }\r
2454 \r
2455                 return 0xE4;\r
2456         }\r
2457 \r
2458         sw::Shader::ParameterType OutputASM::registerType(TIntermTyped *operand)\r
2459         {\r
2460                 if(isSamplerRegister(operand))\r
2461                 {\r
2462                         return sw::Shader::PARAMETER_SAMPLER;\r
2463                 }\r
2464 \r
2465                 const TQualifier qualifier = operand->getQualifier();\r
2466                 if((EvqFragColor == qualifier) || (EvqFragData == qualifier))\r
2467                 {\r
2468                         if(((EvqFragData == qualifier) && (EvqFragColor == outputQualifier)) ||\r
2469                            ((EvqFragColor == qualifier) && (EvqFragData == outputQualifier)))\r
2470                         {\r
2471                                 mContext.error(operand->getLine(), "static assignment to both gl_FragData and gl_FragColor", "");\r
2472                         }\r
2473                         outputQualifier = qualifier;\r
2474                 }\r
2475 \r
2476                 switch(qualifier)\r
2477                 {\r
2478                 case EvqTemporary:           return sw::Shader::PARAMETER_TEMP;\r
2479                 case EvqGlobal:              return sw::Shader::PARAMETER_TEMP;\r
2480                 case EvqConstExpr:           return sw::Shader::PARAMETER_FLOAT4LITERAL;   // All converted to float\r
2481                 case EvqAttribute:           return sw::Shader::PARAMETER_INPUT;\r
2482                 case EvqVaryingIn:           return sw::Shader::PARAMETER_INPUT;\r
2483                 case EvqVaryingOut:          return sw::Shader::PARAMETER_OUTPUT;\r
2484                 case EvqVertexIn:            return sw::Shader::PARAMETER_INPUT;\r
2485                 case EvqFragmentOut:         return sw::Shader::PARAMETER_COLOROUT;\r
2486                 case EvqVertexOut:           return sw::Shader::PARAMETER_OUTPUT;\r
2487                 case EvqFragmentIn:          return sw::Shader::PARAMETER_INPUT;\r
2488                 case EvqInvariantVaryingIn:  return sw::Shader::PARAMETER_INPUT;    // FIXME: Guarantee invariance at the backend\r
2489                 case EvqInvariantVaryingOut: return sw::Shader::PARAMETER_OUTPUT;   // FIXME: Guarantee invariance at the backend\r
2490                 case EvqSmooth:              return sw::Shader::PARAMETER_OUTPUT;\r
2491                 case EvqFlat:                return sw::Shader::PARAMETER_OUTPUT;\r
2492                 case EvqCentroidOut:         return sw::Shader::PARAMETER_OUTPUT;\r
2493                 case EvqSmoothIn:            return sw::Shader::PARAMETER_INPUT;\r
2494                 case EvqFlatIn:              return sw::Shader::PARAMETER_INPUT;\r
2495                 case EvqCentroidIn:          return sw::Shader::PARAMETER_INPUT;\r
2496                 case EvqUniform:             return sw::Shader::PARAMETER_CONST;\r
2497                 case EvqIn:                  return sw::Shader::PARAMETER_TEMP;\r
2498                 case EvqOut:                 return sw::Shader::PARAMETER_TEMP;\r
2499                 case EvqInOut:               return sw::Shader::PARAMETER_TEMP;\r
2500                 case EvqConstReadOnly:       return sw::Shader::PARAMETER_TEMP;\r
2501                 case EvqPosition:            return sw::Shader::PARAMETER_OUTPUT;\r
2502                 case EvqPointSize:           return sw::Shader::PARAMETER_OUTPUT;\r
2503                 case EvqInstanceID:          return sw::Shader::PARAMETER_MISCTYPE;\r
2504                 case EvqFragCoord:           return sw::Shader::PARAMETER_MISCTYPE;\r
2505                 case EvqFrontFacing:         return sw::Shader::PARAMETER_MISCTYPE;\r
2506                 case EvqPointCoord:          return sw::Shader::PARAMETER_INPUT;\r
2507                 case EvqFragColor:           return sw::Shader::PARAMETER_COLOROUT;\r
2508                 case EvqFragData:            return sw::Shader::PARAMETER_COLOROUT;\r
2509                 case EvqFragDepth:           return sw::Shader::PARAMETER_DEPTHOUT;\r
2510                 default: UNREACHABLE(qualifier);\r
2511                 }\r
2512 \r
2513                 return sw::Shader::PARAMETER_VOID;\r
2514         }\r
2515 \r
2516         unsigned int OutputASM::registerIndex(TIntermTyped *operand)\r
2517         {\r
2518                 if(isSamplerRegister(operand))\r
2519                 {\r
2520                         return samplerRegister(operand);\r
2521                 }\r
2522 \r
2523                 switch(operand->getQualifier())\r
2524                 {\r
2525                 case EvqTemporary:           return temporaryRegister(operand);\r
2526                 case EvqGlobal:              return temporaryRegister(operand);\r
2527                 case EvqConstExpr:           UNREACHABLE(EvqConstExpr);\r
2528                 case EvqAttribute:           return attributeRegister(operand);\r
2529                 case EvqVaryingIn:           return varyingRegister(operand);\r
2530                 case EvqVaryingOut:          return varyingRegister(operand);\r
2531                 case EvqVertexIn:            return attributeRegister(operand);\r
2532                 case EvqFragmentOut:         return fragmentOutputRegister(operand);\r
2533                 case EvqVertexOut:           return varyingRegister(operand);\r
2534                 case EvqFragmentIn:          return varyingRegister(operand);\r
2535                 case EvqInvariantVaryingIn:  return varyingRegister(operand);\r
2536                 case EvqInvariantVaryingOut: return varyingRegister(operand);\r
2537                 case EvqSmooth:              return varyingRegister(operand);\r
2538                 case EvqFlat:                return varyingRegister(operand);\r
2539                 case EvqCentroidOut:         return varyingRegister(operand);\r
2540                 case EvqSmoothIn:            return varyingRegister(operand);\r
2541                 case EvqFlatIn:              return varyingRegister(operand);\r
2542                 case EvqCentroidIn:          return varyingRegister(operand);\r
2543                 case EvqUniform:             return uniformRegister(operand);\r
2544                 case EvqIn:                  return temporaryRegister(operand);\r
2545                 case EvqOut:                 return temporaryRegister(operand);\r
2546                 case EvqInOut:               return temporaryRegister(operand);\r
2547                 case EvqConstReadOnly:       return temporaryRegister(operand);\r
2548                 case EvqPosition:            return varyingRegister(operand);\r
2549                 case EvqPointSize:           return varyingRegister(operand);\r
2550                 case EvqInstanceID:          vertexShader->instanceIdDeclared = true; return 0;\r
2551                 case EvqFragCoord:           pixelShader->vPosDeclared = true;  return 0;\r
2552                 case EvqFrontFacing:         pixelShader->vFaceDeclared = true; return 1;\r
2553                 case EvqPointCoord:          return varyingRegister(operand);\r
2554                 case EvqFragColor:           return 0;\r
2555                 case EvqFragData:            return 0;\r
2556                 case EvqFragDepth:           return 0;\r
2557                 default: UNREACHABLE(operand->getQualifier());\r
2558                 }\r
2559 \r
2560                 return 0;\r
2561         }\r
2562 \r
2563         int OutputASM::writeMask(TIntermTyped *destination, int index)\r
2564         {\r
2565                 if(destination->getQualifier() == EvqPointSize)\r
2566                 {\r
2567                         return 0x2;   // Point size stored in the y component\r
2568                 }\r
2569 \r
2570                 return 0xF >> (4 - registerSize(destination->getType(), index));\r
2571         }\r
2572 \r
2573         int OutputASM::readSwizzle(TIntermTyped *argument, int size)\r
2574         {\r
2575                 if(argument->getQualifier() == EvqPointSize)\r
2576                 {\r
2577                         return 0x55;   // Point size stored in the y component\r
2578                 }\r
2579 \r
2580                 static const unsigned char swizzleSize[5] = {0x00, 0x00, 0x54, 0xA4, 0xE4};   // (void), xxxx, xyyy, xyzz, xyzw\r
2581 \r
2582                 return swizzleSize[size];\r
2583         }\r
2584 \r
2585         // Conservatively checks whether an expression is fast to compute and has no side effects\r
2586         bool OutputASM::trivial(TIntermTyped *expression, int budget)\r
2587         {\r
2588                 if(!expression->isRegister())\r
2589                 {\r
2590                         return false;\r
2591                 }\r
2592 \r
2593                 return cost(expression, budget) >= 0;\r
2594         }\r
2595 \r
2596         // Returns the remaining computing budget (if < 0 the expression is too expensive or has side effects)\r
2597         int OutputASM::cost(TIntermNode *expression, int budget)\r
2598         {\r
2599                 if(budget < 0)\r
2600                 {\r
2601                         return budget;\r
2602                 }\r
2603 \r
2604                 if(expression->getAsSymbolNode())\r
2605                 {\r
2606                         return budget;\r
2607                 }\r
2608                 else if(expression->getAsConstantUnion())\r
2609                 {\r
2610                         return budget;\r
2611                 }\r
2612                 else if(expression->getAsBinaryNode())\r
2613                 {\r
2614                         TIntermBinary *binary = expression->getAsBinaryNode();\r
2615 \r
2616                         switch(binary->getOp())\r
2617                         {\r
2618                         case EOpVectorSwizzle:\r
2619                         case EOpIndexDirect:\r
2620                         case EOpIndexDirectStruct:\r
2621                         case EOpIndexDirectInterfaceBlock:\r
2622                                 return cost(binary->getLeft(), budget - 0);\r
2623                         case EOpAdd:\r
2624                         case EOpSub:\r
2625                         case EOpMul:\r
2626                                 return cost(binary->getLeft(), cost(binary->getRight(), budget - 1));\r
2627                         default:\r
2628                                 return -1;\r
2629                         }\r
2630                 }\r
2631                 else if(expression->getAsUnaryNode())\r
2632                 {\r
2633                         TIntermUnary *unary = expression->getAsUnaryNode();\r
2634 \r
2635                         switch(unary->getOp())\r
2636                         {\r
2637                         case EOpAbs:\r
2638                         case EOpNegative:\r
2639                                 return cost(unary->getOperand(), budget - 1);\r
2640                         default:\r
2641                                 return -1;\r
2642                         }\r
2643                 }\r
2644                 else if(expression->getAsSelectionNode())\r
2645                 {\r
2646                         TIntermSelection *selection = expression->getAsSelectionNode();\r
2647 \r
2648                         if(selection->usesTernaryOperator())\r
2649                         {\r
2650                                 TIntermTyped *condition = selection->getCondition();\r
2651                                 TIntermNode *trueBlock = selection->getTrueBlock();\r
2652                                 TIntermNode *falseBlock = selection->getFalseBlock();\r
2653                                 TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();\r
2654 \r
2655                                 if(constantCondition)\r
2656                                 {\r
2657                                         bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();\r
2658 \r
2659                                         if(trueCondition)\r
2660                                         {\r
2661                                                 return cost(trueBlock, budget - 0);\r
2662                                         }\r
2663                                         else\r
2664                                         {\r
2665                                                 return cost(falseBlock, budget - 0);\r
2666                                         }\r
2667                                 }\r
2668                                 else\r
2669                                 {\r
2670                                         return cost(trueBlock, cost(falseBlock, budget - 2));\r
2671                                 }\r
2672                         }\r
2673                 }\r
2674 \r
2675                 return -1;\r
2676         }\r
2677 \r
2678         const Function *OutputASM::findFunction(const TString &name)\r
2679         {\r
2680                 for(unsigned int f = 0; f < functionArray.size(); f++)\r
2681                 {\r
2682                         if(functionArray[f].name == name)\r
2683                         {\r
2684                                 return &functionArray[f];\r
2685                         }\r
2686                 }\r
2687 \r
2688                 return 0;\r
2689         }\r
2690 \r
2691         int OutputASM::temporaryRegister(TIntermTyped *temporary)\r
2692         {\r
2693                 return allocate(temporaries, temporary);\r
2694         }\r
2695 \r
2696         int OutputASM::varyingRegister(TIntermTyped *varying)\r
2697         {\r
2698                 int var = lookup(varyings, varying);\r
2699 \r
2700                 if(var == -1)\r
2701                 {\r
2702                         var = allocate(varyings, varying);\r
2703                         int componentCount = varying->registerSize();\r
2704                         int registerCount = varying->totalRegisterCount();\r
2705 \r
2706                         if(pixelShader)\r
2707                         {\r
2708                                 if((var + registerCount) > sw::PixelShader::MAX_INPUT_VARYINGS)\r
2709                                 {\r
2710                                         mContext.error(varying->getLine(), "Varyings packing failed: Too many varyings", "fragment shader");\r
2711                                         return 0;\r
2712                                 }\r
2713 \r
2714                                 if(varying->getQualifier() == EvqPointCoord)\r
2715                                 {\r
2716                                         ASSERT(varying->isRegister());\r
2717                                         if(componentCount >= 1) pixelShader->semantic[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);\r
2718                                         if(componentCount >= 2) pixelShader->semantic[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);\r
2719                                         if(componentCount >= 3) pixelShader->semantic[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);\r
2720                                         if(componentCount >= 4) pixelShader->semantic[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);\r
2721                                 }\r
2722                                 else\r
2723                                 {\r
2724                                         for(int i = 0; i < varying->totalRegisterCount(); i++)\r
2725                                         {\r
2726                                                 if(componentCount >= 1) pixelShader->semantic[var + i][0] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);\r
2727                                                 if(componentCount >= 2) pixelShader->semantic[var + i][1] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);\r
2728                                                 if(componentCount >= 3) pixelShader->semantic[var + i][2] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);\r
2729                                                 if(componentCount >= 4) pixelShader->semantic[var + i][3] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);\r
2730                                         }\r
2731                                 }\r
2732                         }\r
2733                         else if(vertexShader)\r
2734                         {\r
2735                                 if((var + registerCount) > sw::VertexShader::MAX_OUTPUT_VARYINGS)\r
2736                                 {\r
2737                                         mContext.error(varying->getLine(), "Varyings packing failed: Too many varyings", "vertex shader");\r
2738                                         return 0;\r
2739                                 }\r
2740 \r
2741                                 if(varying->getQualifier() == EvqPosition)\r
2742                                 {\r
2743                                         ASSERT(varying->isRegister());\r
2744                                         vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);\r
2745                                         vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);\r
2746                                         vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);\r
2747                                         vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);\r
2748                                         vertexShader->positionRegister = var;\r
2749                                 }\r
2750                                 else if(varying->getQualifier() == EvqPointSize)\r
2751                                 {\r
2752                                         ASSERT(varying->isRegister());\r
2753                                         vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);\r
2754                                         vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);\r
2755                                         vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);\r
2756                                         vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);\r
2757                                         vertexShader->pointSizeRegister = var;\r
2758                                 }\r
2759                                 else\r
2760                                 {\r
2761                                         // Semantic indexes for user varyings will be assigned during program link to match the pixel shader\r
2762                                 }\r
2763                         }\r
2764                         else UNREACHABLE(0);\r
2765 \r
2766                         declareVarying(varying, var);\r
2767                 }\r
2768 \r
2769                 return var;\r
2770         }\r
2771 \r
2772         void OutputASM::declareVarying(TIntermTyped *varying, int reg)\r
2773         {\r
2774                 if(varying->getQualifier() != EvqPointCoord)   // gl_PointCoord does not need linking\r
2775                 {\r
2776                         const TType &type = varying->getType();\r
2777                         const char *name = varying->getAsSymbolNode()->getSymbol().c_str();\r
2778                         VaryingList &activeVaryings = shaderObject->varyings;\r
2779 \r
2780                         // Check if this varying has been declared before without having a register assigned\r
2781                         for(VaryingList::iterator v = activeVaryings.begin(); v != activeVaryings.end(); v++)\r
2782                         {\r
2783                                 if(v->name == name)\r
2784                                 {\r
2785                                         if(reg >= 0)\r
2786                                         {\r
2787                                                 ASSERT(v->reg < 0 || v->reg == reg);\r
2788                                                 v->reg = reg;\r
2789                                         }\r
2790 \r
2791                                         return;\r
2792                                 }\r
2793                         }\r
2794 \r
2795                         activeVaryings.push_back(glsl::Varying(glVariableType(type), name, varying->getArraySize(), reg, 0));\r
2796                 }\r
2797         }\r
2798 \r
2799         int OutputASM::uniformRegister(TIntermTyped *uniform)\r
2800         {\r
2801                 const TType &type = uniform->getType();\r
2802                 ASSERT(!IsSampler(type.getBasicType()));\r
2803                 TInterfaceBlock *block = type.getAsInterfaceBlock();\r
2804                 TIntermSymbol *symbol = uniform->getAsSymbolNode();\r
2805                 ASSERT(symbol || block);\r
2806 \r
2807                 if(symbol || block)\r
2808                 {\r
2809                         int index = lookup(uniforms, uniform);\r
2810 \r
2811                         if(index == -1)\r
2812                         {\r
2813                                 index = allocate(uniforms, uniform);\r
2814                                 const TString &name = symbol ? symbol->getSymbol() : block->name();\r
2815 \r
2816                                 declareUniform(type, name, index);\r
2817                         }\r
2818 \r
2819                         return index;\r
2820                 }\r
2821 \r
2822                 return 0;\r
2823         }\r
2824 \r
2825         int OutputASM::attributeRegister(TIntermTyped *attribute)\r
2826         {\r
2827                 ASSERT(!attribute->isArray());\r
2828 \r
2829                 int index = lookup(attributes, attribute);\r
2830 \r
2831                 if(index == -1)\r
2832                 {\r
2833                         TIntermSymbol *symbol = attribute->getAsSymbolNode();\r
2834                         ASSERT(symbol);\r
2835 \r
2836                         if(symbol)\r
2837                         {\r
2838                                 index = allocate(attributes, attribute);\r
2839                                 const TType &type = attribute->getType();\r
2840                                 int registerCount = attribute->totalRegisterCount();\r
2841 \r
2842                                 if(vertexShader && (index + registerCount) <= sw::VertexShader::MAX_INPUT_ATTRIBUTES)\r
2843                                 {\r
2844                                         for(int i = 0; i < registerCount; i++)\r
2845                                         {\r
2846                                                 vertexShader->input[index + i] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, index + i);\r
2847                                         }\r
2848                                 }\r
2849 \r
2850                                 ActiveAttributes &activeAttributes = shaderObject->activeAttributes;\r
2851 \r
2852                                 const char *name = symbol->getSymbol().c_str();\r
2853                                 activeAttributes.push_back(Attribute(glVariableType(type), name, type.getArraySize(), type.getLayoutQualifier().location, index));\r
2854                         }\r
2855                 }\r
2856 \r
2857                 return index;\r
2858         }\r
2859 \r
2860         int OutputASM::fragmentOutputRegister(TIntermTyped *fragmentOutput)\r
2861         {\r
2862                 return allocate(fragmentOutputs, fragmentOutput);\r
2863         }\r
2864 \r
2865         int OutputASM::samplerRegister(TIntermTyped *sampler)\r
2866         {\r
2867                 ASSERT(IsSampler(sampler->getType().getBasicType()));\r
2868                 TIntermSymbol *symbol = sampler->getAsSymbolNode();\r
2869                 TIntermBinary *binary = sampler->getAsBinaryNode();\r
2870 \r
2871                 if(symbol)\r
2872                 {\r
2873                         return samplerRegister(symbol);\r
2874                 }\r
2875                 else if(binary)\r
2876                 {\r
2877                         ASSERT(binary->getOp() == EOpIndexDirect || binary->getOp() == EOpIndexIndirect ||\r
2878                                    binary->getOp() == EOpIndexDirectStruct || binary->getOp() == EOpIndexDirectInterfaceBlock);\r
2879 \r
2880                         return samplerRegister(binary->getLeft());   // Index added later\r
2881                 }\r
2882                 else UNREACHABLE(0);\r
2883 \r
2884                 return 0;\r
2885         }\r
2886 \r
2887         int OutputASM::samplerRegister(TIntermSymbol *sampler)\r
2888         {\r
2889                 const TType &type = sampler->getType();\r
2890                 ASSERT(IsSampler(type.getBasicType()) || type.getStruct());   // Structures can contain samplers\r
2891 \r
2892                 int index = lookup(samplers, sampler);\r
2893 \r
2894                 if(index == -1)\r
2895                 {\r
2896                         index = allocate(samplers, sampler);\r
2897 \r
2898                         if(sampler->getQualifier() == EvqUniform)\r
2899                         {\r
2900                                 const char *name = sampler->getSymbol().c_str();\r
2901                                 declareUniform(type, name, index);\r
2902                         }\r
2903                 }\r
2904 \r
2905                 return index;\r
2906         }\r
2907 \r
2908         int OutputASM::lookup(VariableArray &list, TIntermTyped *variable)\r
2909         {\r
2910                 for(unsigned int i = 0; i < list.size(); i++)\r
2911                 {\r
2912                         if(list[i] == variable)\r
2913                         {\r
2914                                 return i;   // Pointer match\r
2915                         }\r
2916                 }\r
2917 \r
2918                 TIntermSymbol *varSymbol = variable->getAsSymbolNode();\r
2919                 TInterfaceBlock *varBlock = variable->getType().getAsInterfaceBlock();\r
2920 \r
2921                 if(varBlock)\r
2922                 {\r
2923                         for(unsigned int i = 0; i < list.size(); i++)\r
2924                         {\r
2925                                 if(list[i])\r
2926                                 {\r
2927                                         TInterfaceBlock *listBlock = list[i]->getType().getAsInterfaceBlock();\r
2928 \r
2929                                         if(listBlock)\r
2930                                         {\r
2931                                                 if(listBlock->name() == varBlock->name())\r
2932                                                 {\r
2933                                                         ASSERT(listBlock->arraySize() == varBlock->arraySize());\r
2934                                                         ASSERT(listBlock->fields() == varBlock->fields());\r
2935                                                         ASSERT(listBlock->blockStorage() == varBlock->blockStorage());\r
2936                                                         ASSERT(listBlock->matrixPacking() == varBlock->matrixPacking());\r
2937 \r
2938                                                         return i;\r
2939                                                 }\r
2940                                         }\r
2941                                 }\r
2942                         }\r
2943                 }\r
2944                 else if(varSymbol)\r
2945                 {\r
2946                         for(unsigned int i = 0; i < list.size(); i++)\r
2947                         {\r
2948                                 if(list[i])\r
2949                                 {\r
2950                                         TIntermSymbol *listSymbol = list[i]->getAsSymbolNode();\r
2951 \r
2952                                         if(listSymbol)\r
2953                                         {\r
2954                                                 if(listSymbol->getId() == varSymbol->getId())\r
2955                                                 {\r
2956                                                         ASSERT(listSymbol->getSymbol() == varSymbol->getSymbol());\r
2957                                                         ASSERT(listSymbol->getType() == varSymbol->getType());\r
2958                                                         ASSERT(listSymbol->getQualifier() == varSymbol->getQualifier());\r
2959 \r
2960                                                         return i;\r
2961                                                 }\r
2962                                         }\r
2963                                 }\r
2964                         }\r
2965                 }\r
2966 \r
2967                 return -1;\r
2968         }\r
2969 \r
2970         int OutputASM::allocate(VariableArray &list, TIntermTyped *variable)\r
2971         {\r
2972                 int index = lookup(list, variable);\r
2973 \r
2974                 if(index == -1)\r
2975                 {\r
2976                         unsigned int registerCount = variable->totalRegisterCount();\r
2977 \r
2978                         for(unsigned int i = 0; i < list.size(); i++)\r
2979                         {\r
2980                                 if(list[i] == 0)\r
2981                                 {\r
2982                                         unsigned int j = 1;\r
2983                                         for( ; j < registerCount && (i + j) < list.size(); j++)\r
2984                                         {\r
2985                                                 if(list[i + j] != 0)\r
2986                                                 {\r
2987                                                         break;\r
2988                                                 }\r
2989                                         }\r
2990 \r
2991                                         if(j == registerCount)   // Found free slots\r
2992                                         {\r
2993                                                 for(unsigned int j = 0; j < registerCount; j++)\r
2994                                                 {\r
2995                                                         list[i + j] = variable;\r
2996                                                 }\r
2997 \r
2998                                                 return i;\r
2999                                         }\r
3000                                 }\r
3001                         }\r
3002 \r
3003                         index = list.size();\r
3004 \r
3005                         for(unsigned int i = 0; i < registerCount; i++)\r
3006                         {\r
3007                                 list.push_back(variable);\r
3008                         }\r
3009                 }\r
3010 \r
3011                 return index;\r
3012         }\r
3013 \r
3014         void OutputASM::free(VariableArray &list, TIntermTyped *variable)\r
3015         {\r
3016                 int index = lookup(list, variable);\r
3017 \r
3018                 if(index >= 0)\r
3019                 {\r
3020                         list[index] = 0;\r
3021                 }\r
3022         }\r
3023 \r
3024         int OutputASM::declareUniform(const TType &type, const TString &name, int registerIndex, int blockId, BlockLayoutEncoder* encoder)\r
3025         {\r
3026                 const TStructure *structure = type.getStruct();\r
3027                 const TInterfaceBlock *block = (type.isInterfaceBlock() || (blockId == -1)) ? type.getInterfaceBlock() : nullptr;\r
3028                 ActiveUniforms &activeUniforms = shaderObject->activeUniforms;\r
3029 \r
3030                 if(!structure && !block)\r
3031                 {\r
3032                         const BlockMemberInfo blockInfo = encoder ? encoder->encodeType(type) : BlockMemberInfo::getDefaultBlockInfo();\r
3033                         if(blockId >= 0)\r
3034                         {\r
3035                                 blockDefinitions[blockId][registerIndex] = TypedMemberInfo(blockInfo, type);\r
3036                                 shaderObject->activeUniformBlocks[blockId].fields.push_back(activeUniforms.size());\r
3037                         }\r
3038                         int fieldRegisterIndex = encoder ? shaderObject->activeUniformBlocks[blockId].registerIndex + BlockLayoutEncoder::getBlockRegister(blockInfo) : registerIndex;\r
3039                         activeUniforms.push_back(Uniform(glVariableType(type), glVariablePrecision(type), name.c_str(), type.getArraySize(),\r
3040                                                          fieldRegisterIndex, blockId, blockInfo));\r
3041                         if(isSamplerRegister(type))\r
3042                         {\r
3043                                 for(int i = 0; i < type.totalRegisterCount(); i++)\r
3044                                 {\r
3045                                         shader->declareSampler(fieldRegisterIndex + i);\r
3046                                 }\r
3047                         }\r
3048                 }\r
3049                 else if(block)\r
3050                 {\r
3051                         ActiveUniformBlocks &activeUniformBlocks = shaderObject->activeUniformBlocks;\r
3052                         const TFieldList& fields = block->fields();\r
3053                         const TString &blockName = block->name();\r
3054                         int fieldRegisterIndex = registerIndex;\r
3055                         bool isUniformBlockMember = !type.isInterfaceBlock() && (blockId == -1);\r
3056 \r
3057                         if(isUniformBlockMember)\r
3058                         {\r
3059                                 // This is a uniform that's part of a block, let's see if the block is already defined\r
3060                                 for(size_t i = 0; i < activeUniformBlocks.size(); ++i)\r
3061                                 {\r
3062                                         if(activeUniformBlocks[i].name == blockName.c_str())\r
3063                                         {\r
3064                                                 // The block is already defined, find the register for the current uniform and return it\r
3065                                                 for(size_t j = 0; j < fields.size(); j++)\r
3066                                                 {\r
3067                                                         const TString &fieldName = fields[j]->name();\r
3068                                                         if(fieldName == name)\r
3069                                                         {\r
3070                                                                 return fieldRegisterIndex;\r
3071                                                         }\r
3072 \r
3073                                                         fieldRegisterIndex += fields[j]->type()->totalRegisterCount();\r
3074                                                 }\r
3075 \r
3076                                                 ASSERT(false);\r
3077                                                 return fieldRegisterIndex;\r
3078                                         }\r
3079                                 }\r
3080                         }\r
3081 \r
3082                         blockId = activeUniformBlocks.size();\r
3083                         bool isRowMajor = block->matrixPacking() == EmpRowMajor;\r
3084                         activeUniformBlocks.push_back(UniformBlock(blockName.c_str(), 0, block->arraySize(),\r
3085                                                                    block->blockStorage(), isRowMajor, registerIndex, blockId));\r
3086                         blockDefinitions.push_back(BlockDefinitionIndexMap());\r
3087 \r
3088                         Std140BlockEncoder currentBlockEncoder(isRowMajor);\r
3089                         currentBlockEncoder.enterAggregateType();\r
3090                         for(size_t i = 0; i < fields.size(); i++)\r
3091                         {\r
3092                                 const TType &fieldType = *(fields[i]->type());\r
3093                                 const TString &fieldName = fields[i]->name();\r
3094                                 if(isUniformBlockMember && (fieldName == name))\r
3095                                 {\r
3096                                         registerIndex = fieldRegisterIndex;\r
3097                                 }\r
3098 \r
3099                                 const TString uniformName = block->hasInstanceName() ? blockName + "." + fieldName : fieldName;\r
3100 \r
3101                                 declareUniform(fieldType, uniformName, fieldRegisterIndex, blockId, &currentBlockEncoder);\r
3102                                 fieldRegisterIndex += fieldType.totalRegisterCount();\r
3103                         }\r
3104                         currentBlockEncoder.exitAggregateType();\r
3105                         activeUniformBlocks[blockId].dataSize = currentBlockEncoder.getBlockSize();\r
3106                 }\r
3107                 else\r
3108                 {\r
3109                         int fieldRegisterIndex = registerIndex;\r
3110 \r
3111                         const TFieldList& fields = structure->fields();\r
3112                         if(type.isArray() && (structure || type.isInterfaceBlock()))\r
3113                         {\r
3114                                 for(int i = 0; i < type.getArraySize(); i++)\r
3115                                 {\r
3116                                         if(encoder)\r
3117                                         {\r
3118                                                 encoder->enterAggregateType();\r
3119                                         }\r
3120                                         for(size_t j = 0; j < fields.size(); j++)\r
3121                                         {\r
3122                                                 const TType &fieldType = *(fields[j]->type());\r
3123                                                 const TString &fieldName = fields[j]->name();\r
3124                                                 const TString uniformName = name + "[" + str(i) + "]." + fieldName;\r
3125 \r
3126                                                 declareUniform(fieldType, uniformName, fieldRegisterIndex, blockId, encoder);\r
3127                                                 fieldRegisterIndex += fieldType.totalRegisterCount();\r
3128                                         }\r
3129                                         if(encoder)\r
3130                                         {\r
3131                                                 encoder->exitAggregateType();\r
3132                                         }\r
3133                                 }\r
3134                         }\r
3135                         else\r
3136                         {\r
3137                                 if(encoder)\r
3138                                 {\r
3139                                         encoder->enterAggregateType();\r
3140                                 }\r
3141                                 for(size_t i = 0; i < fields.size(); i++)\r
3142                                 {\r
3143                                         const TType &fieldType = *(fields[i]->type());\r
3144                                         const TString &fieldName = fields[i]->name();\r
3145                                         const TString uniformName = name + "." + fieldName;\r
3146 \r
3147                                         declareUniform(fieldType, uniformName, fieldRegisterIndex, blockId, encoder);\r
3148                                         fieldRegisterIndex += fieldType.totalRegisterCount();\r
3149                                 }\r
3150                                 if(encoder)\r
3151                                 {\r
3152                                         encoder->exitAggregateType();\r
3153                                 }\r
3154                         }\r
3155                 }\r
3156 \r
3157                 return registerIndex;\r
3158         }\r
3159 \r
3160         GLenum OutputASM::glVariableType(const TType &type)\r
3161         {\r
3162                 switch(type.getBasicType())\r
3163                 {\r
3164                 case EbtFloat:\r
3165                         if(type.isScalar())\r
3166                         {\r
3167                                 return GL_FLOAT;\r
3168                         }\r
3169                         else if(type.isVector())\r
3170                         {\r
3171                                 switch(type.getNominalSize())\r
3172                                 {\r
3173                                 case 2: return GL_FLOAT_VEC2;\r
3174                                 case 3: return GL_FLOAT_VEC3;\r
3175                                 case 4: return GL_FLOAT_VEC4;\r
3176                                 default: UNREACHABLE(type.getNominalSize());\r
3177                                 }\r
3178                         }\r
3179                         else if(type.isMatrix())\r
3180                         {\r
3181                                 switch(type.getNominalSize())\r
3182                                 {\r
3183                                 case 2:\r
3184                                         switch(type.getSecondarySize())\r
3185                                         {\r
3186                                         case 2: return GL_FLOAT_MAT2;\r
3187                                         case 3: return GL_FLOAT_MAT2x3;\r
3188                                         case 4: return GL_FLOAT_MAT2x4;\r
3189                                         default: UNREACHABLE(type.getSecondarySize());\r
3190                                         }\r
3191                                 case 3:\r
3192                                         switch(type.getSecondarySize())\r
3193                                         {\r
3194                                         case 2: return GL_FLOAT_MAT3x2;\r
3195                                         case 3: return GL_FLOAT_MAT3;\r
3196                                         case 4: return GL_FLOAT_MAT3x4;\r
3197                                         default: UNREACHABLE(type.getSecondarySize());\r
3198                                         }\r
3199                                 case 4:\r
3200                                         switch(type.getSecondarySize())\r
3201                                         {\r
3202                                         case 2: return GL_FLOAT_MAT4x2;\r
3203                                         case 3: return GL_FLOAT_MAT4x3;\r
3204                                         case 4: return GL_FLOAT_MAT4;\r
3205                                         default: UNREACHABLE(type.getSecondarySize());\r
3206                                         }\r
3207                                 default: UNREACHABLE(type.getNominalSize());\r
3208                                 }\r
3209                         }\r
3210                         else UNREACHABLE(0);\r
3211                         break;\r
3212                 case EbtInt:\r
3213                         if(type.isScalar())\r
3214                         {\r
3215                                 return GL_INT;\r
3216                         }\r
3217                         else if(type.isVector())\r
3218                         {\r
3219                                 switch(type.getNominalSize())\r
3220                                 {\r
3221                                 case 2: return GL_INT_VEC2;\r
3222                                 case 3: return GL_INT_VEC3;\r
3223                                 case 4: return GL_INT_VEC4;\r
3224                                 default: UNREACHABLE(type.getNominalSize());\r
3225                                 }\r
3226                         }\r
3227                         else UNREACHABLE(0);\r
3228                         break;\r
3229                 case EbtUInt:\r
3230                         if(type.isScalar())\r
3231                         {\r
3232                                 return GL_UNSIGNED_INT;\r
3233                         }\r
3234                         else if(type.isVector())\r
3235                         {\r
3236                                 switch(type.getNominalSize())\r
3237                                 {\r
3238                                 case 2: return GL_UNSIGNED_INT_VEC2;\r
3239                                 case 3: return GL_UNSIGNED_INT_VEC3;\r
3240                                 case 4: return GL_UNSIGNED_INT_VEC4;\r
3241                                 default: UNREACHABLE(type.getNominalSize());\r
3242                                 }\r
3243                         }\r
3244                         else UNREACHABLE(0);\r
3245                         break;\r
3246                 case EbtBool:\r
3247                         if(type.isScalar())\r
3248                         {\r
3249                                 return GL_BOOL;\r
3250                         }\r
3251                         else if(type.isVector())\r
3252                         {\r
3253                                 switch(type.getNominalSize())\r
3254                                 {\r
3255                                 case 2: return GL_BOOL_VEC2;\r
3256                                 case 3: return GL_BOOL_VEC3;\r
3257                                 case 4: return GL_BOOL_VEC4;\r
3258                                 default: UNREACHABLE(type.getNominalSize());\r
3259                                 }\r
3260                         }\r
3261                         else UNREACHABLE(0);\r
3262                         break;\r
3263                 case EbtSampler2D:\r
3264                         return GL_SAMPLER_2D;\r
3265                 case EbtISampler2D:\r
3266                         return GL_INT_SAMPLER_2D;\r
3267                 case EbtUSampler2D:\r
3268                         return GL_UNSIGNED_INT_SAMPLER_2D;\r
3269                 case EbtSamplerCube:\r
3270                         return GL_SAMPLER_CUBE;\r
3271                 case EbtISamplerCube:\r
3272                         return GL_INT_SAMPLER_CUBE;\r
3273                 case EbtUSamplerCube:\r
3274                         return GL_UNSIGNED_INT_SAMPLER_CUBE;\r
3275                 case EbtSamplerExternalOES:\r
3276                         return GL_SAMPLER_EXTERNAL_OES;\r
3277                 case EbtSampler3D:\r
3278                         return GL_SAMPLER_3D_OES;\r
3279                 case EbtISampler3D:\r
3280                         return GL_INT_SAMPLER_3D;\r
3281                 case EbtUSampler3D:\r
3282                         return GL_UNSIGNED_INT_SAMPLER_3D;\r
3283                 case EbtSampler2DArray:\r
3284                         return GL_SAMPLER_2D_ARRAY;\r
3285                 case EbtISampler2DArray:\r
3286                         return GL_INT_SAMPLER_2D_ARRAY;\r
3287                 case EbtUSampler2DArray:\r
3288                         return GL_UNSIGNED_INT_SAMPLER_2D_ARRAY;\r
3289                 case EbtSampler2DShadow:\r
3290                         return GL_SAMPLER_2D_SHADOW;\r
3291                 case EbtSamplerCubeShadow:\r
3292                         return GL_SAMPLER_CUBE_SHADOW;\r
3293                 case EbtSampler2DArrayShadow:\r
3294                         return GL_SAMPLER_2D_ARRAY_SHADOW;\r
3295                 default:\r
3296                         UNREACHABLE(type.getBasicType());\r
3297                         break;\r
3298                 }\r
3299 \r
3300                 return GL_NONE;\r
3301         }\r
3302 \r
3303         GLenum OutputASM::glVariablePrecision(const TType &type)\r
3304         {\r
3305                 if(type.getBasicType() == EbtFloat)\r
3306                 {\r
3307                         switch(type.getPrecision())\r
3308                         {\r
3309                         case EbpHigh:   return GL_HIGH_FLOAT;\r
3310                         case EbpMedium: return GL_MEDIUM_FLOAT;\r
3311                         case EbpLow:    return GL_LOW_FLOAT;\r
3312                         case EbpUndefined:\r
3313                                 // Should be defined as the default precision by the parser\r
3314                         default: UNREACHABLE(type.getPrecision());\r
3315                         }\r
3316                 }\r
3317                 else if(type.getBasicType() == EbtInt)\r
3318                 {\r
3319                         switch(type.getPrecision())\r
3320                         {\r
3321                         case EbpHigh:   return GL_HIGH_INT;\r
3322                         case EbpMedium: return GL_MEDIUM_INT;\r
3323                         case EbpLow:    return GL_LOW_INT;\r
3324                         case EbpUndefined:\r
3325                                 // Should be defined as the default precision by the parser\r
3326                         default: UNREACHABLE(type.getPrecision());\r
3327                         }\r
3328                 }\r
3329 \r
3330                 // Other types (boolean, sampler) don't have a precision\r
3331                 return GL_NONE;\r
3332         }\r
3333 \r
3334         int OutputASM::dim(TIntermNode *v)\r
3335         {\r
3336                 TIntermTyped *vector = v->getAsTyped();\r
3337                 ASSERT(vector && vector->isRegister());\r
3338                 return vector->getNominalSize();\r
3339         }\r
3340 \r
3341         int OutputASM::dim2(TIntermNode *m)\r
3342         {\r
3343                 TIntermTyped *matrix = m->getAsTyped();\r
3344                 ASSERT(matrix && matrix->isMatrix() && !matrix->isArray());\r
3345                 return matrix->getSecondarySize();\r
3346         }\r
3347 \r
3348         // Returns ~0u if no loop count could be determined\r
3349         unsigned int OutputASM::loopCount(TIntermLoop *node)\r
3350         {\r
3351                 // Parse loops of the form:\r
3352                 // for(int index = initial; index [comparator] limit; index += increment)\r
3353                 TIntermSymbol *index = 0;\r
3354                 TOperator comparator = EOpNull;\r
3355                 int initial = 0;\r
3356                 int limit = 0;\r
3357                 int increment = 0;\r
3358 \r
3359                 // Parse index name and intial value\r
3360                 if(node->getInit())\r
3361                 {\r
3362                         TIntermAggregate *init = node->getInit()->getAsAggregate();\r
3363 \r
3364                         if(init)\r
3365                         {\r
3366                                 TIntermSequence &sequence = init->getSequence();\r
3367                                 TIntermTyped *variable = sequence[0]->getAsTyped();\r
3368 \r
3369                                 if(variable && variable->getQualifier() == EvqTemporary)\r
3370                                 {\r
3371                                         TIntermBinary *assign = variable->getAsBinaryNode();\r
3372 \r
3373                                         if(assign->getOp() == EOpInitialize)\r
3374                                         {\r
3375                                                 TIntermSymbol *symbol = assign->getLeft()->getAsSymbolNode();\r
3376                                                 TIntermConstantUnion *constant = assign->getRight()->getAsConstantUnion();\r
3377 \r
3378                                                 if(symbol && constant)\r
3379                                                 {\r
3380                                                         if(constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)\r
3381                                                         {\r
3382                                                                 index = symbol;\r
3383                                                                 initial = constant->getUnionArrayPointer()[0].getIConst();\r
3384                                                         }\r
3385                                                 }\r
3386                                         }\r
3387                                 }\r
3388                         }\r
3389                 }\r
3390 \r
3391                 // Parse comparator and limit value\r
3392                 if(index && node->getCondition())\r
3393                 {\r
3394                         TIntermBinary *test = node->getCondition()->getAsBinaryNode();\r
3395 \r
3396                         if(test && test->getLeft()->getAsSymbolNode()->getId() == index->getId())\r
3397                         {\r
3398                                 TIntermConstantUnion *constant = test->getRight()->getAsConstantUnion();\r
3399 \r
3400                                 if(constant)\r
3401                                 {\r
3402                                         if(constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)\r
3403                                         {\r
3404                                                 comparator = test->getOp();\r
3405                                                 limit = constant->getUnionArrayPointer()[0].getIConst();\r
3406                                         }\r
3407                                 }\r
3408                         }\r
3409                 }\r
3410 \r
3411                 // Parse increment\r
3412                 if(index && comparator != EOpNull && node->getExpression())\r
3413                 {\r
3414                         TIntermBinary *binaryTerminal = node->getExpression()->getAsBinaryNode();\r
3415                         TIntermUnary *unaryTerminal = node->getExpression()->getAsUnaryNode();\r
3416 \r
3417                         if(binaryTerminal)\r
3418                         {\r
3419                                 TOperator op = binaryTerminal->getOp();\r
3420                                 TIntermConstantUnion *constant = binaryTerminal->getRight()->getAsConstantUnion();\r
3421 \r
3422                                 if(constant)\r
3423                                 {\r
3424                                         if(constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)\r
3425                                         {\r
3426                                                 int value = constant->getUnionArrayPointer()[0].getIConst();\r
3427 \r
3428                                                 switch(op)\r
3429                                                 {\r
3430                                                 case EOpAddAssign: increment = value;  break;\r
3431                                                 case EOpSubAssign: increment = -value; break;\r
3432                                                 default: UNIMPLEMENTED();\r
3433                                                 }\r
3434                                         }\r
3435                                 }\r
3436                         }\r
3437                         else if(unaryTerminal)\r
3438                         {\r
3439                                 TOperator op = unaryTerminal->getOp();\r
3440 \r
3441                                 switch(op)\r
3442                                 {\r
3443                                 case EOpPostIncrement: increment = 1;  break;\r
3444                                 case EOpPostDecrement: increment = -1; break;\r
3445                                 case EOpPreIncrement:  increment = 1;  break;\r
3446                                 case EOpPreDecrement:  increment = -1; break;\r
3447                                 default: UNIMPLEMENTED();\r
3448                                 }\r
3449                         }\r
3450                 }\r
3451 \r
3452                 if(index && comparator != EOpNull && increment != 0)\r
3453                 {\r
3454                         if(comparator == EOpLessThanEqual)\r
3455                         {\r
3456                                 comparator = EOpLessThan;\r
3457                                 limit += 1;\r
3458                         }\r
3459 \r
3460                         if(comparator == EOpLessThan)\r
3461                         {\r
3462                                 int iterations = (limit - initial) / increment;\r
3463 \r
3464                                 if(iterations <= 0)\r
3465                                 {\r
3466                                         iterations = 0;\r
3467                                 }\r
3468 \r
3469                                 return iterations;\r
3470                         }\r
3471                         else UNIMPLEMENTED();   // Falls through\r
3472                 }\r
3473 \r
3474                 return ~0u;\r
3475         }\r
3476 \r
3477         bool DetectLoopDiscontinuity::traverse(TIntermNode *node)\r
3478         {\r
3479                 loopDepth = 0;\r
3480                 loopDiscontinuity = false;\r
3481 \r
3482                 node->traverse(this);\r
3483 \r
3484                 return loopDiscontinuity;\r
3485         }\r
3486 \r
3487         bool DetectLoopDiscontinuity::visitLoop(Visit visit, TIntermLoop *loop)\r
3488         {\r
3489                 if(visit == PreVisit)\r
3490                 {\r
3491                         loopDepth++;\r
3492                 }\r
3493                 else if(visit == PostVisit)\r
3494                 {\r
3495                         loopDepth++;\r
3496                 }\r
3497 \r
3498                 return true;\r
3499         }\r
3500 \r
3501         bool DetectLoopDiscontinuity::visitBranch(Visit visit, TIntermBranch *node)\r
3502         {\r
3503                 if(loopDiscontinuity)\r
3504                 {\r
3505                         return false;\r
3506                 }\r
3507 \r
3508                 if(!loopDepth)\r
3509                 {\r
3510                         return true;\r
3511                 }\r
3512 \r
3513                 switch(node->getFlowOp())\r
3514                 {\r
3515                 case EOpKill:\r
3516                         break;\r
3517                 case EOpBreak:\r
3518                 case EOpContinue:\r
3519                 case EOpReturn:\r
3520                         loopDiscontinuity = true;\r
3521                         break;\r
3522                 default: UNREACHABLE(node->getFlowOp());\r
3523                 }\r
3524 \r
3525                 return !loopDiscontinuity;\r
3526         }\r
3527 \r
3528         bool DetectLoopDiscontinuity::visitAggregate(Visit visit, TIntermAggregate *node)\r
3529         {\r
3530                 return !loopDiscontinuity;\r
3531         }\r
3532 }\r