src/OpenGL/compiler/OutputASM.cpp

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