src/OpenGL/compiler/OutputASM.cpp

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