{\r
for(int i = 0; i < leftType.getNominalSize(); i++)\r
{\r
- Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
- mul->dst.index += i;\r
- argument(mul->src[0], left, i);\r
+ emit(sw::Shader::OPCODE_MUL, result, i, left, i, right);\r
}\r
\r
assignLvalue(left, result);\r
\r
for(int i = 0; i < size; i++)\r
{\r
- Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, left, right);\r
+ Instruction *dot = emit(sw::Shader::OPCODE_DP(size), result, 0, left, 0, right, i);\r
dot->dst.mask = 1 << i;\r
- argument(dot->src[1], right, i);\r
}\r
\r
assignLvalue(left, result);\r
\r
for(int i = 0; i < dim; i++)\r
{\r
- Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
- mul->dst.index += i;\r
- argument(mul->src[1], right, i);\r
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, i, left, 0, right, i);\r
mul->src[1].swizzle = 0x00;\r
\r
for(int j = 1; j < dim; j++)\r
{\r
- Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);\r
- mad->dst.index += i;\r
- argument(mad->src[0], left, j);\r
- argument(mad->src[1], right, i);\r
+ Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, i, left, j, right, i, result, i);\r
mad->src[1].swizzle = j * 0x55;\r
- argument(mad->src[2], result, i);\r
}\r
}\r
\r
}\r
else if(result->isRegister())\r
{\r
- Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);\r
-\r
+ int srcIndex = 0;\r
if(left->isRegister())\r
{\r
- mov->src[0].swizzle = index;\r
+ srcIndex = 0;\r
}\r
else if(left->isArray())\r
{\r
- argument(mov->src[0], left, index * left->elementRegisterCount());\r
+ srcIndex = index * left->elementRegisterCount();\r
}\r
else if(left->isMatrix())\r
{\r
ASSERT(index < left->getNominalSize()); // FIXME: Report semantic error\r
- argument(mov->src[0], left, index);\r
+ srcIndex = index;\r
}\r
else UNREACHABLE(0);\r
+\r
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, 0, left, srcIndex);\r
+\r
+ if(left->isRegister())\r
+ {\r
+ mov->src[0].swizzle = index;\r
+ }\r
}\r
else UNREACHABLE(0);\r
}\r
{\r
for(int index = 0; index < result->totalRegisterCount(); index++)\r
{\r
- Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, left);\r
- mov->dst.index += index;\r
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, index, left, index);\r
mov->dst.mask = writeMask(result, index);\r
- argument(mov->src[0], left, index);\r
\r
if(left->totalRegisterCount() > 1)\r
{\r
for(int index = 1; index < left->totalRegisterCount(); index++)\r
{\r
Temporary equal(this);\r
- Instruction *eq = emit(sw::Shader::OPCODE_EQ, &equal, left, right);\r
- argument(eq->src[0], left, index);\r
- argument(eq->src[1], right, index);\r
+ emit(sw::Shader::OPCODE_EQ, &equal, 0, left, index, right, index);\r
emit(sw::Shader::OPCODE_AND, result, result, &equal);\r
}\r
}\r
for(int index = 1; index < left->totalRegisterCount(); index++)\r
{\r
Temporary notEqual(this);\r
- Instruction *eq = emit(sw::Shader::OPCODE_NE, ¬Equal, left, right);\r
- argument(eq->src[0], left, index);\r
- argument(eq->src[1], right, index);\r
+ emit(sw::Shader::OPCODE_NE, ¬Equal, 0, left, index, right, index);\r
emit(sw::Shader::OPCODE_OR, result, result, ¬Equal);\r
}\r
}\r
{\r
for(int i = 0; i < leftType.getNominalSize(); i++)\r
{\r
- Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
- mul->dst.index += i;\r
- argument(mul->src[0], left, i);\r
+ emit(sw::Shader::OPCODE_MUL, result, i, left, i, right);\r
}\r
}\r
break;\r
int size = rightType.getNominalSize();\r
for(int i = 0; i < size; i++)\r
{\r
- Instruction *dot = emit(dpOpcode, result, left, right);\r
+ Instruction *dot = emit(dpOpcode, result, 0, left, 0, right, i);\r
dot->dst.mask = 1 << i;\r
- argument(dot->src[1], right, i);\r
}\r
}\r
break;\r
int size = rightType.getNominalSize();\r
for(int i = 1; i < size; i++)\r
{\r
- Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);\r
- argument(mad->src[0], left, i);\r
+ Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, 0, left, i, right, 0, result);\r
mad->src[1].swizzle = i * 0x55;\r
}\r
}\r
int size = rightType.getNominalSize();\r
for(int i = 0; i < size; i++)\r
{\r
- Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, left, right);\r
- mul->dst.index += i;\r
- argument(mul->src[1], right, i);\r
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, i, left, 0, right, i);\r
mul->src[1].swizzle = 0x00;\r
\r
for(int j = 1; j < dim; j++)\r
{\r
- Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, left, right, result);\r
- mad->dst.index += i;\r
- argument(mad->src[0], left, j);\r
- argument(mad->src[1], right, i);\r
+ Instruction *mad = emit(sw::Shader::OPCODE_MAD, result, i, left, j, right, i, result, i);\r
mad->src[1].swizzle = j * 0x55;\r
- argument(mad->src[2], result, i);\r
}\r
}\r
}\r
// For a 2x2 matrix, the cofactor is simply a transposed move or negate\r
bool isMov = (row == col);\r
sw::Shader::Opcode op = isMov ? sw::Shader::OPCODE_MOV : sw::Shader::OPCODE_NEG;\r
- Instruction *mov = emit(op, result, arg);\r
- mov->src[0].index += isMov ? 1 - row : row;\r
+ Instruction *mov = emit(op, result, outCol, arg, isMov ? 1 - row : row);\r
mov->src[0].swizzle = 0x55 * (isMov ? 1 - col : col);\r
- mov->dst.index += outCol;\r
mov->dst.mask = 1 << outRow;\r
}\r
break;\r
int col1 = (isCofactor && (col <= 1)) ? 2 : 1;\r
bool negate = isCofactor && ((col & 0x01) ^ (row & 0x01));\r
\r
- Instruction *det = emit(sw::Shader::OPCODE_DET2, result, arg, arg);\r
- det->src[0].index += negate ? col1 : col0;\r
- det->src[1].index += negate ? col0 : col1;\r
+ Instruction *det = emit(sw::Shader::OPCODE_DET2, result, outCol, arg, negate ? col1 : col0, arg, negate ? col0 : col1);\r
det->src[0].swizzle = det->src[1].swizzle = swizzle[isCofactor ? row : 2];\r
- det->dst.index += outCol;\r
det->dst.mask = 1 << outRow;\r
}\r
break;\r
int col2 = (isCofactor && (col <= 2)) ? 3 : 2;\r
bool negate = isCofactor && ((col & 0x01) ^ (row & 0x01));\r
\r
- Instruction *det = emit(sw::Shader::OPCODE_DET3, result, arg, arg, arg);\r
- det->src[0].index += col0;\r
- det->src[1].index += negate ? col2 : col1;\r
- det->src[2].index += negate ? col1 : col2;\r
+ Instruction *det = emit(sw::Shader::OPCODE_DET3, result, outCol, arg, col0, arg, negate ? col2 : col1, arg, negate ? col1 : col2);\r
det->src[0].swizzle = det->src[1].swizzle = det->src[2].swizzle = swizzle[isCofactor ? row : 3];\r
- det->dst.index += outCol;\r
det->dst.mask = 1 << outRow;\r
}\r
break;\r
case 4:\r
{\r
- Instruction *det = emit(sw::Shader::OPCODE_DET4, result, arg, arg, arg, arg);\r
- det->src[1].index += 1;\r
- det->src[2].index += 2;\r
- det->src[3].index += 3;\r
- det->dst.index += outCol;\r
+ Instruction *det = emit(sw::Shader::OPCODE_DET4, result, outCol, arg, 0, arg, 1, arg, 2, arg, 3);\r
det->dst.mask = 1 << outRow;\r
}\r
break;\r
sw::Shader::Opcode negOpcode = getOpcode(sw::Shader::OPCODE_NEG, arg);\r
for(int index = 0; index < arg->totalRegisterCount(); index++)\r
{\r
- Instruction *neg = emit(negOpcode, result, arg);\r
- neg->dst.index += index;\r
- argument(neg->src[0], arg, index);\r
+ emit(negOpcode, result, index, arg, index);\r
}\r
}\r
break;\r
sw::Shader::Opcode addOpcode = getOpcode(sw::Shader::OPCODE_ADD, arg);\r
for(int index = 0; index < arg->totalRegisterCount(); index++)\r
{\r
- Instruction *add = emit(addOpcode, arg, arg, &one);\r
- add->dst.index += index;\r
- argument(add->src[0], arg, index);\r
+ emit(addOpcode, arg, index, arg, index, &one);\r
}\r
\r
assignLvalue(arg, arg);\r
sw::Shader::Opcode subOpcode = getOpcode(sw::Shader::OPCODE_SUB, arg);\r
for(int index = 0; index < arg->totalRegisterCount(); index++)\r
{\r
- Instruction *sub = emit(subOpcode, arg, arg, &one);\r
- sub->dst.index += index;\r
- argument(sub->src[0], arg, index);\r
+ emit(subOpcode, arg, index, arg, index, &one);\r
}\r
\r
assignLvalue(arg, arg);\r
sw::Shader::Opcode addOpcode = getOpcode(sw::Shader::OPCODE_ADD, arg);\r
for(int index = 0; index < arg->totalRegisterCount(); index++)\r
{\r
- Instruction *add = emit(addOpcode, result, arg, &one);\r
- add->dst.index += index;\r
- argument(add->src[0], arg, index);\r
+ emit(addOpcode, result, index, arg, index, &one);\r
}\r
\r
assignLvalue(arg, result);\r
sw::Shader::Opcode subOpcode = getOpcode(sw::Shader::OPCODE_SUB, arg);\r
for(int index = 0; index < arg->totalRegisterCount(); index++)\r
{\r
- Instruction *sub = emit(subOpcode, result, arg, &one);\r
- sub->dst.index += index;\r
- argument(sub->src[0], arg, index);\r
+ emit(subOpcode, result, index, arg, index, &one);\r
}\r
\r
assignLvalue(arg, result);\r
{\r
for(int j = 0; j < numRows; ++j)\r
{\r
- Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, arg);\r
- mov->src[0].index += i;\r
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, j, arg, i);\r
mov->src[0].swizzle = 0x55 * j;\r
- mov->dst.index += j;\r
mov->dst.mask = 1 << i;\r
}\r
}\r
// Divide transposed matrix of cofactors by determinant\r
for(int i = 0; i < size; ++i)\r
{\r
- Instruction *div = emit(sw::Shader::OPCODE_MUL, result, result, &invDet);\r
- div->src[0].index += i;\r
- div->dst.index += i;\r
+ emit(sw::Shader::OPCODE_MUL, result, i, result, i, &invDet);\r
}\r
}\r
break;\r
\r
while(component < resultType.getNominalSize())\r
{\r
- Instruction *mov = emitCast(result, argi);\r
+ Instruction *mov = emitCast(result, 0, argi, column);\r
mov->dst.mask = (0xF << component) & 0xF;\r
- mov->src[0].index += column;\r
mov->src[0].swizzle = readSwizzle(argi, size) << (component * 2);\r
\r
column++;\r
{\r
for(int i = 0; i < outCols; i++)\r
{\r
- Instruction *init = emit(sw::Shader::OPCODE_MOV, result, &zero);\r
- init->dst.index += i;\r
- Instruction *mov = emitCast(result, arg0);\r
- mov->dst.index += i;\r
+ Instruction *init = emit(sw::Shader::OPCODE_MOV, result, i, &zero);\r
+ Instruction *mov = emitCast(result, i, arg0, 0);\r
mov->dst.mask = 1 << i;\r
ASSERT(mov->src[0].swizzle == 0x00);\r
}\r
{\r
// Initialize to identity matrix\r
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
- Instruction *mov = emitCast(result, &col);\r
- mov->dst.index += i;\r
+ Instruction *mov = emitCast(result, i, &col, 0);\r
}\r
\r
if(i < inCols)\r
{\r
- Instruction *mov = emitCast(result, arg0);\r
- mov->dst.index += i;\r
+ Instruction *mov = emitCast(result, i, arg0, i);\r
mov->dst.mask = 0xF >> (4 - inRows);\r
- argument(mov->src[0], arg0, i);\r
}\r
}\r
}\r
\r
while(element < size)\r
{\r
- Instruction *mov = emitCast(result, argi);\r
- mov->dst.index += column;\r
+ Instruction *mov = emitCast(result, column, argi, 0);\r
mov->dst.mask = (0xF << row) & 0xF;\r
mov->src[0].swizzle = (readSwizzle(argi, size) << (row * 2)) + 0x55 * element;\r
\r
\r
for(int index = 0; index < size; index++)\r
{\r
- Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, argi);\r
- mov->dst.index += index + offset;\r
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, result, index + offset, argi, index);\r
mov->dst.mask = writeMask(result, offset + index);\r
- argument(mov->src[0], argi, index);\r
}\r
\r
offset += size;\r
int size = arg0->getNominalSize();\r
for(int i = 0; i < size; i++)\r
{\r
- Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, arg[0], arg[1]);\r
- mul->dst.index += i;\r
- argument(mul->src[0], arg[0], i);\r
- argument(mul->src[1], arg[1], i);\r
+ emit(sw::Shader::OPCODE_MUL, result, i, arg[0], i, arg[1], i);\r
}\r
}\r
break;\r
{\r
for(int i = 0; i < dim(arg[1]); i++)\r
{\r
- Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, arg[0], arg[1]);\r
- mul->dst.index += i;\r
+ Instruction *mul = emit(sw::Shader::OPCODE_MUL, result, i, arg[0], 0, arg[1]);\r
mul->src[1].swizzle = 0x55 * i;\r
}\r
}\r
return IsSampler(type.getBasicType()) && (type.getQualifier() == EvqUniform || type.getQualifier() == EvqTemporary);\r
}\r
\r
- Instruction *OutputASM::emit(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2, TIntermNode *src3, TIntermNode *src4, int index)\r
+ Instruction *OutputASM::emit(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2, TIntermNode *src3, TIntermNode *src4)\r
+ {\r
+ return emit(op, dst, 0, src0, 0, src1, 0, src2, 0, src3, 0, src4, 0);\r
+ }\r
+\r
+ Instruction *OutputASM::emit(sw::Shader::Opcode op, TIntermTyped *dst, int dstIndex, TIntermNode *src0, int index0, TIntermNode *src1, int index1,\r
+ TIntermNode *src2, int index2, TIntermNode *src3, int index3, TIntermNode *src4, int index4)\r
{\r
if(isSamplerRegister(dst))\r
{\r
if(dst)\r
{\r
instruction->dst.type = registerType(dst);\r
- instruction->dst.index = registerIndex(dst) + index;\r
+ instruction->dst.index = registerIndex(dst) + dstIndex;\r
instruction->dst.mask = writeMask(dst);\r
instruction->dst.integer = (dst->getBasicType() == EbtInt);\r
}\r
\r
- argument(instruction->src[0], src0, index);\r
- argument(instruction->src[1], src1, index);\r
- argument(instruction->src[2], src2, index);\r
- argument(instruction->src[3], src3, index);\r
- argument(instruction->src[4], src4, index);\r
+ argument(instruction->src[0], src0, index0);\r
+ argument(instruction->src[1], src1, index1);\r
+ argument(instruction->src[2], src2, index2);\r
+ argument(instruction->src[3], src3, index3);\r
+ argument(instruction->src[4], src4, index4);\r
\r
shader->append(instruction);\r
\r
\r
Instruction *OutputASM::emitCast(TIntermTyped *dst, TIntermTyped *src)\r
{\r
+ return emitCast(dst, 0, src, 0);\r
+ }\r
+\r
+ Instruction *OutputASM::emitCast(TIntermTyped *dst, int dstIndex, TIntermTyped *src, int srcIndex)\r
+ {\r
switch(src->getBasicType())\r
{\r
case EbtBool:\r
switch(dst->getBasicType())\r
{\r
- case EbtInt: return emit(sw::Shader::OPCODE_B2I, dst, src);\r
- case EbtUInt: return emit(sw::Shader::OPCODE_B2I, dst, src);\r
- case EbtFloat: return emit(sw::Shader::OPCODE_B2F, dst, src);\r
+ case EbtInt: return emit(sw::Shader::OPCODE_B2I, dst, dstIndex, src, srcIndex);\r
+ case EbtUInt: return emit(sw::Shader::OPCODE_B2I, dst, dstIndex, src, srcIndex);\r
+ case EbtFloat: return emit(sw::Shader::OPCODE_B2F, dst, dstIndex, src, srcIndex);\r
default: break;\r
}\r
break;\r
case EbtInt:\r
switch(dst->getBasicType())\r
{\r
- case EbtBool: return emit(sw::Shader::OPCODE_I2B, dst, src);\r
- case EbtFloat: return emit(sw::Shader::OPCODE_I2F, dst, src);\r
+ case EbtBool: return emit(sw::Shader::OPCODE_I2B, dst, dstIndex, src, srcIndex);\r
+ case EbtFloat: return emit(sw::Shader::OPCODE_I2F, dst, dstIndex, src, srcIndex);\r
default: break;\r
}\r
break;\r
case EbtUInt:\r
switch(dst->getBasicType())\r
{\r
- case EbtBool: return emit(sw::Shader::OPCODE_I2B, dst, src);\r
- case EbtFloat: return emit(sw::Shader::OPCODE_U2F, dst, src);\r
+ case EbtBool: return emit(sw::Shader::OPCODE_I2B, dst, dstIndex, src, srcIndex);\r
+ case EbtFloat: return emit(sw::Shader::OPCODE_U2F, dst, dstIndex, src, srcIndex);\r
default: break;\r
}\r
break;\r
case EbtFloat:\r
switch(dst->getBasicType())\r
{\r
- case EbtBool: return emit(sw::Shader::OPCODE_F2B, dst, src);\r
- case EbtInt: return emit(sw::Shader::OPCODE_F2I, dst, src);\r
- case EbtUInt: return emit(sw::Shader::OPCODE_F2U, dst, src);\r
+ case EbtBool: return emit(sw::Shader::OPCODE_F2B, dst, dstIndex, src, srcIndex);\r
+ case EbtInt: return emit(sw::Shader::OPCODE_F2I, dst, dstIndex, src, srcIndex);\r
+ case EbtUInt: return emit(sw::Shader::OPCODE_F2U, dst, dstIndex, src, srcIndex);\r
default: break;\r
}\r
break;\r
\r
ASSERT(src->getBasicType() == dst->getBasicType());\r
\r
- return emit(sw::Shader::OPCODE_MOV, dst, src);\r
+ return emit(sw::Shader::OPCODE_MOV, dst, dstIndex, src, srcIndex);\r
}\r
\r
void OutputASM::emitBinary(sw::Shader::Opcode op, TIntermTyped *dst, TIntermNode *src0, TIntermNode *src1, TIntermNode *src2)\r
{\r
for(int index = 0; index < dst->elementRegisterCount(); index++)\r
{\r
- emit(op, dst, src0, src1, src2, 0, 0, index);\r
+ emit(op, dst, index, src0, index, src1, index, src2, index);\r
}\r
}\r
\r
break;\r
}\r
\r
- Instruction *cmp = emit(opcode, dst, left, right);\r
+ Instruction *cmp = emit(opcode, dst, 0, left, index, right, index);\r
cmp->control = cmpOp;\r
- argument(cmp->src[0], left, index);\r
- argument(cmp->src[1], right, index);\r
}\r
\r
int componentCount(const TType &type, int registers)\r
{\r
for(int index = 0; index < dst->totalRegisterCount(); index++)\r
{\r
- Instruction *mov = emit(sw::Shader::OPCODE_MOV, dst, src);\r
- mov->dst.index += index;\r
+ Instruction *mov = emit(sw::Shader::OPCODE_MOV, dst, index, src, offset + index);\r
mov->dst.mask = writeMask(dst, index);\r
- argument(mov->src[0], src, offset + index);\r
}\r
}\r
\r
OSDN Git Service
