static boolean get_buffer_ptr( struct aos_compilation *cp,
boolean linear,
unsigned buf_idx,
struct x86_reg elt,
struct x86_reg ptr)
{
struct x86_reg buf = x86_make_disp(aos_get_x86( cp, 0, X86_BUFFERS ),
buf_idx * sizeof(struct aos_buffer));
struct x86_reg buf_stride = x86_make_disp(buf,
Offset(struct aos_buffer, stride));
if (linear) {
struct x86_reg buf_ptr = x86_make_disp(buf,
Offset(struct aos_buffer, ptr));
/* Calculate pointer to current attrib:
*/
x86_mov(cp->func, ptr, buf_ptr);
x86_mov(cp->func, elt, buf_stride);
x86_add(cp->func, elt, ptr);
if (buf_idx == 0) sse_prefetchnta(cp->func, x86_make_disp(elt, 192));
x86_mov(cp->func, buf_ptr, elt);
}
else {
static void update_src_ptr( struct x86_program *p,
struct x86_reg srcREG,
struct x86_reg vtxREG,
struct tnl_clipspace_attr *a )
{
if (a->inputstride) {
struct tnl_clipspace *vtx = GET_VERTEX_STATE(p->ctx);
struct x86_reg ptr_to_src = x86_make_disp(vtxREG, get_offset(vtx, &a->inputptr));
/* add a[j].inputstride (hardcoded value - could just as easily
* pull the stride value from memory each time).
*/
x86_lea(&p->func, srcREG, x86_make_disp(srcREG, a->inputstride));
/* save new value of a[j].inputptr
*/
x86_mov(&p->func, ptr_to_src, srcREG);
}
}
/* Not much happens here. Eventually use this function to try and
* avoid saving/reloading the source pointers each vertex (if some of
* them can fit in registers).
*/
static void get_src_ptr( struct x86_program *p,
struct x86_reg srcREG,
struct x86_reg vtxREG,
struct tnl_clipspace_attr *a )
{
struct tnl_clipspace *vtx = GET_VERTEX_STATE(p->ctx);
struct x86_reg ptr_to_src = x86_make_disp(vtxREG, get_offset(vtx, &a->inputptr));
/* Load current a[j].inputptr
*/
x86_mov(&p->func, srcREG, ptr_to_src);
}
static void emit_load4f_3( struct x86_program *p,
struct x86_reg dest,
struct x86_reg arg0 )
{
/* Have to jump through some hoops:
*
* c 0 0 0
* c 0 0 1
* 0 0 c 1
* a b c 1
*/
sse_movss(&p->func, dest, x86_make_disp(arg0, 8));
sse_shufps(&p->func, dest, get_identity(p), SHUF(X,Y,Z,W) );
sse_shufps(&p->func, dest, dest, SHUF(Y,Z,X,W) );
sse_movlps(&p->func, dest, arg0);
}
static void emit_store3f( struct x86_program *p,
struct x86_reg dest,
struct x86_reg arg0 )
{
if (p->outputs_safe) {
/* Emit the extra dword anyway. This may hurt writecombining,
* may cause other problems.
*/
sse_movups(&p->func, dest, arg0);
}
else {
/* Alternate strategy - emit two, shuffle, emit one.
*/
sse_movlps(&p->func, dest, arg0);
sse_shufps(&p->func, arg0, arg0, SHUF(Z,Z,Z,Z) ); /* NOTE! destructive */
sse_movss(&p->func, x86_make_disp(dest,8), arg0);
}
}
static void emit_load3f_3( struct x86_program *p,
struct x86_reg dest,
struct x86_reg arg0 )
{
/* Over-reads by 1 dword - potential SEGV if input is a vertex
* array.
*/
if (p->inputs_safe) {
sse_movups(&p->func, dest, arg0);
}
else {
/* c 0 0 0
* c c c c
* a b c c
*/
sse_movss(&p->func, dest, x86_make_disp(arg0, 8));
sse_shufps(&p->func, dest, dest, SHUF(X,X,X,X));
sse_movlps(&p->func, dest, arg0);
}
}
static void emit_load_R32G32B32( struct aos_compilation *cp,
struct x86_reg data,
struct x86_reg src_ptr )
{
#if 1
sse_movss(cp->func, data, x86_make_disp(src_ptr, 8));
/* data = z ? ? ? */
sse_shufps(cp->func, data, aos_get_internal_xmm( cp, IMM_IDENTITY ), SHUF(X,Y,Z,W) );
/* data = z ? 0 1 */
sse_shufps(cp->func, data, data, SHUF(Y,Z,X,W) );
/* data = ? 0 z 1 */
sse_movlps(cp->func, data, src_ptr);
/* data = x y z 1 */
#else
sse_movups(cp->func, data, src_ptr);
/* data = x y z ? */
sse2_pshufd(cp->func, data, data, SHUF(W,X,Y,Z) );
/* data = ? x y z */
sse_movss(cp->func, data, aos_get_internal_xmm( cp, IMM_ONES ) );
/* data = 1 x y z */
sse2_pshufd(cp->func, data, data, SHUF(Y,Z,W,X) );
/* data = x y z 1 */
#endif
}
struct x86_reg x86_deref( struct x86_reg reg )
{
return x86_make_disp(reg, 0);
}
/* Retreive a reference to one of the function arguments, taking into
* account any push/pop activity:
*/
struct x86_reg x86_fn_arg( struct x86_function *p,
unsigned arg )
{
return x86_make_disp(x86_make_reg(file_REG32, reg_SP),
p->stack_offset + arg * 4); /* ??? */
}
/* Lots of hardcoding
*
* EAX -- pointer to current output vertex
* ECX -- pointer to current attribute
*
*/
static GLboolean build_vertex_emit( struct x86_program *p )
{
struct gl_context *ctx = p->ctx;
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
GLuint j = 0;
struct x86_reg vertexEAX = x86_make_reg(file_REG32, reg_AX);
struct x86_reg srcECX = x86_make_reg(file_REG32, reg_CX);
struct x86_reg countEBP = x86_make_reg(file_REG32, reg_BP);
struct x86_reg vtxESI = x86_make_reg(file_REG32, reg_SI);
struct x86_reg temp = x86_make_reg(file_XMM, 0);
struct x86_reg vp0 = x86_make_reg(file_XMM, 1);
struct x86_reg vp1 = x86_make_reg(file_XMM, 2);
struct x86_reg temp2 = x86_make_reg(file_XMM, 3);
GLubyte *fixup, *label;
/* Push a few regs?
*/
x86_push(&p->func, countEBP);
x86_push(&p->func, vtxESI);
/* Get vertex count, compare to zero
*/
x86_xor(&p->func, srcECX, srcECX);
x86_mov(&p->func, countEBP, x86_fn_arg(&p->func, 2));
x86_cmp(&p->func, countEBP, srcECX);
fixup = x86_jcc_forward(&p->func, cc_E);
/* Initialize destination register.
*/
x86_mov(&p->func, vertexEAX, x86_fn_arg(&p->func, 3));
/* Dereference ctx to get tnl, then vtx:
*/
x86_mov(&p->func, vtxESI, x86_fn_arg(&p->func, 1));
x86_mov(&p->func, vtxESI, x86_make_disp(vtxESI, get_offset(ctx, &ctx->swtnl_context)));
vtxESI = x86_make_disp(vtxESI, get_offset(tnl, &tnl->clipspace));
/* Possibly load vp0, vp1 for viewport calcs:
*/
if (vtx->need_viewport) {
sse_movups(&p->func, vp0, x86_make_disp(vtxESI, get_offset(vtx, &vtx->vp_scale[0])));
sse_movups(&p->func, vp1, x86_make_disp(vtxESI, get_offset(vtx, &vtx->vp_xlate[0])));
}
/* always load, needed or not:
*/
sse_movups(&p->func, p->chan0, x86_make_disp(vtxESI, get_offset(vtx, &vtx->chan_scale[0])));
sse_movups(&p->func, p->identity, x86_make_disp(vtxESI, get_offset(vtx, &vtx->identity[0])));
/* Note address for loop jump */
label = x86_get_label(&p->func);
/* Emit code for each of the attributes. Currently routes
* everything through SSE registers, even when it might be more
* efficient to stick with regular old x86. No optimization or
* other tricks - enough new ground to cover here just getting
* things working.
*/
while (j < vtx->attr_count) {
struct tnl_clipspace_attr *a = &vtx->attr[j];
struct x86_reg dest = x86_make_disp(vertexEAX, a->vertoffset);
/* Now, load an XMM reg from src, perhaps transform, then save.
* Could be shortcircuited in specific cases:
*/
switch (a->format) {
case EMIT_1F:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 1, x86_deref(srcECX), a->inputsize);
emit_store(p, dest, 1, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_2F:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 2, x86_deref(srcECX), a->inputsize);
emit_store(p, dest, 2, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_3F:
/* Potentially the worst case - hardcode 2+1 copying:
*/
if (0) {
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 3, x86_deref(srcECX), a->inputsize);
emit_store(p, dest, 3, temp);
update_src_ptr(p, srcECX, vtxESI, a);
}
else {
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 2, x86_deref(srcECX), a->inputsize);
emit_store(p, dest, 2, temp);
if (a->inputsize > 2) {
emit_load(p, temp, 1, x86_make_disp(srcECX, 8), 1);
emit_store(p, x86_make_disp(dest,8), 1, temp);
}
else {
sse_movss(&p->func, x86_make_disp(dest,8), get_identity(p));
}
update_src_ptr(p, srcECX, vtxESI, a);
}
break;
case EMIT_4F:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 4, x86_deref(srcECX), a->inputsize);
emit_store(p, dest, 4, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_2F_VIEWPORT:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 2, x86_deref(srcECX), a->inputsize);
sse_mulps(&p->func, temp, vp0);
sse_addps(&p->func, temp, vp1);
emit_store(p, dest, 2, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_3F_VIEWPORT:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 3, x86_deref(srcECX), a->inputsize);
sse_mulps(&p->func, temp, vp0);
sse_addps(&p->func, temp, vp1);
emit_store(p, dest, 3, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_4F_VIEWPORT:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 4, x86_deref(srcECX), a->inputsize);
sse_mulps(&p->func, temp, vp0);
sse_addps(&p->func, temp, vp1);
emit_store(p, dest, 4, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_3F_XYW:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 4, x86_deref(srcECX), a->inputsize);
sse_shufps(&p->func, temp, temp, SHUF(X,Y,W,Z));
emit_store(p, dest, 3, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_1UB_1F:
/* Test for PAD3 + 1UB:
*/
if (j > 0 &&
a[-1].vertoffset + a[-1].vertattrsize <= a->vertoffset - 3)
{
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 1, x86_deref(srcECX), a->inputsize);
sse_shufps(&p->func, temp, temp, SHUF(X,X,X,X));
emit_pack_store_4ub(p, x86_make_disp(dest, -3), temp); /* overkill! */
update_src_ptr(p, srcECX, vtxESI, a);
}
else {
printf("Can't emit 1ub %x %x %d\n", a->vertoffset, a[-1].vertoffset, a[-1].vertattrsize );
return GL_FALSE;
}
break;
case EMIT_3UB_3F_RGB:
case EMIT_3UB_3F_BGR:
/* Test for 3UB + PAD1:
*/
if (j == vtx->attr_count - 1 ||
a[1].vertoffset >= a->vertoffset + 4) {
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 3, x86_deref(srcECX), a->inputsize);
if (a->format == EMIT_3UB_3F_BGR)
sse_shufps(&p->func, temp, temp, SHUF(Z,Y,X,W));
emit_pack_store_4ub(p, dest, temp);
update_src_ptr(p, srcECX, vtxESI, a);
}
/* Test for 3UB + 1UB:
*/
else if (j < vtx->attr_count - 1 &&
a[1].format == EMIT_1UB_1F &&
a[1].vertoffset == a->vertoffset + 3) {
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 3, x86_deref(srcECX), a->inputsize);
update_src_ptr(p, srcECX, vtxESI, a);
/* Make room for incoming value:
*/
sse_shufps(&p->func, temp, temp, SHUF(W,X,Y,Z));
get_src_ptr(p, srcECX, vtxESI, &a[1]);
emit_load(p, temp2, 1, x86_deref(srcECX), a[1].inputsize);
sse_movss(&p->func, temp, temp2);
update_src_ptr(p, srcECX, vtxESI, &a[1]);
/* Rearrange and possibly do BGR conversion:
*/
if (a->format == EMIT_3UB_3F_BGR)
sse_shufps(&p->func, temp, temp, SHUF(W,Z,Y,X));
else
sse_shufps(&p->func, temp, temp, SHUF(Y,Z,W,X));
emit_pack_store_4ub(p, dest, temp);
j++; /* NOTE: two attrs consumed */
}
else {
printf("Can't emit 3ub\n");
return GL_FALSE; /* add this later */
}
break;
case EMIT_4UB_4F_RGBA:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 4, x86_deref(srcECX), a->inputsize);
emit_pack_store_4ub(p, dest, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_4UB_4F_BGRA:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 4, x86_deref(srcECX), a->inputsize);
sse_shufps(&p->func, temp, temp, SHUF(Z,Y,X,W));
emit_pack_store_4ub(p, dest, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_4UB_4F_ARGB:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 4, x86_deref(srcECX), a->inputsize);
sse_shufps(&p->func, temp, temp, SHUF(W,X,Y,Z));
emit_pack_store_4ub(p, dest, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_4UB_4F_ABGR:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 4, x86_deref(srcECX), a->inputsize);
sse_shufps(&p->func, temp, temp, SHUF(W,Z,Y,X));
emit_pack_store_4ub(p, dest, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case EMIT_4CHAN_4F_RGBA:
switch (CHAN_TYPE) {
case GL_UNSIGNED_BYTE:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 4, x86_deref(srcECX), a->inputsize);
emit_pack_store_4ub(p, dest, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case GL_FLOAT:
get_src_ptr(p, srcECX, vtxESI, a);
emit_load(p, temp, 4, x86_deref(srcECX), a->inputsize);
emit_store(p, dest, 4, temp);
update_src_ptr(p, srcECX, vtxESI, a);
break;
case GL_UNSIGNED_SHORT:
default:
printf("unknown CHAN_TYPE %s\n", _mesa_lookup_enum_by_nr(CHAN_TYPE));
return GL_FALSE;
}
break;
default:
printf("unknown a[%d].format %d\n", j, a->format);
return GL_FALSE; /* catch any new opcodes */
}
/* Increment j by at least 1 - may have been incremented above also:
*/
j++;
}
/* Next vertex:
*/
x86_lea(&p->func, vertexEAX, x86_make_disp(vertexEAX, vtx->vertex_size));
/* decr count, loop if not zero
*/
x86_dec(&p->func, countEBP);
x86_test(&p->func, countEBP, countEBP);
x86_jcc(&p->func, cc_NZ, label);
/* Exit mmx state?
*/
if (p->func.need_emms)
mmx_emms(&p->func);
/* Land forward jump here:
*/
x86_fixup_fwd_jump(&p->func, fixup);
/* Pop regs and return
*/
x86_pop(&p->func, x86_get_base_reg(vtxESI));
x86_pop(&p->func, countEBP);
x86_ret(&p->func);
assert(!vtx->emit);
vtx->emit = (tnl_emit_func)x86_get_func(&p->func);
assert( (char *) p->func.csr - (char *) p->func.store <= MAX_SSE_CODE_SIZE );
return GL_TRUE;
}
