void
i915_fini_program(struct i915_fragment_program *p)
{
GLuint program_size = p->csr - p->program;
GLuint decl_size = p->decl - p->declarations;
if (p->nr_tex_indirect > I915_MAX_TEX_INDIRECT)
i915_program_error(p, "Exceeded max nr indirect texture lookups");
if (p->nr_tex_insn > I915_MAX_TEX_INSN)
i915_program_error(p, "Exceeded max TEX instructions");
if (p->nr_alu_insn > I915_MAX_ALU_INSN)
i915_program_error(p, "Exceeded max ALU instructions");
if (p->nr_decl_insn > I915_MAX_DECL_INSN)
i915_program_error(p, "Exceeded max DECL instructions");
if (p->error) {
p->FragProg.Base.NumNativeInstructions = 0;
p->FragProg.Base.NumNativeAluInstructions = 0;
p->FragProg.Base.NumNativeTexInstructions = 0;
p->FragProg.Base.NumNativeTexIndirections = 0;
}
else {
p->FragProg.Base.NumNativeInstructions = (p->nr_alu_insn +
p->nr_tex_insn +
p->nr_decl_insn);
p->FragProg.Base.NumNativeAluInstructions = p->nr_alu_insn;
p->FragProg.Base.NumNativeTexInstructions = p->nr_tex_insn;
p->FragProg.Base.NumNativeTexIndirections = p->nr_tex_indirect;
}
p->declarations[0] |= program_size + decl_size - 2;
}
/**
* Construct a ureg for a destination register.
*/
static uint
get_result_vector(struct i915_fp_compile *p,
const struct i915_full_dst_register *dest)
{
switch (dest->Register.File) {
case TGSI_FILE_OUTPUT:
{
uint sem_name = p->shader->info.output_semantic_name[dest->Register.Index];
switch (sem_name) {
case TGSI_SEMANTIC_POSITION:
return UREG(REG_TYPE_OD, 0);
case TGSI_SEMANTIC_COLOR:
return UREG(REG_TYPE_OC, 0);
default:
i915_program_error(p, "Bad inst->DstReg.Index/semantics");
return 0;
}
}
case TGSI_FILE_TEMPORARY:
return UREG(REG_TYPE_R, dest->Register.Index);
default:
i915_program_error(p, "Bad inst->DstReg.File");
return 0;
}
}
uint
i915_emit_decl(struct i915_fp_compile *p,
uint type, uint nr, uint d0_flags)
{
uint reg = UREG(type, nr);
if (type == REG_TYPE_T) {
if (p->decl_t & (1 << nr))
return reg;
p->decl_t |= (1 << nr);
}
else if (type == REG_TYPE_S) {
if (p->decl_s & (1 << nr))
return reg;
p->decl_s |= (1 << nr);
}
else
return reg;
if (p->decl< p->declarations + I915_PROGRAM_SIZE) {
*(p->decl++) = (D0_DCL | D0_DEST(reg) | d0_flags);
*(p->decl++) = D1_MBZ;
*(p->decl++) = D2_MBZ;
}
else
i915_program_error(p, "Out of declarations");
p->nr_decl_insn++;
return reg;
}
uint
i915_emit_const4f(struct i915_fp_compile * p,
float c0, float c1, float c2, float c3)
{
struct i915_fragment_shader *ifs = p->shader;
unsigned reg;
// XXX emit swizzle here for 0, 1, -1 and any combination thereof
// we can use swizzle + neg for that
for (reg = 0; reg < I915_MAX_CONSTANT; reg++) {
if (ifs->constant_flags[reg] == 0xf &&
ifs->constants[reg][0] == c0 &&
ifs->constants[reg][1] == c1 &&
ifs->constants[reg][2] == c2 &&
ifs->constants[reg][3] == c3) {
return UREG(REG_TYPE_CONST, reg);
}
else if (ifs->constant_flags[reg] == 0) {
ifs->constants[reg][0] = c0;
ifs->constants[reg][1] = c1;
ifs->constants[reg][2] = c2;
ifs->constants[reg][3] = c3;
ifs->constant_flags[reg] = 0xf;
if (reg + 1 > ifs->num_constants)
ifs->num_constants = reg + 1;
return UREG(REG_TYPE_CONST, reg);
}
}
i915_program_error(p, "i915_emit_const4f: out of constants");
return 0;
}
/**
* Convert TGSI_TEXTURE_x token to DO_SAMPLE_TYPE_x token
*/
static uint
translate_tex_src_target(struct i915_fp_compile *p, uint tex)
{
switch (tex) {
case TGSI_TEXTURE_SHADOW1D:
/* fall-through */
case TGSI_TEXTURE_1D:
return D0_SAMPLE_TYPE_2D;
case TGSI_TEXTURE_SHADOW2D:
/* fall-through */
case TGSI_TEXTURE_2D:
return D0_SAMPLE_TYPE_2D;
case TGSI_TEXTURE_SHADOWRECT:
/* fall-through */
case TGSI_TEXTURE_RECT:
return D0_SAMPLE_TYPE_2D;
case TGSI_TEXTURE_3D:
return D0_SAMPLE_TYPE_VOLUME;
case TGSI_TEXTURE_CUBE:
return D0_SAMPLE_TYPE_CUBE;
default:
i915_program_error(p, "TexSrc type");
return 0;
}
}
uint
i915_emit_const1f(struct i915_fp_compile * p, float c0)
{
struct i915_fragment_shader *ifs = p->shader;
unsigned reg, idx;
if (c0 == 0.0)
return swizzle(UREG(REG_TYPE_R, 0), ZERO, ZERO, ZERO, ZERO);
if (c0 == 1.0)
return swizzle(UREG(REG_TYPE_R, 0), ONE, ONE, ONE, ONE);
for (reg = 0; reg < I915_MAX_CONSTANT; reg++) {
if (ifs->constant_flags[reg] == I915_CONSTFLAG_USER)
continue;
for (idx = 0; idx < 4; idx++) {
if (!(ifs->constant_flags[reg] & (1 << idx)) ||
ifs->constants[reg][idx] == c0) {
ifs->constants[reg][idx] = c0;
ifs->constant_flags[reg] |= 1 << idx;
if (reg + 1 > ifs->num_constants)
ifs->num_constants = reg + 1;
return swizzle(UREG(REG_TYPE_CONST, reg), idx, ZERO, ZERO, ONE);
}
}
}
i915_program_error(p, "i915_emit_const1f: out of constants");
return 0;
}
static GLuint get_free_rreg (struct i915_fragment_program *p,
GLuint live_regs)
{
int bit = ffs(~live_regs);
if (!bit) {
i915_program_error(p, "Can't find free R reg");
return UREG_BAD;
}
return UREG(REG_TYPE_R, bit - 1);
}
uint
i915_get_temp(struct i915_fp_compile *p)
{
int bit = ffs(~p->temp_flag);
if (!bit) {
i915_program_error(p, "i915_get_temp: out of temporaries");
return 0;
}
p->temp_flag |= 1 << (bit - 1);
return bit - 1;
}
/**
* Get unpreserved temporary, a temp whose value is not preserved between
* PS program phases.
*/
uint
i915_get_utemp(struct i915_fp_compile * p)
{
int bit = ffs(~p->utemp_flag);
if (!bit) {
i915_program_error(p, "i915_get_utemp: out of temporaries");
return 0;
}
p->utemp_flag |= 1 << (bit - 1);
return UREG(REG_TYPE_U, (bit - 1));
}
static GLuint translate_tex_src_bit( struct i915_fragment_program *p,
GLubyte bit )
{
switch (bit) {
case TEXTURE_1D_BIT: return D0_SAMPLE_TYPE_2D;
case TEXTURE_2D_BIT: return D0_SAMPLE_TYPE_2D;
case TEXTURE_RECT_BIT: return D0_SAMPLE_TYPE_2D;
case TEXTURE_3D_BIT: return D0_SAMPLE_TYPE_VOLUME;
case TEXTURE_CUBE_BIT: return D0_SAMPLE_TYPE_CUBE;
default: i915_program_error(p, "TexSrcBit"); return 0;
}
}
static GLuint get_result_vector( struct i915_fragment_program *p,
const struct fp_instruction *inst )
{
switch (inst->DstReg.File) {
case PROGRAM_OUTPUT:
switch (inst->DstReg.Index) {
case FRAG_OUTPUT_COLR:
return UREG(REG_TYPE_OC, 0);
case FRAG_OUTPUT_DEPR:
p->depth_written = 1;
return UREG(REG_TYPE_OD, 0);
default:
i915_program_error( p, "Bad inst->DstReg.Index" );
return 0;
}
case PROGRAM_TEMPORARY:
return UREG(REG_TYPE_R, inst->DstReg.Index);
default:
i915_program_error( p, "Bad inst->DstReg.File" );
return 0;
}
}
GLuint i915_emit_texld( struct i915_fragment_program *p,
GLuint dest,
GLuint destmask,
GLuint sampler,
GLuint coord,
GLuint op )
{
if (coord != UREG(GET_UREG_TYPE(coord), GET_UREG_NR(coord))) {
/* No real way to work around this in the general case - need to
* allocate and declare a new temporary register (a utemp won't
* do). Will fallback for now.
*/
i915_program_error(p, "Can't (yet) swizzle TEX arguments");
return 0;
}
/* Don't worry about saturate as we only support
*/
if (destmask != A0_DEST_CHANNEL_ALL) {
GLuint tmp = i915_get_utemp(p);
i915_emit_texld( p, tmp, A0_DEST_CHANNEL_ALL, sampler, coord, op );
i915_emit_arith( p, A0_MOV, dest, destmask, 0, tmp, 0, 0 );
return dest;
}
else {
assert(GET_UREG_TYPE(dest) != REG_TYPE_CONST);
assert(dest = UREG(GET_UREG_TYPE(dest), GET_UREG_NR(dest)));
if (GET_UREG_TYPE(coord) != REG_TYPE_T) {
p->nr_tex_indirect++;
}
*(p->csr++) = (op |
T0_DEST( dest ) |
T0_SAMPLER( sampler ));
*(p->csr++) = T1_ADDRESS_REG( coord );
*(p->csr++) = T2_MBZ;
p->nr_tex_insn++;
return dest;
}
}
static void check_wpos( struct i915_fragment_program *p )
{
GLuint inputs = p->FragProg.InputsRead;
GLint i;
p->wpos_tex = -1;
for (i = 0; i < p->ctx->Const.MaxTextureCoordUnits; i++) {
if (inputs & FRAG_BIT_TEX(i))
continue;
else if (inputs & FRAG_BIT_WPOS) {
p->wpos_tex = i;
inputs &= ~FRAG_BIT_WPOS;
}
}
if (inputs & FRAG_BIT_WPOS) {
i915_program_error(p, "No free texcoord for wpos value");
}
}
/**
* Return the number of coords needed to access a given TGSI_TEXTURE_*
*/
static uint
texture_num_coords(struct i915_fp_compile *p, uint tex)
{
switch (tex) {
case TGSI_TEXTURE_SHADOW1D:
case TGSI_TEXTURE_1D:
return 1;
case TGSI_TEXTURE_SHADOW2D:
case TGSI_TEXTURE_2D:
case TGSI_TEXTURE_SHADOWRECT:
case TGSI_TEXTURE_RECT:
return 2;
case TGSI_TEXTURE_3D:
case TGSI_TEXTURE_CUBE:
return 3;
default:
i915_program_error(p, "Num coords");
return 2;
}
}
uint
i915_emit_const2f(struct i915_fp_compile * p, float c0, float c1)
{
struct i915_fragment_shader *ifs = p->shader;
unsigned reg, idx;
if (c0 == 0.0)
return swizzle(i915_emit_const1f(p, c1), ZERO, X, Z, W);
if (c0 == 1.0)
return swizzle(i915_emit_const1f(p, c1), ONE, X, Z, W);
if (c1 == 0.0)
return swizzle(i915_emit_const1f(p, c0), X, ZERO, Z, W);
if (c1 == 1.0)
return swizzle(i915_emit_const1f(p, c0), X, ONE, Z, W);
// XXX emit swizzle here for 0, 1, -1 and any combination thereof
// we can use swizzle + neg for that
for (reg = 0; reg < I915_MAX_CONSTANT; reg++) {
if (ifs->constant_flags[reg] == 0xf ||
ifs->constant_flags[reg] == I915_CONSTFLAG_USER)
continue;
for (idx = 0; idx < 3; idx++) {
if (!(ifs->constant_flags[reg] & (3 << idx))) {
ifs->constants[reg][idx + 0] = c0;
ifs->constants[reg][idx + 1] = c1;
ifs->constant_flags[reg] |= 3 << idx;
if (reg + 1 > ifs->num_constants)
ifs->num_constants = reg + 1;
return swizzle(UREG(REG_TYPE_CONST, reg), idx, idx + 1, ZERO, ONE);
}
}
}
i915_program_error(p, "i915_emit_const2f: out of constants");
return 0;
}
/**
* Retrieve a ureg for the given source register. Will emit
* constants, apply swizzling and negation as needed.
*/
static GLuint
src_vector(struct i915_fragment_program *p,
const struct prog_src_register *source,
const struct gl_fragment_program *program)
{
GLuint src;
switch (source->File) {
/* Registers:
*/
case PROGRAM_TEMPORARY:
if (source->Index >= I915_MAX_TEMPORARY) {
i915_program_error(p, "Exceeded max temporary reg");
return 0;
}
src = UREG(REG_TYPE_R, source->Index);
break;
case PROGRAM_INPUT:
switch (source->Index) {
case FRAG_ATTRIB_WPOS:
src = i915_emit_decl(p, REG_TYPE_T, p->wpos_tex, D0_CHANNEL_ALL);
break;
case FRAG_ATTRIB_COL0:
src = i915_emit_decl(p, REG_TYPE_T, T_DIFFUSE, D0_CHANNEL_ALL);
break;
case FRAG_ATTRIB_COL1:
src = i915_emit_decl(p, REG_TYPE_T, T_SPECULAR, D0_CHANNEL_XYZ);
src = swizzle(src, X, Y, Z, ONE);
break;
case FRAG_ATTRIB_FOGC:
src = i915_emit_decl(p, REG_TYPE_T, T_FOG_W, D0_CHANNEL_W);
src = swizzle(src, W, ZERO, ZERO, ONE);
break;
case FRAG_ATTRIB_TEX0:
case FRAG_ATTRIB_TEX1:
case FRAG_ATTRIB_TEX2:
case FRAG_ATTRIB_TEX3:
case FRAG_ATTRIB_TEX4:
case FRAG_ATTRIB_TEX5:
case FRAG_ATTRIB_TEX6:
case FRAG_ATTRIB_TEX7:
src = i915_emit_decl(p, REG_TYPE_T,
T_TEX0 + (source->Index - FRAG_ATTRIB_TEX0),
D0_CHANNEL_ALL);
break;
default:
i915_program_error(p, "Bad source->Index");
return 0;
}
break;
/* Various paramters and env values. All emitted to
* hardware as program constants.
*/
case PROGRAM_LOCAL_PARAM:
src = i915_emit_param4fv(p, program->Base.LocalParams[source->Index]);
break;
case PROGRAM_ENV_PARAM:
src =
i915_emit_param4fv(p,
p->ctx->FragmentProgram.Parameters[source->
Index]);
break;
case PROGRAM_CONSTANT:
case PROGRAM_STATE_VAR:
case PROGRAM_NAMED_PARAM:
src =
i915_emit_param4fv(p,
program->Base.Parameters->ParameterValues[source->
Index]);
break;
default:
i915_program_error(p, "Bad source->File");
return 0;
}
src = swizzle(src,
GET_SWZ(source->Swizzle, 0),
GET_SWZ(source->Swizzle, 1),
GET_SWZ(source->Swizzle, 2), GET_SWZ(source->Swizzle, 3));
if (source->NegateBase)
src = negate(src,
GET_BIT(source->NegateBase, 0),
GET_BIT(source->NegateBase, 1),
GET_BIT(source->NegateBase, 2),
GET_BIT(source->NegateBase, 3));
return src;
}
/* Possible concerns:
*
* SIN, COS -- could use another taylor step?
* LIT -- results seem a little different to sw mesa
* LOG -- different to mesa on negative numbers, but this is conformant.
*
* Parse failures -- Mesa doesn't currently give a good indication
* internally whether a particular program string parsed or not. This
* can lead to confusion -- hopefully we cope with it ok now.
*
*/
static void
upload_program(struct i915_fragment_program *p)
{
const struct gl_fragment_program *program =
p->ctx->FragmentProgram._Current;
const struct prog_instruction *inst = program->Base.Instructions;
/* _mesa_debug_fp_inst(program->Base.NumInstructions, inst); */
/* Is this a parse-failed program? Ensure a valid program is
* loaded, as the flagging of an error isn't sufficient to stop
* this being uploaded to hardware.
*/
if (inst[0].Opcode == OPCODE_END) {
GLuint tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_MOV,
UREG(REG_TYPE_OC, 0),
A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, ONE, ZERO, ONE, ONE), 0, 0);
return;
}
if (program->Base.NumInstructions > I915_MAX_INSN) {
i915_program_error( p, "Exceeded max instructions" );
return;
}
/* Not always needed:
*/
calc_live_regs(p);
while (1) {
GLuint src0, src1, src2, flags;
GLuint tmp = 0, consts0 = 0, consts1 = 0;
switch (inst->Opcode) {
case OPCODE_ABS:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_MAX,
get_result_vector(p, inst),
get_result_flags(inst), 0,
src0, negate(src0, 1, 1, 1, 1), 0);
break;
case OPCODE_ADD:
EMIT_2ARG_ARITH(A0_ADD);
break;
case OPCODE_CMP:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
src2 = src_vector(p, &inst->SrcReg[2], program);
i915_emit_arith(p, A0_CMP, get_result_vector(p, inst), get_result_flags(inst), 0, src0, src2, src1); /* NOTE: order of src2, src1 */
break;
case OPCODE_COS:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
consts0 = i915_emit_const4fv(p, sin_quad_constants[0]);
consts1 = i915_emit_const4fv(p, sin_quad_constants[1]);
/* Reduce range from repeating about [-pi,pi] to [-1,1] */
i915_emit_arith(p,
A0_MAD,
tmp, A0_DEST_CHANNEL_X, 0,
src0,
swizzle(consts1, Z, ZERO, ZERO, ZERO), /* 1/(2pi) */
swizzle(consts0, W, ZERO, ZERO, ZERO)); /* .75 */
i915_emit_arith(p, A0_FRC, tmp, A0_DEST_CHANNEL_X, 0, tmp, 0, 0);
i915_emit_arith(p,
A0_MAD,
tmp, A0_DEST_CHANNEL_X, 0,
tmp,
swizzle(consts0, X, ZERO, ZERO, ZERO), /* 2 */
swizzle(consts0, Y, ZERO, ZERO, ZERO)); /* -1 */
/* Compute COS with the same calculation used for SIN, but a
* different source range has been mapped to [-1,1] this time.
*/
/* tmp.y = abs(tmp.x); {x, abs(x), 0, 0} */
i915_emit_arith(p,
A0_MAX,
tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, X, ZERO, ZERO),
negate(swizzle(tmp, ZERO, X, ZERO, ZERO), 0, 1, 0, 0),
0);
/* tmp.y = tmp.y * tmp.x; {x, x * abs(x), 0, 0} */
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, X, ZERO, ZERO),
tmp,
0);
/* tmp.x = tmp.xy DP sin_quad_constants[2].xy */
i915_emit_arith(p,
A0_DP3,
tmp, A0_DEST_CHANNEL_X, 0,
tmp,
swizzle(consts1, X, Y, ZERO, ZERO),
0);
/* tmp.x now contains a first approximation (y). Now, weight it
* against tmp.y**2 to get closer.
*/
i915_emit_arith(p,
A0_MAX,
tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, X, ZERO, ZERO),
negate(swizzle(tmp, ZERO, X, ZERO, ZERO), 0, 1, 0, 0),
0);
/* tmp.y = tmp.x * tmp.y - tmp.x; {y, y * abs(y) - y, 0, 0} */
i915_emit_arith(p,
A0_MAD,
tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, X, ZERO, ZERO),
swizzle(tmp, ZERO, Y, ZERO, ZERO),
negate(swizzle(tmp, ZERO, X, ZERO, ZERO), 0, 1, 0, 0));
/* result = .2225 * tmp.y + tmp.x =.2225(y * abs(y) - y) + y= */
i915_emit_arith(p,
A0_MAD,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(consts1, W, W, W, W),
swizzle(tmp, Y, Y, Y, Y),
swizzle(tmp, X, X, X, X));
break;
case OPCODE_DP3:
EMIT_2ARG_ARITH(A0_DP3);
break;
case OPCODE_DP4:
EMIT_2ARG_ARITH(A0_DP4);
break;
case OPCODE_DPH:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, Y, Z, ONE), src1, 0);
break;
case OPCODE_DST:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
/* result[0] = 1 * 1;
* result[1] = a[1] * b[1];
* result[2] = a[2] * 1;
* result[3] = 1 * b[3];
*/
i915_emit_arith(p,
A0_MUL,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, ONE, Y, Z, ONE),
swizzle(src1, ONE, Y, ONE, W), 0);
break;
case OPCODE_EX2:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_EXP,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case OPCODE_FLR:
EMIT_1ARG_ARITH(A0_FLR);
break;
case OPCODE_FRC:
EMIT_1ARG_ARITH(A0_FRC);
break;
case OPCODE_KIL:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
i915_emit_texld(p, get_live_regs(p, inst),
tmp, A0_DEST_CHANNEL_ALL, /* use a dummy dest reg */
0, src0, T0_TEXKILL);
break;
case OPCODE_LG2:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_LOG,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case OPCODE_LIT:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
/* tmp = max( a.xyzw, a.00zw )
* XXX: Clamp tmp.w to -128..128
* tmp.y = log(tmp.y)
* tmp.y = tmp.w * tmp.y
* tmp.y = exp(tmp.y)
* result = cmp (a.11-x1, a.1x01, a.1xy1 )
*/
i915_emit_arith(p, A0_MAX, tmp, A0_DEST_CHANNEL_ALL, 0,
src0, swizzle(src0, ZERO, ZERO, Z, W), 0);
i915_emit_arith(p, A0_LOG, tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, Y, Y, Y, Y), 0, 0);
i915_emit_arith(p, A0_MUL, tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, Y, ZERO, ZERO),
swizzle(tmp, ZERO, W, ZERO, ZERO), 0);
i915_emit_arith(p, A0_EXP, tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, Y, Y, Y, Y), 0, 0);
i915_emit_arith(p, A0_CMP,
get_result_vector(p, inst),
get_result_flags(inst), 0,
negate(swizzle(tmp, ONE, ONE, X, ONE), 0, 0, 1, 0),
swizzle(tmp, ONE, X, ZERO, ONE),
swizzle(tmp, ONE, X, Y, ONE));
break;
case OPCODE_LRP:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
src2 = src_vector(p, &inst->SrcReg[2], program);
flags = get_result_flags(inst);
tmp = i915_get_utemp(p);
/* b*a + c*(1-a)
*
* b*a + c - ca
*
* tmp = b*a + c,
* result = (-c)*a + tmp
*/
i915_emit_arith(p, A0_MAD, tmp,
flags & A0_DEST_CHANNEL_ALL, 0, src1, src0, src2);
i915_emit_arith(p, A0_MAD,
get_result_vector(p, inst),
flags, 0, negate(src2, 1, 1, 1, 1), src0, tmp);
break;
case OPCODE_MAD:
EMIT_3ARG_ARITH(A0_MAD);
break;
case OPCODE_MAX:
EMIT_2ARG_ARITH(A0_MAX);
break;
case OPCODE_MIN:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
tmp = i915_get_utemp(p);
flags = get_result_flags(inst);
i915_emit_arith(p,
A0_MAX,
tmp, flags & A0_DEST_CHANNEL_ALL, 0,
negate(src0, 1, 1, 1, 1),
negate(src1, 1, 1, 1, 1), 0);
i915_emit_arith(p,
A0_MOV,
get_result_vector(p, inst),
flags, 0, negate(tmp, 1, 1, 1, 1), 0, 0);
break;
case OPCODE_MOV:
EMIT_1ARG_ARITH(A0_MOV);
break;
case OPCODE_MUL:
EMIT_2ARG_ARITH(A0_MUL);
break;
case OPCODE_POW:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
tmp = i915_get_utemp(p);
flags = get_result_flags(inst);
/* XXX: masking on intermediate values, here and elsewhere.
*/
i915_emit_arith(p,
A0_LOG,
tmp, A0_DEST_CHANNEL_X, 0,
swizzle(src0, X, X, X, X), 0, 0);
i915_emit_arith(p, A0_MUL, tmp, A0_DEST_CHANNEL_X, 0, tmp, src1, 0);
i915_emit_arith(p,
A0_EXP,
get_result_vector(p, inst),
flags, 0, swizzle(tmp, X, X, X, X), 0, 0);
break;
case OPCODE_RCP:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_RCP,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case OPCODE_RSQ:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_RSQ,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case OPCODE_SCS:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
/*
* t0.xy = MUL x.xx11, x.x1111 ; x^2, x, 1, 1
* t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, x
* t1 = MUL t0.xyyw t0.yz11 ; x^7 x^5 x^3 x
* scs.x = DP4 t1, sin_constants
* t1 = MUL t0.xxz1 t0.z111 ; x^6 x^4 x^2 1
* scs.y = DP4 t1, cos_constants
*/
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XY, 0,
swizzle(src0, X, X, ONE, ONE),
swizzle(src0, X, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, X, Y),
swizzle(tmp, X, X, ONE, ONE), 0);
if (inst->DstReg.WriteMask & WRITEMASK_Y) {
GLuint tmp1;
if (inst->DstReg.WriteMask & WRITEMASK_X)
tmp1 = i915_get_utemp(p);
else
tmp1 = tmp;
i915_emit_arith(p,
A0_MUL,
tmp1, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, Y, W),
swizzle(tmp, X, Z, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, inst),
A0_DEST_CHANNEL_Y, 0,
swizzle(tmp1, W, Z, Y, X),
i915_emit_const4fv(p, sin_constants), 0);
}
if (inst->DstReg.WriteMask & WRITEMASK_X) {
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XYZ, 0,
swizzle(tmp, X, X, Z, ONE),
swizzle(tmp, Z, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, inst),
A0_DEST_CHANNEL_X, 0,
swizzle(tmp, ONE, Z, Y, X),
i915_emit_const4fv(p, cos_constants), 0);
}
break;
case OPCODE_SGE:
EMIT_2ARG_ARITH(A0_SGE);
break;
case OPCODE_SIN:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
consts0 = i915_emit_const4fv(p, sin_quad_constants[0]);
consts1 = i915_emit_const4fv(p, sin_quad_constants[1]);
/* Reduce range from repeating about [-pi,pi] to [-1,1] */
i915_emit_arith(p,
A0_MAD,
tmp, A0_DEST_CHANNEL_X, 0,
src0,
swizzle(consts1, Z, ZERO, ZERO, ZERO), /* 1/(2pi) */
swizzle(consts0, Z, ZERO, ZERO, ZERO)); /* .5 */
i915_emit_arith(p, A0_FRC, tmp, A0_DEST_CHANNEL_X, 0, tmp, 0, 0);
i915_emit_arith(p,
A0_MAD,
tmp, A0_DEST_CHANNEL_X, 0,
tmp,
swizzle(consts0, X, ZERO, ZERO, ZERO), /* 2 */
swizzle(consts0, Y, ZERO, ZERO, ZERO)); /* -1 */
/* Compute sin using a quadratic and quartic. It gives continuity
* that repeating the Taylor series lacks every 2*pi, and has
* reduced error.
*
* The idea was described at:
* http://www.devmaster.net/forums/showthread.php?t=5784
*/
/* tmp.y = abs(tmp.x); {x, abs(x), 0, 0} */
i915_emit_arith(p,
A0_MAX,
tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, X, ZERO, ZERO),
negate(swizzle(tmp, ZERO, X, ZERO, ZERO), 0, 1, 0, 0),
0);
/* tmp.y = tmp.y * tmp.x; {x, x * abs(x), 0, 0} */
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, X, ZERO, ZERO),
tmp,
0);
/* tmp.x = tmp.xy DP sin_quad_constants[2].xy */
i915_emit_arith(p,
A0_DP3,
tmp, A0_DEST_CHANNEL_X, 0,
tmp,
swizzle(consts1, X, Y, ZERO, ZERO),
0);
/* tmp.x now contains a first approximation (y). Now, weight it
* against tmp.y**2 to get closer.
*/
i915_emit_arith(p,
A0_MAX,
tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, X, ZERO, ZERO),
negate(swizzle(tmp, ZERO, X, ZERO, ZERO), 0, 1, 0, 0),
0);
/* tmp.y = tmp.x * tmp.y - tmp.x; {y, y * abs(y) - y, 0, 0} */
i915_emit_arith(p,
A0_MAD,
tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, X, ZERO, ZERO),
swizzle(tmp, ZERO, Y, ZERO, ZERO),
negate(swizzle(tmp, ZERO, X, ZERO, ZERO), 0, 1, 0, 0));
/* result = .2225 * tmp.y + tmp.x =.2225(y * abs(y) - y) + y= */
i915_emit_arith(p,
A0_MAD,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(consts1, W, W, W, W),
swizzle(tmp, Y, Y, Y, Y),
swizzle(tmp, X, X, X, X));
break;
case OPCODE_SLT:
EMIT_2ARG_ARITH(A0_SLT);
break;
case OPCODE_SUB:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
i915_emit_arith(p,
A0_ADD,
get_result_vector(p, inst),
get_result_flags(inst), 0,
src0, negate(src1, 1, 1, 1, 1), 0);
break;
case OPCODE_SWZ:
EMIT_1ARG_ARITH(A0_MOV); /* extended swizzle handled natively */
break;
case OPCODE_TEX:
EMIT_TEX(T0_TEXLD);
break;
case OPCODE_TXB:
EMIT_TEX(T0_TEXLDB);
break;
case OPCODE_TXP:
EMIT_TEX(T0_TEXLDP);
break;
case OPCODE_XPD:
/* Cross product:
* result.x = src0.y * src1.z - src0.z * src1.y;
* result.y = src0.z * src1.x - src0.x * src1.z;
* result.z = src0.x * src1.y - src0.y * src1.x;
* result.w = undef;
*/
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(src0, Z, X, Y, ONE),
swizzle(src1, Y, Z, X, ONE), 0);
i915_emit_arith(p,
A0_MAD,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, Y, Z, X, ONE),
swizzle(src1, Z, X, Y, ONE),
negate(tmp, 1, 1, 1, 0));
break;
case OPCODE_END:
return;
default:
i915_program_error(p, "bad opcode");
return;
}
inst++;
i915_release_utemps(p);
}
}
/* Possible concerns:
*
* SIN, COS -- could use another taylor step?
* LIT -- results seem a little different to sw mesa
* LOG -- different to mesa on negative numbers, but this is conformant.
*
* Parse failures -- Mesa doesn't currently give a good indication
* internally whether a particular program string parsed or not. This
* can lead to confusion -- hopefully we cope with it ok now.
*
*/
static void
upload_program(struct i915_fragment_program *p)
{
const struct gl_fragment_program *program =
p->ctx->FragmentProgram._Current;
const struct prog_instruction *inst = program->Base.Instructions;
/* _mesa_debug_fp_inst(program->Base.NumInstructions, inst); */
/* Is this a parse-failed program? Ensure a valid program is
* loaded, as the flagging of an error isn't sufficient to stop
* this being uploaded to hardware.
*/
if (inst[0].Opcode == OPCODE_END) {
GLuint tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_MOV,
UREG(REG_TYPE_OC, 0),
A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, ONE, ZERO, ONE, ONE), 0, 0);
return;
}
while (1) {
GLuint src0, src1, src2, flags;
GLuint tmp = 0;
switch (inst->Opcode) {
case OPCODE_ABS:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_MAX,
get_result_vector(p, inst),
get_result_flags(inst), 0,
src0, negate(src0, 1, 1, 1, 1), 0);
break;
case OPCODE_ADD:
EMIT_2ARG_ARITH(A0_ADD);
break;
case OPCODE_CMP:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
src2 = src_vector(p, &inst->SrcReg[2], program);
i915_emit_arith(p, A0_CMP, get_result_vector(p, inst), get_result_flags(inst), 0, src0, src2, src1); /* NOTE: order of src2, src1 */
break;
case OPCODE_COS:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_X, 0,
src0, i915_emit_const1f(p, 1.0 / (M_PI)), 0);
i915_emit_arith(p, A0_MOD, tmp, A0_DEST_CHANNEL_X, 0, tmp, 0, 0);
/* By choosing different taylor constants, could get rid of this mul:
*/
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_X, 0,
tmp, i915_emit_const1f(p, (M_PI)), 0);
/*
* t0.xy = MUL x.xx11, x.x1111 ; x^2, x, 1, 1
* t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, 1
* t0 = MUL t0.xxz1 t0.z111 ; x^6 x^4 x^2 1
* result = DP4 t0, cos_constants
*/
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XY, 0,
swizzle(tmp, X, X, ONE, ONE),
swizzle(tmp, X, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XYZ, 0,
swizzle(tmp, X, Y, X, ONE),
swizzle(tmp, X, X, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XYZ, 0,
swizzle(tmp, X, X, Z, ONE),
swizzle(tmp, Z, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(tmp, ONE, Z, Y, X),
i915_emit_const4fv(p, cos_constants), 0);
break;
case OPCODE_DP3:
EMIT_2ARG_ARITH(A0_DP3);
break;
case OPCODE_DP4:
EMIT_2ARG_ARITH(A0_DP4);
break;
case OPCODE_DPH:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, Y, Z, ONE), src1, 0);
break;
case OPCODE_DST:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
/* result[0] = 1 * 1;
* result[1] = a[1] * b[1];
* result[2] = a[2] * 1;
* result[3] = 1 * b[3];
*/
i915_emit_arith(p,
A0_MUL,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, ONE, Y, Z, ONE),
swizzle(src1, ONE, Y, ONE, W), 0);
break;
case OPCODE_EX2:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_EXP,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case OPCODE_FLR:
EMIT_1ARG_ARITH(A0_FLR);
break;
case OPCODE_FRC:
EMIT_1ARG_ARITH(A0_FRC);
break;
case OPCODE_KIL:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
i915_emit_texld(p, tmp, A0_DEST_CHANNEL_ALL, /* use a dummy dest reg */
0, src0, T0_TEXKILL);
break;
case OPCODE_LG2:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_LOG,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case OPCODE_LIT:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
/* tmp = max( a.xyzw, a.00zw )
* XXX: Clamp tmp.w to -128..128
* tmp.y = log(tmp.y)
* tmp.y = tmp.w * tmp.y
* tmp.y = exp(tmp.y)
* result = cmp (a.11-x1, a.1x01, a.1xy1 )
*/
i915_emit_arith(p, A0_MAX, tmp, A0_DEST_CHANNEL_ALL, 0,
src0, swizzle(src0, ZERO, ZERO, Z, W), 0);
i915_emit_arith(p, A0_LOG, tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, Y, Y, Y, Y), 0, 0);
i915_emit_arith(p, A0_MUL, tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, Y, ZERO, ZERO),
swizzle(tmp, ZERO, W, ZERO, ZERO), 0);
i915_emit_arith(p, A0_EXP, tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, Y, Y, Y, Y), 0, 0);
i915_emit_arith(p, A0_CMP,
get_result_vector(p, inst),
get_result_flags(inst), 0,
negate(swizzle(tmp, ONE, ONE, X, ONE), 0, 0, 1, 0),
swizzle(tmp, ONE, X, ZERO, ONE),
swizzle(tmp, ONE, X, Y, ONE));
break;
case OPCODE_LRP:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
src2 = src_vector(p, &inst->SrcReg[2], program);
flags = get_result_flags(inst);
tmp = i915_get_utemp(p);
/* b*a + c*(1-a)
*
* b*a + c - ca
*
* tmp = b*a + c,
* result = (-c)*a + tmp
*/
i915_emit_arith(p, A0_MAD, tmp,
flags & A0_DEST_CHANNEL_ALL, 0, src1, src0, src2);
i915_emit_arith(p, A0_MAD,
get_result_vector(p, inst),
flags, 0, negate(src2, 1, 1, 1, 1), src0, tmp);
break;
case OPCODE_MAD:
EMIT_3ARG_ARITH(A0_MAD);
break;
case OPCODE_MAX:
EMIT_2ARG_ARITH(A0_MAX);
break;
case OPCODE_MIN:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
tmp = i915_get_utemp(p);
flags = get_result_flags(inst);
i915_emit_arith(p,
A0_MAX,
tmp, flags & A0_DEST_CHANNEL_ALL, 0,
negate(src0, 1, 1, 1, 1),
negate(src1, 1, 1, 1, 1), 0);
i915_emit_arith(p,
A0_MOV,
get_result_vector(p, inst),
flags, 0, negate(tmp, 1, 1, 1, 1), 0, 0);
break;
case OPCODE_MOV:
EMIT_1ARG_ARITH(A0_MOV);
break;
case OPCODE_MUL:
EMIT_2ARG_ARITH(A0_MUL);
break;
case OPCODE_POW:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
tmp = i915_get_utemp(p);
flags = get_result_flags(inst);
/* XXX: masking on intermediate values, here and elsewhere.
*/
i915_emit_arith(p,
A0_LOG,
tmp, A0_DEST_CHANNEL_X, 0,
swizzle(src0, X, X, X, X), 0, 0);
i915_emit_arith(p, A0_MUL, tmp, A0_DEST_CHANNEL_X, 0, tmp, src1, 0);
i915_emit_arith(p,
A0_EXP,
get_result_vector(p, inst),
flags, 0, swizzle(tmp, X, X, X, X), 0, 0);
break;
case OPCODE_RCP:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_RCP,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case OPCODE_RSQ:
src0 = src_vector(p, &inst->SrcReg[0], program);
i915_emit_arith(p,
A0_RSQ,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case OPCODE_SCS:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
/*
* t0.xy = MUL x.xx11, x.x1111 ; x^2, x, 1, 1
* t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, x
* t1 = MUL t0.xyyw t0.yz11 ; x^7 x^5 x^3 x
* scs.x = DP4 t1, sin_constants
* t1 = MUL t0.xxz1 t0.z111 ; x^6 x^4 x^2 1
* scs.y = DP4 t1, cos_constants
*/
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XY, 0,
swizzle(src0, X, X, ONE, ONE),
swizzle(src0, X, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, X, Y),
swizzle(tmp, X, X, ONE, ONE), 0);
if (inst->DstReg.WriteMask & WRITEMASK_Y) {
GLuint tmp1;
if (inst->DstReg.WriteMask & WRITEMASK_X)
tmp1 = i915_get_utemp(p);
else
tmp1 = tmp;
i915_emit_arith(p,
A0_MUL,
tmp1, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, Y, W),
swizzle(tmp, X, Z, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, inst),
A0_DEST_CHANNEL_Y, 0,
swizzle(tmp1, W, Z, Y, X),
i915_emit_const4fv(p, sin_constants), 0);
}
if (inst->DstReg.WriteMask & WRITEMASK_X) {
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XYZ, 0,
swizzle(tmp, X, X, Z, ONE),
swizzle(tmp, Z, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, inst),
A0_DEST_CHANNEL_X, 0,
swizzle(tmp, ONE, Z, Y, X),
i915_emit_const4fv(p, cos_constants), 0);
}
break;
case OPCODE_SGE:
EMIT_2ARG_ARITH(A0_SGE);
break;
case OPCODE_SIN:
src0 = src_vector(p, &inst->SrcReg[0], program);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_X, 0,
src0, i915_emit_const1f(p, 1.0 / (M_PI)), 0);
i915_emit_arith(p, A0_MOD, tmp, A0_DEST_CHANNEL_X, 0, tmp, 0, 0);
/* By choosing different taylor constants, could get rid of this mul:
*/
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_X, 0,
tmp, i915_emit_const1f(p, (M_PI)), 0);
/*
* t0.xy = MUL x.xx11, x.x1111 ; x^2, x, 1, 1
* t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, x
* t1 = MUL t0.xyyw t0.yz11 ; x^7 x^5 x^3 x
* result = DP4 t1.wzyx, sin_constants
*/
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XY, 0,
swizzle(tmp, X, X, ONE, ONE),
swizzle(tmp, X, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, X, Y),
swizzle(tmp, X, X, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, Y, W),
swizzle(tmp, X, Z, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(tmp, W, Z, Y, X),
i915_emit_const4fv(p, sin_constants), 0);
break;
case OPCODE_SLT:
EMIT_2ARG_ARITH(A0_SLT);
break;
case OPCODE_SUB:
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
i915_emit_arith(p,
A0_ADD,
get_result_vector(p, inst),
get_result_flags(inst), 0,
src0, negate(src1, 1, 1, 1, 1), 0);
break;
case OPCODE_SWZ:
EMIT_1ARG_ARITH(A0_MOV); /* extended swizzle handled natively */
break;
case OPCODE_TEX:
EMIT_TEX(T0_TEXLD);
break;
case OPCODE_TXB:
EMIT_TEX(T0_TEXLDB);
break;
case OPCODE_TXP:
EMIT_TEX(T0_TEXLDP);
break;
case OPCODE_XPD:
/* Cross product:
* result.x = src0.y * src1.z - src0.z * src1.y;
* result.y = src0.z * src1.x - src0.x * src1.z;
* result.z = src0.x * src1.y - src0.y * src1.x;
* result.w = undef;
*/
src0 = src_vector(p, &inst->SrcReg[0], program);
src1 = src_vector(p, &inst->SrcReg[1], program);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(src0, Z, X, Y, ONE),
swizzle(src1, Y, Z, X, ONE), 0);
i915_emit_arith(p,
A0_MAD,
get_result_vector(p, inst),
get_result_flags(inst), 0,
swizzle(src0, Y, Z, X, ONE),
swizzle(src1, Z, X, Y, ONE),
negate(tmp, 1, 1, 1, 0));
break;
case OPCODE_END:
return;
default:
i915_program_error(p, "bad opcode");
return;
}
inst++;
i915_release_utemps(p);
}
}
GLuint i915_emit_texld( struct i915_fragment_program *p,
GLuint live_regs,
GLuint dest,
GLuint destmask,
GLuint sampler,
GLuint coord,
GLuint op )
{
if (coord != UREG(GET_UREG_TYPE(coord), GET_UREG_NR(coord))) {
/* With the help of the "needed registers" table created earlier, pick
* a register we can MOV the swizzled TC to (since TEX doesn't support
* swizzled sources) */
GLuint swizCoord = get_free_rreg(p, live_regs);
if (swizCoord == UREG_BAD)
return 0;
i915_emit_arith( p, A0_MOV, swizCoord, A0_DEST_CHANNEL_ALL, 0, coord, 0, 0 );
coord = swizCoord;
}
/* Don't worry about saturate as we only support texture formats
* that are always in the 0..1 range.
*/
if (destmask != A0_DEST_CHANNEL_ALL) {
GLuint tmp = i915_get_utemp(p);
i915_emit_texld( p, 0, tmp, A0_DEST_CHANNEL_ALL, sampler, coord, op );
i915_emit_arith( p, A0_MOV, dest, destmask, 0, tmp, 0, 0 );
return dest;
}
else {
assert(GET_UREG_TYPE(dest) != REG_TYPE_CONST);
assert(dest == UREG(GET_UREG_TYPE(dest), GET_UREG_NR(dest)));
/* Can't use unsaved temps for coords, as the phase boundary would result
* in the contents becoming undefined.
*/
assert(GET_UREG_TYPE(coord) != REG_TYPE_U);
if ((GET_UREG_TYPE(coord) != REG_TYPE_R) &&
(GET_UREG_TYPE(coord) != REG_TYPE_OC) &&
(GET_UREG_TYPE(coord) != REG_TYPE_OD) &&
(GET_UREG_TYPE(coord) != REG_TYPE_T)) {
GLuint tmpCoord = get_free_rreg(p, live_regs);
if (tmpCoord == UREG_BAD)
return 0;
i915_emit_arith(p, A0_MOV, tmpCoord, A0_DEST_CHANNEL_ALL, 0, coord, 0, 0);
coord = tmpCoord;
}
/* Output register being oC or oD defines a phase boundary */
if (GET_UREG_TYPE(dest) == REG_TYPE_OC ||
GET_UREG_TYPE(dest) == REG_TYPE_OD)
p->nr_tex_indirect++;
/* Reading from an r# register whose contents depend on output of the
* current phase defines a phase boundary.
*/
if (GET_UREG_TYPE(coord) == REG_TYPE_R &&
p->register_phases[GET_UREG_NR(coord)] == p->nr_tex_indirect)
p->nr_tex_indirect++;
if (p->csr >= p->program + ARRAY_SIZE(p->program)) {
i915_program_error(p, "Program contains too many instructions");
return UREG_BAD;
}
*(p->csr++) = (op |
T0_DEST( dest ) |
T0_SAMPLER( sampler ));
*(p->csr++) = T1_ADDRESS_REG( coord );
*(p->csr++) = T2_MBZ;
if (GET_UREG_TYPE(dest) == REG_TYPE_R)
p->register_phases[GET_UREG_NR(dest)] = p->nr_tex_indirect;
p->nr_tex_insn++;
return dest;
}
}
GLuint
i915_emit_arith(struct i915_fragment_program * p,
GLuint op,
GLuint dest,
GLuint mask,
GLuint saturate, GLuint src0, GLuint src1, GLuint src2)
{
GLuint c[3];
GLuint nr_const = 0;
assert(GET_UREG_TYPE(dest) != REG_TYPE_CONST);
dest = UREG(GET_UREG_TYPE(dest), GET_UREG_NR(dest));
assert(dest);
if (GET_UREG_TYPE(src0) == REG_TYPE_CONST)
c[nr_const++] = 0;
if (GET_UREG_TYPE(src1) == REG_TYPE_CONST)
c[nr_const++] = 1;
if (GET_UREG_TYPE(src2) == REG_TYPE_CONST)
c[nr_const++] = 2;
/* Recursively call this function to MOV additional const values
* into temporary registers. Use utemp registers for this -
* currently shouldn't be possible to run out, but keep an eye on
* this.
*/
if (nr_const > 1) {
GLuint s[3], first, i, old_utemp_flag;
s[0] = src0;
s[1] = src1;
s[2] = src2;
old_utemp_flag = p->utemp_flag;
first = GET_UREG_NR(s[c[0]]);
for (i = 1; i < nr_const; i++) {
if (GET_UREG_NR(s[c[i]]) != first) {
GLuint tmp = i915_get_utemp(p);
i915_emit_arith(p, A0_MOV, tmp, A0_DEST_CHANNEL_ALL, 0,
s[c[i]], 0, 0);
s[c[i]] = tmp;
}
}
src0 = s[0];
src1 = s[1];
src2 = s[2];
p->utemp_flag = old_utemp_flag; /* restore */
}
if (p->csr >= p->program + ARRAY_SIZE(p->program)) {
i915_program_error(p, "Program contains too many instructions");
return UREG_BAD;
}
*(p->csr++) = (op | A0_DEST(dest) | mask | saturate | A0_SRC0(src0));
*(p->csr++) = (A1_SRC0(src0) | A1_SRC1(src1));
*(p->csr++) = (A2_SRC1(src1) | A2_SRC2(src2));
if (GET_UREG_TYPE(dest) == REG_TYPE_R)
p->register_phases[GET_UREG_NR(dest)] = p->nr_tex_indirect;
p->nr_alu_insn++;
return dest;
}
/* Copy compile results to the fragment program struct and destroy the
* compilation context.
*/
static void
i915_fini_compile(struct i915_context *i915, struct i915_fp_compile *p)
{
struct i915_fragment_shader *ifs = p->shader;
unsigned long program_size = (unsigned long) (p->csr - p->program);
unsigned long decl_size = (unsigned long) (p->decl - p->declarations);
if (p->nr_tex_indirect > I915_MAX_TEX_INDIRECT)
debug_printf("Exceeded max nr indirect texture lookups\n");
if (p->nr_tex_insn > I915_MAX_TEX_INSN)
i915_program_error(p, "Exceeded max TEX instructions");
if (p->nr_alu_insn > I915_MAX_ALU_INSN)
i915_program_error(p, "Exceeded max ALU instructions");
if (p->nr_decl_insn > I915_MAX_DECL_INSN)
i915_program_error(p, "Exceeded max DECL instructions");
if (p->error) {
p->NumNativeInstructions = 0;
p->NumNativeAluInstructions = 0;
p->NumNativeTexInstructions = 0;
p->NumNativeTexIndirections = 0;
i915_use_passthrough_shader(ifs);
}
else {
p->NumNativeInstructions
= p->nr_alu_insn + p->nr_tex_insn + p->nr_decl_insn;
p->NumNativeAluInstructions = p->nr_alu_insn;
p->NumNativeTexInstructions = p->nr_tex_insn;
p->NumNativeTexIndirections = p->nr_tex_indirect;
/* patch in the program length */
p->declarations[0] |= program_size + decl_size - 2;
/* Copy compilation results to fragment program struct:
*/
assert(!ifs->decl);
assert(!ifs->program);
ifs->decl
= (uint *) MALLOC(decl_size * sizeof(uint));
ifs->program
= (uint *) MALLOC(program_size * sizeof(uint));
if (ifs->decl) {
ifs->decl_len = decl_size;
memcpy(ifs->decl,
p->declarations,
decl_size * sizeof(uint));
}
if (ifs->program) {
ifs->program_len = program_size;
memcpy(ifs->program,
p->program,
program_size * sizeof(uint));
}
}
/* Release the compilation struct:
*/
FREE(p);
}
/**
* Construct a ureg for the given source register. Will emit
* constants, apply swizzling and negation as needed.
*/
static uint
src_vector(struct i915_fp_compile *p,
const struct i915_full_src_register *source,
struct i915_fragment_shader *fs)
{
uint index = source->Register.Index;
uint src = 0, sem_name, sem_ind;
switch (source->Register.File) {
case TGSI_FILE_TEMPORARY:
if (source->Register.Index >= I915_MAX_TEMPORARY) {
i915_program_error(p, "Exceeded max temporary reg");
return 0;
}
src = UREG(REG_TYPE_R, index);
break;
case TGSI_FILE_INPUT:
/* XXX: Packing COL1, FOGC into a single attribute works for
* texenv programs, but will fail for real fragment programs
* that use these attributes and expect them to be a full 4
* components wide. Could use a texcoord to pass these
* attributes if necessary, but that won't work in the general
* case.
*
* We also use a texture coordinate to pass wpos when possible.
*/
sem_name = p->shader->info.input_semantic_name[index];
sem_ind = p->shader->info.input_semantic_index[index];
switch (sem_name) {
case TGSI_SEMANTIC_POSITION:
{
/* for fragcoord */
int real_tex_unit = get_mapping(fs, I915_SEMANTIC_POS);
src = i915_emit_decl(p, REG_TYPE_T, T_TEX0 + real_tex_unit, D0_CHANNEL_ALL);
break;
}
case TGSI_SEMANTIC_COLOR:
if (sem_ind == 0) {
src = i915_emit_decl(p, REG_TYPE_T, T_DIFFUSE, D0_CHANNEL_ALL);
}
else {
/* secondary color */
assert(sem_ind == 1);
src = i915_emit_decl(p, REG_TYPE_T, T_SPECULAR, D0_CHANNEL_XYZ);
src = swizzle(src, X, Y, Z, ONE);
}
break;
case TGSI_SEMANTIC_FOG:
src = i915_emit_decl(p, REG_TYPE_T, T_FOG_W, D0_CHANNEL_W);
src = swizzle(src, W, W, W, W);
break;
case TGSI_SEMANTIC_GENERIC:
{
int real_tex_unit = get_mapping(fs, sem_ind);
src = i915_emit_decl(p, REG_TYPE_T, T_TEX0 + real_tex_unit, D0_CHANNEL_ALL);
break;
}
case TGSI_SEMANTIC_FACE:
{
/* for back/front faces */
int real_tex_unit = get_mapping(fs, I915_SEMANTIC_FACE);
src = i915_emit_decl(p, REG_TYPE_T, T_TEX0 + real_tex_unit, D0_CHANNEL_X);
break;
}
default:
i915_program_error(p, "Bad source->Index");
return 0;
}
break;
case TGSI_FILE_IMMEDIATE:
assert(index < p->num_immediates);
index = p->immediates_map[index];
/* fall-through */
case TGSI_FILE_CONSTANT:
src = UREG(REG_TYPE_CONST, index);
break;
default:
i915_program_error(p, "Bad source->File");
return 0;
}
src = swizzle(src,
source->Register.SwizzleX,
source->Register.SwizzleY,
source->Register.SwizzleZ,
source->Register.SwizzleW);
/* There's both negate-all-components and per-component negation.
* Try to handle both here.
*/
{
int n = source->Register.Negate;
src = negate(src, n, n, n, n);
}
/* no abs() */
#if 0
/* XXX assertions disabled to allow arbfplight.c to run */
/* XXX enable these assertions, or fix things */
assert(!source->Register.Absolute);
#endif
if (source->Register.Absolute)
debug_printf("Unhandled absolute value\n");
return src;
}
/*
* Translate TGSI instruction to i915 instruction.
*
* Possible concerns:
*
* DDX, DDY -- return 0
* SIN, COS -- could use another taylor step?
* LIT -- results seem a little different to sw mesa
* LOG -- different to mesa on negative numbers, but this is conformant.
*/
static void
i915_translate_instruction(struct i915_fp_compile *p,
const struct i915_full_instruction *inst,
struct i915_fragment_shader *fs)
{
uint writemask;
uint src0, src1, src2, flags;
uint tmp = 0;
switch (inst->Instruction.Opcode) {
case TGSI_OPCODE_ABS:
src0 = src_vector(p, &inst->Src[0], fs);
i915_emit_arith(p,
A0_MAX,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
src0, negate(src0, 1, 1, 1, 1), 0);
break;
case TGSI_OPCODE_ADD:
emit_simple_arith(p, inst, A0_ADD, 2, fs);
break;
case TGSI_OPCODE_CEIL:
src0 = src_vector(p, &inst->Src[0], fs);
tmp = i915_get_utemp(p);
flags = get_result_flags(inst);
i915_emit_arith(p,
A0_FLR,
tmp,
flags & A0_DEST_CHANNEL_ALL, 0,
negate(src0, 1, 1, 1, 1), 0, 0);
i915_emit_arith(p,
A0_MOV,
get_result_vector(p, &inst->Dst[0]),
flags, 0,
negate(tmp, 1, 1, 1, 1), 0, 0);
break;
case TGSI_OPCODE_CMP:
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
src2 = src_vector(p, &inst->Src[2], fs);
i915_emit_arith(p, A0_CMP,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst),
0, src0, src2, src1); /* NOTE: order of src2, src1 */
break;
case TGSI_OPCODE_COS:
src0 = src_vector(p, &inst->Src[0], fs);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_X, 0,
src0, i915_emit_const1f(p, 1.0f / (float) (M_PI * 2.0)), 0);
i915_emit_arith(p, A0_MOD, tmp, A0_DEST_CHANNEL_X, 0, tmp, 0, 0);
/*
* t0.xy = MUL x.xx11, x.x111 ; x^2, x, 1, 1
* t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, 1
* t0 = MUL t0.xxz1 t0.z111 ; x^6 x^4 x^2 1
* result = DP4 t0, cos_constants
*/
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XY, 0,
swizzle(tmp, X, X, ONE, ONE),
swizzle(tmp, X, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XYZ, 0,
swizzle(tmp, X, Y, X, ONE),
swizzle(tmp, X, X, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XYZ, 0,
swizzle(tmp, X, X, Z, ONE),
swizzle(tmp, Z, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(tmp, ONE, Z, Y, X),
i915_emit_const4fv(p, cos_constants), 0);
break;
case TGSI_OPCODE_DDX:
case TGSI_OPCODE_DDY:
/* XXX We just output 0 here */
debug_printf("Punting DDX/DDX\n");
src0 = get_result_vector(p, &inst->Dst[0]);
i915_emit_arith(p,
A0_MOV,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(src0, ZERO, ZERO, ZERO, ZERO), 0, 0);
break;
case TGSI_OPCODE_DP2:
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
i915_emit_arith(p,
A0_DP3,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(src0, X, Y, ZERO, ZERO), src1, 0);
break;
case TGSI_OPCODE_DP3:
emit_simple_arith(p, inst, A0_DP3, 2, fs);
break;
case TGSI_OPCODE_DP4:
emit_simple_arith(p, inst, A0_DP4, 2, fs);
break;
case TGSI_OPCODE_DPH:
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(src0, X, Y, Z, ONE), src1, 0);
break;
case TGSI_OPCODE_DST:
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
/* result[0] = 1 * 1;
* result[1] = a[1] * b[1];
* result[2] = a[2] * 1;
* result[3] = 1 * b[3];
*/
i915_emit_arith(p,
A0_MUL,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(src0, ONE, Y, Z, ONE),
swizzle(src1, ONE, Y, ONE, W), 0);
break;
case TGSI_OPCODE_END:
/* no-op */
break;
case TGSI_OPCODE_EX2:
src0 = src_vector(p, &inst->Src[0], fs);
i915_emit_arith(p,
A0_EXP,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case TGSI_OPCODE_FLR:
emit_simple_arith(p, inst, A0_FLR, 1, fs);
break;
case TGSI_OPCODE_FRC:
emit_simple_arith(p, inst, A0_FRC, 1, fs);
break;
case TGSI_OPCODE_KILL_IF:
/* kill if src[0].x < 0 || src[0].y < 0 ... */
src0 = src_vector(p, &inst->Src[0], fs);
tmp = i915_get_utemp(p);
i915_emit_texld(p,
tmp, /* dest reg: a dummy reg */
A0_DEST_CHANNEL_ALL, /* dest writemask */
0, /* sampler */
src0, /* coord*/
T0_TEXKILL, /* opcode */
1); /* num_coord */
break;
case TGSI_OPCODE_KILL:
/* unconditional kill */
tmp = i915_get_utemp(p);
i915_emit_texld(p,
tmp, /* dest reg: a dummy reg */
A0_DEST_CHANNEL_ALL, /* dest writemask */
0, /* sampler */
negate(swizzle(0, ONE, ONE, ONE, ONE), 1, 1, 1, 1), /* coord */
T0_TEXKILL, /* opcode */
1); /* num_coord */
break;
case TGSI_OPCODE_LG2:
src0 = src_vector(p, &inst->Src[0], fs);
i915_emit_arith(p,
A0_LOG,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case TGSI_OPCODE_LIT:
src0 = src_vector(p, &inst->Src[0], fs);
tmp = i915_get_utemp(p);
/* tmp = max( a.xyzw, a.00zw )
* XXX: Clamp tmp.w to -128..128
* tmp.y = log(tmp.y)
* tmp.y = tmp.w * tmp.y
* tmp.y = exp(tmp.y)
* result = cmp (a.11-x1, a.1x01, a.1xy1 )
*/
i915_emit_arith(p, A0_MAX, tmp, A0_DEST_CHANNEL_ALL, 0,
src0, swizzle(src0, ZERO, ZERO, Z, W), 0);
i915_emit_arith(p, A0_LOG, tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, Y, Y, Y, Y), 0, 0);
i915_emit_arith(p, A0_MUL, tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, ZERO, Y, ZERO, ZERO),
swizzle(tmp, ZERO, W, ZERO, ZERO), 0);
i915_emit_arith(p, A0_EXP, tmp, A0_DEST_CHANNEL_Y, 0,
swizzle(tmp, Y, Y, Y, Y), 0, 0);
i915_emit_arith(p, A0_CMP,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
negate(swizzle(tmp, ONE, ONE, X, ONE), 0, 0, 1, 0),
swizzle(tmp, ONE, X, ZERO, ONE),
swizzle(tmp, ONE, X, Y, ONE));
break;
case TGSI_OPCODE_LRP:
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
src2 = src_vector(p, &inst->Src[2], fs);
flags = get_result_flags(inst);
tmp = i915_get_utemp(p);
/* b*a + c*(1-a)
*
* b*a + c - ca
*
* tmp = b*a + c,
* result = (-c)*a + tmp
*/
i915_emit_arith(p, A0_MAD, tmp,
flags & A0_DEST_CHANNEL_ALL, 0, src1, src0, src2);
i915_emit_arith(p, A0_MAD,
get_result_vector(p, &inst->Dst[0]),
flags, 0, negate(src2, 1, 1, 1, 1), src0, tmp);
break;
case TGSI_OPCODE_MAD:
emit_simple_arith(p, inst, A0_MAD, 3, fs);
break;
case TGSI_OPCODE_MAX:
emit_simple_arith(p, inst, A0_MAX, 2, fs);
break;
case TGSI_OPCODE_MIN:
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
tmp = i915_get_utemp(p);
flags = get_result_flags(inst);
i915_emit_arith(p,
A0_MAX,
tmp, flags & A0_DEST_CHANNEL_ALL, 0,
negate(src0, 1, 1, 1, 1),
negate(src1, 1, 1, 1, 1), 0);
i915_emit_arith(p,
A0_MOV,
get_result_vector(p, &inst->Dst[0]),
flags, 0, negate(tmp, 1, 1, 1, 1), 0, 0);
break;
case TGSI_OPCODE_MOV:
emit_simple_arith(p, inst, A0_MOV, 1, fs);
break;
case TGSI_OPCODE_MUL:
emit_simple_arith(p, inst, A0_MUL, 2, fs);
break;
case TGSI_OPCODE_NOP:
break;
case TGSI_OPCODE_POW:
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
tmp = i915_get_utemp(p);
flags = get_result_flags(inst);
/* XXX: masking on intermediate values, here and elsewhere.
*/
i915_emit_arith(p,
A0_LOG,
tmp, A0_DEST_CHANNEL_X, 0,
swizzle(src0, X, X, X, X), 0, 0);
i915_emit_arith(p, A0_MUL, tmp, A0_DEST_CHANNEL_X, 0, tmp, src1, 0);
i915_emit_arith(p,
A0_EXP,
get_result_vector(p, &inst->Dst[0]),
flags, 0, swizzle(tmp, X, X, X, X), 0, 0);
break;
case TGSI_OPCODE_RET:
/* XXX: no-op? */
break;
case TGSI_OPCODE_RCP:
src0 = src_vector(p, &inst->Src[0], fs);
i915_emit_arith(p,
A0_RCP,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case TGSI_OPCODE_RSQ:
src0 = src_vector(p, &inst->Src[0], fs);
i915_emit_arith(p,
A0_RSQ,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(src0, X, X, X, X), 0, 0);
break;
case TGSI_OPCODE_SCS:
src0 = src_vector(p, &inst->Src[0], fs);
tmp = i915_get_utemp(p);
/*
* t0.xy = MUL x.xx11, x.x1111 ; x^2, x, 1, 1
* t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, x
* t1 = MUL t0.xyyw t0.yz11 ; x^7 x^5 x^3 x
* scs.x = DP4 t1, scs_sin_constants
* t1 = MUL t0.xxz1 t0.z111 ; x^6 x^4 x^2 1
* scs.y = DP4 t1, scs_cos_constants
*/
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XY, 0,
swizzle(src0, X, X, ONE, ONE),
swizzle(src0, X, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, X, Y),
swizzle(tmp, X, X, ONE, ONE), 0);
writemask = inst->Dst[0].Register.WriteMask;
if (writemask & TGSI_WRITEMASK_Y) {
uint tmp1;
if (writemask & TGSI_WRITEMASK_X)
tmp1 = i915_get_utemp(p);
else
tmp1 = tmp;
i915_emit_arith(p,
A0_MUL,
tmp1, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, Y, W),
swizzle(tmp, X, Z, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, &inst->Dst[0]),
A0_DEST_CHANNEL_Y, 0,
swizzle(tmp1, W, Z, Y, X),
i915_emit_const4fv(p, scs_sin_constants), 0);
}
if (writemask & TGSI_WRITEMASK_X) {
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XYZ, 0,
swizzle(tmp, X, X, Z, ONE),
swizzle(tmp, Z, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, &inst->Dst[0]),
A0_DEST_CHANNEL_X, 0,
swizzle(tmp, ONE, Z, Y, X),
i915_emit_const4fv(p, scs_cos_constants), 0);
}
break;
case TGSI_OPCODE_SEQ:
/* if we're both >= and <= then we're == */
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_SGE,
tmp, A0_DEST_CHANNEL_ALL, 0,
src0,
src1, 0);
i915_emit_arith(p,
A0_SGE,
get_result_vector(p, &inst->Dst[0]),
A0_DEST_CHANNEL_ALL, 0,
src1,
src0, 0);
i915_emit_arith(p,
A0_MUL,
get_result_vector(p, &inst->Dst[0]),
A0_DEST_CHANNEL_ALL, 0,
get_result_vector(p, &inst->Dst[0]),
tmp, 0);
break;
case TGSI_OPCODE_SGE:
emit_simple_arith(p, inst, A0_SGE, 2, fs);
break;
case TGSI_OPCODE_SIN:
src0 = src_vector(p, &inst->Src[0], fs);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_X, 0,
src0, i915_emit_const1f(p, 1.0f / (float) (M_PI * 2.0)), 0);
i915_emit_arith(p, A0_MOD, tmp, A0_DEST_CHANNEL_X, 0, tmp, 0, 0);
/*
* t0.xy = MUL x.xx11, x.x1111 ; x^2, x, 1, 1
* t0 = MUL t0.xyxy t0.xx11 ; x^4, x^3, x^2, x
* t1 = MUL t0.xyyw t0.yz11 ; x^7 x^5 x^3 x
* result = DP4 t1.wzyx, sin_constants
*/
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_XY, 0,
swizzle(tmp, X, X, ONE, ONE),
swizzle(tmp, X, ONE, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, X, Y),
swizzle(tmp, X, X, ONE, ONE), 0);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(tmp, X, Y, Y, W),
swizzle(tmp, X, Z, ONE, ONE), 0);
i915_emit_arith(p,
A0_DP4,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(tmp, W, Z, Y, X),
i915_emit_const4fv(p, sin_constants), 0);
break;
case TGSI_OPCODE_SLE:
/* like SGE, but swap reg0, reg1 */
emit_simple_arith_swap2(p, inst, A0_SGE, 2, fs);
break;
case TGSI_OPCODE_SLT:
emit_simple_arith(p, inst, A0_SLT, 2, fs);
break;
case TGSI_OPCODE_SGT:
/* like SLT, but swap reg0, reg1 */
emit_simple_arith_swap2(p, inst, A0_SLT, 2, fs);
break;
case TGSI_OPCODE_SNE:
/* if we're < or > then we're != */
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_SLT,
tmp,
A0_DEST_CHANNEL_ALL, 0,
src0,
src1, 0);
i915_emit_arith(p,
A0_SLT,
get_result_vector(p, &inst->Dst[0]),
A0_DEST_CHANNEL_ALL, 0,
src1,
src0, 0);
i915_emit_arith(p,
A0_ADD,
get_result_vector(p, &inst->Dst[0]),
A0_DEST_CHANNEL_ALL, 0,
get_result_vector(p, &inst->Dst[0]),
tmp, 0);
break;
case TGSI_OPCODE_SSG:
/* compute (src>0) - (src<0) */
src0 = src_vector(p, &inst->Src[0], fs);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_SLT,
tmp,
A0_DEST_CHANNEL_ALL, 0,
src0,
swizzle(src0, ZERO, ZERO, ZERO, ZERO), 0);
i915_emit_arith(p,
A0_SLT,
get_result_vector(p, &inst->Dst[0]),
A0_DEST_CHANNEL_ALL, 0,
swizzle(src0, ZERO, ZERO, ZERO, ZERO),
src0, 0);
i915_emit_arith(p,
A0_ADD,
get_result_vector(p, &inst->Dst[0]),
A0_DEST_CHANNEL_ALL, 0,
get_result_vector(p, &inst->Dst[0]),
negate(tmp, 1, 1, 1, 1), 0);
break;
case TGSI_OPCODE_SUB:
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
i915_emit_arith(p,
A0_ADD,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
src0, negate(src1, 1, 1, 1, 1), 0);
break;
case TGSI_OPCODE_TEX:
emit_tex(p, inst, T0_TEXLD, fs);
break;
case TGSI_OPCODE_TRUNC:
emit_simple_arith(p, inst, A0_TRC, 1, fs);
break;
case TGSI_OPCODE_TXB:
emit_tex(p, inst, T0_TEXLDB, fs);
break;
case TGSI_OPCODE_TXP:
emit_tex(p, inst, T0_TEXLDP, fs);
break;
case TGSI_OPCODE_XPD:
/* Cross product:
* result.x = src0.y * src1.z - src0.z * src1.y;
* result.y = src0.z * src1.x - src0.x * src1.z;
* result.z = src0.x * src1.y - src0.y * src1.x;
* result.w = undef;
*/
src0 = src_vector(p, &inst->Src[0], fs);
src1 = src_vector(p, &inst->Src[1], fs);
tmp = i915_get_utemp(p);
i915_emit_arith(p,
A0_MUL,
tmp, A0_DEST_CHANNEL_ALL, 0,
swizzle(src0, Z, X, Y, ONE),
swizzle(src1, Y, Z, X, ONE), 0);
i915_emit_arith(p,
A0_MAD,
get_result_vector(p, &inst->Dst[0]),
get_result_flags(inst), 0,
swizzle(src0, Y, Z, X, ONE),
swizzle(src1, Z, X, Y, ONE),
negate(tmp, 1, 1, 1, 0));
break;
default:
i915_program_error(p, "bad opcode %d", inst->Instruction.Opcode);
p->error = 1;
return;
}
i915_release_utemps(p);
}
/**
* Emit a texture load or texkill instruction.
* \param dest the dest i915 register
* \param destmask the dest register writemask
* \param sampler the i915 sampler register
* \param coord the i915 source texcoord operand
* \param opcode the instruction opcode
*/
uint i915_emit_texld( struct i915_fp_compile *p,
uint dest,
uint destmask,
uint sampler,
uint coord,
uint opcode,
uint num_coord )
{
const uint k = UREG(GET_UREG_TYPE(coord), GET_UREG_NR(coord));
int temp = -1;
uint ignore = 0;
/* Eliminate the useless texture coordinates. Otherwise we end up generating
* a swizzle for no reason below. */
switch(num_coord) {
case 0:
/* Ignore x */
ignore |= (0xf << UREG_CHANNEL_X_SHIFT);
case 1:
/* Ignore y */
ignore |= (0xf << UREG_CHANNEL_Y_SHIFT);
case 2:
/* Ignore z */
ignore |= (0xf << UREG_CHANNEL_Z_SHIFT);
case 3:
/* Ignore w */
ignore |= (0xf << UREG_CHANNEL_W_SHIFT);
}
if ( (coord &~ignore ) != (k & ~ignore) ) {
/* texcoord is swizzled or negated. Need to allocate a new temporary
* register (a utemp / unpreserved temp) won't do.
*/
uint tempReg;
temp = i915_get_temp(p); /* get temp reg index */
tempReg = UREG(REG_TYPE_R, temp); /* make i915 register */
i915_emit_arith( p, A0_MOV,
tempReg, A0_DEST_CHANNEL_ALL, /* dest reg, writemask */
0, /* saturate */
coord, 0, 0 ); /* src0, src1, src2 */
/* new src texcoord is tempReg */
coord = tempReg;
}
/* Don't worry about saturate as we only support
*/
if (destmask != A0_DEST_CHANNEL_ALL) {
/* if not writing to XYZW... */
uint tmp = i915_get_utemp(p);
i915_emit_texld( p, tmp, A0_DEST_CHANNEL_ALL, sampler, coord, opcode, num_coord );
i915_emit_arith( p, A0_MOV, dest, destmask, 0, tmp, 0, 0 );
/* XXX release utemp here? */
}
else {
assert(GET_UREG_TYPE(dest) != REG_TYPE_CONST);
assert(dest == UREG(GET_UREG_TYPE(dest), GET_UREG_NR(dest)));
/* Output register being oC or oD defines a phase boundary */
if (GET_UREG_TYPE(dest) == REG_TYPE_OC ||
GET_UREG_TYPE(dest) == REG_TYPE_OD)
p->nr_tex_indirect++;
/* Reading from an r# register whose contents depend on output of the
* current phase defines a phase boundary.
*/
if (GET_UREG_TYPE(coord) == REG_TYPE_R &&
p->register_phases[GET_UREG_NR(coord)] == p->nr_tex_indirect)
p->nr_tex_indirect++;
if (p->csr< p->program + I915_PROGRAM_SIZE) {
*(p->csr++) = (opcode |
T0_DEST( dest ) |
T0_SAMPLER( sampler ));
*(p->csr++) = T1_ADDRESS_REG( coord );
*(p->csr++) = T2_MBZ;
}
else
i915_program_error(p, "Out of instructions");
if (GET_UREG_TYPE(dest) == REG_TYPE_R)
p->register_phases[GET_UREG_NR(dest)] = p->nr_tex_indirect;
p->nr_tex_insn++;
}
if (temp >= 0)
i915_release_temp(p, temp);
return dest;
}
