/**
* Find the live intervals for each temporary register in the program.
* For register R, the interval [A,B] indicates that R is referenced
* from instruction A through instruction B.
* Special consideration is needed for loops and subroutines.
* \return GL_TRUE if success, GL_FALSE if we cannot proceed for some reason
*/
static GLboolean
find_live_intervals(struct gl_program *prog,
struct interval_list *liveIntervals)
{
GLint intBegin[MAX_PROGRAM_TEMPS], intEnd[MAX_PROGRAM_TEMPS];
GLuint i;
/*
* Note: we'll return GL_FALSE below if we find relative indexing
* into the TEMP register file. We can't handle that yet.
* We also give up on subroutines for now.
*/
if (dbg) {
_mesa_printf("Optimize: Begin find intervals\n");
}
/* build intermediate arrays */
if (!_mesa_find_temp_intervals(prog->Instructions, prog->NumInstructions,
intBegin, intEnd))
return GL_FALSE;
/* Build live intervals list from intermediate arrays */
liveIntervals->Num = 0;
for (i = 0; i < MAX_PROGRAM_TEMPS; i++) {
if (intBegin[i] >= 0) {
struct interval inv;
inv.Reg = i;
inv.Start = intBegin[i];
inv.End = intEnd[i];
append_interval(liveIntervals, &inv);
}
}
/* Sort the list according to interval starts */
sort_interval_list_by_start(liveIntervals);
if (dbg) {
/* print interval info */
for (i = 0; i < liveIntervals->Num; i++) {
const struct interval *inv = liveIntervals->Intervals + i;
_mesa_printf("Reg[%d] live [%d, %d]:",
inv->Reg, inv->Start, inv->End);
if (1) {
int j;
for (j = 0; j < inv->Start; j++)
_mesa_printf(" ");
for (j = inv->Start; j <= inv->End; j++)
_mesa_printf("x");
}
_mesa_printf("\n");
}
}
return GL_TRUE;
}
static void
PrintDstReg(const struct prog_dst_register *dst)
{
if (dst->File == PROGRAM_OUTPUT) {
_mesa_printf("o[%s]", OutputRegisters[dst->Index]);
}
else if (dst->File == PROGRAM_INPUT) {
_mesa_printf("v[%s]", InputRegisters[dst->Index]);
}
else if (dst->File == PROGRAM_ENV_PARAM) {
_mesa_printf("c[%d]", dst->Index);
}
else {
ASSERT(dst->File == PROGRAM_TEMPORARY);
_mesa_printf("R%d", dst->Index);
}
if (dst->WriteMask != 0 && dst->WriteMask != WRITEMASK_XYZW) {
_mesa_printf(".");
if (dst->WriteMask & WRITEMASK_X)
_mesa_printf("x");
if (dst->WriteMask & WRITEMASK_Y)
_mesa_printf("y");
if (dst->WriteMask & WRITEMASK_Z)
_mesa_printf("z");
if (dst->WriteMask & WRITEMASK_W)
_mesa_printf("w");
}
}
static void
PrintDstReg(const struct vp_dst_register *dst)
{
GLint w = dst->WriteMask[0] + dst->WriteMask[1]
+ dst->WriteMask[2] + dst->WriteMask[3];
if (dst->File == PROGRAM_OUTPUT) {
_mesa_printf("o[%s]", OutputRegisters[dst->Index]);
}
else if (dst->File == PROGRAM_INPUT) {
_mesa_printf("v[%s]", InputRegisters[dst->Index]);
}
else if (dst->File == PROGRAM_ENV_PARAM) {
_mesa_printf("c[%d]", dst->Index);
}
else {
ASSERT(dst->File == PROGRAM_TEMPORARY);
_mesa_printf("R%d", dst->Index);
}
if (w != 0 && w != 4) {
_mesa_printf(".");
if (dst->WriteMask[0])
_mesa_printf("x");
if (dst->WriteMask[1])
_mesa_printf("y");
if (dst->WriteMask[2])
_mesa_printf("z");
if (dst->WriteMask[3])
_mesa_printf("w");
}
}
void
_mesa_print_swizzle(GLuint swizzle)
{
if (swizzle == SWIZZLE_XYZW) {
_mesa_printf(".xyzw\n");
}
else {
const char *s = _mesa_swizzle_string(swizzle, 0, 0);
_mesa_printf("%s\n", s);
}
}
/* Use a hashtable to attempt to identify recently-emitted vertices
* and avoid re-emitting them.
*/
static GLuint elt(struct copy_context *copy, GLuint elt_idx)
{
GLuint elt = copy->srcelt[elt_idx];
GLuint slot = elt & (ELT_TABLE_SIZE-1);
/* _mesa_printf("elt %d\n", elt); */
/* Look up the incoming element in the vertex cache. Re-emit if
* necessary.
*/
if (copy->vert_cache[slot].in != elt) {
GLubyte *csr = copy->dstptr;
GLuint i;
/* _mesa_printf(" --> emit to dstelt %d\n", copy->dstbuf_nr); */
for (i = 0; i < copy->nr_varying; i++) {
const struct gl_client_array *srcarray = copy->varying[i].array;
const GLubyte *srcptr = copy->varying[i].src_ptr + elt * srcarray->StrideB;
memcpy(csr, srcptr, copy->varying[i].size);
csr += copy->varying[i].size;
if (0)
{
const GLuint *f = (const GLuint *)srcptr;
GLuint j;
_mesa_printf(" varying %d: ", i);
for(j = 0; j < copy->varying[i].size / 4; j++)
_mesa_printf("%x ", f[j]);
_mesa_printf("\n");
}
}
copy->vert_cache[slot].in = elt;
copy->vert_cache[slot].out = copy->dstbuf_nr++;
copy->dstptr += copy->vertex_size;
assert(csr == copy->dstptr);
assert(copy->dstptr == (copy->dstbuf +
copy->dstbuf_nr *
copy->vertex_size));
}
/* else */
/* _mesa_printf(" --> reuse vertex\n"); */
/* _mesa_printf(" --> emit %d\n", copy->vert_cache[slot].out); */
copy->dstelt[copy->dstelt_nr++] = copy->vert_cache[slot].out;
return check_flush(copy);
}
GLuint vf_set_vertex_attributes( struct vertex_fetch *vf,
const struct vf_attr_map *map,
GLuint nr,
GLuint vertex_stride )
{
GLuint offset = 0;
GLuint i, j;
assert(nr < VF_ATTRIB_MAX);
memset(vf->lookup, 0, sizeof(vf->lookup));
for (j = 0, i = 0; i < nr; i++) {
const GLuint format = map[i].format;
if (format == EMIT_PAD) {
if (DBG)
_mesa_printf("%d: pad %d, offset %d\n", i,
map[i].offset, offset);
offset += map[i].offset;
}
else {
assert(vf->lookup[map[i].attrib] == 0);
vf->lookup[map[i].attrib] = &vf->attr[j];
vf->attr[j].attrib = map[i].attrib;
vf->attr[j].format = format;
vf->attr[j].insert = vf_format_info[format].insert;
vf->attr[j].extract = vf_format_info[format].extract;
vf->attr[j].vertattrsize = vf_format_info[format].attrsize;
vf->attr[j].vertoffset = offset;
if (DBG)
_mesa_printf("%d: %s, offset %d\n", i,
vf_format_info[format].name,
vf->attr[j].vertoffset);
offset += vf_format_info[format].attrsize;
j++;
}
}
vf->attr_count = j;
vf->vertex_stride = vertex_stride ? vertex_stride : offset;
vf->emit = choose_emit_func;
assert(vf->vertex_stride >= offset);
return vf->vertex_stride;
}
static void debug_insn( struct prog_instruction *inst, const char *fn,
GLuint line )
{
if (DISASSEM) {
static const char *last_fn;
if (fn != last_fn) {
last_fn = fn;
_mesa_printf("%s:\n", fn);
}
_mesa_printf("%d:\t", line);
_mesa_print_instruction(inst);
}
}
static GLuint get_surface_type( GLenum type, GLuint size, GLboolean normalized )
{
if (INTEL_DEBUG & DEBUG_VERTS)
_mesa_printf("type %s size %d normalized %d\n",
_mesa_lookup_enum_by_nr(type), size, normalized);
if (normalized) {
switch (type) {
case GL_DOUBLE: return double_types[size];
case GL_FLOAT: return float_types[size];
case GL_INT: return int_types_norm[size];
case GL_SHORT: return short_types_norm[size];
case GL_BYTE: return byte_types_norm[size];
case GL_UNSIGNED_INT: return uint_types_norm[size];
case GL_UNSIGNED_SHORT: return ushort_types_norm[size];
case GL_UNSIGNED_BYTE: return ubyte_types_norm[size];
default: assert(0); return 0;
}
}
else {
switch (type) {
case GL_DOUBLE: return double_types[size];
case GL_FLOAT: return float_types[size];
case GL_INT: return int_types_scale[size];
case GL_SHORT: return short_types_scale[size];
case GL_BYTE: return byte_types_scale[size];
case GL_UNSIGNED_INT: return uint_types_scale[size];
case GL_UNSIGNED_SHORT: return ushort_types_scale[size];
case GL_UNSIGNED_BYTE: return ubyte_types_scale[size];
default: assert(0); return 0;
}
}
}
void *
_mesa_exec_malloc(GLuint size)
{
struct mem_block *block = NULL;
void *addr = NULL;
_glthread_LOCK_MUTEX(exec_mutex);
if (!init_heap())
goto bail;
if (exec_heap) {
size = (size + 31) & ~31;
block = mmAllocMem( exec_heap, size, 32, 0 );
}
if (block)
addr = exec_mem + block->ofs;
else
_mesa_printf("_mesa_exec_malloc failed\n");
bail:
_glthread_UNLOCK_MUTEX(exec_mutex);
return addr;
}
static const struct brw_wm_ref *get_param_ref( struct brw_wm_compile *c,
const GLfloat *param_ptr )
{
GLuint i = c->prog_data.nr_params++;
if (i >= BRW_WM_MAX_PARAM) {
_mesa_printf("%s: out of params\n", __FUNCTION__);
c->prog_data.error = 1;
return NULL;
}
else {
struct brw_wm_ref *ref = get_ref(c);
c->prog_data.param[i] = param_ptr;
c->nr_creg = (i+16)/16;
/* Push the offsets into hw_reg. These will be added to the
* real register numbers once one is allocated in pass2.
*/
ref->hw_reg = brw_vec1_grf((i&8)?1:0, i%8);
ref->value = &c->creg[i/16];
ref->insn = 0;
ref->prevuse = NULL;
return ref;
}
}
/* When the primitive changes, set a state bit and re-validate. Not
* the nicest and would rather deal with this by having all the
* programs be immune to the active primitive (ie. cope with all
* possibilities). That may not be realistic however.
*/
static GLuint brw_set_prim(struct brw_context *brw, GLenum prim)
{
if (INTEL_DEBUG & DEBUG_PRIMS)
_mesa_printf("PRIM: %s\n", _mesa_lookup_enum_by_nr(prim));
/* Slight optimization to avoid the GS program when not needed:
*/
if (prim == GL_QUAD_STRIP &&
brw->attribs.Light->ShadeModel != GL_FLAT &&
brw->attribs.Polygon->FrontMode == GL_FILL &&
brw->attribs.Polygon->BackMode == GL_FILL)
prim = GL_TRIANGLE_STRIP;
if (prim != brw->primitive) {
brw->primitive = prim;
brw->state.dirty.brw |= BRW_NEW_PRIMITIVE;
if (reduced_prim[prim] != brw->intel.reduced_primitive) {
brw->intel.reduced_primitive = reduced_prim[prim];
brw->state.dirty.brw |= BRW_NEW_REDUCED_PRIMITIVE;
}
brw_validate_state(brw);
}
return hw_prim[prim];
}
static const struct brw_wm_ref *get_const_ref( struct brw_wm_compile *c,
const GLfloat *constval )
{
GLuint i;
/* Search for an existing const value matching the request:
*/
for (i = 0; i < c->nr_constrefs; i++) {
if (c->constref[i].constval == *constval)
return c->constref[i].ref;
}
/* Else try to add a new one:
*/
if (c->nr_constrefs < BRW_WM_MAX_CONST) {
GLuint i = c->nr_constrefs++;
/* A constant is a special type of parameter:
*/
c->constref[i].constval = *constval;
c->constref[i].ref = get_param_ref(c, constval);
return c->constref[i].ref;
}
else {
_mesa_printf("%s: out of constrefs\n", __FUNCTION__);
c->prog_data.error = 1;
return NULL;
}
}
static void brw_emit_prim( struct brw_context *brw,
const struct _mesa_prim *prim )
{
struct brw_3d_primitive prim_packet;
if (INTEL_DEBUG & DEBUG_PRIMS)
_mesa_printf("PRIM: %s %d %d\n", _mesa_lookup_enum_by_nr(prim->mode),
prim->start, prim->count);
prim_packet.header.opcode = CMD_3D_PRIM;
prim_packet.header.length = sizeof(prim_packet)/4 - 2;
prim_packet.header.pad = 0;
prim_packet.header.topology = brw_set_prim(brw, prim->mode);
prim_packet.header.indexed = prim->indexed;
prim_packet.verts_per_instance = trim(prim->mode, prim->count);
prim_packet.start_vert_location = prim->start;
prim_packet.instance_count = 1;
prim_packet.start_instance_location = 0;
prim_packet.base_vert_location = 0;
if (prim_packet.verts_per_instance) {
intel_batchbuffer_data( brw->intel.batch, &prim_packet, sizeof(prim_packet),
INTEL_BATCH_NO_CLIPRECTS);
}
}
void _math_test_all_transform_functions( char *description )
{
int psize, mtype;
unsigned long benchmark_tab[4][7];
static int first_time = 1;
if ( first_time ) {
first_time = 0;
mesa_profile = _mesa_getenv( "MESA_PROFILE" );
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
if ( !counter_overhead ) {
INIT_COUNTER();
_mesa_printf("counter overhead: %lu cycles\n\n", counter_overhead );
}
_mesa_printf("transform results after hooking in %s functions:\n", description );
}
#endif
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile ) {
_mesa_printf("\n" );
for ( psize = 1 ; psize <= 4 ; psize++ ) {
_mesa_printf(" p%d\t", psize );
}
_mesa_printf("\n--------------------------------------------------------\n" );
}
#endif
for ( mtype = 0 ; mtype < 7 ; mtype++ ) {
for ( psize = 1 ; psize <= 4 ; psize++ ) {
transform_func func = _mesa_transform_tab[psize][mtypes[mtype]];
unsigned long *cycles = &(benchmark_tab[psize-1][mtype]);
if ( test_transform_function( func, psize, mtype, cycles ) == 0 ) {
char buf[100];
_mesa_sprintf(buf, "_mesa_transform_tab[0][%d][%s] failed test (%s)",
psize, mstrings[mtype], description );
_mesa_problem( NULL, buf );
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf(" %li\t", benchmark_tab[psize-1][mtype] );
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf(" | [%s]\n", mstrings[mtype] );
#endif
}
#ifdef RUN_DEBUG_BENCHMARK
if ( mesa_profile )
_mesa_printf( "\n" );
#endif
}
void vbo_exec_vtx_map( struct vbo_exec_context *exec )
{
GLcontext *ctx = exec->ctx;
const GLenum target = GL_ARRAY_BUFFER_ARB;
const GLenum access = GL_READ_WRITE_ARB; /* for MapBuffer */
const GLenum accessRange = GL_MAP_WRITE_BIT | /* for MapBufferRange */
GL_MAP_INVALIDATE_RANGE_BIT |
GL_MAP_UNSYNCHRONIZED_BIT |
GL_MAP_FLUSH_EXPLICIT_BIT |
MESA_MAP_NOWAIT_BIT;
const GLenum usage = GL_STREAM_DRAW_ARB;
if (exec->vtx.bufferobj->Name == 0)
return;
if (exec->vtx.buffer_map != NULL) {
assert(0);
exec->vtx.buffer_map = NULL;
exec->vtx.buffer_ptr = NULL;
}
if (VBO_VERT_BUFFER_SIZE > exec->vtx.buffer_used + 1024 &&
ctx->Driver.MapBufferRange)
{
exec->vtx.buffer_map =
(GLfloat *)ctx->Driver.MapBufferRange(ctx,
target,
exec->vtx.buffer_used,
(VBO_VERT_BUFFER_SIZE -
exec->vtx.buffer_used),
accessRange,
exec->vtx.bufferobj);
exec->vtx.buffer_ptr = exec->vtx.buffer_map;
}
if (!exec->vtx.buffer_map) {
exec->vtx.buffer_used = 0;
ctx->Driver.BufferData(ctx, target,
VBO_VERT_BUFFER_SIZE,
NULL, usage, exec->vtx.bufferobj);
if (ctx->Driver.MapBufferRange)
exec->vtx.buffer_map =
(GLfloat *)ctx->Driver.MapBufferRange(ctx, target,
0, VBO_VERT_BUFFER_SIZE,
accessRange,
exec->vtx.bufferobj);
else
exec->vtx.buffer_map =
(GLfloat *)ctx->Driver.MapBuffer(ctx, target, access, exec->vtx.bufferobj);
exec->vtx.buffer_ptr = exec->vtx.buffer_map;
}
if (0) _mesa_printf("map %d..\n", exec->vtx.buffer_used);
}
void vbo_exec_BeginVertices( GLcontext *ctx )
{
struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
if (0) _mesa_printf("%s\n", __FUNCTION__);
vbo_exec_vtx_map( exec );
assert((exec->ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0);
exec->ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT;
}
/**
* Emit all ready texture instructions in a single block.
*
* Emit as a single block to (hopefully) sample many textures in parallel,
* and to avoid hardware indirections on R300.
*
* In R500, we don't really know when the result of a texture instruction
* arrives. So allocate all destinations first, to make sure they do not
* arrive early and overwrite a texture coordinate we're going to use later
* in the block.
*/
static void emit_all_tex(struct pair_state *s)
{
struct pair_state_instruction *readytex;
struct pair_state_instruction *pairinst;
ASSERT(s->ReadyTEX);
// Don't let the ready list change under us!
readytex = s->ReadyTEX;
s->ReadyTEX = 0;
// Allocate destination hardware registers in one block to avoid conflicts.
for(pairinst = readytex; pairinst; pairinst = pairinst->NextReady) {
int ip = pairinst - s->Instructions;
struct prog_instruction *inst = s->Program->Instructions + ip;
if (inst->Opcode != OPCODE_KIL)
get_hw_reg(s, inst->DstReg.File, inst->DstReg.Index);
}
if (s->Debug)
_mesa_printf(" BEGIN_TEX\n");
if (s->Handler->BeginTexBlock)
s->Error = s->Error || !s->Handler->BeginTexBlock(s->UserData);
for(pairinst = readytex; pairinst; pairinst = pairinst->NextReady) {
int ip = pairinst - s->Instructions;
struct prog_instruction *inst = s->Program->Instructions + ip;
commit_instruction(s, ip);
if (inst->Opcode != OPCODE_KIL)
inst->DstReg.Index = get_hw_reg(s, inst->DstReg.File, inst->DstReg.Index);
inst->SrcReg[0].Index = get_hw_reg(s, inst->SrcReg[0].File, inst->SrcReg[0].Index);
if (s->Debug) {
_mesa_printf(" ");
_mesa_print_instruction(inst);
}
s->Error = s->Error || !s->Handler->EmitTex(s->UserData, inst);
}
if (s->Debug)
_mesa_printf(" END_TEX\n");
}
static void
PrintSrcReg(const struct vp_src_register *src)
{
static const char comps[5] = "xyzw";
if (src->Negate)
_mesa_printf("-");
if (src->RelAddr) {
if (src->Index > 0)
_mesa_printf("c[A0.x + %d]", src->Index);
else if (src->Index < 0)
_mesa_printf("c[A0.x - %d]", -src->Index);
else
_mesa_printf("c[A0.x]");
}
else if (src->File == PROGRAM_OUTPUT) {
_mesa_printf("o[%s]", OutputRegisters[src->Index]);
}
else if (src->File == PROGRAM_INPUT) {
_mesa_printf("v[%s]", InputRegisters[src->Index]);
}
else if (src->File == PROGRAM_ENV_PARAM) {
_mesa_printf("c[%d]", src->Index);
}
else {
ASSERT(src->File == PROGRAM_TEMPORARY);
_mesa_printf("R%d", src->Index);
}
if (src->Swizzle[0] == src->Swizzle[1] &&
src->Swizzle[0] == src->Swizzle[2] &&
src->Swizzle[0] == src->Swizzle[3]) {
_mesa_printf(".%c", comps[src->Swizzle[0]]);
}
else if (src->Swizzle[0] != 0 ||
src->Swizzle[1] != 1 ||
src->Swizzle[2] != 2 ||
src->Swizzle[3] != 3) {
_mesa_printf(".%c%c%c%c",
comps[src->Swizzle[0]],
comps[src->Swizzle[1]],
comps[src->Swizzle[2]],
comps[src->Swizzle[3]]);
}
}
GLboolean radeonPairProgram(GLcontext *ctx, struct gl_program *program,
const struct radeon_pair_handler* handler, void *userdata)
{
struct pair_state s;
_mesa_bzero(&s, sizeof(s));
s.Ctx = ctx;
s.Program = program;
s.Handler = handler;
s.UserData = userdata;
s.Debug = (RADEON_DEBUG & DEBUG_PIXEL) ? GL_TRUE : GL_FALSE;
s.Verbose = GL_FALSE && s.Debug;
s.Instructions = (struct pair_state_instruction*)_mesa_calloc(
sizeof(struct pair_state_instruction)*s.Program->NumInstructions);
s.ValuePool = (struct reg_value*)_mesa_calloc(sizeof(struct reg_value)*s.Program->NumInstructions*4);
s.ReaderPool = (struct reg_value_reader*)_mesa_calloc(
sizeof(struct reg_value_reader)*s.Program->NumInstructions*12);
if (s.Debug)
_mesa_printf("Emit paired program\n");
scan_instructions(&s);
allocate_input_registers(&s);
while(!s.Error &&
(s.ReadyTEX || s.ReadyRGB || s.ReadyAlpha || s.ReadyFullALU)) {
if (s.ReadyTEX)
emit_all_tex(&s);
while(s.ReadyFullALU || s.ReadyRGB || s.ReadyAlpha)
emit_alu(&s);
}
if (s.Debug)
_mesa_printf(" END\n");
_mesa_free(s.Instructions);
_mesa_free(s.ValuePool);
_mesa_free(s.ReaderPool);
return !s.Error;
}
static void *
timed_memcpy(void *dest, const void *src, size_t n)
{
void *ret;
unsigned t1, t2;
double rate;
if ((((unsigned) src) & 63) || (((unsigned) dest) & 63))
_mesa_printf("Warning - non-aligned texture copy!\n");
t1 = fastrdtsc();
ret = do_memcpy(dest, src, n);
t2 = fastrdtsc();
rate = time_diff(t1, t2);
rate /= (double) n;
_mesa_printf("timed_memcpy: %u %u --> %f clocks/byte\n", t1, t2, rate);
return ret;
}
void _tnl_UpdateFixedFunctionProgram( GLcontext *ctx )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct state_key *key;
GLuint hash;
const struct gl_vertex_program *prev = ctx->VertexProgram._Current;
if (!ctx->VertexProgram._Current ||
ctx->VertexProgram._Current == ctx->VertexProgram._TnlProgram) {
struct gl_vertex_program *newProg;
/* Grab all the relevent state and put it in a single structure:
*/
key = make_state_key(ctx);
hash = hash_key(key);
/* Look for an already-prepared program for this state:
*/
newProg = search_cache( tnl->vp_cache, hash, key, sizeof(*key));
/* OK, we'll have to build a new one:
*/
if (!newProg) {
if (0)
_mesa_printf("Build new TNL program\n");
newProg = (struct gl_vertex_program *)
ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
create_new_program( key, newProg, ctx->Const.VertexProgram.MaxTemps );
if (ctx->Driver.ProgramStringNotify)
ctx->Driver.ProgramStringNotify( ctx, GL_VERTEX_PROGRAM_ARB,
&newProg->Base );
/* Our ownership of newProg is transferred to the cache */
cache_item(ctx, tnl->vp_cache, hash, key, newProg);
}
else {
FREE(key);
}
_mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, newProg);
_mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, newProg);
}
/* Tell the driver about the change. Could define a new target for
* this?
*/
if (ctx->VertexProgram._Current != prev && ctx->Driver.BindProgram) {
ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB,
(struct gl_program *) ctx->VertexProgram._Current);
}
}
/* XXX: Do this for TexSubImage also:
*/
static GLboolean
try_pbo_upload(struct intel_context *intel,
struct intel_texture_image *intelImage,
const struct gl_pixelstore_attrib *unpack,
GLint internalFormat,
GLint width, GLint height,
GLenum format, GLenum type, const void *pixels)
{
struct intel_buffer_object *pbo = intel_buffer_object(unpack->BufferObj);
GLuint src_offset, src_stride;
GLuint dst_offset, dst_stride;
if (!pbo ||
intel->ctx._ImageTransferState ||
unpack->SkipPixels || unpack->SkipRows) {
_mesa_printf("%s: failure 1\n", __FUNCTION__);
return GL_FALSE;
}
src_offset = (GLuint) pixels;
if (unpack->RowLength > 0)
src_stride = unpack->RowLength;
else
src_stride = width;
dst_offset = intel_miptree_image_offset(intelImage->mt,
intelImage->face,
intelImage->level);
dst_stride = intelImage->mt->pitch;
intelFlush(&intel->ctx);
LOCK_HARDWARE(intel);
{
struct _DriBufferObject *src_buffer =
intel_bufferobj_buffer(intel, pbo, INTEL_READ);
struct _DriBufferObject *dst_buffer =
intel_region_buffer(intel->intelScreen, intelImage->mt->region,
INTEL_WRITE_FULL);
intelEmitCopyBlit(intel,
intelImage->mt->cpp,
src_stride, src_buffer, src_offset,
dst_stride, dst_buffer, dst_offset,
0, 0, 0, 0, width, height,
GL_COPY);
intel_batchbuffer_flush(intel->batch);
}
UNLOCK_HARDWARE(intel);
return GL_TRUE;
}
/**
* Execute the buffer and save copied verts.
*/
void vbo_save_playback_vertex_list( GLcontext *ctx, void *data )
{
const struct vbo_save_vertex_list *node = (const struct vbo_save_vertex_list *) data;
struct vbo_save_context *save = &vbo_context(ctx)->save;
FLUSH_CURRENT(ctx, 0);
if (node->prim_count > 0 && node->count > 0) {
if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END &&
node->prim[0].begin) {
/* Degenerate case: list is called inside begin/end pair and
* includes operations such as glBegin or glDrawArrays.
*/
if (0)
_mesa_printf("displaylist recursive begin");
vbo_save_loopback_vertex_list( ctx, node );
return;
}
else if (save->replay_flags) {
/* Various degnerate cases: translate into immediate mode
* calls rather than trying to execute in place.
*/
vbo_save_loopback_vertex_list( ctx, node );
return;
}
if (ctx->NewState)
_mesa_update_state( ctx );
/* XXX also need to check if shader enabled, but invalid */
if ((ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) ||
(ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBegin (invalid vertex/fragment program)");
return;
}
vbo_bind_vertex_list( ctx, node );
vbo_context(ctx)->draw_prims( ctx,
save->inputs,
node->prim,
node->prim_count,
NULL,
0, /* Node is a VBO, so this is ok */
node->count - 1);
}
/* Copy to current?
*/
_playback_copy_to_current( ctx, node );
}
static void print_insns( const struct prog_instruction *insn,
GLuint nr )
{
GLuint i;
for (i = 0; i < nr; i++, insn++) {
_mesa_printf("%3d: ", i);
if (insn->Opcode < MAX_OPCODE)
_mesa_print_instruction(insn);
else if (insn->Opcode < MAX_WM_OPCODE) {
GLuint idx = insn->Opcode - MAX_OPCODE;
_mesa_print_alu_instruction(insn,
wm_opcode_strings[idx],
3);
}
else
_mesa_printf("UNKNOWN\n");
}
}
static void
PrintSrcReg(const struct prog_src_register *src)
{
static const char comps[5] = "xyzw";
if (src->NegateBase)
_mesa_printf("-");
if (src->RelAddr) {
if (src->Index > 0)
_mesa_printf("c[A0.x + %d]", src->Index);
else if (src->Index < 0)
_mesa_printf("c[A0.x - %d]", -src->Index);
else
_mesa_printf("c[A0.x]");
}
else if (src->File == PROGRAM_OUTPUT) {
_mesa_printf("o[%s]", OutputRegisters[src->Index]);
}
else if (src->File == PROGRAM_INPUT) {
_mesa_printf("v[%s]", InputRegisters[src->Index]);
}
else if (src->File == PROGRAM_ENV_PARAM) {
_mesa_printf("c[%d]", src->Index);
}
else {
ASSERT(src->File == PROGRAM_TEMPORARY);
_mesa_printf("R%d", src->Index);
}
if (GET_SWZ(src->Swizzle, 0) == GET_SWZ(src->Swizzle, 1) &&
GET_SWZ(src->Swizzle, 0) == GET_SWZ(src->Swizzle, 2) &&
GET_SWZ(src->Swizzle, 0) == GET_SWZ(src->Swizzle, 3)) {
_mesa_printf(".%c", comps[GET_SWZ(src->Swizzle, 0)]);
}
else if (src->Swizzle != SWIZZLE_NOOP) {
_mesa_printf(".%c%c%c%c",
comps[GET_SWZ(src->Swizzle, 0)],
comps[GET_SWZ(src->Swizzle, 1)],
comps[GET_SWZ(src->Swizzle, 2)],
comps[GET_SWZ(src->Swizzle, 3)]);
}
}
static GLboolean
try_pbo_zcopy(struct intel_context *intel,
struct intel_texture_image *intelImage,
const struct gl_pixelstore_attrib *unpack,
GLint internalFormat,
GLint width, GLint height,
GLenum format, GLenum type, const void *pixels)
{
struct intel_buffer_object *pbo = intel_buffer_object(unpack->BufferObj);
GLuint src_offset, src_stride;
GLuint dst_offset, dst_stride;
if (!pbo ||
intel->ctx._ImageTransferState ||
unpack->SkipPixels || unpack->SkipRows) {
_mesa_printf("%s: failure 1\n", __FUNCTION__);
return GL_FALSE;
}
src_offset = (GLuint) pixels;
if (unpack->RowLength > 0)
src_stride = unpack->RowLength;
else
src_stride = width;
dst_offset = intel_miptree_image_offset(intelImage->mt,
intelImage->face,
intelImage->level);
dst_stride = intelImage->mt->pitch;
if (src_stride != dst_stride || dst_offset != 0 || src_offset != 0) {
_mesa_printf("%s: failure 2\n", __FUNCTION__);
return GL_FALSE;
}
intel_region_attach_pbo(intel->intelScreen, intelImage->mt->region, pbo);
return GL_TRUE;
}
static struct prog_dst_register get_temp( struct brw_wm_compile *c )
{
int bit = ffs( ~c->fp_temp );
if (!bit) {
_mesa_printf("%s: out of temporaries\n", __FILE__);
exit(1);
}
c->fp_temp |= 1<<(bit-1);
return dst_reg(PROGRAM_TEMPORARY, FIRST_INTERNAL_TEMP+(bit-1));
}
/* Extract a rectangle's worth of data from the bitmap. Called
* per-cliprect.
*/
static GLuint get_bitmap_rect(GLsizei width, GLsizei height,
const struct gl_pixelstore_attrib *unpack,
const GLubyte *bitmap,
GLuint x, GLuint y,
GLuint w, GLuint h,
GLubyte *dest,
GLuint row_align,
GLboolean invert)
{
GLuint src_offset = (x + unpack->SkipPixels) & 0x7;
GLuint mask = unpack->LsbFirst ? 0 : 7;
GLuint bit = 0;
GLint row, col;
GLint first, last;
GLint incr;
GLuint count = 0;
if (INTEL_DEBUG & DEBUG_PIXEL)
_mesa_printf("%s %d,%d %dx%d bitmap %dx%d skip %d src_offset %d mask %d\n",
__FUNCTION__, x,y,w,h,width,height,unpack->SkipPixels, src_offset, mask);
if (invert) {
first = h-1;
last = 0;
incr = -1;
}
else {
first = 0;
last = h-1;
incr = 1;
}
/* Require that dest be pre-zero'd.
*/
for (row = first; row != (last+incr); row += incr) {
const GLubyte *rowsrc = _mesa_image_address2d(unpack, bitmap,
width, height,
GL_COLOR_INDEX, GL_BITMAP,
y + row, x);
for (col = 0; col < w; col++, bit++) {
if (test_bit(rowsrc, (col + src_offset) ^ mask)) {
set_bit(dest, bit ^ 7);
count++;
}
}
if (row_align)
bit = ALIGN(bit, row_align);
}
return count;
}
void vbo_exec_FlushVertices( GLcontext *ctx, GLuint flags )
{
struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
if (0) _mesa_printf("%s\n", __FUNCTION__);
if (exec->ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
if (0) _mesa_printf("%s - inside begin/end\n", __FUNCTION__);
return;
}
vbo_exec_FlushVertices_internal( ctx, GL_TRUE );
/* Need to do this to ensure BeginVertices gets called again:
*/
if (exec->ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) {
_mesa_restore_exec_vtxfmt( ctx );
exec->ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT;
}
exec->ctx->Driver.NeedFlush &= ~flags;
}
int main(int argc, char *argv[])
{
int a, b, c;
struct HashTable *t;
_mesa_printf("&a = %p\n", &a);
_mesa_printf("&b = %p\n", &b);
t = _mesa_NewHashTable();
_mesa_HashInsert(t, 501, &a);
_mesa_HashInsert(t, 10, &c);
_mesa_HashInsert(t, 0xfffffff8, &b);
_mesa_HashPrint(t);
_mesa_printf("Find 501: %p\n", _mesa_HashLookup(t,501));
_mesa_printf("Find 1313: %p\n", _mesa_HashLookup(t,1313));
_mesa_printf("Find block of 100: %d\n", _mesa_HashFindFreeKeyBlock(t, 100));
_mesa_DeleteHashTable(t);
return 0;
}