1 // SwiftShader Software Renderer
\r
3 // Copyright(c) 2005-2013 TransGaming Inc.
\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
12 #include "OutputASM.h"
\r
14 #include "common/debug.h"
\r
15 #include "InfoSink.h"
\r
17 #include "libGLESv2/Shader.h"
\r
19 #include <GLES2/gl2.h>
\r
20 #include <GLES2/gl2ext.h>
\r
21 #include <GLES3/gl3.h>
\r
25 // Integer to TString conversion
\r
29 sprintf(buffer, "%d", i);
\r
33 class Temporary : public TIntermSymbol
\r
36 Temporary(OutputASM *assembler) : TIntermSymbol(TSymbolTableLevel::nextUniqueId(), "tmp", TType(EbtFloat, EbpHigh, EvqTemporary, 4, 1, false)), assembler(assembler)
\r
42 assembler->freeTemporary(this);
\r
46 OutputASM *const assembler;
\r
49 class Constant : public TIntermConstantUnion
\r
52 Constant(float x, float y, float z, float w) : TIntermConstantUnion(constants, TType(EbtFloat, EbpHigh, EvqConstExpr, 4, 1, false))
\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
60 Constant(bool b) : TIntermConstantUnion(constants, TType(EbtBool, EbpHigh, EvqConstExpr, 1, 1, false))
\r
62 constants[0].setBConst(b);
\r
65 Constant(int i) : TIntermConstantUnion(constants, TType(EbtInt, EbpHigh, EvqConstExpr, 1, 1, false))
\r
67 constants[0].setIConst(i);
\r
75 ConstantUnion constants[4];
\r
78 Uniform::Uniform(GLenum type, GLenum precision, const std::string &name, int arraySize, int registerIndex, int offset, int blockId) :
\r
79 type(type), precision(precision), name(name), arraySize(arraySize), registerIndex(registerIndex), offset(offset), blockId(blockId)
\r
83 UniformBlock::UniformBlock(const std::string& name, const std::string& instanceName, unsigned int dataSize, unsigned int arraySize,
\r
84 TLayoutBlockStorage layout, bool isRowMajorLayout, int registerIndex, int blockId) :
\r
85 name(name), instanceName(instanceName), dataSize(dataSize), arraySize(arraySize), layout(layout),
\r
86 isRowMajorLayout(isRowMajorLayout), registerIndex(registerIndex), blockId(blockId)
\r
90 Attribute::Attribute()
\r
97 Attribute::Attribute(GLenum type, const std::string &name, int arraySize, int location, int registerIndex)
\r
101 this->arraySize = arraySize;
\r
102 this->location = location;
\r
103 this->registerIndex = registerIndex;
\r
106 sw::PixelShader *Shader::getPixelShader() const
\r
111 sw::VertexShader *Shader::getVertexShader() const
\r
116 OutputASM::OutputASM(TParseContext &context, Shader *shaderObject) : TIntermTraverser(true, true, true), mContext(context), shaderObject(shaderObject)
\r
124 shader = shaderObject->getShader();
\r
125 pixelShader = shaderObject->getPixelShader();
\r
126 vertexShader = shaderObject->getVertexShader();
\r
129 functionArray.push_back(Function(0, "main(", 0, 0));
\r
130 currentFunction = 0;
\r
131 outputQualifier = EvqOutput; // Set outputQualifier to any value other than EvqFragColor or EvqFragData
\r
134 OutputASM::~OutputASM()
\r
138 void OutputASM::output()
\r
142 emitShader(GLOBAL);
\r
144 if(functionArray.size() > 1) // Only call main() when there are other functions
\r
146 Instruction *callMain = emit(sw::Shader::OPCODE_CALL);
\r
147 callMain->dst.type = sw::Shader::PARAMETER_LABEL;
\r
148 callMain->dst.index = 0; // main()
\r
150 emit(sw::Shader::OPCODE_RET);
\r
153 emitShader(FUNCTION);
\r
157 void OutputASM::emitShader(Scope scope)
\r
160 currentScope = GLOBAL;
\r
161 mContext.getTreeRoot()->traverse(this);
\r
164 void OutputASM::freeTemporary(Temporary *temporary)
\r
166 free(temporaries, temporary);
\r
169 sw::Shader::Opcode OutputASM::getOpcode(sw::Shader::Opcode op, TIntermTyped *in) const
\r
171 TBasicType baseType = in->getType().getBasicType();
\r
175 case sw::Shader::OPCODE_NEG:
\r
180 return sw::Shader::OPCODE_INEG;
\r
185 case sw::Shader::OPCODE_ADD:
\r
190 return sw::Shader::OPCODE_IADD;
\r
195 case sw::Shader::OPCODE_SUB:
\r
200 return sw::Shader::OPCODE_ISUB;
\r
205 case sw::Shader::OPCODE_MUL:
\r
210 return sw::Shader::OPCODE_IMUL;
\r
215 case sw::Shader::OPCODE_DIV:
\r
219 return sw::Shader::OPCODE_IDIV;
\r
221 return sw::Shader::OPCODE_UDIV;
\r
226 case sw::Shader::OPCODE_IMOD:
\r
227 return baseType == EbtUInt ? sw::Shader::OPCODE_UMOD : op;
\r
228 case sw::Shader::OPCODE_ISHR:
\r
229 return baseType == EbtUInt ? sw::Shader::OPCODE_USHR : op;
\r
230 case sw::Shader::OPCODE_MIN:
\r
234 return sw::Shader::OPCODE_IMIN;
\r
236 return sw::Shader::OPCODE_UMIN;
\r
241 case sw::Shader::OPCODE_MAX:
\r
245 return sw::Shader::OPCODE_IMAX;
\r
247 return sw::Shader::OPCODE_UMAX;
\r
257 void OutputASM::visitSymbol(TIntermSymbol *symbol)
\r
259 // Vertex varyings don't have to be actively used to successfully link
\r
260 // against pixel shaders that use them. So make sure they're declared.
\r
261 if(symbol->getQualifier() == EvqVaryingOut || symbol->getQualifier() == EvqInvariantVaryingOut || symbol->getQualifier() == EvqVertexOut)
\r
263 if(symbol->getBasicType() != EbtInvariant) // Typeless declarations are not new varyings
\r
265 declareVarying(symbol, -1);
\r
270 bool OutputASM::visitBinary(Visit visit, TIntermBinary *node)
\r
272 if(currentScope != emitScope)
\r
277 TIntermTyped *result = node;
\r
278 TIntermTyped *left = node->getLeft();
\r
279 TIntermTyped *right = node->getRight();
\r
280 const TType &leftType = left->getType();
\r
281 const TType &rightType = right->getType();
\r
282 const TType &resultType = node->getType();
\r
284 switch(node->getOp())
\r
287 if(visit == PostVisit)
\r
289 assignLvalue(left, right);
\r
290 copy(result, right);
\r
293 case EOpInitialize:
\r
294 if(visit == PostVisit)
\r
299 case EOpMatrixTimesScalarAssign:
\r
300 if(visit == PostVisit)
\r
302 for(int i = 0; i < leftType.getNominalSize(); i++)
\r
304 Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
\r
305 mul->dst.index += i;
\r
306 argument(mul->src[0], left, i);
\r
309 assignLvalue(left, result);
\r
312 case EOpVectorTimesMatrixAssign:
\r
313 if(visit == PostVisit)
\r
315 int size = leftType.getNominalSize();
\r
317 for(int i = 0; i < size; i++)
\r
319 Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, left, right);
\r
320 dot->dst.mask = 1 << i;
\r
321 argument(dot->src[1], right, i);
\r
324 assignLvalue(left, result);
\r
327 case EOpMatrixTimesMatrixAssign:
\r
328 if(visit == PostVisit)
\r
330 int dim = leftType.getNominalSize();
\r
332 for(int i = 0; i < dim; i++)
\r
334 Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
\r
335 mul->dst.index += i;
\r
336 argument(mul->src[1], right, i);
\r
337 mul->src[1].swizzle = 0x00;
\r
339 for(int j = 1; j < dim; j++)
\r
341 Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);
\r
342 mad->dst.index += i;
\r
343 argument(mad->src[0], left, j);
\r
344 argument(mad->src[1], right, i);
\r
345 mad->src[1].swizzle = j * 0x55;
\r
346 argument(mad->src[2], result, i);
\r
350 assignLvalue(left, result);
\r
353 case EOpIndexDirect:
\r
354 if(visit == PostVisit)
\r
356 int index = right->getAsConstantUnion()->getIConst(0);
\r
358 if(result->isMatrix() || result->isStruct())
\r
360 ASSERT(left->isArray());
\r
361 copy(result, left, index * left->elementRegisterCount());
\r
363 else if(result->isRegister())
\r
365 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);
\r
367 if(left->isRegister())
\r
369 mov->src[0].swizzle = index;
\r
371 else if(left->isArray())
\r
373 argument(mov->src[0], left, index * left->elementRegisterCount());
\r
375 else if(left->isMatrix())
\r
377 ASSERT(index < left->getNominalSize()); // FIXME: Report semantic error
\r
378 argument(mov->src[0], left, index);
\r
380 else UNREACHABLE(0);
\r
382 else UNREACHABLE(0);
\r
385 case EOpIndexIndirect:
\r
386 if(visit == PostVisit)
\r
388 if(left->isArray() || left->isMatrix())
\r
390 for(int index = 0; index < result->totalRegisterCount(); index++)
\r
392 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);
\r
393 mov->dst.index += index;
\r
394 mov->dst.mask = writeMask(result, index);
\r
395 argument(mov->src[0], left, index);
\r
397 if(left->totalRegisterCount() > 1)
\r
399 sw::Shader::SourceParameter relativeRegister;
\r
400 argument(relativeRegister, right);
\r
402 mov->src[0].rel.type = relativeRegister.type;
\r
403 mov->src[0].rel.index = relativeRegister.index;
\r
404 mov->src[0].rel.scale = result->totalRegisterCount();
\r
405 mov->src[0].rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);
\r
409 else if(left->isRegister())
\r
411 emit(sw::Shader::OPCODE_EXTRACT, result, left, right);
\r
413 else UNREACHABLE(0);
\r
416 case EOpIndexDirectStruct:
\r
417 case EOpIndexDirectInterfaceBlock:
\r
418 if(visit == PostVisit)
\r
420 ASSERT(leftType.isStruct() || (leftType.isInterfaceBlock()));
\r
422 const TFieldList& fields = (node->getOp() == EOpIndexDirectStruct) ?
\r
423 leftType.getStruct()->fields() :
\r
424 leftType.getInterfaceBlock()->fields();
\r
425 int index = right->getAsConstantUnion()->getIConst(0);
\r
426 int fieldOffset = 0;
\r
428 for(int i = 0; i < index; i++)
\r
430 fieldOffset += fields[i]->type()->totalRegisterCount();
\r
433 copy(result, left, fieldOffset);
\r
436 case EOpVectorSwizzle:
\r
437 if(visit == PostVisit)
\r
440 TIntermAggregate *components = right->getAsAggregate();
\r
444 TIntermSequence &sequence = components->getSequence();
\r
447 for(TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++)
\r
449 TIntermConstantUnion *element = (*sit)->getAsConstantUnion();
\r
453 int i = element->getUnionArrayPointer()[0].getIConst();
\r
454 swizzle |= i << (component * 2);
\r
457 else UNREACHABLE(0);
\r
460 else UNREACHABLE(0);
\r
462 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);
\r
463 mov->src[0].swizzle = swizzle;
\r
466 case EOpAddAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_ADD, result), result, left, left, right); break;
\r
467 case EOpAdd: if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_ADD, result), result, left, right); break;
\r
468 case EOpSubAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_SUB, result), result, left, left, right); break;
\r
469 case EOpSub: if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_SUB, result), result, left, right); break;
\r
470 case EOpMulAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_MUL, result), result, left, left, right); break;
\r
471 case EOpMul: if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_MUL, result), result, left, right); break;
\r
472 case EOpDivAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_DIV, result), result, left, left, right); break;
\r
473 case EOpDiv: if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_DIV, result), result, left, right); break;
\r
474 case EOpIModAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_IMOD, result), result, left, left, right); break;
\r
475 case EOpIMod: if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_IMOD, result), result, left, right); break;
\r
476 case EOpBitShiftLeftAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_SHL, result, left, left, right); break;
\r
477 case EOpBitShiftLeft: if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_SHL, result, left, right); break;
\r
478 case EOpBitShiftRightAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_ISHR, result), result, left, left, right); break;
\r
479 case EOpBitShiftRight: if(visit == PostVisit) emitBinary(getOpcode(sw::Shader::OPCODE_ISHR, result), result, left, right); break;
\r
480 case EOpBitwiseAndAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_AND, result, left, left, right); break;
\r
481 case EOpBitwiseAnd: if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_AND, result, left, right); break;
\r
482 case EOpBitwiseXorAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_XOR, result, left, left, right); break;
\r
483 case EOpBitwiseXor: if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_XOR, result, left, right); break;
\r
484 case EOpBitwiseOrAssign: if(visit == PostVisit) emitAssign(sw::Shader::OPCODE_OR, result, left, left, right); break;
\r
485 case EOpBitwiseOr: if(visit == PostVisit) emitBinary(sw::Shader::OPCODE_OR, result, left, right); break;
\r
487 if(visit == PostVisit)
\r
489 emitBinary(sw::Shader::OPCODE_EQ, result, left, right);
\r
491 for(int index = 1; index < left->totalRegisterCount(); index++)
\r
493 Temporary equal(this);
\r
494 Instruction *eq = emit(sw::Shader::OPCODE_EQ, &equal, left, right);
\r
495 argument(eq->src[0], left, index);
\r
496 argument(eq->src[1], right, index);
\r
497 emit(sw::Shader::OPCODE_AND, result, result, &equal);
\r
502 if(visit == PostVisit)
\r
504 emitBinary(sw::Shader::OPCODE_NE, result, left, right);
\r
506 for(int index = 1; index < left->totalRegisterCount(); index++)
\r
508 Temporary notEqual(this);
\r
509 Instruction *eq = emit(sw::Shader::OPCODE_NE, ¬Equal, left, right);
\r
510 argument(eq->src[0], left, index);
\r
511 argument(eq->src[1], right, index);
\r
512 emit(sw::Shader::OPCODE_OR, result, result, ¬Equal);
\r
516 case EOpLessThan: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, left, right); break;
\r
517 case EOpGreaterThan: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, left, right); break;
\r
518 case EOpLessThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, left, right); break;
\r
519 case EOpGreaterThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, left, right); break;
\r
520 case EOpVectorTimesScalarAssign: if(visit == PostVisit) emitAssign(getOpcode(sw::Shader::OPCODE_MUL, left), result, left, left, right); break;
\r
521 case EOpVectorTimesScalar: if(visit == PostVisit) emit(getOpcode(sw::Shader::OPCODE_MUL, left), result, left, right); break;
\r
522 case EOpMatrixTimesScalar:
\r
523 if(visit == PostVisit)
\r
525 for(int i = 0; i < leftType.getNominalSize(); i++)
\r
527 Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
\r
528 mul->dst.index += i;
\r
529 argument(mul->src[0], left, i);
\r
533 case EOpVectorTimesMatrix:
\r
534 if(visit == PostVisit)
\r
536 sw::Shader::Opcode dpOpcode = sw::Shader::OPCODE_DP(leftType.getNominalSize());
\r
538 int size = rightType.getNominalSize();
\r
539 for(int i = 0; i < size; i++)
\r
541 Instruction *dot = emit(dpOpcode, result, left, right);
\r
542 dot->dst.mask = 1 << i;
\r
543 argument(dot->src[1], right, i);
\r
547 case EOpMatrixTimesVector:
\r
548 if(visit == PostVisit)
\r
550 Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
\r
551 mul->src[1].swizzle = 0x00;
\r
553 int size = rightType.getNominalSize();
\r
554 for(int i = 1; i < size; i++)
\r
556 Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);
\r
557 argument(mad->src[0], left, i);
\r
558 mad->src[1].swizzle = i * 0x55;
\r
562 case EOpMatrixTimesMatrix:
\r
563 if(visit == PostVisit)
\r
565 int dim = leftType.getNominalSize();
\r
567 int size = rightType.getNominalSize();
\r
568 for(int i = 0; i < size; i++)
\r
570 Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);
\r
571 mul->dst.index += i;
\r
572 argument(mul->src[1], right, i);
\r
573 mul->src[1].swizzle = 0x00;
\r
575 for(int j = 1; j < dim; j++)
\r
577 Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);
\r
578 mad->dst.index += i;
\r
579 argument(mad->src[0], left, j);
\r
580 argument(mad->src[1], right, i);
\r
581 mad->src[1].swizzle = j * 0x55;
\r
582 argument(mad->src[2], result, i);
\r
588 if(trivial(right, 6))
\r
590 if(visit == PostVisit)
\r
592 emit(sw::Shader::OPCODE_OR, result, left, right);
\r
595 else // Short-circuit evaluation
\r
597 if(visit == InVisit)
\r
599 emit(sw::Shader::OPCODE_MOV, result, left);
\r
600 Instruction *ifnot = emit(sw::Shader::OPCODE_IF, 0, result);
\r
601 ifnot->src[0].modifier = sw::Shader::MODIFIER_NOT;
\r
603 else if(visit == PostVisit)
\r
605 emit(sw::Shader::OPCODE_MOV, result, right);
\r
606 emit(sw::Shader::OPCODE_ENDIF);
\r
610 case EOpLogicalXor: if(visit == PostVisit) emit(sw::Shader::OPCODE_XOR, result, left, right); break;
\r
611 case EOpLogicalAnd:
\r
612 if(trivial(right, 6))
\r
614 if(visit == PostVisit)
\r
616 emit(sw::Shader::OPCODE_AND, result, left, right);
\r
619 else // Short-circuit evaluation
\r
621 if(visit == InVisit)
\r
623 emit(sw::Shader::OPCODE_MOV, result, left);
\r
624 emit(sw::Shader::OPCODE_IF, 0, result);
\r
626 else if(visit == PostVisit)
\r
628 emit(sw::Shader::OPCODE_MOV, result, right);
\r
629 emit(sw::Shader::OPCODE_ENDIF);
\r
633 default: UNREACHABLE(node->getOp());
\r
639 bool OutputASM::visitUnary(Visit visit, TIntermUnary *node)
\r
641 if(currentScope != emitScope)
\r
646 TIntermTyped *result = node;
\r
647 TIntermTyped *arg = node->getOperand();
\r
648 TBasicType basicType = arg->getType().getBasicType();
\r
656 if(basicType == EbtInt || basicType == EbtUInt)
\r
662 one_value.f = 1.0f;
\r
665 Constant one(one_value.f, one_value.f, one_value.f, one_value.f);
\r
666 Constant rad(1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f, 1.74532925e-2f);
\r
667 Constant deg(5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f, 5.72957795e+1f);
\r
669 switch(node->getOp())
\r
672 if(visit == PostVisit)
\r
674 sw::Shader::Opcode negOpcode = getOpcode(sw::Shader::OPCODE_NEG, arg);
\r
675 for(int index = 0; index < arg->totalRegisterCount(); index++)
\r
677 Instruction *neg = emit(negOpcode, result, arg);
\r
678 neg->dst.index += index;
\r
679 argument(neg->src[0], arg, index);
\r
683 case EOpVectorLogicalNot: if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;
\r
684 case EOpLogicalNot: if(visit == PostVisit) emit(sw::Shader::OPCODE_NOT, result, arg); break;
\r
685 case EOpPostIncrement:
\r
686 if(visit == PostVisit)
\r
690 sw::Shader::Opcode addOpcode = getOpcode(sw::Shader::OPCODE_ADD, arg);
\r
691 for(int index = 0; index < arg->totalRegisterCount(); index++)
\r
693 Instruction *add = emit(addOpcode, arg, arg, &one);
\r
694 add->dst.index += index;
\r
695 argument(add->src[0], arg, index);
\r
698 assignLvalue(arg, arg);
\r
701 case EOpPostDecrement:
\r
702 if(visit == PostVisit)
\r
706 sw::Shader::Opcode subOpcode = getOpcode(sw::Shader::OPCODE_SUB, arg);
\r
707 for(int index = 0; index < arg->totalRegisterCount(); index++)
\r
709 Instruction *sub = emit(subOpcode, arg, arg, &one);
\r
710 sub->dst.index += index;
\r
711 argument(sub->src[0], arg, index);
\r
714 assignLvalue(arg, arg);
\r
717 case EOpPreIncrement:
\r
718 if(visit == PostVisit)
\r
720 sw::Shader::Opcode addOpcode = getOpcode(sw::Shader::OPCODE_ADD, arg);
\r
721 for(int index = 0; index < arg->totalRegisterCount(); index++)
\r
723 Instruction *add = emit(addOpcode, result, arg, &one);
\r
724 add->dst.index += index;
\r
725 argument(add->src[0], arg, index);
\r
728 assignLvalue(arg, result);
\r
731 case EOpPreDecrement:
\r
732 if(visit == PostVisit)
\r
734 sw::Shader::Opcode subOpcode = getOpcode(sw::Shader::OPCODE_SUB, arg);
\r
735 for(int index = 0; index < arg->totalRegisterCount(); index++)
\r
737 Instruction *sub = emit(subOpcode, result, arg, &one);
\r
738 sub->dst.index += index;
\r
739 argument(sub->src[0], arg, index);
\r
742 assignLvalue(arg, result);
\r
745 case EOpRadians: if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, &rad); break;
\r
746 case EOpDegrees: if(visit == PostVisit) emit(sw::Shader::OPCODE_MUL, result, arg, °); break;
\r
747 case EOpSin: if(visit == PostVisit) emit(sw::Shader::OPCODE_SIN, result, arg); break;
\r
748 case EOpCos: if(visit == PostVisit) emit(sw::Shader::OPCODE_COS, result, arg); break;
\r
749 case EOpTan: if(visit == PostVisit) emit(sw::Shader::OPCODE_TAN, result, arg); break;
\r
750 case EOpAsin: if(visit == PostVisit) emit(sw::Shader::OPCODE_ASIN, result, arg); break;
\r
751 case EOpAcos: if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOS, result, arg); break;
\r
752 case EOpAtan: if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN, result, arg); break;
\r
753 case EOpSinh: if(visit == PostVisit) emit(sw::Shader::OPCODE_SINH, result, arg); break;
\r
754 case EOpCosh: if(visit == PostVisit) emit(sw::Shader::OPCODE_COSH, result, arg); break;
\r
755 case EOpTanh: if(visit == PostVisit) emit(sw::Shader::OPCODE_TANH, result, arg); break;
\r
756 case EOpAsinh: if(visit == PostVisit) emit(sw::Shader::OPCODE_ASINH, result, arg); break;
\r
757 case EOpAcosh: if(visit == PostVisit) emit(sw::Shader::OPCODE_ACOSH, result, arg); break;
\r
758 case EOpAtanh: if(visit == PostVisit) emit(sw::Shader::OPCODE_ATANH, result, arg); break;
\r
759 case EOpExp: if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP, result, arg); break;
\r
760 case EOpLog: if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG, result, arg); break;
\r
761 case EOpExp2: if(visit == PostVisit) emit(sw::Shader::OPCODE_EXP2, result, arg); break;
\r
762 case EOpLog2: if(visit == PostVisit) emit(sw::Shader::OPCODE_LOG2, result, arg); break;
\r
763 case EOpSqrt: if(visit == PostVisit) emit(sw::Shader::OPCODE_SQRT, result, arg); break;
\r
764 case EOpInverseSqrt: if(visit == PostVisit) emit(sw::Shader::OPCODE_RSQ, result, arg); break;
\r
765 case EOpAbs: if(visit == PostVisit) emit(sw::Shader::OPCODE_ABS, result, arg); break;
\r
766 case EOpSign: if(visit == PostVisit) emit(sw::Shader::OPCODE_SGN, result, arg); break;
\r
767 case EOpFloor: if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOOR, result, arg); break;
\r
768 case EOpTrunc: if(visit == PostVisit) emit(sw::Shader::OPCODE_TRUNC, result, arg); break;
\r
769 case EOpRound: if(visit == PostVisit) emit(sw::Shader::OPCODE_ROUND, result, arg); break;
\r
770 case EOpRoundEven: if(visit == PostVisit) emit(sw::Shader::OPCODE_ROUNDEVEN, result, arg); break;
\r
771 case EOpCeil: if(visit == PostVisit) emit(sw::Shader::OPCODE_CEIL, result, arg, result); break;
\r
772 case EOpFract: if(visit == PostVisit) emit(sw::Shader::OPCODE_FRC, result, arg); break;
\r
773 case EOpIsNan: if(visit == PostVisit) emit(sw::Shader::OPCODE_ISNAN, result, arg); break;
\r
774 case EOpIsInf: if(visit == PostVisit) emit(sw::Shader::OPCODE_ISINF, result, arg); break;
\r
775 case EOpLength: if(visit == PostVisit) emit(sw::Shader::OPCODE_LEN(dim(arg)), result, arg); break;
\r
776 case EOpNormalize: if(visit == PostVisit) emit(sw::Shader::OPCODE_NRM(dim(arg)), result, arg); break;
\r
777 case EOpDFdx: if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDX, result, arg); break;
\r
778 case EOpDFdy: if(visit == PostVisit) emit(sw::Shader::OPCODE_DFDY, result, arg); break;
\r
779 case EOpFwidth: if(visit == PostVisit) emit(sw::Shader::OPCODE_FWIDTH, result, arg); break;
\r
780 case EOpAny: if(visit == PostVisit) emit(sw::Shader::OPCODE_ANY, result, arg); break;
\r
781 case EOpAll: if(visit == PostVisit) emit(sw::Shader::OPCODE_ALL, result, arg); break;
\r
782 case EOpFloatBitsToInt: if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOATBITSTOINT, result, arg); break;
\r
783 case EOpFloatBitsToUint: if(visit == PostVisit) emit(sw::Shader::OPCODE_FLOATBITSTOUINT, result, arg); break;
\r
784 case EOpIntBitsToFloat: if(visit == PostVisit) emit(sw::Shader::OPCODE_INTBITSTOFLOAT, result, arg); break;
\r
785 case EOpUintBitsToFloat: if(visit == PostVisit) emit(sw::Shader::OPCODE_UINTBITSTOFLOAT, result, arg); break;
\r
786 case EOpPackSnorm2x16: if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKSNORM2x16, result, arg); break;
\r
787 case EOpPackUnorm2x16: if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKUNORM2x16, result, arg); break;
\r
788 case EOpPackHalf2x16: if(visit == PostVisit) emit(sw::Shader::OPCODE_PACKHALF2x16, result, arg); break;
\r
789 case EOpUnpackSnorm2x16: if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKSNORM2x16, result, arg); break;
\r
790 case EOpUnpackUnorm2x16: if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKUNORM2x16, result, arg); break;
\r
791 case EOpUnpackHalf2x16: if(visit == PostVisit) emit(sw::Shader::OPCODE_UNPACKHALF2x16, result, arg); break;
\r
793 if(visit == PostVisit)
\r
795 int numCols = arg->getNominalSize();
\r
796 int numRows = arg->getSecondarySize();
\r
797 for(int i = 0; i < numCols; ++i)
\r
799 for(int j = 0; j < numRows; ++j)
\r
801 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, arg);
\r
802 mov->src[0].index += i;
\r
803 mov->src[0].swizzle = 0x55 * j;
\r
804 mov->dst.index += j;
\r
805 mov->dst.mask = 1 << i;
\r
810 default: UNREACHABLE(node->getOp());
\r
816 bool OutputASM::visitAggregate(Visit visit, TIntermAggregate *node)
\r
818 if(currentScope != emitScope && node->getOp() != EOpFunction && node->getOp() != EOpSequence)
\r
823 Constant zero(0.0f, 0.0f, 0.0f, 0.0f);
\r
825 TIntermTyped *result = node;
\r
826 const TType &resultType = node->getType();
\r
827 TIntermSequence &arg = node->getSequence();
\r
828 int argumentCount = arg.size();
\r
830 switch(node->getOp())
\r
832 case EOpSequence: break;
\r
833 case EOpDeclaration: break;
\r
834 case EOpPrototype: break;
\r
836 if(visit == PostVisit)
\r
838 copy(result, arg[1]);
\r
842 if(visit == PreVisit)
\r
844 const TString &name = node->getName();
\r
846 if(emitScope == FUNCTION)
\r
848 if(functionArray.size() > 1) // No need for a label when there's only main()
\r
850 Instruction *label = emit(sw::Shader::OPCODE_LABEL);
\r
851 label->dst.type = sw::Shader::PARAMETER_LABEL;
\r
853 const Function *function = findFunction(name);
\r
854 ASSERT(function); // Should have been added during global pass
\r
855 label->dst.index = function->label;
\r
856 currentFunction = function->label;
\r
859 else if(emitScope == GLOBAL)
\r
861 if(name != "main(")
\r
863 TIntermSequence &arguments = node->getSequence()[0]->getAsAggregate()->getSequence();
\r
864 functionArray.push_back(Function(functionArray.size(), name, &arguments, node));
\r
867 else UNREACHABLE(emitScope);
\r
869 currentScope = FUNCTION;
\r
871 else if(visit == PostVisit)
\r
873 if(emitScope == FUNCTION)
\r
875 if(functionArray.size() > 1) // No need to return when there's only main()
\r
877 emit(sw::Shader::OPCODE_RET);
\r
881 currentScope = GLOBAL;
\r
884 case EOpFunctionCall:
\r
885 if(visit == PostVisit)
\r
887 if(node->isUserDefined())
\r
889 const TString &name = node->getName();
\r
890 const Function *function = findFunction(name);
\r
894 mContext.error(node->getLine(), "function definition not found", name.c_str());
\r
898 TIntermSequence &arguments = *function->arg;
\r
900 for(int i = 0; i < argumentCount; i++)
\r
902 TIntermTyped *in = arguments[i]->getAsTyped();
\r
904 if(in->getQualifier() == EvqIn ||
\r
905 in->getQualifier() == EvqInOut ||
\r
906 in->getQualifier() == EvqConstReadOnly)
\r
912 Instruction *call = emit(sw::Shader::OPCODE_CALL);
\r
913 call->dst.type = sw::Shader::PARAMETER_LABEL;
\r
914 call->dst.index = function->label;
\r
916 if(function->ret && function->ret->getType().getBasicType() != EbtVoid)
\r
918 copy(result, function->ret);
\r
921 for(int i = 0; i < argumentCount; i++)
\r
923 TIntermTyped *argument = arguments[i]->getAsTyped();
\r
924 TIntermTyped *out = arg[i]->getAsTyped();
\r
926 if(argument->getQualifier() == EvqOut ||
\r
927 argument->getQualifier() == EvqInOut)
\r
929 copy(out, argument);
\r
935 TString name = TFunction::unmangleName(node->getName());
\r
937 if(name == "texture" || name == "texture2D" || name == "textureCube" || name == "texture3D")
\r
939 if(argumentCount == 2)
\r
941 emit(sw::Shader::OPCODE_TEX, result, arg[1], arg[0]);
\r
943 else if(argumentCount == 3) // bias
\r
945 Temporary uvwb(this);
\r
946 emit(sw::Shader::OPCODE_MOV, &uvwb, arg[1]);
\r
947 Instruction *bias = emit(sw::Shader::OPCODE_MOV, &uvwb, arg[2]);
\r
948 bias->dst.mask = 0x8;
\r
950 Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, &uvwb, arg[0]); // FIXME: Implement an efficient TEXLDB instruction
\r
953 else UNREACHABLE(argumentCount);
\r
955 else if(name == "texture2DProj" || name == "textureProj")
\r
957 TIntermTyped *t = arg[1]->getAsTyped();
\r
959 if(argumentCount == 2)
\r
961 Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, arg[1], arg[0]);
\r
962 tex->project = true;
\r
964 if(t->getNominalSize() == 3)
\r
966 tex->src[0].swizzle = 0xA4;
\r
968 else ASSERT(t->getNominalSize() == 4);
\r
970 else if(argumentCount == 3) // bias
\r
972 Temporary proj(this);
\r
974 if(t->getNominalSize() == 3)
\r
976 Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);
\r
977 div->src[1].swizzle = 0xAA;
\r
978 div->dst.mask = 0x3;
\r
980 else if(t->getNominalSize() == 4)
\r
982 Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);
\r
983 div->src[1].swizzle = 0xFF;
\r
984 div->dst.mask = 0x3;
\r
986 else UNREACHABLE(t->getNominalSize());
\r
988 Instruction *bias = emit(sw::Shader::OPCODE_MOV, &proj, arg[2]);
\r
989 bias->dst.mask = 0x8;
\r
991 Instruction *tex = emit(sw::Shader::OPCODE_TEX, result, &proj, arg[0]);
\r
994 else UNREACHABLE(argumentCount);
\r
996 else if(name == "texture2DLod" || name == "textureCubeLod" || name == "textureLod")
\r
998 Temporary uvwb(this);
\r
999 emit(sw::Shader::OPCODE_MOV, &uvwb, arg[1]);
\r
1000 Instruction *lod = emit(sw::Shader::OPCODE_MOV, &uvwb, arg[2]);
\r
1001 lod->dst.mask = 0x8;
\r
1003 emit(sw::Shader::OPCODE_TEXLDL, result, &uvwb, arg[0]);
\r
1005 else if(name == "texture2DProjLod" || name == "textureProjLod")
\r
1007 TIntermTyped *t = arg[1]->getAsTyped();
\r
1008 Temporary proj(this);
\r
1010 if(t->getNominalSize() == 3)
\r
1012 Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);
\r
1013 div->src[1].swizzle = 0xAA;
\r
1014 div->dst.mask = 0x3;
\r
1016 else if(t->getNominalSize() == 4)
\r
1018 Instruction *div = emit(sw::Shader::OPCODE_DIV, &proj, arg[1], arg[1]);
\r
1019 div->src[1].swizzle = 0xFF;
\r
1020 div->dst.mask = 0x3;
\r
1022 else UNREACHABLE(t->getNominalSize());
\r
1024 Instruction *lod = emit(sw::Shader::OPCODE_MOV, &proj, arg[2]);
\r
1025 lod->dst.mask = 0x8;
\r
1027 emit(sw::Shader::OPCODE_TEXLDL, result, &proj, arg[0]);
\r
1029 else UNREACHABLE(0);
\r
1033 case EOpParameters:
\r
1035 case EOpConstructFloat:
\r
1036 case EOpConstructVec2:
\r
1037 case EOpConstructVec3:
\r
1038 case EOpConstructVec4:
\r
1039 case EOpConstructBool:
\r
1040 case EOpConstructBVec2:
\r
1041 case EOpConstructBVec3:
\r
1042 case EOpConstructBVec4:
\r
1043 case EOpConstructInt:
\r
1044 case EOpConstructIVec2:
\r
1045 case EOpConstructIVec3:
\r
1046 case EOpConstructIVec4:
\r
1047 case EOpConstructUInt:
\r
1048 case EOpConstructUVec2:
\r
1049 case EOpConstructUVec3:
\r
1050 case EOpConstructUVec4:
\r
1051 if(visit == PostVisit)
\r
1053 int component = 0;
\r
1055 for(int i = 0; i < argumentCount; i++)
\r
1057 TIntermTyped *argi = arg[i]->getAsTyped();
\r
1058 int size = argi->getNominalSize();
\r
1060 if(!argi->isMatrix())
\r
1062 Instruction *mov = emitCast(result, argi);
\r
1063 mov->dst.mask = (0xF << component) & 0xF;
\r
1064 mov->src[0].swizzle = readSwizzle(argi, size) << (component * 2);
\r
1066 component += size;
\r
1072 while(component < resultType.getNominalSize())
\r
1074 Instruction *mov = emitCast(result, argi);
\r
1075 mov->dst.mask = (0xF << component) & 0xF;
\r
1076 mov->src[0].index += column;
\r
1077 mov->src[0].swizzle = readSwizzle(argi, size) << (component * 2);
\r
1080 component += size;
\r
1086 case EOpConstructMat2:
\r
1087 case EOpConstructMat2x3:
\r
1088 case EOpConstructMat2x4:
\r
1089 case EOpConstructMat3x2:
\r
1090 case EOpConstructMat3:
\r
1091 case EOpConstructMat3x4:
\r
1092 case EOpConstructMat4x2:
\r
1093 case EOpConstructMat4x3:
\r
1094 case EOpConstructMat4:
\r
1095 if(visit == PostVisit)
\r
1097 TIntermTyped *arg0 = arg[0]->getAsTyped();
\r
1098 const int outCols = result->getNominalSize();
\r
1099 const int outRows = result->getSecondarySize();
\r
1101 if(arg0->isScalar() && arg.size() == 1) // Construct scale matrix
\r
1103 for(int i = 0; i < outCols; i++)
\r
1105 Instruction *init = emit(sw::Shader::OPCODE_MOV, result, &zero);
\r
1106 init->dst.index += i;
\r
1107 Instruction *mov = emitCast(result, arg0);
\r
1108 mov->dst.index += i;
\r
1109 mov->dst.mask = 1 << i;
\r
1110 ASSERT(mov->src[0].swizzle == 0x00);
\r
1113 else if(arg0->isMatrix())
\r
1115 const int inCols = arg0->getNominalSize();
\r
1116 const int inRows = arg0->getSecondarySize();
\r
1118 for(int i = 0; i < outCols; i++)
\r
1120 if(i >= inCols || outRows > inRows)
\r
1122 // Initialize to identity matrix
\r
1123 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
1124 Instruction *mov = emitCast(result, &col);
\r
1125 mov->dst.index += i;
\r
1130 Instruction *mov = emitCast(result, arg0);
\r
1131 mov->dst.index += i;
\r
1132 mov->dst.mask = 0xF >> (4 - inRows);
\r
1133 argument(mov->src[0], arg0, i);
\r
1142 for(int i = 0; i < argumentCount; i++)
\r
1144 TIntermTyped *argi = arg[i]->getAsTyped();
\r
1145 int size = argi->getNominalSize();
\r
1148 while(element < size)
\r
1150 Instruction *mov = emitCast(result, argi);
\r
1151 mov->dst.index += column;
\r
1152 mov->dst.mask = (0xF << row) & 0xF;
\r
1153 mov->src[0].swizzle = (readSwizzle(argi, size) << (row * 2)) + 0x55 * element;
\r
1155 int end = row + size - element;
\r
1156 column = end >= outRows ? column + 1 : column;
\r
1157 element = element + outRows - row;
\r
1158 row = end >= outRows ? 0 : end;
\r
1164 case EOpConstructStruct:
\r
1165 if(visit == PostVisit)
\r
1168 for(int i = 0; i < argumentCount; i++)
\r
1170 TIntermTyped *argi = arg[i]->getAsTyped();
\r
1171 int size = argi->totalRegisterCount();
\r
1173 for(int index = 0; index < size; index++)
\r
1175 Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, argi);
\r
1176 mov->dst.index += index + offset;
\r
1177 mov->dst.mask = writeMask(result, offset + index);
\r
1178 argument(mov->src[0], argi, index);
\r
1185 case EOpLessThan: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LT, result, arg[0], arg[1]); break;
\r
1186 case EOpGreaterThan: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GT, result, arg[0], arg[1]); break;
\r
1187 case EOpLessThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_LE, result, arg[0], arg[1]); break;
\r
1188 case EOpGreaterThanEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_GE, result, arg[0], arg[1]); break;
\r
1189 case EOpVectorEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_EQ, result, arg[0], arg[1]); break;
\r
1190 case EOpVectorNotEqual: if(visit == PostVisit) emitCmp(sw::Shader::CONTROL_NE, result, arg[0], arg[1]); break;
\r
1191 case EOpMod: if(visit == PostVisit) emit(sw::Shader::OPCODE_MOD, result, arg[0], arg[1]); break;
\r
1192 case EOpPow: if(visit == PostVisit) emit(sw::Shader::OPCODE_POW, result, arg[0], arg[1]); break;
\r
1193 case EOpAtan: if(visit == PostVisit) emit(sw::Shader::OPCODE_ATAN2, result, arg[0], arg[1]); break;
\r
1194 case EOpMin: if(visit == PostVisit) emit(getOpcode(sw::Shader::OPCODE_MIN, result), result, arg[0], arg[1]); break;
\r
1195 case EOpMax: if(visit == PostVisit) emit(getOpcode(sw::Shader::OPCODE_MAX, result), result, arg[0], arg[1]); break;
\r
1197 if(visit == PostVisit)
\r
1199 emit(getOpcode(sw::Shader::OPCODE_MAX, result), result, arg[0], arg[1]);
\r
1200 emit(getOpcode(sw::Shader::OPCODE_MIN, result), result, result, arg[2]);
\r
1203 case EOpMix: if(visit == PostVisit) emit(sw::Shader::OPCODE_LRP, result, arg[2], arg[1], arg[0]); break;
\r
1204 case EOpStep: if(visit == PostVisit) emit(sw::Shader::OPCODE_STEP, result, arg[0], arg[1]); break;
\r
1205 case EOpSmoothStep: if(visit == PostVisit) emit(sw::Shader::OPCODE_SMOOTH, result, arg[0], arg[1], arg[2]); break;
\r
1206 case EOpDistance: if(visit == PostVisit) emit(sw::Shader::OPCODE_DIST(dim(arg[0])), result, arg[0], arg[1]); break;
\r
1207 case EOpDot: if(visit == PostVisit) emit(sw::Shader::OPCODE_DP(dim(arg[0])), result, arg[0], arg[1]); break;
\r
1208 case EOpCross: if(visit == PostVisit) emit(sw::Shader::OPCODE_CRS, result, arg[0], arg[1]); break;
\r
1209 case EOpFaceForward: if(visit == PostVisit) emit(sw::Shader::OPCODE_FORWARD(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;
\r
1210 case EOpReflect: if(visit == PostVisit) emit(sw::Shader::OPCODE_REFLECT(dim(arg[0])), result, arg[0], arg[1]); break;
\r
1211 case EOpRefract: if(visit == PostVisit) emit(sw::Shader::OPCODE_REFRACT(dim(arg[0])), result, arg[0], arg[1], arg[2]); break;
\r
1213 if(visit == PostVisit)
\r
1215 TIntermTyped *arg0 = arg[0]->getAsTyped();
\r
1216 TIntermTyped *arg1 = arg[1]->getAsTyped();
\r
1217 ASSERT((arg0->getNominalSize() == arg1->getNominalSize()) && (arg0->getSecondarySize() == arg1->getSecondarySize()));
\r
1219 int size = arg0->getNominalSize();
\r
1220 for(int i = 0; i < size; i++)
\r
1222 Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, arg[0], arg[1]);
\r
1223 mul->dst.index += i;
\r
1224 argument(mul->src[0], arg[0], i);
\r
1225 argument(mul->src[1], arg[1], i);
\r
1229 case EOpOuterProduct:
\r
1230 if(visit == PostVisit)
\r
1232 for(int i = 0; i < dim(arg[1]); i++)
\r
1234 Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, arg[0], arg[1]);
\r
1235 mul->dst.index += i;
\r
1236 mul->src[1].swizzle = 0x55 * i;
\r
1240 default: UNREACHABLE(node->getOp());
\r
1246 bool OutputASM::visitSelection(Visit visit, TIntermSelection *node)
\r
1248 if(currentScope != emitScope)
\r
1253 TIntermTyped *condition = node->getCondition();
\r
1254 TIntermNode *trueBlock = node->getTrueBlock();
\r
1255 TIntermNode *falseBlock = node->getFalseBlock();
\r
1256 TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();
\r
1258 condition->traverse(this);
\r
1260 if(node->usesTernaryOperator())
\r
1262 if(constantCondition)
\r
1264 bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();
\r
1268 trueBlock->traverse(this);
\r
1269 copy(node, trueBlock);
\r
1273 falseBlock->traverse(this);
\r
1274 copy(node, falseBlock);
\r
1277 else if(trivial(node, 6)) // Fast to compute both potential results and no side effects
\r
1279 trueBlock->traverse(this);
\r
1280 falseBlock->traverse(this);
\r
1281 emit(sw::Shader::OPCODE_SELECT, node, condition, trueBlock, falseBlock);
\r
1285 emit(sw::Shader::OPCODE_IF, 0, condition);
\r
1289 trueBlock->traverse(this);
\r
1290 copy(node, trueBlock);
\r
1295 emit(sw::Shader::OPCODE_ELSE);
\r
1296 falseBlock->traverse(this);
\r
1297 copy(node, falseBlock);
\r
1300 emit(sw::Shader::OPCODE_ENDIF);
\r
1303 else // if/else statement
\r
1305 if(constantCondition)
\r
1307 bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();
\r
1313 trueBlock->traverse(this);
\r
1320 falseBlock->traverse(this);
\r
1326 emit(sw::Shader::OPCODE_IF, 0, condition);
\r
1330 trueBlock->traverse(this);
\r
1335 emit(sw::Shader::OPCODE_ELSE);
\r
1336 falseBlock->traverse(this);
\r
1339 emit(sw::Shader::OPCODE_ENDIF);
\r
1346 bool OutputASM::visitLoop(Visit visit, TIntermLoop *node)
\r
1348 if(currentScope != emitScope)
\r
1353 unsigned int iterations = loopCount(node);
\r
1355 if(iterations == 0)
\r
1360 bool unroll = (iterations <= 4);
\r
1364 DetectLoopDiscontinuity detectLoopDiscontinuity;
\r
1365 unroll = !detectLoopDiscontinuity.traverse(node);
\r
1368 TIntermNode *init = node->getInit();
\r
1369 TIntermTyped *condition = node->getCondition();
\r
1370 TIntermTyped *expression = node->getExpression();
\r
1371 TIntermNode *body = node->getBody();
\r
1373 if(node->getType() == ELoopDoWhile)
\r
1375 Temporary iterate(this);
\r
1376 Constant True(true);
\r
1377 emit(sw::Shader::OPCODE_MOV, &iterate, &True);
\r
1379 emit(sw::Shader::OPCODE_WHILE, 0, &iterate); // FIXME: Implement real do-while
\r
1383 body->traverse(this);
\r
1386 emit(sw::Shader::OPCODE_TEST);
\r
1388 condition->traverse(this);
\r
1389 emit(sw::Shader::OPCODE_MOV, &iterate, condition);
\r
1391 emit(sw::Shader::OPCODE_ENDWHILE);
\r
1397 init->traverse(this);
\r
1402 for(unsigned int i = 0; i < iterations; i++)
\r
1404 // condition->traverse(this); // Condition could contain statements, but not in an unrollable loop
\r
1408 body->traverse(this);
\r
1413 expression->traverse(this);
\r
1421 condition->traverse(this);
\r
1424 emit(sw::Shader::OPCODE_WHILE, 0, condition);
\r
1428 body->traverse(this);
\r
1431 emit(sw::Shader::OPCODE_TEST);
\r
1435 expression->traverse(this);
\r
1440 condition->traverse(this);
\r
1443 emit(sw::Shader::OPCODE_ENDWHILE);
\r
1450 bool OutputASM::visitBranch(Visit visit, TIntermBranch *node)
\r
1452 if(currentScope != emitScope)
\r
1457 switch(node->getFlowOp())
\r
1459 case EOpKill: if(visit == PostVisit) emit(sw::Shader::OPCODE_DISCARD); break;
\r
1460 case EOpBreak: if(visit == PostVisit) emit(sw::Shader::OPCODE_BREAK); break;
\r
1461 case EOpContinue: if(visit == PostVisit) emit(sw::Shader::OPCODE_CONTINUE); break;
\r
1463 if(visit == PostVisit)
\r
1465 TIntermTyped *value = node->getExpression();
\r
1469 copy(functionArray[currentFunction].ret, value);
\r
1472 emit(sw::Shader::OPCODE_LEAVE);
\r
1475 default: UNREACHABLE(node->getFlowOp());
\r
1481 bool OutputASM::isSamplerRegister(TIntermTyped *operand)
\r
1483 return operand && isSamplerRegister(operand->getType());
\r
1486 bool OutputASM::isSamplerRegister(const TType &type)
\r
1488 // A sampler register's qualifiers can be:
\r
1489 // - EvqUniform: The sampler uniform is used as is in the code (default case).
\r
1490 // - EvqTemporary: The sampler is indexed. It's still a sampler register.
\r
1491 // - EvqIn (and other similar types): The sampler has been passed as a function argument. At this point,
\r
1492 // the sampler has been copied and is no longer a sampler register.
\r
1493 return IsSampler(type.getBasicType()) && (type.getQualifier() == EvqUniform || type.getQualifier() == EvqTemporary);
\r
1496 Instruction *OutputASM::emit(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2, int index)
\r
1498 if(isSamplerRegister(dst))
\r
1500 op = sw::Shader::OPCODE_NULL; // Can't assign to a sampler, but this is hit when indexing sampler arrays
\r
1503 Instruction *instruction = new Instruction(op);
\r
1507 instruction->dst.type = registerType(dst);
\r
1508 instruction->dst.index = registerIndex(dst) + index;
\r
1509 instruction->dst.mask = writeMask(dst);
\r
1510 instruction->dst.integer = (dst->getBasicType() == EbtInt);
\r
1513 argument(instruction->src[0], src0, index);
\r
1514 argument(instruction->src[1], src1, index);
\r
1515 argument(instruction->src[2], src2, index);
\r
1517 shader->append(instruction);
\r
1519 return instruction;
\r
1522 Instruction *OutputASM::emitCast(TIntermTyped *dst, TIntermTyped *src)
\r
1524 switch(src->getBasicType())
\r
1527 switch(dst->getBasicType())
\r
1529 case EbtInt: return emit(sw::Shader::OPCODE_B2I, dst, src);
\r
1530 case EbtUInt: return emit(sw::Shader::OPCODE_B2U, dst, src);
\r
1531 case EbtFloat: return emit(sw::Shader::OPCODE_B2F, dst, src);
\r
1536 switch(dst->getBasicType())
\r
1538 case EbtBool: return emit(sw::Shader::OPCODE_I2B, dst, src);
\r
1539 case EbtFloat: return emit(sw::Shader::OPCODE_I2F, dst, src);
\r
1544 switch(dst->getBasicType())
\r
1546 case EbtBool: return emit(sw::Shader::OPCODE_U2B, dst, src);
\r
1547 case EbtFloat: return emit(sw::Shader::OPCODE_U2F, dst, src);
\r
1552 switch(dst->getBasicType())
\r
1554 case EbtBool: return emit(sw::Shader::OPCODE_F2B, dst, src);
\r
1555 case EbtInt: return emit(sw::Shader::OPCODE_F2I, dst, src);
\r
1556 case EbtUInt: return emit(sw::Shader::OPCODE_F2U, dst, src);
\r
1564 return emit(sw::Shader::OPCODE_MOV, dst, src);
\r
1567 void OutputASM::emitBinary(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2)
\r
1569 for(int index = 0; index < dst->elementRegisterCount(); index++)
\r
1571 emit(op, dst, src0, src1, src2, index);
\r
1575 void OutputASM::emitAssign(sw::Shader::Opcode op, TIntermTyped *result, TIntermTyped *lhs, TIntermTyped *src0, TIntermTyped *src1)
\r
1577 emitBinary(op, result, src0, src1);
\r
1578 assignLvalue(lhs, result);
\r
1581 void OutputASM::emitCmp(sw::Shader::Control cmpOp, TIntermTyped *dst, TIntermNode *left, TIntermNode *right, int index)
\r
1583 sw::Shader::Opcode opcode;
\r
1584 switch(left->getAsTyped()->getBasicType())
\r
1588 opcode = sw::Shader::OPCODE_ICMP;
\r
1591 opcode = sw::Shader::OPCODE_UCMP;
\r
1594 opcode = sw::Shader::OPCODE_CMP;
\r
1598 Instruction *cmp = emit(opcode, dst, left, right);
\r
1599 cmp->control = cmpOp;
\r
1600 argument(cmp->src[0], left, index);
\r
1601 argument(cmp->src[1], right, index);
\r
1604 int componentCount(const TType &type, int registers)
\r
1606 if(registers == 0)
\r
1611 if(type.isArray() && registers >= type.elementRegisterCount())
\r
1613 int index = registers / type.elementRegisterCount();
\r
1614 registers -= index * type.elementRegisterCount();
\r
1615 return index * type.getElementSize() + componentCount(type, registers);
\r
1618 if(type.isStruct() || type.isInterfaceBlock())
\r
1620 const TFieldList& fields = type.getStruct() ? type.getStruct()->fields() : type.getInterfaceBlock()->fields();
\r
1623 for(TFieldList::const_iterator field = fields.begin(); field != fields.end(); field++)
\r
1625 const TType &fieldType = *((*field)->type());
\r
1627 if(fieldType.totalRegisterCount() <= registers)
\r
1629 registers -= fieldType.totalRegisterCount();
\r
1630 elements += fieldType.getObjectSize();
\r
1632 else // Register within this field
\r
1634 return elements + componentCount(fieldType, registers);
\r
1638 else if(type.isMatrix())
\r
1640 return registers * type.registerSize();
\r
1647 int registerSize(const TType &type, int registers)
\r
1649 if(registers == 0)
\r
1651 if(type.isStruct())
\r
1653 return registerSize(*((*(type.getStruct()->fields().begin()))->type()), 0);
\r
1656 return type.registerSize();
\r
1659 if(type.isArray() && registers >= type.elementRegisterCount())
\r
1661 int index = registers / type.elementRegisterCount();
\r
1662 registers -= index * type.elementRegisterCount();
\r
1663 return registerSize(type, registers);
\r
1666 if(type.isStruct() || type.isInterfaceBlock())
\r
1668 const TFieldList& fields = type.getStruct() ? type.getStruct()->fields() : type.getInterfaceBlock()->fields();
\r
1671 for(TFieldList::const_iterator field = fields.begin(); field != fields.end(); field++)
\r
1673 const TType &fieldType = *((*field)->type());
\r
1675 if(fieldType.totalRegisterCount() <= registers)
\r
1677 registers -= fieldType.totalRegisterCount();
\r
1678 elements += fieldType.getObjectSize();
\r
1680 else // Register within this field
\r
1682 return registerSize(fieldType, registers);
\r
1686 else if(type.isMatrix())
\r
1688 return registerSize(type, 0);
\r
1695 void OutputASM::argument(sw::Shader::SourceParameter ¶meter, TIntermNode *argument, int index)
\r
1699 TIntermTyped *arg = argument->getAsTyped();
\r
1700 const TType &type = arg->getType();
\r
1701 index = (index >= arg->totalRegisterCount()) ? arg->totalRegisterCount() - 1 : index;
\r
1703 int size = registerSize(type, index);
\r
1705 parameter.type = registerType(arg);
\r
1707 if(arg->getQualifier() == EvqConstExpr)
\r
1709 int component = componentCount(type, index);
\r
1710 ConstantUnion *constants = arg->getAsConstantUnion()->getUnionArrayPointer();
\r
1712 for(int i = 0; i < 4; i++)
\r
1714 if(size == 1) // Replicate
\r
1716 parameter.value[i] = constants[component + 0].getAsFloat();
\r
1720 parameter.value[i] = constants[component + i].getAsFloat();
\r
1724 parameter.value[i] = 0.0f;
\r
1730 parameter.index = registerIndex(arg) + index;
\r
1732 if(isSamplerRegister(arg))
\r
1734 TIntermBinary *binary = argument->getAsBinaryNode();
\r
1738 TIntermTyped *left = binary->getLeft();
\r
1739 TIntermTyped *right = binary->getRight();
\r
1741 switch(binary->getOp())
\r
1743 case EOpIndexDirect:
\r
1744 parameter.index += right->getAsConstantUnion()->getIConst(0);
\r
1746 case EOpIndexIndirect:
\r
1747 if(left->getArraySize() > 1)
\r
1749 parameter.rel.type = registerType(binary->getRight());
\r
1750 parameter.rel.index = registerIndex(binary->getRight());
\r
1751 parameter.rel.scale = 1;
\r
1752 parameter.rel.deterministic = true;
\r
1755 case EOpIndexDirectStruct:
\r
1756 case EOpIndexDirectInterfaceBlock:
\r
1757 parameter.index += right->getAsConstantUnion()->getIConst(0);
\r
1760 UNREACHABLE(binary->getOp());
\r
1766 if(!IsSampler(arg->getBasicType()))
\r
1768 parameter.swizzle = readSwizzle(arg, size);
\r
1773 void OutputASM::copy(TIntermTyped *dst, TIntermNode *src, int offset)
\r
1775 for(int index = 0; index < dst->totalRegisterCount(); index++)
\r
1777 Instruction *mov = emit(sw::Shader::OPCODE_MOV, dst, src);
\r
1778 mov->dst.index += index;
\r
1779 mov->dst.mask = writeMask(dst, index);
\r
1780 argument(mov->src[0], src, offset + index);
\r
1784 int swizzleElement(int swizzle, int index)
\r
1786 return (swizzle >> (index * 2)) & 0x03;
\r
1789 int swizzleSwizzle(int leftSwizzle, int rightSwizzle)
\r
1791 return (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 0)) << 0) |
\r
1792 (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 1)) << 2) |
\r
1793 (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 2)) << 4) |
\r
1794 (swizzleElement(leftSwizzle, swizzleElement(rightSwizzle, 3)) << 6);
\r
1797 void OutputASM::assignLvalue(TIntermTyped *dst, TIntermTyped *src)
\r
1800 ((src->isVector() && (!dst->isVector() || (dst->getNominalSize() != dst->getNominalSize()))) ||
\r
1801 (src->isMatrix() && (!dst->isMatrix() || (src->getNominalSize() != dst->getNominalSize()) || (src->getSecondarySize() != dst->getSecondarySize())))))
\r
1803 return mContext.error(src->getLine(), "Result type should match the l-value type in compound assignment", src->isVector() ? "vector" : "matrix");
\r
1806 TIntermBinary *binary = dst->getAsBinaryNode();
\r
1808 if(binary && binary->getOp() == EOpIndexIndirect && dst->isScalar())
\r
1810 Instruction *insert = new Instruction(sw::Shader::OPCODE_INSERT);
\r
1812 Temporary address(this);
\r
1813 lvalue(insert->dst, address, dst);
\r
1815 insert->src[0].type = insert->dst.type;
\r
1816 insert->src[0].index = insert->dst.index;
\r
1817 insert->src[0].rel = insert->dst.rel;
\r
1818 argument(insert->src[1], src);
\r
1819 argument(insert->src[2], binary->getRight());
\r
1821 shader->append(insert);
\r
1825 for(int offset = 0; offset < dst->totalRegisterCount(); offset++)
\r
1827 Instruction *mov = new Instruction(sw::Shader::OPCODE_MOV);
\r
1829 Temporary address(this);
\r
1830 int swizzle = lvalue(mov->dst, address, dst);
\r
1831 mov->dst.index += offset;
\r
1835 mov->dst.mask = writeMask(dst, offset);
\r
1838 argument(mov->src[0], src, offset);
\r
1839 mov->src[0].swizzle = swizzleSwizzle(mov->src[0].swizzle, swizzle);
\r
1841 shader->append(mov);
\r
1846 int OutputASM::lvalue(sw::Shader::DestinationParameter &dst, Temporary &address, TIntermTyped *node)
\r
1848 TIntermTyped *result = node;
\r
1849 TIntermBinary *binary = node->getAsBinaryNode();
\r
1850 TIntermSymbol *symbol = node->getAsSymbolNode();
\r
1854 TIntermTyped *left = binary->getLeft();
\r
1855 TIntermTyped *right = binary->getRight();
\r
1857 int leftSwizzle = lvalue(dst, address, left); // Resolve the l-value of the left side
\r
1859 switch(binary->getOp())
\r
1861 case EOpIndexDirect:
\r
1863 int rightIndex = right->getAsConstantUnion()->getIConst(0);
\r
1865 if(left->isRegister())
\r
1867 int leftMask = dst.mask;
\r
1870 while((leftMask & dst.mask) == 0)
\r
1872 dst.mask = dst.mask << 1;
\r
1875 int element = swizzleElement(leftSwizzle, rightIndex);
\r
1876 dst.mask = 1 << element;
\r
1880 else if(left->isArray() || left->isMatrix())
\r
1882 dst.index += rightIndex * result->totalRegisterCount();
\r
1885 else UNREACHABLE(0);
\r
1888 case EOpIndexIndirect:
\r
1890 if(left->isRegister())
\r
1892 // Requires INSERT instruction (handled by calling function)
\r
1894 else if(left->isArray() || left->isMatrix())
\r
1896 int scale = result->totalRegisterCount();
\r
1898 if(dst.rel.type == sw::Shader::PARAMETER_VOID) // Use the index register as the relative address directly
\r
1900 if(left->totalRegisterCount() > 1)
\r
1902 sw::Shader::SourceParameter relativeRegister;
\r
1903 argument(relativeRegister, right);
\r
1905 dst.rel.index = relativeRegister.index;
\r
1906 dst.rel.type = relativeRegister.type;
\r
1907 dst.rel.scale = scale;
\r
1908 dst.rel.deterministic = !(vertexShader && left->getQualifier() == EvqUniform);
\r
1911 else if(dst.rel.index != registerIndex(&address)) // Move the previous index register to the address register
\r
1915 Constant oldScale((int)dst.rel.scale);
\r
1916 Instruction *mad = emit(sw::Shader::OPCODE_IMAD, &address, &address, &oldScale, right);
\r
1917 mad->src[0].index = dst.rel.index;
\r
1918 mad->src[0].type = dst.rel.type;
\r
1922 Constant oldScale((int)dst.rel.scale);
\r
1923 Instruction *mul = emit(sw::Shader::OPCODE_IMUL, &address, &address, &oldScale);
\r
1924 mul->src[0].index = dst.rel.index;
\r
1925 mul->src[0].type = dst.rel.type;
\r
1927 Constant newScale(scale);
\r
1928 emit(sw::Shader::OPCODE_IMAD, &address, right, &newScale, &address);
\r
1931 dst.rel.type = sw::Shader::PARAMETER_TEMP;
\r
1932 dst.rel.index = registerIndex(&address);
\r
1933 dst.rel.scale = 1;
\r
1935 else // Just add the new index to the address register
\r
1939 emit(sw::Shader::OPCODE_IADD, &address, &address, right);
\r
1943 Constant newScale(scale);
\r
1944 emit(sw::Shader::OPCODE_IMAD, &address, right, &newScale, &address);
\r
1948 else UNREACHABLE(0);
\r
1951 case EOpIndexDirectStruct:
\r
1952 case EOpIndexDirectInterfaceBlock:
\r
1954 const TFieldList& fields = (binary->getOp() == EOpIndexDirectStruct) ?
\r
1955 left->getType().getStruct()->fields() :
\r
1956 left->getType().getInterfaceBlock()->fields();
\r
1957 int index = right->getAsConstantUnion()->getIConst(0);
\r
1958 int fieldOffset = 0;
\r
1960 for(int i = 0; i < index; i++)
\r
1962 fieldOffset += fields[i]->type()->totalRegisterCount();
\r
1965 dst.type = registerType(left);
\r
1966 dst.index += fieldOffset;
\r
1967 dst.mask = writeMask(right);
\r
1972 case EOpVectorSwizzle:
\r
1974 ASSERT(left->isRegister());
\r
1976 int leftMask = dst.mask;
\r
1979 int rightMask = 0;
\r
1981 TIntermSequence &sequence = right->getAsAggregate()->getSequence();
\r
1983 for(unsigned int i = 0; i < sequence.size(); i++)
\r
1985 int index = sequence[i]->getAsConstantUnion()->getIConst(0);
\r
1987 int element = swizzleElement(leftSwizzle, index);
\r
1988 rightMask = rightMask | (1 << element);
\r
1989 swizzle = swizzle | swizzleElement(leftSwizzle, i) << (element * 2);
\r
1992 dst.mask = leftMask & rightMask;
\r
1998 UNREACHABLE(binary->getOp()); // Not an l-value operator
\r
2004 dst.type = registerType(symbol);
\r
2005 dst.index = registerIndex(symbol);
\r
2006 dst.mask = writeMask(symbol);
\r
2013 sw::Shader::ParameterType OutputASM::registerType(TIntermTyped *operand)
\r
2015 if(isSamplerRegister(operand))
\r
2017 return sw::Shader::PARAMETER_SAMPLER;
\r
2020 const TQualifier qualifier = operand->getQualifier();
\r
2021 if((EvqFragColor == qualifier) || (EvqFragData == qualifier))
\r
2023 if(((EvqFragData == qualifier) && (EvqFragColor == outputQualifier)) ||
\r
2024 ((EvqFragColor == qualifier) && (EvqFragData == outputQualifier)))
\r
2026 mContext.error(operand->getLine(), "static assignment to both gl_FragData and gl_FragColor", "");
\r
2028 outputQualifier = qualifier;
\r
2033 case EvqTemporary: return sw::Shader::PARAMETER_TEMP;
\r
2034 case EvqGlobal: return sw::Shader::PARAMETER_TEMP;
\r
2035 case EvqConstExpr: return sw::Shader::PARAMETER_FLOAT4LITERAL; // All converted to float
\r
2036 case EvqAttribute: return sw::Shader::PARAMETER_INPUT;
\r
2037 case EvqVaryingIn: return sw::Shader::PARAMETER_INPUT;
\r
2038 case EvqVaryingOut: return sw::Shader::PARAMETER_OUTPUT;
\r
2039 case EvqVertexIn: return sw::Shader::PARAMETER_INPUT;
\r
2040 case EvqFragmentOut: return sw::Shader::PARAMETER_COLOROUT;
\r
2041 case EvqVertexOut: return sw::Shader::PARAMETER_OUTPUT;
\r
2042 case EvqFragmentIn: return sw::Shader::PARAMETER_INPUT;
\r
2043 case EvqInvariantVaryingIn: return sw::Shader::PARAMETER_INPUT; // FIXME: Guarantee invariance at the backend
\r
2044 case EvqInvariantVaryingOut: return sw::Shader::PARAMETER_OUTPUT; // FIXME: Guarantee invariance at the backend
\r
2045 case EvqSmooth: return sw::Shader::PARAMETER_OUTPUT;
\r
2046 case EvqFlat: return sw::Shader::PARAMETER_OUTPUT;
\r
2047 case EvqCentroidOut: return sw::Shader::PARAMETER_OUTPUT;
\r
2048 case EvqSmoothIn: return sw::Shader::PARAMETER_INPUT;
\r
2049 case EvqFlatIn: return sw::Shader::PARAMETER_INPUT;
\r
2050 case EvqCentroidIn: return sw::Shader::PARAMETER_INPUT;
\r
2051 case EvqUniform: return sw::Shader::PARAMETER_CONST;
\r
2052 case EvqIn: return sw::Shader::PARAMETER_TEMP;
\r
2053 case EvqOut: return sw::Shader::PARAMETER_TEMP;
\r
2054 case EvqInOut: return sw::Shader::PARAMETER_TEMP;
\r
2055 case EvqConstReadOnly: return sw::Shader::PARAMETER_TEMP;
\r
2056 case EvqPosition: return sw::Shader::PARAMETER_OUTPUT;
\r
2057 case EvqPointSize: return sw::Shader::PARAMETER_OUTPUT;
\r
2058 case EvqInstanceID: return sw::Shader::PARAMETER_MISCTYPE;
\r
2059 case EvqFragCoord: return sw::Shader::PARAMETER_MISCTYPE;
\r
2060 case EvqFrontFacing: return sw::Shader::PARAMETER_MISCTYPE;
\r
2061 case EvqPointCoord: return sw::Shader::PARAMETER_INPUT;
\r
2062 case EvqFragColor: return sw::Shader::PARAMETER_COLOROUT;
\r
2063 case EvqFragData: return sw::Shader::PARAMETER_COLOROUT;
\r
2064 case EvqFragDepth: return sw::Shader::PARAMETER_DEPTHOUT;
\r
2065 default: UNREACHABLE(qualifier);
\r
2068 return sw::Shader::PARAMETER_VOID;
\r
2071 int OutputASM::registerIndex(TIntermTyped *operand)
\r
2073 if(isSamplerRegister(operand))
\r
2075 return samplerRegister(operand);
\r
2078 switch(operand->getQualifier())
\r
2080 case EvqTemporary: return temporaryRegister(operand);
\r
2081 case EvqGlobal: return temporaryRegister(operand);
\r
2082 case EvqConstExpr: UNREACHABLE(EvqConstExpr);
\r
2083 case EvqAttribute: return attributeRegister(operand);
\r
2084 case EvqVaryingIn: return varyingRegister(operand);
\r
2085 case EvqVaryingOut: return varyingRegister(operand);
\r
2086 case EvqVertexIn: return attributeRegister(operand);
\r
2087 case EvqFragmentOut: return 0;
\r
2088 case EvqVertexOut: return varyingRegister(operand);
\r
2089 case EvqFragmentIn: return varyingRegister(operand);
\r
2090 case EvqInvariantVaryingIn: return varyingRegister(operand);
\r
2091 case EvqInvariantVaryingOut: return varyingRegister(operand);
\r
2092 case EvqSmooth: return varyingRegister(operand);
\r
2093 case EvqFlat: return varyingRegister(operand);
\r
2094 case EvqCentroidOut: return varyingRegister(operand);
\r
2095 case EvqSmoothIn: return varyingRegister(operand);
\r
2096 case EvqFlatIn: return varyingRegister(operand);
\r
2097 case EvqCentroidIn: return varyingRegister(operand);
\r
2098 case EvqUniform: return uniformRegister(operand);
\r
2099 case EvqIn: return temporaryRegister(operand);
\r
2100 case EvqOut: return temporaryRegister(operand);
\r
2101 case EvqInOut: return temporaryRegister(operand);
\r
2102 case EvqConstReadOnly: return temporaryRegister(operand);
\r
2103 case EvqPosition: return varyingRegister(operand);
\r
2104 case EvqPointSize: return varyingRegister(operand);
\r
2105 case EvqInstanceID: vertexShader->instanceIdDeclared = true; return 0;
\r
2106 case EvqFragCoord: pixelShader->vPosDeclared = true; return 0;
\r
2107 case EvqFrontFacing: pixelShader->vFaceDeclared = true; return 1;
\r
2108 case EvqPointCoord: return varyingRegister(operand);
\r
2109 case EvqFragColor: return 0;
\r
2110 case EvqFragData: return 0;
\r
2111 case EvqFragDepth: return 0;
\r
2112 default: UNREACHABLE(operand->getQualifier());
\r
2118 int OutputASM::writeMask(TIntermTyped *destination, int index)
\r
2120 if(destination->getQualifier() == EvqPointSize)
\r
2122 return 0x2; // Point size stored in the y component
\r
2125 return 0xF >> (4 - registerSize(destination->getType(), index));
\r
2128 int OutputASM::readSwizzle(TIntermTyped *argument, int size)
\r
2130 if(argument->getQualifier() == EvqPointSize)
\r
2132 return 0x55; // Point size stored in the y component
\r
2135 static const unsigned char swizzleSize[5] = {0x00, 0x00, 0x54, 0xA4, 0xE4}; // (void), xxxx, xyyy, xyzz, xyzw
\r
2137 return swizzleSize[size];
\r
2140 // Conservatively checks whether an expression is fast to compute and has no side effects
\r
2141 bool OutputASM::trivial(TIntermTyped *expression, int budget)
\r
2143 if(!expression->isRegister())
\r
2148 return cost(expression, budget) >= 0;
\r
2151 // Returns the remaining computing budget (if < 0 the expression is too expensive or has side effects)
\r
2152 int OutputASM::cost(TIntermNode *expression, int budget)
\r
2159 if(expression->getAsSymbolNode())
\r
2163 else if(expression->getAsConstantUnion())
\r
2167 else if(expression->getAsBinaryNode())
\r
2169 TIntermBinary *binary = expression->getAsBinaryNode();
\r
2171 switch(binary->getOp())
\r
2173 case EOpVectorSwizzle:
\r
2174 case EOpIndexDirect:
\r
2175 case EOpIndexDirectStruct:
\r
2176 case EOpIndexDirectInterfaceBlock:
\r
2177 return cost(binary->getLeft(), budget - 0);
\r
2181 return cost(binary->getLeft(), cost(binary->getRight(), budget - 1));
\r
2186 else if(expression->getAsUnaryNode())
\r
2188 TIntermUnary *unary = expression->getAsUnaryNode();
\r
2190 switch(unary->getOp())
\r
2194 return cost(unary->getOperand(), budget - 1);
\r
2199 else if(expression->getAsSelectionNode())
\r
2201 TIntermSelection *selection = expression->getAsSelectionNode();
\r
2203 if(selection->usesTernaryOperator())
\r
2205 TIntermTyped *condition = selection->getCondition();
\r
2206 TIntermNode *trueBlock = selection->getTrueBlock();
\r
2207 TIntermNode *falseBlock = selection->getFalseBlock();
\r
2208 TIntermConstantUnion *constantCondition = condition->getAsConstantUnion();
\r
2210 if(constantCondition)
\r
2212 bool trueCondition = constantCondition->getUnionArrayPointer()->getBConst();
\r
2216 return cost(trueBlock, budget - 0);
\r
2220 return cost(falseBlock, budget - 0);
\r
2225 return cost(trueBlock, cost(falseBlock, budget - 2));
\r
2233 const Function *OutputASM::findFunction(const TString &name)
\r
2235 for(unsigned int f = 0; f < functionArray.size(); f++)
\r
2237 if(functionArray[f].name == name)
\r
2239 return &functionArray[f];
\r
2246 int OutputASM::temporaryRegister(TIntermTyped *temporary)
\r
2248 return allocate(temporaries, temporary);
\r
2251 int OutputASM::varyingRegister(TIntermTyped *varying)
\r
2253 int var = lookup(varyings, varying);
\r
2257 var = allocate(varyings, varying);
\r
2258 int componentCount = varying->registerSize();
\r
2259 int registerCount = varying->totalRegisterCount();
\r
2263 if((var + registerCount) > sw::PixelShader::MAX_INPUT_VARYINGS)
\r
2265 mContext.error(varying->getLine(), "Varyings packing failed: Too many varyings", "fragment shader");
\r
2269 if(varying->getQualifier() == EvqPointCoord)
\r
2271 ASSERT(varying->isRegister());
\r
2272 if(componentCount >= 1) pixelShader->semantic[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
\r
2273 if(componentCount >= 2) pixelShader->semantic[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
\r
2274 if(componentCount >= 3) pixelShader->semantic[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
\r
2275 if(componentCount >= 4) pixelShader->semantic[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, var);
\r
2279 for(int i = 0; i < varying->totalRegisterCount(); i++)
\r
2281 if(componentCount >= 1) pixelShader->semantic[var + i][0] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
\r
2282 if(componentCount >= 2) pixelShader->semantic[var + i][1] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
\r
2283 if(componentCount >= 3) pixelShader->semantic[var + i][2] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
\r
2284 if(componentCount >= 4) pixelShader->semantic[var + i][3] = sw::Shader::Semantic(sw::Shader::USAGE_COLOR, var + i);
\r
2288 else if(vertexShader)
\r
2290 if((var + registerCount) > sw::VertexShader::MAX_OUTPUT_VARYINGS)
\r
2292 mContext.error(varying->getLine(), "Varyings packing failed: Too many varyings", "vertex shader");
\r
2296 if(varying->getQualifier() == EvqPosition)
\r
2298 ASSERT(varying->isRegister());
\r
2299 vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
\r
2300 vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
\r
2301 vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
\r
2302 vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0);
\r
2303 vertexShader->positionRegister = var;
\r
2305 else if(varying->getQualifier() == EvqPointSize)
\r
2307 ASSERT(varying->isRegister());
\r
2308 vertexShader->output[var][0] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
\r
2309 vertexShader->output[var][1] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
\r
2310 vertexShader->output[var][2] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
\r
2311 vertexShader->output[var][3] = sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0);
\r
2312 vertexShader->pointSizeRegister = var;
\r
2316 // Semantic indexes for user varyings will be assigned during program link to match the pixel shader
\r
2319 else UNREACHABLE(0);
\r
2321 declareVarying(varying, var);
\r
2327 void OutputASM::declareVarying(TIntermTyped *varying, int reg)
\r
2329 if(varying->getQualifier() != EvqPointCoord) // gl_PointCoord does not need linking
\r
2331 const TType &type = varying->getType();
\r
2332 const char *name = varying->getAsSymbolNode()->getSymbol().c_str();
\r
2333 VaryingList &activeVaryings = shaderObject->varyings;
\r
2335 // Check if this varying has been declared before without having a register assigned
\r
2336 for(VaryingList::iterator v = activeVaryings.begin(); v != activeVaryings.end(); v++)
\r
2338 if(v->name == name)
\r
2342 ASSERT(v->reg < 0 || v->reg == reg);
\r
2350 activeVaryings.push_back(glsl::Varying(glVariableType(type), name, varying->getArraySize(), reg, 0));
\r
2354 int OutputASM::uniformRegister(TIntermTyped *uniform)
\r
2356 const TType &type = uniform->getType();
\r
2357 ASSERT(!IsSampler(type.getBasicType()));
\r
2358 TInterfaceBlock *block = type.getAsInterfaceBlock();
\r
2359 TIntermSymbol *symbol = uniform->getAsSymbolNode();
\r
2360 ASSERT(symbol || block);
\r
2362 if(symbol || block)
\r
2364 int index = lookup(uniforms, uniform);
\r
2368 index = allocate(uniforms, uniform);
\r
2369 const TString &name = symbol ? symbol->getSymbol() : block->name();
\r
2371 declareUniform(type, name, index);
\r
2380 int OutputASM::attributeRegister(TIntermTyped *attribute)
\r
2382 ASSERT(!attribute->isArray());
\r
2384 int index = lookup(attributes, attribute);
\r
2388 TIntermSymbol *symbol = attribute->getAsSymbolNode();
\r
2393 index = allocate(attributes, attribute);
\r
2394 const TType &type = attribute->getType();
\r
2395 int registerCount = attribute->totalRegisterCount();
\r
2397 if(vertexShader && (index + registerCount) <= sw::VertexShader::MAX_INPUT_ATTRIBUTES)
\r
2399 for(int i = 0; i < registerCount; i++)
\r
2401 vertexShader->input[index + i] = sw::Shader::Semantic(sw::Shader::USAGE_TEXCOORD, index + i);
\r
2405 ActiveAttributes &activeAttributes = shaderObject->activeAttributes;
\r
2407 const char *name = symbol->getSymbol().c_str();
\r
2408 activeAttributes.push_back(Attribute(glVariableType(type), name, type.getArraySize(), type.getLayoutQualifier().location, index));
\r
2415 int OutputASM::samplerRegister(TIntermTyped *sampler)
\r
2417 ASSERT(IsSampler(sampler->getType().getBasicType()));
\r
2418 TIntermSymbol *symbol = sampler->getAsSymbolNode();
\r
2419 TIntermBinary *binary = sampler->getAsBinaryNode();
\r
2423 return samplerRegister(symbol);
\r
2427 ASSERT(binary->getOp() == EOpIndexDirect || binary->getOp() == EOpIndexIndirect ||
\r
2428 binary->getOp() == EOpIndexDirectStruct || binary->getOp() == EOpIndexDirectInterfaceBlock);
\r
2430 return samplerRegister(binary->getLeft()); // Index added later
\r
2432 else UNREACHABLE(0);
\r
2437 int OutputASM::samplerRegister(TIntermSymbol *sampler)
\r
2439 const TType &type = sampler->getType();
\r
2440 ASSERT(IsSampler(type.getBasicType()) || type.getStruct()); // Structures can contain samplers
\r
2442 int index = lookup(samplers, sampler);
\r
2446 index = allocate(samplers, sampler);
\r
2448 if(sampler->getQualifier() == EvqUniform)
\r
2450 const char *name = sampler->getSymbol().c_str();
\r
2451 declareUniform(type, name, index);
\r
2458 int OutputASM::lookup(VariableArray &list, TIntermTyped *variable)
\r
2460 for(unsigned int i = 0; i < list.size(); i++)
\r
2462 if(list[i] == variable)
\r
2464 return i; // Pointer match
\r
2468 TIntermSymbol *varSymbol = variable->getAsSymbolNode();
\r
2469 TInterfaceBlock *varBlock = variable->getType().getAsInterfaceBlock();
\r
2473 for(unsigned int i = 0; i < list.size(); i++)
\r
2477 TIntermSymbol *listSymbol = list[i]->getAsSymbolNode();
\r
2481 if(listSymbol->getId() == varSymbol->getId())
\r
2483 ASSERT(listSymbol->getSymbol() == varSymbol->getSymbol());
\r
2484 ASSERT(listSymbol->getType() == varSymbol->getType());
\r
2485 ASSERT(listSymbol->getQualifier() == varSymbol->getQualifier());
\r
2495 for(unsigned int i = 0; i < list.size(); i++)
\r
2499 TInterfaceBlock *listBlock = list[i]->getType().getAsInterfaceBlock();
\r
2503 if(listBlock->name() == varBlock->name())
\r
2505 ASSERT(listBlock->arraySize() == varBlock->arraySize());
\r
2506 ASSERT(listBlock->fields() == varBlock->fields());
\r
2507 ASSERT(listBlock->blockStorage() == varBlock->blockStorage());
\r
2508 ASSERT(listBlock->matrixPacking() == varBlock->matrixPacking());
\r
2520 int OutputASM::allocate(VariableArray &list, TIntermTyped *variable)
\r
2522 int index = lookup(list, variable);
\r
2526 unsigned int registerCount = variable->totalRegisterCount();
\r
2528 for(unsigned int i = 0; i < list.size(); i++)
\r
2532 unsigned int j = 1;
\r
2533 for( ; j < registerCount && (i + j) < list.size(); j++)
\r
2535 if(list[i + j] != 0)
\r
2541 if(j == registerCount) // Found free slots
\r
2543 for(unsigned int j = 0; j < registerCount; j++)
\r
2545 list[i + j] = variable;
\r
2553 index = list.size();
\r
2555 for(unsigned int i = 0; i < registerCount; i++)
\r
2557 list.push_back(variable);
\r
2564 void OutputASM::free(VariableArray &list, TIntermTyped *variable)
\r
2566 int index = lookup(list, variable);
\r
2574 void OutputASM::declareUniform(const TType &type, const TString &name, int registerIndex, int offset, int blockId)
\r
2576 const TStructure *structure = type.getStruct();
\r
2577 const TInterfaceBlock *block = (type.isInterfaceBlock() || (blockId == -1)) ? type.getInterfaceBlock() : nullptr;
\r
2578 ActiveUniforms &activeUniforms = shaderObject->activeUniforms;
\r
2582 ActiveUniformBlocks &activeUniformBlocks = shaderObject->activeUniformBlocks;
\r
2583 blockId = activeUniformBlocks.size();
\r
2584 unsigned int dataSize = block->objectSize() * 4; // FIXME: assuming 4 bytes per element
\r
2585 activeUniformBlocks.push_back(UniformBlock(block->name().c_str(), block->hasInstanceName() ? block->instanceName().c_str() : std::string(), dataSize,
\r
2586 block->arraySize(), block->blockStorage(), block->matrixPacking() == EmpRowMajor, registerIndex, blockId));
\r
2589 if(!structure && !block)
\r
2593 shaderObject->activeUniformBlocks[blockId].fields.push_back(activeUniforms.size());
\r
2595 activeUniforms.push_back(Uniform(glVariableType(type), glVariablePrecision(type), name.c_str(), type.getArraySize(), registerIndex, offset, blockId));
\r
2597 if(isSamplerRegister(type))
\r
2599 for(int i = 0; i < type.totalRegisterCount(); i++)
\r
2601 shader->declareSampler(registerIndex + i);
\r
2607 const TFieldList& fields = structure ? structure->fields() : block->fields();
\r
2608 const bool containerHasName = structure || block->hasInstanceName();
\r
2609 const TString &containerName = structure ? name : (containerHasName ? block->instanceName() : TString());
\r
2610 if(type.isArray() && (structure || type.isInterfaceBlock()))
\r
2612 int fieldRegisterIndex = (blockId == -1) ? registerIndex : 0;
\r
2613 int fieldOffset = 0;
\r
2615 for(int i = 0; i < type.getArraySize(); i++)
\r
2617 for(size_t j = 0; j < fields.size(); j++)
\r
2619 const TType &fieldType = *(fields[j]->type());
\r
2620 const TString &fieldName = fields[j]->name();
\r
2622 const TString uniformName = containerHasName ? containerName + "[" + str(i) + "]." + fieldName : fieldName;
\r
2623 declareUniform(fieldType, uniformName, fieldRegisterIndex, fieldOffset, blockId);
\r
2624 int registerCount = fieldType.totalRegisterCount();
\r
2625 fieldRegisterIndex += registerCount;
\r
2626 fieldOffset += registerCount * fieldType.registerSize();
\r
2632 int fieldRegisterIndex = (blockId == -1) ? registerIndex : 0;
\r
2633 int fieldOffset = 0;
\r
2635 for(size_t i = 0; i < fields.size(); i++)
\r
2637 const TType &fieldType = *(fields[i]->type());
\r
2638 const TString &fieldName = fields[i]->name();
\r
2640 const TString uniformName = containerHasName ? containerName + "." + fieldName : fieldName;
\r
2641 declareUniform(fieldType, uniformName, fieldRegisterIndex, fieldOffset, blockId);
\r
2642 int registerCount = fieldType.totalRegisterCount();
\r
2643 fieldRegisterIndex += registerCount;
\r
2644 fieldOffset += registerCount * fieldType.registerSize();
\r
2650 GLenum OutputASM::glVariableType(const TType &type)
\r
2652 switch(type.getBasicType())
\r
2655 if(type.isScalar())
\r
2659 else if(type.isVector())
\r
2661 switch(type.getNominalSize())
\r
2663 case 2: return GL_FLOAT_VEC2;
\r
2664 case 3: return GL_FLOAT_VEC3;
\r
2665 case 4: return GL_FLOAT_VEC4;
\r
2666 default: UNREACHABLE(type.getNominalSize());
\r
2669 else if(type.isMatrix())
\r
2671 switch(type.getNominalSize())
\r
2674 switch(type.getSecondarySize())
\r
2676 case 2: return GL_FLOAT_MAT2;
\r
2677 case 3: return GL_FLOAT_MAT2x3;
\r
2678 case 4: return GL_FLOAT_MAT2x4;
\r
2679 default: UNREACHABLE(type.getSecondarySize());
\r
2682 switch(type.getSecondarySize())
\r
2684 case 2: return GL_FLOAT_MAT3x2;
\r
2685 case 3: return GL_FLOAT_MAT3;
\r
2686 case 4: return GL_FLOAT_MAT3x4;
\r
2687 default: UNREACHABLE(type.getSecondarySize());
\r
2690 switch(type.getSecondarySize())
\r
2692 case 2: return GL_FLOAT_MAT4x2;
\r
2693 case 3: return GL_FLOAT_MAT4x3;
\r
2694 case 4: return GL_FLOAT_MAT4;
\r
2695 default: UNREACHABLE(type.getSecondarySize());
\r
2697 default: UNREACHABLE(type.getNominalSize());
\r
2700 else UNREACHABLE(0);
\r
2703 if(type.isScalar())
\r
2707 else if(type.isVector())
\r
2709 switch(type.getNominalSize())
\r
2711 case 2: return GL_INT_VEC2;
\r
2712 case 3: return GL_INT_VEC3;
\r
2713 case 4: return GL_INT_VEC4;
\r
2714 default: UNREACHABLE(type.getNominalSize());
\r
2717 else UNREACHABLE(0);
\r
2720 if(type.isScalar())
\r
2722 return GL_UNSIGNED_INT;
\r
2724 else if(type.isVector())
\r
2726 switch(type.getNominalSize())
\r
2728 case 2: return GL_UNSIGNED_INT_VEC2;
\r
2729 case 3: return GL_UNSIGNED_INT_VEC3;
\r
2730 case 4: return GL_UNSIGNED_INT_VEC4;
\r
2731 default: UNREACHABLE(type.getNominalSize());
\r
2734 else UNREACHABLE(0);
\r
2737 if(type.isScalar())
\r
2741 else if(type.isVector())
\r
2743 switch(type.getNominalSize())
\r
2745 case 2: return GL_BOOL_VEC2;
\r
2746 case 3: return GL_BOOL_VEC3;
\r
2747 case 4: return GL_BOOL_VEC4;
\r
2748 default: UNREACHABLE(type.getNominalSize());
\r
2751 else UNREACHABLE(0);
\r
2753 case EbtSampler2D:
\r
2754 return GL_SAMPLER_2D;
\r
2755 case EbtISampler2D:
\r
2756 return GL_INT_SAMPLER_2D;
\r
2757 case EbtUSampler2D:
\r
2758 return GL_UNSIGNED_INT_SAMPLER_2D;
\r
2759 case EbtSamplerCube:
\r
2760 return GL_SAMPLER_CUBE;
\r
2761 case EbtISamplerCube:
\r
2762 return GL_INT_SAMPLER_CUBE;
\r
2763 case EbtUSamplerCube:
\r
2764 return GL_UNSIGNED_INT_SAMPLER_CUBE;
\r
2765 case EbtSamplerExternalOES:
\r
2766 return GL_SAMPLER_EXTERNAL_OES;
\r
2767 case EbtSampler3D:
\r
2768 return GL_SAMPLER_3D_OES;
\r
2769 case EbtISampler3D:
\r
2770 return GL_INT_SAMPLER_3D;
\r
2771 case EbtUSampler3D:
\r
2772 return GL_UNSIGNED_INT_SAMPLER_3D;
\r
2773 case EbtSampler2DArray:
\r
2774 return GL_SAMPLER_2D_ARRAY;
\r
2775 case EbtISampler2DArray:
\r
2776 return GL_INT_SAMPLER_2D_ARRAY;
\r
2777 case EbtUSampler2DArray:
\r
2778 return GL_UNSIGNED_INT_SAMPLER_2D_ARRAY;
\r
2779 case EbtSampler2DShadow:
\r
2780 return GL_SAMPLER_2D_SHADOW;
\r
2781 case EbtSamplerCubeShadow:
\r
2782 return GL_SAMPLER_CUBE_SHADOW;
\r
2783 case EbtSampler2DArrayShadow:
\r
2784 return GL_SAMPLER_2D_ARRAY_SHADOW;
\r
2786 UNREACHABLE(type.getBasicType());
\r
2793 GLenum OutputASM::glVariablePrecision(const TType &type)
\r
2795 if(type.getBasicType() == EbtFloat)
\r
2797 switch(type.getPrecision())
\r
2799 case EbpHigh: return GL_HIGH_FLOAT;
\r
2800 case EbpMedium: return GL_MEDIUM_FLOAT;
\r
2801 case EbpLow: return GL_LOW_FLOAT;
\r
2802 case EbpUndefined:
\r
2803 // Should be defined as the default precision by the parser
\r
2804 default: UNREACHABLE(type.getPrecision());
\r
2807 else if(type.getBasicType() == EbtInt)
\r
2809 switch(type.getPrecision())
\r
2811 case EbpHigh: return GL_HIGH_INT;
\r
2812 case EbpMedium: return GL_MEDIUM_INT;
\r
2813 case EbpLow: return GL_LOW_INT;
\r
2814 case EbpUndefined:
\r
2815 // Should be defined as the default precision by the parser
\r
2816 default: UNREACHABLE(type.getPrecision());
\r
2820 // Other types (boolean, sampler) don't have a precision
\r
2824 int OutputASM::dim(TIntermNode *v)
\r
2826 TIntermTyped *vector = v->getAsTyped();
\r
2827 ASSERT(vector && vector->isRegister());
\r
2828 return vector->getNominalSize();
\r
2831 int OutputASM::dim2(TIntermNode *m)
\r
2833 TIntermTyped *matrix = m->getAsTyped();
\r
2834 ASSERT(matrix && matrix->isMatrix() && !matrix->isArray());
\r
2835 return matrix->getSecondarySize();
\r
2838 // Returns ~0 if no loop count could be determined
\r
2839 unsigned int OutputASM::loopCount(TIntermLoop *node)
\r
2841 // Parse loops of the form:
\r
2842 // for(int index = initial; index [comparator] limit; index += increment)
\r
2843 TIntermSymbol *index = 0;
\r
2844 TOperator comparator = EOpNull;
\r
2847 int increment = 0;
\r
2849 // Parse index name and intial value
\r
2850 if(node->getInit())
\r
2852 TIntermAggregate *init = node->getInit()->getAsAggregate();
\r
2856 TIntermSequence &sequence = init->getSequence();
\r
2857 TIntermTyped *variable = sequence[0]->getAsTyped();
\r
2859 if(variable && variable->getQualifier() == EvqTemporary)
\r
2861 TIntermBinary *assign = variable->getAsBinaryNode();
\r
2863 if(assign->getOp() == EOpInitialize)
\r
2865 TIntermSymbol *symbol = assign->getLeft()->getAsSymbolNode();
\r
2866 TIntermConstantUnion *constant = assign->getRight()->getAsConstantUnion();
\r
2868 if(symbol && constant)
\r
2870 if(constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)
\r
2873 initial = constant->getUnionArrayPointer()[0].getIConst();
\r
2881 // Parse comparator and limit value
\r
2882 if(index && node->getCondition())
\r
2884 TIntermBinary *test = node->getCondition()->getAsBinaryNode();
\r
2886 if(test && test->getLeft()->getAsSymbolNode()->getId() == index->getId())
\r
2888 TIntermConstantUnion *constant = test->getRight()->getAsConstantUnion();
\r
2892 if(constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)
\r
2894 comparator = test->getOp();
\r
2895 limit = constant->getUnionArrayPointer()[0].getIConst();
\r
2901 // Parse increment
\r
2902 if(index && comparator != EOpNull && node->getExpression())
\r
2904 TIntermBinary *binaryTerminal = node->getExpression()->getAsBinaryNode();
\r
2905 TIntermUnary *unaryTerminal = node->getExpression()->getAsUnaryNode();
\r
2907 if(binaryTerminal)
\r
2909 TOperator op = binaryTerminal->getOp();
\r
2910 TIntermConstantUnion *constant = binaryTerminal->getRight()->getAsConstantUnion();
\r
2914 if(constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)
\r
2916 int value = constant->getUnionArrayPointer()[0].getIConst();
\r
2920 case EOpAddAssign: increment = value; break;
\r
2921 case EOpSubAssign: increment = -value; break;
\r
2922 default: UNIMPLEMENTED();
\r
2927 else if(unaryTerminal)
\r
2929 TOperator op = unaryTerminal->getOp();
\r
2933 case EOpPostIncrement: increment = 1; break;
\r
2934 case EOpPostDecrement: increment = -1; break;
\r
2935 case EOpPreIncrement: increment = 1; break;
\r
2936 case EOpPreDecrement: increment = -1; break;
\r
2937 default: UNIMPLEMENTED();
\r
2942 if(index && comparator != EOpNull && increment != 0)
\r
2944 if(comparator == EOpLessThanEqual)
\r
2946 comparator = EOpLessThan;
\r
2950 if(comparator == EOpLessThan)
\r
2952 int iterations = (limit - initial) / increment;
\r
2954 if(iterations <= 0)
\r
2959 return iterations;
\r
2961 else UNIMPLEMENTED(); // Falls through
\r
2967 bool DetectLoopDiscontinuity::traverse(TIntermNode *node)
\r
2970 loopDiscontinuity = false;
\r
2972 node->traverse(this);
\r
2974 return loopDiscontinuity;
\r
2977 bool DetectLoopDiscontinuity::visitLoop(Visit visit, TIntermLoop *loop)
\r
2979 if(visit == PreVisit)
\r
2983 else if(visit == PostVisit)
\r
2991 bool DetectLoopDiscontinuity::visitBranch(Visit visit, TIntermBranch *node)
\r
2993 if(loopDiscontinuity)
\r
3003 switch(node->getFlowOp())
\r
3010 loopDiscontinuity = true;
\r
3012 default: UNREACHABLE(node->getFlowOp());
\r
3015 return !loopDiscontinuity;
\r
3018 bool DetectLoopDiscontinuity::visitAggregate(Visit visit, TIntermAggregate *node)
\r
3020 return !loopDiscontinuity;
\r
OSDN Git Service
