[Mesa-dev] [RFC PATCH] st/mesa/r200/i915/i965: move ARB program fields into a union
Timothy Arceri
timothy.arceri at collabora.com
Wed Nov 2 01:38:56 UTC 2016
I'm about to do some refactoring that will move a bunch of glsl only
fields from gl_linked_program into gl_program.
If we wan't to share memory it makes sense to do it while I move
things. I just wanted to see what people think about this before
I get started as it's not going to be fun to go back and undo.
It seems common for games to compile 2000 programs or more so at
32bits X 2000 programs X 22 fields X 2 (at least) stages
This should give us something like 352 kilobytes in savings.
What do you think?
---
src/mesa/drivers/dri/i915/i915_fragprog.c | 12 ++--
src/mesa/drivers/dri/i915/i915_program.c | 16 ++---
src/mesa/drivers/dri/i965/brw_program.c | 4 +-
src/mesa/drivers/dri/r200/r200_state_init.c | 4 +-
src/mesa/drivers/dri/r200/r200_vertprog.c | 36 ++++++------
src/mesa/main/arbprogram.c | 40 ++++++-------
src/mesa/main/ffvertex_prog.c | 32 +++++-----
src/mesa/main/mtypes.h | 91 +++++++++++++++--------------
src/mesa/main/state.c | 4 +-
src/mesa/program/arbprogparse.c | 66 ++++++++++-----------
src/mesa/program/ir_to_mesa.cpp | 12 ++--
src/mesa/program/prog_execute.c | 18 +++---
src/mesa/program/prog_opt_constant_fold.c | 4 +-
src/mesa/program/prog_optimize.c | 54 ++++++++---------
src/mesa/program/prog_print.c | 17 +++---
src/mesa/program/prog_statevars.c | 17 +++---
src/mesa/program/prog_to_nir.c | 10 ++--
src/mesa/program/program.c | 42 ++++++-------
src/mesa/program/program_parse.y | 50 ++++++++--------
src/mesa/program/programopt.c | 68 ++++++++++-----------
src/mesa/state_tracker/st_atifs_to_tgsi.c | 6 +-
src/mesa/state_tracker/st_glsl_to_nir.cpp | 3 -
src/mesa/state_tracker/st_glsl_to_tgsi.cpp | 3 -
src/mesa/state_tracker/st_mesa_to_tgsi.c | 14 ++---
src/mesa/state_tracker/st_program.c | 2 +-
src/mesa/swrast/s_fragprog.c | 2 +-
src/mesa/tnl/t_vb_program.c | 4 +-
27 files changed, 316 insertions(+), 315 deletions(-)
diff --git a/src/mesa/drivers/dri/i915/i915_fragprog.c b/src/mesa/drivers/dri/i915/i915_fragprog.c
index a571254..e123338 100644
--- a/src/mesa/drivers/dri/i915/i915_fragprog.c
+++ b/src/mesa/drivers/dri/i915/i915_fragprog.c
@@ -318,8 +318,8 @@ static bool calc_live_regs( struct i915_fragment_program *p )
uint8_t live_components[I915_MAX_TEMPORARY] = { 0, };
GLint i;
- for (i = program->NumInstructions - 1; i >= 0; i--) {
- struct prog_instruction *inst = &program->Instructions[i];
+ for (i = program->a.NumInstructions - 1; i >= 0; i--) {
+ struct prog_instruction *inst = &program->a.Instructions[i];
int opArgs = _mesa_num_inst_src_regs(inst->Opcode);
int a;
@@ -362,7 +362,7 @@ static GLuint get_live_regs( struct i915_fragment_program *p,
const struct prog_instruction *inst )
{
const struct gl_program *program = &p->FragProg;
- GLuint nr = inst - program->Instructions;
+ GLuint nr = inst - program->a.Instructions;
return p->usedRegs[nr];
}
@@ -383,7 +383,7 @@ static void
upload_program(struct i915_fragment_program *p)
{
const struct gl_program *program = &p->FragProg;
- const struct prog_instruction *inst = program->Instructions;
+ const struct prog_instruction *inst = program->a.Instructions;
if (INTEL_DEBUG & DEBUG_WM)
_mesa_print_program(program);
@@ -402,9 +402,9 @@ upload_program(struct i915_fragment_program *p)
return;
}
- if (program->NumInstructions > I915_MAX_INSN) {
+ if (program->a.NumInstructions > I915_MAX_INSN) {
i915_program_error(p, "Exceeded max instructions (%d out of %d)",
- program->NumInstructions, I915_MAX_INSN);
+ program->a.NumInstructions, I915_MAX_INSN);
return;
}
diff --git a/src/mesa/drivers/dri/i915/i915_program.c b/src/mesa/drivers/dri/i915/i915_program.c
index 0abc7e2..35b4a85 100644
--- a/src/mesa/drivers/dri/i915/i915_program.c
+++ b/src/mesa/drivers/dri/i915/i915_program.c
@@ -517,18 +517,18 @@ i915_fini_program(struct i915_fragment_program *p)
}
if (p->error) {
- p->FragProg.NumNativeInstructions = 0;
- p->FragProg.NumNativeAluInstructions = 0;
- p->FragProg.NumNativeTexInstructions = 0;
- p->FragProg.NumNativeTexIndirections = 0;
+ p->FragProg.a.NumNativeInstructions = 0;
+ p->FragProg.a.NumNativeAluInstructions = 0;
+ p->FragProg.a.NumNativeTexInstructions = 0;
+ p->FragProg.a.NumNativeTexIndirections = 0;
}
else {
- p->FragProg.NumNativeInstructions = (p->nr_alu_insn +
+ p->FragProg.a.NumNativeInstructions = (p->nr_alu_insn +
p->nr_tex_insn +
p->nr_decl_insn);
- p->FragProg.NumNativeAluInstructions = p->nr_alu_insn;
- p->FragProg.NumNativeTexInstructions = p->nr_tex_insn;
- p->FragProg.NumNativeTexIndirections = p->nr_tex_indirect;
+ p->FragProg.a.NumNativeAluInstructions = p->nr_alu_insn;
+ p->FragProg.a.NumNativeTexInstructions = p->nr_tex_insn;
+ p->FragProg.a.NumNativeTexIndirections = p->nr_tex_indirect;
}
p->declarations[0] |= program_size + decl_size - 2;
diff --git a/src/mesa/drivers/dri/i965/brw_program.c b/src/mesa/drivers/dri/i965/brw_program.c
index c15c0b1..3c231eb 100644
--- a/src/mesa/drivers/dri/i965/brw_program.c
+++ b/src/mesa/drivers/dri/i965/brw_program.c
@@ -183,7 +183,7 @@ brwProgramStringNotify(struct gl_context *ctx,
GLenum target,
struct gl_program *prog)
{
- assert(target == GL_VERTEX_PROGRAM_ARB || !prog->IsPositionInvariant);
+ assert(target == GL_VERTEX_PROGRAM_ARB || !prog->a.IsPositionInvariant);
struct brw_context *brw = brw_context(ctx);
const struct brw_compiler *compiler = brw->screen->compiler;
@@ -212,7 +212,7 @@ brwProgramStringNotify(struct gl_context *ctx,
if (newVP == curVP)
brw->ctx.NewDriverState |= BRW_NEW_VERTEX_PROGRAM;
- if (newVP->program.IsPositionInvariant) {
+ if (newVP->program.a.IsPositionInvariant) {
_mesa_insert_mvp_code(ctx, &newVP->program);
}
newVP->id = get_new_program_id(brw->screen);
diff --git a/src/mesa/drivers/dri/r200/r200_state_init.c b/src/mesa/drivers/dri/r200/r200_state_init.c
index f31a191..1d22bf7 100644
--- a/src/mesa/drivers/dri/r200/r200_state_init.c
+++ b/src/mesa/drivers/dri/r200/r200_state_init.c
@@ -271,8 +271,8 @@ TCL_OR_VP_CHECK( tcl_or_vp, GL_TRUE, 0 )
TCL_OR_VP_CHECK( tcl_or_vp_add2, GL_TRUE, 2 )
VP_CHECK( tcl_vp, GL_TRUE, 0 )
VP_CHECK( tcl_vp_add4, GL_TRUE, 4 )
-VP_CHECK( tcl_vp_size_add4, ctx->VertexProgram.Current->NumNativeInstructions > 64, 4 )
-VP_CHECK( tcl_vpp_size_add4, ctx->VertexProgram.Current->NumNativeParameters > 96, 4 )
+VP_CHECK( tcl_vp_size_add4, ctx->VertexProgram.Current->a.NumNativeInstructions > 64, 4 )
+VP_CHECK( tcl_vpp_size_add4, ctx->VertexProgram.Current->a.NumNativeParameters > 96, 4 )
#define OUT_VEC(hdr, data) do { \
drm_radeon_cmd_header_t h; \
diff --git a/src/mesa/drivers/dri/r200/r200_vertprog.c b/src/mesa/drivers/dri/r200/r200_vertprog.c
index 3f1d53e..ae2a7c4 100644
--- a/src/mesa/drivers/dri/r200/r200_vertprog.c
+++ b/src/mesa/drivers/dri/r200/r200_vertprog.c
@@ -409,7 +409,7 @@ static GLboolean r200_translate_vertex_program(struct gl_context *ctx, struct r2
vp->translated = GL_TRUE;
vp->fogmode = ctx->Fog.Mode;
- if (mesa_vp->NumInstructions == 0)
+ if (mesa_vp->a.NumInstructions == 0)
return GL_FALSE;
#if 0
@@ -445,7 +445,7 @@ static GLboolean r200_translate_vertex_program(struct gl_context *ctx, struct r2
struct prog_dst_register dst;
/* FIXME: is changing the prog safe to do here? */
- if (mesa_vp->IsPositionInvariant &&
+ if (mesa_vp->a.IsPositionInvariant &&
/* make sure we only do this once */
!(mesa_vp->info.outputs_written & (1 << VARYING_SLOT_POS))) {
_mesa_insert_mvp_code(ctx, mesa_vp);
@@ -462,11 +462,11 @@ static GLboolean r200_translate_vertex_program(struct gl_context *ctx, struct r2
}
vp->pos_end = 0;
- mesa_vp->NumNativeInstructions = 0;
+ mesa_vp->a.NumNativeInstructions = 0;
if (mesa_vp->Parameters)
- mesa_vp->NumNativeParameters = mesa_vp->Parameters->NumParameters;
+ mesa_vp->a.NumNativeParameters = mesa_vp->Parameters->NumParameters;
else
- mesa_vp->NumNativeParameters = 0;
+ mesa_vp->a.NumNativeParameters = 0;
for(i = 0; i < VERT_ATTRIB_MAX; i++)
vp->inputs[i] = -1;
@@ -590,7 +590,7 @@ static GLboolean r200_translate_vertex_program(struct gl_context *ctx, struct r2
}
o_inst = vp->instr;
- for (vpi = mesa_vp->Instructions; vpi->Opcode != OPCODE_END; vpi++, o_inst++){
+ for (vpi = mesa_vp->a.Instructions; vpi->Opcode != OPCODE_END; vpi++, o_inst++){
operands = op_operands(vpi->Opcode);
are_srcs_scalar = operands & SCALAR_FLAG;
operands &= OP_MASK;
@@ -1070,20 +1070,20 @@ else {
}
u_temp_used = (R200_VSF_MAX_TEMPS - 1) - u_temp_i;
- if (mesa_vp->NumNativeTemporaries <
- (mesa_vp->NumTemporaries + u_temp_used)) {
- mesa_vp->NumNativeTemporaries =
- mesa_vp->NumTemporaries + u_temp_used;
+ if (mesa_vp->a.NumNativeTemporaries <
+ (mesa_vp->a.NumTemporaries + u_temp_used)) {
+ mesa_vp->a.NumNativeTemporaries =
+ mesa_vp->a.NumTemporaries + u_temp_used;
}
- if ((mesa_vp->NumTemporaries + u_temp_used) > R200_VSF_MAX_TEMPS) {
+ if ((mesa_vp->a.NumTemporaries + u_temp_used) > R200_VSF_MAX_TEMPS) {
if (R200_DEBUG & RADEON_FALLBACKS) {
- fprintf(stderr, "Ran out of temps, num temps %d, us %d\n", mesa_vp->NumTemporaries, u_temp_used);
+ fprintf(stderr, "Ran out of temps, num temps %d, us %d\n", mesa_vp->a.NumTemporaries, u_temp_used);
}
return GL_FALSE;
}
u_temp_i = R200_VSF_MAX_TEMPS - 1;
if(o_inst - vp->instr >= R200_VSF_MAX_INST) {
- mesa_vp->NumNativeInstructions = 129;
+ mesa_vp->a.NumNativeInstructions = 129;
if (R200_DEBUG & RADEON_FALLBACKS) {
fprintf(stderr, "more than 128 native instructions\n");
}
@@ -1095,7 +1095,7 @@ else {
}
vp->native = GL_TRUE;
- mesa_vp->NumNativeInstructions = (o_inst - vp->instr);
+ mesa_vp->a.NumNativeInstructions = (o_inst - vp->instr);
#if 0
fprintf(stderr, "hw program:\n");
for(i=0; i < vp->program.length; i++)
@@ -1127,15 +1127,15 @@ void r200SetupVertexProg( struct gl_context *ctx ) {
R200_STATECHANGE( rmesa, pvs );
rmesa->hw.pvs.cmd[PVS_CNTL_1] = (0 << R200_PVS_CNTL_1_PROGRAM_START_SHIFT) |
- ((vp->mesa_program.NumNativeInstructions - 1) << R200_PVS_CNTL_1_PROGRAM_END_SHIFT) |
+ ((vp->mesa_program.a.NumNativeInstructions - 1) << R200_PVS_CNTL_1_PROGRAM_END_SHIFT) |
(vp->pos_end << R200_PVS_CNTL_1_POS_END_SHIFT);
rmesa->hw.pvs.cmd[PVS_CNTL_2] = (0 << R200_PVS_CNTL_2_PARAM_OFFSET_SHIFT) |
- (vp->mesa_program.NumNativeParameters << R200_PVS_CNTL_2_PARAM_COUNT_SHIFT);
+ (vp->mesa_program.a.NumNativeParameters << R200_PVS_CNTL_2_PARAM_COUNT_SHIFT);
/* maybe user clip planes just work with vertex progs... untested */
if (ctx->Transform.ClipPlanesEnabled) {
R200_STATECHANGE( rmesa, tcl );
- if (vp->mesa_program.IsPositionInvariant) {
+ if (vp->mesa_program.a.IsPositionInvariant) {
rmesa->hw.tcl.cmd[TCL_UCP_VERT_BLEND_CTL] |= (ctx->Transform.ClipPlanesEnabled << 2);
}
else {
@@ -1144,7 +1144,7 @@ void r200SetupVertexProg( struct gl_context *ctx ) {
}
if (vp != rmesa->curr_vp_hw) {
- GLuint count = vp->mesa_program.NumNativeInstructions;
+ GLuint count = vp->mesa_program.a.NumNativeInstructions;
drm_radeon_cmd_header_t tmp;
R200_STATECHANGE( rmesa, vpi[0] );
diff --git a/src/mesa/main/arbprogram.c b/src/mesa/main/arbprogram.c
index 9c7622a..bef729b 100644
--- a/src/mesa/main/arbprogram.c
+++ b/src/mesa/main/arbprogram.c
@@ -274,13 +274,13 @@ get_local_param_pointer(struct gl_context *ctx, const char *func,
return GL_FALSE;
}
- if (!prog->LocalParams) {
- prog->LocalParams = calloc(maxParams, sizeof(float[4]));
- if (!prog->LocalParams)
+ if (!prog->a.LocalParams) {
+ prog->a.LocalParams = calloc(maxParams, sizeof(float[4]));
+ if (!prog->a.LocalParams)
return GL_FALSE;
}
- *param = prog->LocalParams[index];
+ *param = prog->a.LocalParams[index];
return GL_TRUE;
}
@@ -680,61 +680,61 @@ _mesa_GetProgramivARB(GLenum target, GLenum pname, GLint *params)
*params = prog->Id;
return;
case GL_PROGRAM_INSTRUCTIONS_ARB:
- *params = prog->NumInstructions;
+ *params = prog->a.NumInstructions;
return;
case GL_MAX_PROGRAM_INSTRUCTIONS_ARB:
*params = limits->MaxInstructions;
return;
case GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
- *params = prog->NumNativeInstructions;
+ *params = prog->a.NumNativeInstructions;
return;
case GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB:
*params = limits->MaxNativeInstructions;
return;
case GL_PROGRAM_TEMPORARIES_ARB:
- *params = prog->NumTemporaries;
+ *params = prog->a.NumTemporaries;
return;
case GL_MAX_PROGRAM_TEMPORARIES_ARB:
*params = limits->MaxTemps;
return;
case GL_PROGRAM_NATIVE_TEMPORARIES_ARB:
- *params = prog->NumNativeTemporaries;
+ *params = prog->a.NumNativeTemporaries;
return;
case GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB:
*params = limits->MaxNativeTemps;
return;
case GL_PROGRAM_PARAMETERS_ARB:
- *params = prog->NumParameters;
+ *params = prog->a.NumParameters;
return;
case GL_MAX_PROGRAM_PARAMETERS_ARB:
*params = limits->MaxParameters;
return;
case GL_PROGRAM_NATIVE_PARAMETERS_ARB:
- *params = prog->NumNativeParameters;
+ *params = prog->a.NumNativeParameters;
return;
case GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB:
*params = limits->MaxNativeParameters;
return;
case GL_PROGRAM_ATTRIBS_ARB:
- *params = prog->NumAttributes;
+ *params = prog->a.NumAttributes;
return;
case GL_MAX_PROGRAM_ATTRIBS_ARB:
*params = limits->MaxAttribs;
return;
case GL_PROGRAM_NATIVE_ATTRIBS_ARB:
- *params = prog->NumNativeAttributes;
+ *params = prog->a.NumNativeAttributes;
return;
case GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB:
*params = limits->MaxNativeAttribs;
return;
case GL_PROGRAM_ADDRESS_REGISTERS_ARB:
- *params = prog->NumAddressRegs;
+ *params = prog->a.NumAddressRegs;
return;
case GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB:
*params = limits->MaxAddressRegs;
return;
case GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
- *params = prog->NumNativeAddressRegs;
+ *params = prog->a.NumNativeAddressRegs;
return;
case GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB:
*params = limits->MaxNativeAddressRegs;
@@ -778,22 +778,22 @@ _mesa_GetProgramivARB(GLenum target, GLenum pname, GLint *params)
const struct gl_program *fp = ctx->FragmentProgram.Current;
switch (pname) {
case GL_PROGRAM_ALU_INSTRUCTIONS_ARB:
- *params = fp->NumNativeAluInstructions;
+ *params = fp->a.NumNativeAluInstructions;
return;
case GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB:
- *params = fp->NumAluInstructions;
+ *params = fp->a.NumAluInstructions;
return;
case GL_PROGRAM_TEX_INSTRUCTIONS_ARB:
- *params = fp->NumTexInstructions;
+ *params = fp->a.NumTexInstructions;
return;
case GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB:
- *params = fp->NumNativeTexInstructions;
+ *params = fp->a.NumNativeTexInstructions;
return;
case GL_PROGRAM_TEX_INDIRECTIONS_ARB:
- *params = fp->NumTexIndirections;
+ *params = fp->a.NumTexIndirections;
return;
case GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB:
- *params = fp->NumNativeTexIndirections;
+ *params = fp->a.NumNativeTexIndirections;
return;
case GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB:
*params = limits->MaxAluInstructions;
diff --git a/src/mesa/main/ffvertex_prog.c b/src/mesa/main/ffvertex_prog.c
index 8cec1cb..4b9836c 100644
--- a/src/mesa/main/ffvertex_prog.c
+++ b/src/mesa/main/ffvertex_prog.c
@@ -383,8 +383,8 @@ static struct ureg get_temp( struct tnl_program *p )
exit(1);
}
- if ((GLuint) bit > p->program->NumTemporaries)
- p->program->NumTemporaries = bit;
+ if ((GLuint) bit > p->program->a.NumTemporaries)
+ p->program->a.NumTemporaries = bit;
p->temp_in_use |= 1<<(bit-1);
return make_ureg(PROGRAM_TEMPORARY, bit-1);
@@ -577,9 +577,9 @@ static void emit_op3fn(struct tnl_program *p,
GLuint nr;
struct prog_instruction *inst;
- assert(p->program->NumInstructions <= p->max_inst);
+ assert(p->program->a.NumInstructions <= p->max_inst);
- if (p->program->NumInstructions == p->max_inst) {
+ if (p->program->a.NumInstructions == p->max_inst) {
/* need to extend the program's instruction array */
struct prog_instruction *newInst;
@@ -592,18 +592,18 @@ static void emit_op3fn(struct tnl_program *p,
return;
}
- _mesa_copy_instructions(newInst, p->program->Instructions,
- p->program->NumInstructions);
+ _mesa_copy_instructions(newInst, p->program->a.Instructions,
+ p->program->a.NumInstructions);
- _mesa_free_instructions(p->program->Instructions,
- p->program->NumInstructions);
+ _mesa_free_instructions(p->program->a.Instructions,
+ p->program->a.NumInstructions);
- p->program->Instructions = newInst;
+ p->program->a.Instructions = newInst;
}
- nr = p->program->NumInstructions++;
+ nr = p->program->a.NumInstructions++;
- inst = &p->program->Instructions[nr];
+ inst = &p->program->a.Instructions[nr];
inst->Opcode = (enum prog_opcode) op;
emit_arg( &inst->SrcReg[0], src0 );
@@ -1632,12 +1632,12 @@ create_new_program( const struct state_key *key,
* If we need more, we'll grow the instruction array as needed.
*/
p.max_inst = 32;
- p.program->Instructions = _mesa_alloc_instructions(p.max_inst);
+ p.program->a.Instructions = _mesa_alloc_instructions(p.max_inst);
p.program->String = NULL;
- p.program->NumInstructions =
- p.program->NumTemporaries =
- p.program->NumParameters =
- p.program->NumAttributes = p.program->NumAddressRegs = 0;
+ p.program->a.NumInstructions =
+ p.program->a.NumTemporaries =
+ p.program->a.NumParameters =
+ p.program->a.NumAttributes = p.program->a.NumAddressRegs = 0;
p.program->Parameters = _mesa_new_parameter_list();
p.program->info.inputs_read = 0;
p.program->info.outputs_written = 0;
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 3f3c41b..cc88ba2 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -1916,8 +1916,6 @@ struct gl_program
GLenum Target; /**< GL_VERTEX/FRAGMENT_PROGRAM_ARB, GL_GEOMETRY_PROGRAM_NV */
GLenum Format; /**< String encoding format */
- struct prog_instruction *Instructions;
-
struct nir_shader *nir;
struct shader_info info;
@@ -1939,50 +1937,57 @@ struct gl_program
/** Named parameters, constants, etc. from program text */
struct gl_program_parameter_list *Parameters;
- /**
- * Local parameters used by the program.
- *
- * It's dynamically allocated because it is rarely used (just
- * assembly-style programs), and MAX_PROGRAM_LOCAL_PARAMS entries once it's
- * allocated.
- */
- GLfloat (*LocalParams)[4];
-
/** Map from sampler unit to texture unit (set by glUniform1i()) */
GLubyte SamplerUnits[MAX_SAMPLERS];
- /** Bitmask of which register files are read/written with indirect
- * addressing. Mask of (1 << PROGRAM_x) bits.
- */
- GLbitfield IndirectRegisterFiles;
-
- /** Logical counts */
- /*@{*/
- GLuint NumInstructions;
- GLuint NumTemporaries;
- GLuint NumParameters;
- GLuint NumAttributes;
- GLuint NumAddressRegs;
- GLuint NumAluInstructions;
- GLuint NumTexInstructions;
- GLuint NumTexIndirections;
- /*@}*/
- /** Native, actual h/w counts */
- /*@{*/
- GLuint NumNativeInstructions;
- GLuint NumNativeTemporaries;
- GLuint NumNativeParameters;
- GLuint NumNativeAttributes;
- GLuint NumNativeAddressRegs;
- GLuint NumNativeAluInstructions;
- GLuint NumNativeTexInstructions;
- GLuint NumNativeTexIndirections;
- /*@}*/
-
- /** Used by ARB assembly-style programs. Can only be true for vertex
- * programs.
- */
- GLboolean IsPositionInvariant;
+ union {
+ /** ARB assembly-style program fields */
+ struct {
+ struct prog_instruction *Instructions;
+
+ /**
+ * Local parameters used by the program.
+ *
+ * It's dynamically allocated because it is rarely used (just
+ * assembly-style programs), and MAX_PROGRAM_LOCAL_PARAMS entries
+ * once it's allocated.
+ */
+ GLfloat (*LocalParams)[4];
+
+ /** Bitmask of which register files are read/written with indirect
+ * addressing. Mask of (1 << PROGRAM_x) bits.
+ */
+ GLbitfield IndirectRegisterFiles;
+
+ /** Logical counts */
+ /*@{*/
+ GLuint NumInstructions;
+ GLuint NumTemporaries;
+ GLuint NumParameters;
+ GLuint NumAttributes;
+ GLuint NumAddressRegs;
+ GLuint NumAluInstructions;
+ GLuint NumTexInstructions;
+ GLuint NumTexIndirections;
+ /*@}*/
+ /** Native, actual h/w counts */
+ /*@{*/
+ GLuint NumNativeInstructions;
+ GLuint NumNativeTemporaries;
+ GLuint NumNativeParameters;
+ GLuint NumNativeAttributes;
+ GLuint NumNativeAddressRegs;
+ GLuint NumNativeAluInstructions;
+ GLuint NumNativeTexInstructions;
+ GLuint NumNativeTexIndirections;
+ /*@}*/
+
+ /** Used by ARB assembly-style programs. Can only be true for vertex
+ * programs.
+ */
+ GLboolean IsPositionInvariant;
+ } a;
+ };
};
diff --git a/src/mesa/main/state.c b/src/mesa/main/state.c
index 721f0ef..f84728b 100644
--- a/src/mesa/main/state.c
+++ b/src/mesa/main/state.c
@@ -70,9 +70,9 @@ update_program_enables(struct gl_context *ctx)
* GLSL shaders not relevant here.
*/
ctx->VertexProgram._Enabled = ctx->VertexProgram.Enabled
- && ctx->VertexProgram.Current->Instructions;
+ && ctx->VertexProgram.Current->a.Instructions;
ctx->FragmentProgram._Enabled = ctx->FragmentProgram.Enabled
- && ctx->FragmentProgram.Current->Instructions;
+ && ctx->FragmentProgram.Current->a.Instructions;
ctx->ATIFragmentShader._Enabled = ctx->ATIFragmentShader.Enabled
&& ctx->ATIFragmentShader.Current->Instructions[0];
}
diff --git a/src/mesa/program/arbprogparse.c b/src/mesa/program/arbprogparse.c
index e545d71..ac8030e 100644
--- a/src/mesa/program/arbprogparse.c
+++ b/src/mesa/program/arbprogparse.c
@@ -91,25 +91,25 @@ _mesa_parse_arb_fragment_program(struct gl_context* ctx, GLenum target,
* fragment_program struct.
*/
program->String = prog.String;
- program->NumInstructions = prog.NumInstructions;
- program->NumTemporaries = prog.NumTemporaries;
- program->NumParameters = prog.NumParameters;
- program->NumAttributes = prog.NumAttributes;
- program->NumAddressRegs = prog.NumAddressRegs;
- program->NumNativeInstructions = prog.NumNativeInstructions;
- program->NumNativeTemporaries = prog.NumNativeTemporaries;
- program->NumNativeParameters = prog.NumNativeParameters;
- program->NumNativeAttributes = prog.NumNativeAttributes;
- program->NumNativeAddressRegs = prog.NumNativeAddressRegs;
- program->NumAluInstructions = prog.NumAluInstructions;
- program->NumTexInstructions = prog.NumTexInstructions;
- program->NumTexIndirections = prog.NumTexIndirections;
- program->NumNativeAluInstructions = prog.NumAluInstructions;
- program->NumNativeTexInstructions = prog.NumTexInstructions;
- program->NumNativeTexIndirections = prog.NumTexIndirections;
+ program->a.NumInstructions = prog.a.NumInstructions;
+ program->a.NumTemporaries = prog.a.NumTemporaries;
+ program->a.NumParameters = prog.a.NumParameters;
+ program->a.NumAttributes = prog.a.NumAttributes;
+ program->a.NumAddressRegs = prog.a.NumAddressRegs;
+ program->a.NumNativeInstructions = prog.a.NumNativeInstructions;
+ program->a.NumNativeTemporaries = prog.a.NumNativeTemporaries;
+ program->a.NumNativeParameters = prog.a.NumNativeParameters;
+ program->a.NumNativeAttributes = prog.a.NumNativeAttributes;
+ program->a.NumNativeAddressRegs = prog.a.NumNativeAddressRegs;
+ program->a.NumAluInstructions = prog.a.NumAluInstructions;
+ program->a.NumTexInstructions = prog.a.NumTexInstructions;
+ program->a.NumTexIndirections = prog.a.NumTexIndirections;
+ program->a.NumNativeAluInstructions = prog.a.NumAluInstructions;
+ program->a.NumNativeTexInstructions = prog.a.NumTexInstructions;
+ program->a.NumNativeTexIndirections = prog.a.NumTexIndirections;
program->info.inputs_read = prog.info.inputs_read;
program->info.outputs_written = prog.info.outputs_written;
- program->IndirectRegisterFiles = prog.IndirectRegisterFiles;
+ program->a.IndirectRegisterFiles = prog.a.IndirectRegisterFiles;
for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++) {
program->TexturesUsed[i] = prog.TexturesUsed[i];
if (prog.TexturesUsed[i])
@@ -121,8 +121,8 @@ _mesa_parse_arb_fragment_program(struct gl_context* ctx, GLenum target,
program->info.fs.uses_discard = state.fragment.UsesKill;
- free(program->Instructions);
- program->Instructions = prog.Instructions;
+ free(program->a.Instructions);
+ program->a.Instructions = prog.a.Instructions;
if (program->Parameters)
_mesa_free_parameter_list(program->Parameters);
@@ -186,24 +186,24 @@ _mesa_parse_arb_vertex_program(struct gl_context *ctx, GLenum target,
* vertex_program struct.
*/
program->String = prog.String;
- program->NumInstructions = prog.NumInstructions;
- program->NumTemporaries = prog.NumTemporaries;
- program->NumParameters = prog.NumParameters;
- program->NumAttributes = prog.NumAttributes;
- program->NumAddressRegs = prog.NumAddressRegs;
- program->NumNativeInstructions = prog.NumNativeInstructions;
- program->NumNativeTemporaries = prog.NumNativeTemporaries;
- program->NumNativeParameters = prog.NumNativeParameters;
- program->NumNativeAttributes = prog.NumNativeAttributes;
- program->NumNativeAddressRegs = prog.NumNativeAddressRegs;
+ program->a.NumInstructions = prog.a.NumInstructions;
+ program->a.NumTemporaries = prog.a.NumTemporaries;
+ program->a.NumParameters = prog.a.NumParameters;
+ program->a.NumAttributes = prog.a.NumAttributes;
+ program->a.NumAddressRegs = prog.a.NumAddressRegs;
+ program->a.NumNativeInstructions = prog.a.NumNativeInstructions;
+ program->a.NumNativeTemporaries = prog.a.NumNativeTemporaries;
+ program->a.NumNativeParameters = prog.a.NumNativeParameters;
+ program->a.NumNativeAttributes = prog.a.NumNativeAttributes;
+ program->a.NumNativeAddressRegs = prog.a.NumNativeAddressRegs;
program->info.inputs_read = prog.info.inputs_read;
program->info.outputs_written = prog.info.outputs_written;
- program->IndirectRegisterFiles = prog.IndirectRegisterFiles;
- program->IsPositionInvariant = (state.option.PositionInvariant)
+ program->a.IndirectRegisterFiles = prog.a.IndirectRegisterFiles;
+ program->a.IsPositionInvariant = (state.option.PositionInvariant)
? GL_TRUE : GL_FALSE;
- free(program->Instructions);
- program->Instructions = prog.Instructions;
+ free(program->a.Instructions);
+ program->a.Instructions = prog.a.Instructions;
if (program->Parameters)
_mesa_free_parameter_list(program->Parameters);
diff --git a/src/mesa/program/ir_to_mesa.cpp b/src/mesa/program/ir_to_mesa.cpp
index 5776d15..24029cf 100644
--- a/src/mesa/program/ir_to_mesa.cpp
+++ b/src/mesa/program/ir_to_mesa.cpp
@@ -2807,7 +2807,7 @@ get_mesa_program(struct gl_context *ctx,
visit_exec_list(shader->ir, &v);
v.emit(NULL, OPCODE_END);
- prog->NumTemporaries = v.next_temp;
+ prog->a.NumTemporaries = v.next_temp;
unsigned num_instructions = v.instructions.length();
@@ -2841,12 +2841,12 @@ get_mesa_program(struct gl_context *ctx,
/* Set IndirectRegisterFiles. */
if (mesa_inst->DstReg.RelAddr)
- prog->IndirectRegisterFiles |= 1 << mesa_inst->DstReg.File;
+ prog->a.IndirectRegisterFiles |= 1 << mesa_inst->DstReg.File;
/* Update program's bitmask of indirectly accessed register files */
for (unsigned src = 0; src < 3; src++)
if (mesa_inst->SrcReg[src].RelAddr)
- prog->IndirectRegisterFiles |= 1 << mesa_inst->SrcReg[src].File;
+ prog->a.IndirectRegisterFiles |= 1 << mesa_inst->SrcReg[src].File;
switch (mesa_inst->Opcode) {
case OPCODE_IF:
@@ -2874,7 +2874,7 @@ get_mesa_program(struct gl_context *ctx,
}
break;
case OPCODE_ARL:
- prog->NumAddressRegs = 1;
+ prog->a.NumAddressRegs = 1;
break;
default:
break;
@@ -2907,8 +2907,8 @@ get_mesa_program(struct gl_context *ctx,
fflush(stderr);
}
- prog->Instructions = mesa_instructions;
- prog->NumInstructions = num_instructions;
+ prog->a.Instructions = mesa_instructions;
+ prog->a.NumInstructions = num_instructions;
/* Setting this to NULL prevents a possible double free in the fail_exit
* path (far below).
diff --git a/src/mesa/program/prog_execute.c b/src/mesa/program/prog_execute.c
index cb06e62..b564d56 100644
--- a/src/mesa/program/prog_execute.c
+++ b/src/mesa/program/prog_execute.c
@@ -374,7 +374,7 @@ _mesa_execute_program(struct gl_context * ctx,
const struct gl_program *program,
struct gl_program_machine *machine)
{
- const GLuint numInst = program->NumInstructions;
+ const GLuint numInst = program->a.NumInstructions;
const GLuint maxExec = 65536;
GLuint pc, numExec = 0;
@@ -392,7 +392,7 @@ _mesa_execute_program(struct gl_context * ctx,
}
for (pc = 0; pc < numInst; pc++) {
- const struct prog_instruction *inst = program->Instructions + pc;
+ const struct prog_instruction *inst = program->a.Instructions + pc;
if (DEBUG_PROG) {
_mesa_print_instruction(inst);
@@ -439,12 +439,12 @@ _mesa_execute_program(struct gl_context * ctx,
break;
case OPCODE_BGNLOOP:
/* no-op */
- assert(program->Instructions[inst->BranchTarget].Opcode
+ assert(program->a.Instructions[inst->BranchTarget].Opcode
== OPCODE_ENDLOOP);
break;
case OPCODE_ENDLOOP:
/* subtract 1 here since pc is incremented by for(pc) loop */
- assert(program->Instructions[inst->BranchTarget].Opcode
+ assert(program->a.Instructions[inst->BranchTarget].Opcode
== OPCODE_BGNLOOP);
pc = inst->BranchTarget - 1; /* go to matching BNGLOOP */
break;
@@ -453,14 +453,14 @@ _mesa_execute_program(struct gl_context * ctx,
case OPCODE_ENDSUB: /* end subroutine */
break;
case OPCODE_BRK: /* break out of loop (conditional) */
- assert(program->Instructions[inst->BranchTarget].Opcode
+ assert(program->a.Instructions[inst->BranchTarget].Opcode
== OPCODE_ENDLOOP);
/* break out of loop */
/* pc++ at end of for-loop will put us after the ENDLOOP inst */
pc = inst->BranchTarget;
break;
case OPCODE_CONT: /* continue loop (conditional) */
- assert(program->Instructions[inst->BranchTarget].Opcode
+ assert(program->a.Instructions[inst->BranchTarget].Opcode
== OPCODE_ENDLOOP);
/* continue at ENDLOOP */
/* Subtract 1 here since we'll do pc++ at end of for-loop */
@@ -645,9 +645,9 @@ _mesa_execute_program(struct gl_context * ctx,
case OPCODE_IF:
{
GLboolean cond;
- assert(program->Instructions[inst->BranchTarget].Opcode
+ assert(program->a.Instructions[inst->BranchTarget].Opcode
== OPCODE_ELSE ||
- program->Instructions[inst->BranchTarget].Opcode
+ program->a.Instructions[inst->BranchTarget].Opcode
== OPCODE_ENDIF);
/* eval condition */
GLfloat a[4];
@@ -669,7 +669,7 @@ _mesa_execute_program(struct gl_context * ctx,
break;
case OPCODE_ELSE:
/* goto ENDIF */
- assert(program->Instructions[inst->BranchTarget].Opcode
+ assert(program->a.Instructions[inst->BranchTarget].Opcode
== OPCODE_ENDIF);
assert(inst->BranchTarget >= 0);
pc = inst->BranchTarget;
diff --git a/src/mesa/program/prog_opt_constant_fold.c b/src/mesa/program/prog_opt_constant_fold.c
index d17e206..573088d 100644
--- a/src/mesa/program/prog_opt_constant_fold.c
+++ b/src/mesa/program/prog_opt_constant_fold.c
@@ -127,8 +127,8 @@ _mesa_constant_fold(struct gl_program *prog)
bool progress = false;
unsigned i;
- for (i = 0; i < prog->NumInstructions; i++) {
- struct prog_instruction *const inst = &prog->Instructions[i];
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ struct prog_instruction *const inst = &prog->a.Instructions[i];
switch (inst->Opcode) {
case OPCODE_ADD:
diff --git a/src/mesa/program/prog_optimize.c b/src/mesa/program/prog_optimize.c
index 321cffa..2e6d66c 100644
--- a/src/mesa/program/prog_optimize.c
+++ b/src/mesa/program/prog_optimize.c
@@ -165,7 +165,7 @@ remove_instructions(struct gl_program *prog, const GLboolean *removeFlags)
GLuint totalRemoved = 0;
/* go backward */
- for (i = prog->NumInstructions - 1; i >= 0; i--) {
+ for (i = prog->a.NumInstructions - 1; i >= 0; i--) {
if (removeFlags[i]) {
totalRemoved++;
if (removeCount == 0) {
@@ -209,8 +209,8 @@ replace_regs(struct gl_program *prog, gl_register_file file, const GLint map[])
{
GLuint i;
- for (i = 0; i < prog->NumInstructions; i++) {
- struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ struct prog_instruction *inst = prog->a.Instructions + i;
const GLuint numSrc = _mesa_num_inst_src_regs(inst->Opcode);
GLuint j;
for (j = 0; j < numSrc; j++) {
@@ -250,11 +250,11 @@ _mesa_remove_dead_code_global(struct gl_program *prog)
}
removeInst =
- calloc(prog->NumInstructions, sizeof(GLboolean));
+ calloc(prog->a.NumInstructions, sizeof(GLboolean));
/* Determine which temps are read and written */
- for (i = 0; i < prog->NumInstructions; i++) {
- const struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ const struct prog_instruction *inst = prog->a.Instructions + i;
const GLuint numSrc = _mesa_num_inst_src_regs(inst->Opcode);
GLuint j;
@@ -296,8 +296,8 @@ _mesa_remove_dead_code_global(struct gl_program *prog)
}
/* find instructions that write to dead registers, flag for removal */
- for (i = 0; i < prog->NumInstructions; i++) {
- struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ struct prog_instruction *inst = prog->a.Instructions + i;
const GLuint numDst = _mesa_num_inst_dst_regs(inst->Opcode);
if (numDst != 0 && inst->DstReg.File == PROGRAM_TEMPORARY) {
@@ -364,8 +364,8 @@ find_next_use(const struct gl_program *prog,
{
GLuint i;
- for (i = start; i < prog->NumInstructions; i++) {
- const struct prog_instruction *inst = prog->Instructions + i;
+ for (i = start; i < prog->a.NumInstructions; i++) {
+ const struct prog_instruction *inst = prog->a.Instructions + i;
switch (inst->Opcode) {
case OPCODE_BGNLOOP:
case OPCODE_BGNSUB:
@@ -481,8 +481,8 @@ _mesa_remove_extra_move_use(struct gl_program *prog)
* FOO tmpY, arg0, arg1;
*/
- for (i = 0; i + 1 < prog->NumInstructions; i++) {
- const struct prog_instruction *mov = prog->Instructions + i;
+ for (i = 0; i + 1 < prog->a.NumInstructions; i++) {
+ const struct prog_instruction *mov = prog->a.Instructions + i;
GLuint dst_mask, src_mask;
if (can_upward_mov_be_modifed(mov) == GL_FALSE)
continue;
@@ -497,8 +497,8 @@ _mesa_remove_extra_move_use(struct gl_program *prog)
* rewritten or we get into some flow-control, eliminating the use of
* this MOV.
*/
- for (j = i + 1; j < prog->NumInstructions; j++) {
- struct prog_instruction *inst2 = prog->Instructions + j;
+ for (j = i + 1; j < prog->a.NumInstructions; j++) {
+ struct prog_instruction *inst2 = prog->a.Instructions + j;
GLuint arg;
if (_mesa_is_flow_control_opcode(inst2->Opcode))
@@ -574,10 +574,10 @@ _mesa_remove_dead_code_local(struct gl_program *prog)
GLuint i, arg, rem = 0;
removeInst =
- calloc(prog->NumInstructions, sizeof(GLboolean));
+ calloc(prog->a.NumInstructions, sizeof(GLboolean));
- for (i = 0; i < prog->NumInstructions; i++) {
- const struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ const struct prog_instruction *inst = prog->a.Instructions + i;
const GLuint index = inst->DstReg.Index;
const GLuint mask = inst->DstReg.WriteMask;
enum inst_use use;
@@ -715,7 +715,7 @@ _mesa_remove_extra_moves(struct gl_program *prog)
}
removeInst =
- calloc(prog->NumInstructions, sizeof(GLboolean));
+ calloc(prog->a.NumInstructions, sizeof(GLboolean));
/*
* Look for sequences such as this:
@@ -725,8 +725,8 @@ _mesa_remove_extra_moves(struct gl_program *prog)
* FOO tmpY, arg0, arg1;
*/
- for (i = 0; i < prog->NumInstructions; i++) {
- const struct prog_instruction *mov = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ const struct prog_instruction *mov = prog->a.Instructions + i;
switch (mov->Opcode) {
case OPCODE_BGNLOOP:
@@ -755,7 +755,7 @@ _mesa_remove_extra_moves(struct gl_program *prog)
prevI = i - 1;
while (prevI > 0 && removeInst[prevI])
prevI--;
- prevInst = prog->Instructions + prevI;
+ prevInst = prog->a.Instructions + prevI;
if (prevInst->DstReg.File == PROGRAM_TEMPORARY &&
prevInst->DstReg.Index == id &&
@@ -1033,8 +1033,8 @@ find_live_intervals(struct gl_program *prog,
}
/* build intermediate arrays */
- if (!_mesa_find_temp_intervals(prog->Instructions, prog->NumInstructions,
- intBegin, intEnd))
+ if (!_mesa_find_temp_intervals(prog->a.Instructions,
+ prog->a.NumInstructions, intBegin, intEnd))
return GL_FALSE;
/* Build live intervals list from intermediate arrays */
@@ -1193,7 +1193,7 @@ _mesa_reallocate_registers(struct gl_program *prog)
*/
replace_regs(prog, PROGRAM_TEMPORARY, registerMap);
- prog->NumTemporaries = maxTemp + 1;
+ prog->a.NumTemporaries = maxTemp + 1;
}
if (dbg) {
@@ -1208,7 +1208,7 @@ _mesa_reallocate_registers(struct gl_program *prog)
#if 0
static void
print_it(struct gl_context *ctx, struct gl_program *program, const char *txt) {
- fprintf(stderr, "%s (%u inst):\n", txt, program->NumInstructions);
+ fprintf(stderr, "%s (%u inst):\n", txt, program->a.NumInstructions);
_mesa_print_program(program);
_mesa_print_program_parameters(ctx, program);
fprintf(stderr, "\n\n");
@@ -1256,8 +1256,8 @@ _mesa_simplify_cmp(struct gl_program * program)
outputWrites[i] = 0;
}
- for (i = 0; i < program->NumInstructions; i++) {
- struct prog_instruction *inst = program->Instructions + i;
+ for (i = 0; i < program->a.NumInstructions; i++) {
+ struct prog_instruction *inst = program->a.Instructions + i;
GLuint prevWriteMask;
/* Give up if we encounter relative addressing or flow control. */
diff --git a/src/mesa/program/prog_print.c b/src/mesa/program/prog_print.c
index 182da6d..0116abf 100644
--- a/src/mesa/program/prog_print.c
+++ b/src/mesa/program/prog_print.c
@@ -817,10 +817,10 @@ _mesa_fprint_program_opt(FILE *f,
fprintf(f, "# Geometry Shader\n");
}
- for (i = 0; i < prog->NumInstructions; i++) {
+ for (i = 0; i < prog->a.NumInstructions; i++) {
if (lineNumbers)
fprintf(f, "%3d: ", i);
- indent = _mesa_fprint_instruction_opt(f, prog->Instructions + i,
+ indent = _mesa_fprint_instruction_opt(f, prog->a.Instructions + i,
indent, mode, prog);
}
}
@@ -876,13 +876,14 @@ _mesa_fprint_program_parameters(FILE *f,
fprintf(f, "OutputsWritten: %" PRIx64 " (0b%s)\n",
(uint64_t) prog->info.outputs_written,
binary(prog->info.outputs_written));
- fprintf(f, "NumInstructions=%d\n", prog->NumInstructions);
- fprintf(f, "NumTemporaries=%d\n", prog->NumTemporaries);
- fprintf(f, "NumParameters=%d\n", prog->NumParameters);
- fprintf(f, "NumAttributes=%d\n", prog->NumAttributes);
- fprintf(f, "NumAddressRegs=%d\n", prog->NumAddressRegs);
+ fprintf(f, "NumInstructions=%d\n", prog->a.NumInstructions);
+ fprintf(f, "NumTemporaries=%d\n", prog->a.NumTemporaries);
+ fprintf(f, "NumParameters=%d\n", prog->a.NumParameters);
+ fprintf(f, "NumAttributes=%d\n", prog->a.NumAttributes);
+ fprintf(f, "NumAddressRegs=%d\n", prog->a.NumAddressRegs);
fprintf(f, "IndirectRegisterFiles: 0x%x (0b%s)\n",
- prog->IndirectRegisterFiles, binary(prog->IndirectRegisterFiles));
+ prog->a.IndirectRegisterFiles,
+ binary(prog->a.IndirectRegisterFiles));
fprintf(f, "SamplersUsed: 0x%x (0b%s)\n",
prog->SamplersUsed, binary(prog->SamplersUsed));
fprintf(f, "Samplers=[ ");
diff --git a/src/mesa/program/prog_statevars.c b/src/mesa/program/prog_statevars.c
index f1786e5..bb22092 100644
--- a/src/mesa/program/prog_statevars.c
+++ b/src/mesa/program/prog_statevars.c
@@ -373,14 +373,15 @@ _mesa_fetch_state(struct gl_context *ctx, const gl_state_index state[],
COPY_4V(value, ctx->FragmentProgram.Parameters[idx]);
return;
case STATE_LOCAL:
- if (!ctx->FragmentProgram.Current->LocalParams) {
- ctx->FragmentProgram.Current->LocalParams =
+ if (!ctx->FragmentProgram.Current->a.LocalParams) {
+ ctx->FragmentProgram.Current->a.LocalParams =
calloc(MAX_PROGRAM_LOCAL_PARAMS, sizeof(float[4]));
- if (!ctx->FragmentProgram.Current->LocalParams)
+ if (!ctx->FragmentProgram.Current->a.LocalParams)
return;
}
- COPY_4V(value, ctx->FragmentProgram.Current->LocalParams[idx]);
+ COPY_4V(value,
+ ctx->FragmentProgram.Current->a.LocalParams[idx]);
return;
default:
_mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
@@ -399,14 +400,14 @@ _mesa_fetch_state(struct gl_context *ctx, const gl_state_index state[],
COPY_4V(value, ctx->VertexProgram.Parameters[idx]);
return;
case STATE_LOCAL:
- if (!ctx->VertexProgram.Current->LocalParams) {
- ctx->VertexProgram.Current->LocalParams =
+ if (!ctx->VertexProgram.Current->a.LocalParams) {
+ ctx->VertexProgram.Current->a.LocalParams =
calloc(MAX_PROGRAM_LOCAL_PARAMS, sizeof(float[4]));
- if (!ctx->VertexProgram.Current->LocalParams)
+ if (!ctx->VertexProgram.Current->a.LocalParams)
return;
}
- COPY_4V(value, ctx->VertexProgram.Current->LocalParams[idx]);
+ COPY_4V(value, ctx->VertexProgram.Current->a.LocalParams[idx]);
return;
default:
_mesa_problem(ctx, "Bad state switch in _mesa_fetch_state()");
diff --git a/src/mesa/program/prog_to_nir.c b/src/mesa/program/prog_to_nir.c
index 08df05d..869f7fa 100644
--- a/src/mesa/program/prog_to_nir.c
+++ b/src/mesa/program/prog_to_nir.c
@@ -159,7 +159,7 @@ ptn_get_src(struct ptn_compile *c, const struct prog_src_register *prog_src)
switch (file) {
case PROGRAM_CONSTANT:
- if ((c->prog->IndirectRegisterFiles & (1 << PROGRAM_CONSTANT)) == 0) {
+ if ((c->prog->a.IndirectRegisterFiles & (1 << PROGRAM_CONSTANT)) == 0) {
float *v = (float *) plist->ParameterValues[prog_src->Index];
src.src = nir_src_for_ssa(nir_imm_vec4(b, v[0], v[1], v[2], v[3]));
break;
@@ -977,10 +977,10 @@ setup_registers_and_variables(struct ptn_compile *c)
}
/* Create temporary registers. */
- c->temp_regs = rzalloc_array(c, nir_register *, c->prog->NumTemporaries);
+ c->temp_regs = rzalloc_array(c, nir_register *, c->prog->a.NumTemporaries);
nir_register *reg;
- for (unsigned i = 0; i < c->prog->NumTemporaries; i++) {
+ for (unsigned i = 0; i < c->prog->a.NumTemporaries; i++) {
reg = nir_local_reg_create(b->impl);
if (!reg) {
c->error = true;
@@ -1036,8 +1036,8 @@ prog_to_nir(const struct gl_program *prog,
if (unlikely(c->error))
goto fail;
- for (unsigned int i = 0; i < prog->NumInstructions; i++) {
- ptn_emit_instruction(c, &prog->Instructions[i]);
+ for (unsigned int i = 0; i < prog->a.NumInstructions; i++) {
+ ptn_emit_instruction(c, &prog->a.Instructions[i]);
if (unlikely(c->error))
break;
diff --git a/src/mesa/program/program.c b/src/mesa/program/program.c
index 3b7745b..4a1c81a 100644
--- a/src/mesa/program/program.c
+++ b/src/mesa/program/program.c
@@ -248,10 +248,10 @@ _mesa_delete_program(struct gl_context *ctx, struct gl_program *prog)
return;
free(prog->String);
- free(prog->LocalParams);
+ free(prog->a.LocalParams);
- if (prog->Instructions) {
- _mesa_free_instructions(prog->Instructions, prog->NumInstructions);
+ if (prog->a.Instructions) {
+ _mesa_free_instructions(prog->a.Instructions, prog->a.NumInstructions);
}
if (prog->Parameters) {
_mesa_free_parameter_list(prog->Parameters);
@@ -342,14 +342,14 @@ _mesa_reference_program_(struct gl_context *ctx,
GLboolean
_mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)
{
- const GLuint origLen = prog->NumInstructions;
+ const GLuint origLen = prog->a.NumInstructions;
const GLuint newLen = origLen + count;
struct prog_instruction *newInst;
GLuint i;
/* adjust branches */
- for (i = 0; i < prog->NumInstructions; i++) {
- struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ struct prog_instruction *inst = prog->a.Instructions + i;
if (inst->BranchTarget > 0) {
if ((GLuint)inst->BranchTarget >= start) {
inst->BranchTarget += count;
@@ -364,22 +364,22 @@ _mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)
}
/* Copy 'start' instructions into new instruction buffer */
- _mesa_copy_instructions(newInst, prog->Instructions, start);
+ _mesa_copy_instructions(newInst, prog->a.Instructions, start);
/* init the new instructions */
_mesa_init_instructions(newInst + start, count);
/* Copy the remaining/tail instructions to new inst buffer */
_mesa_copy_instructions(newInst + start + count,
- prog->Instructions + start,
+ prog->a.Instructions + start,
origLen - start);
/* free old instructions */
- _mesa_free_instructions(prog->Instructions, origLen);
+ _mesa_free_instructions(prog->a.Instructions, origLen);
/* install new instructions */
- prog->Instructions = newInst;
- prog->NumInstructions = newLen;
+ prog->a.Instructions = newInst;
+ prog->a.NumInstructions = newLen;
return GL_TRUE;
}
@@ -391,14 +391,14 @@ _mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)
GLboolean
_mesa_delete_instructions(struct gl_program *prog, GLuint start, GLuint count)
{
- const GLuint origLen = prog->NumInstructions;
+ const GLuint origLen = prog->a.NumInstructions;
const GLuint newLen = origLen - count;
struct prog_instruction *newInst;
GLuint i;
/* adjust branches */
- for (i = 0; i < prog->NumInstructions; i++) {
- struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ struct prog_instruction *inst = prog->a.Instructions + i;
if (inst->BranchTarget > 0) {
if (inst->BranchTarget > (GLint) start) {
inst->BranchTarget -= count;
@@ -413,19 +413,19 @@ _mesa_delete_instructions(struct gl_program *prog, GLuint start, GLuint count)
}
/* Copy 'start' instructions into new instruction buffer */
- _mesa_copy_instructions(newInst, prog->Instructions, start);
+ _mesa_copy_instructions(newInst, prog->a.Instructions, start);
/* Copy the remaining/tail instructions to new inst buffer */
_mesa_copy_instructions(newInst + start,
- prog->Instructions + start + count,
+ prog->a.Instructions + start + count,
newLen - start);
/* free old instructions */
- _mesa_free_instructions(prog->Instructions, origLen);
+ _mesa_free_instructions(prog->a.Instructions, origLen);
/* install new instructions */
- prog->Instructions = newInst;
- prog->NumInstructions = newLen;
+ prog->a.Instructions = newInst;
+ prog->a.NumInstructions = newLen;
return GL_TRUE;
}
@@ -447,8 +447,8 @@ _mesa_find_used_registers(const struct gl_program *prog,
memset(used, 0, usedSize);
- for (i = 0; i < prog->NumInstructions; i++) {
- const struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ const struct prog_instruction *inst = prog->a.Instructions + i;
const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);
if (inst->DstReg.File == file) {
diff --git a/src/mesa/program/program_parse.y b/src/mesa/program/program_parse.y
index 41aeb24..603aa85 100644
--- a/src/mesa/program/program_parse.y
+++ b/src/mesa/program/program_parse.y
@@ -348,7 +348,7 @@ statement: instruction ';'
state->inst_tail = $1;
$1->next = NULL;
- state->prog->NumInstructions++;
+ state->prog->a.NumInstructions++;
}
}
| namingStatement ';'
@@ -357,12 +357,12 @@ statement: instruction ';'
instruction: ALU_instruction
{
$$ = $1;
- state->prog->NumAluInstructions++;
+ state->prog->a.NumAluInstructions++;
}
| TexInstruction
{
$$ = $1;
- state->prog->NumTexInstructions++;
+ state->prog->a.NumTexInstructions++;
}
;
@@ -785,7 +785,7 @@ srcReg: USED_IDENTIFIER /* temporaryReg | progParamSingle */
$$.Base.File = $1->param_binding_type;
if ($3.Base.RelAddr) {
- state->prog->IndirectRegisterFiles |= (1 << $$.Base.File);
+ state->prog->a.IndirectRegisterFiles |= (1 << $$.Base.File);
$1->param_accessed_indirectly = 1;
$$.Base.RelAddr = 1;
@@ -2247,18 +2247,18 @@ declare_variable(struct asm_parser_state *state, char *name, enum asm_type t,
switch (t) {
case at_temp:
- if (state->prog->NumTemporaries >= state->limits->MaxTemps) {
+ if (state->prog->a.NumTemporaries >= state->limits->MaxTemps) {
yyerror(locp, state, "too many temporaries declared");
free(s);
return NULL;
}
- s->temp_binding = state->prog->NumTemporaries;
- state->prog->NumTemporaries++;
+ s->temp_binding = state->prog->a.NumTemporaries;
+ state->prog->a.NumTemporaries++;
break;
case at_address:
- if (state->prog->NumAddressRegs >= state->limits->MaxAddressRegs) {
+ if (state->prog->a.NumAddressRegs >= state->limits->MaxAddressRegs) {
yyerror(locp, state, "too many address registers declared");
free(s);
return NULL;
@@ -2266,7 +2266,7 @@ declare_variable(struct asm_parser_state *state, char *name, enum asm_type t,
/* FINISHME: Add support for multiple address registers.
*/
- state->prog->NumAddressRegs++;
+ state->prog->a.NumAddressRegs++;
break;
default:
@@ -2564,42 +2564,42 @@ _mesa_parse_arb_program(struct gl_context *ctx, GLenum target, const GLubyte *st
/* Add one instruction to store the "END" instruction.
*/
- state->prog->Instructions =
- _mesa_alloc_instructions(state->prog->NumInstructions + 1);
+ state->prog->a.Instructions =
+ _mesa_alloc_instructions(state->prog->a.NumInstructions + 1);
- if (state->prog->Instructions == NULL) {
+ if (state->prog->a.Instructions == NULL) {
goto error;
}
inst = state->inst_head;
- for (i = 0; i < state->prog->NumInstructions; i++) {
+ for (i = 0; i < state->prog->a.NumInstructions; i++) {
struct asm_instruction *const temp = inst->next;
- state->prog->Instructions[i] = inst->Base;
+ state->prog->a.Instructions[i] = inst->Base;
inst = temp;
}
/* Finally, tag on an OPCODE_END instruction */
{
- const GLuint numInst = state->prog->NumInstructions;
- _mesa_init_instructions(state->prog->Instructions + numInst, 1);
- state->prog->Instructions[numInst].Opcode = OPCODE_END;
+ const GLuint numInst = state->prog->a.NumInstructions;
+ _mesa_init_instructions(state->prog->a.Instructions + numInst, 1);
+ state->prog->a.Instructions[numInst].Opcode = OPCODE_END;
}
- state->prog->NumInstructions++;
+ state->prog->a.NumInstructions++;
- state->prog->NumParameters = state->prog->Parameters->NumParameters;
- state->prog->NumAttributes =
+ state->prog->a.NumParameters = state->prog->Parameters->NumParameters;
+ state->prog->a.NumAttributes =
_mesa_bitcount_64(state->prog->info.inputs_read);
/*
* Initialize native counts to logical counts. The device driver may
* change them if program is translated into a hardware program.
*/
- state->prog->NumNativeInstructions = state->prog->NumInstructions;
- state->prog->NumNativeTemporaries = state->prog->NumTemporaries;
- state->prog->NumNativeParameters = state->prog->NumParameters;
- state->prog->NumNativeAttributes = state->prog->NumAttributes;
- state->prog->NumNativeAddressRegs = state->prog->NumAddressRegs;
+ state->prog->a.NumNativeInstructions = state->prog->a.NumInstructions;
+ state->prog->a.NumNativeTemporaries = state->prog->a.NumTemporaries;
+ state->prog->a.NumNativeParameters = state->prog->a.NumParameters;
+ state->prog->a.NumNativeAttributes = state->prog->a.NumAttributes;
+ state->prog->a.NumNativeAddressRegs = state->prog->a.NumAddressRegs;
result = GL_TRUE;
diff --git a/src/mesa/program/programopt.c b/src/mesa/program/programopt.c
index 1b50b5b..ca29822 100644
--- a/src/mesa/program/programopt.c
+++ b/src/mesa/program/programopt.c
@@ -49,7 +49,7 @@ static void
_mesa_insert_mvp_dp4_code(struct gl_context *ctx, struct gl_program *vprog)
{
struct prog_instruction *newInst;
- const GLuint origLen = vprog->NumInstructions;
+ const GLuint origLen = vprog->a.NumInstructions;
const GLuint newLen = origLen + 4;
GLuint i;
@@ -99,14 +99,14 @@ _mesa_insert_mvp_dp4_code(struct gl_context *ctx, struct gl_program *vprog)
}
/* Append original instructions after new instructions */
- _mesa_copy_instructions (newInst + 4, vprog->Instructions, origLen);
+ _mesa_copy_instructions (newInst + 4, vprog->a.Instructions, origLen);
/* free old instructions */
- _mesa_free_instructions(vprog->Instructions, origLen);
+ _mesa_free_instructions(vprog->a.Instructions, origLen);
/* install new instructions */
- vprog->Instructions = newInst;
- vprog->NumInstructions = newLen;
+ vprog->a.Instructions = newInst;
+ vprog->a.NumInstructions = newLen;
vprog->info.inputs_read |= VERT_BIT_POS;
vprog->info.outputs_written |= BITFIELD64_BIT(VARYING_SLOT_POS);
}
@@ -116,7 +116,7 @@ static void
_mesa_insert_mvp_mad_code(struct gl_context *ctx, struct gl_program *vprog)
{
struct prog_instruction *newInst;
- const GLuint origLen = vprog->NumInstructions;
+ const GLuint origLen = vprog->a.NumInstructions;
const GLuint newLen = origLen + 4;
GLuint hposTemp;
GLuint i;
@@ -146,7 +146,7 @@ _mesa_insert_mvp_mad_code(struct gl_context *ctx, struct gl_program *vprog)
}
/* TEMP hposTemp; */
- hposTemp = vprog->NumTemporaries++;
+ hposTemp = vprog->a.NumTemporaries++;
/*
* Generated instructions:
@@ -200,14 +200,14 @@ _mesa_insert_mvp_mad_code(struct gl_context *ctx, struct gl_program *vprog)
/* Append original instructions after new instructions */
- _mesa_copy_instructions (newInst + 4, vprog->Instructions, origLen);
+ _mesa_copy_instructions (newInst + 4, vprog->a.Instructions, origLen);
/* free old instructions */
- _mesa_free_instructions(vprog->Instructions, origLen);
+ _mesa_free_instructions(vprog->a.Instructions, origLen);
/* install new instructions */
- vprog->Instructions = newInst;
- vprog->NumInstructions = newLen;
+ vprog->a.Instructions = newInst;
+ vprog->a.NumInstructions = newLen;
vprog->info.inputs_read |= VERT_BIT_POS;
vprog->info.outputs_written |= BITFIELD64_BIT(VARYING_SLOT_POS);
}
@@ -252,7 +252,7 @@ _mesa_append_fog_code(struct gl_context *ctx, struct gl_program *fprog,
static const gl_state_index fogColorState[STATE_LENGTH]
= { STATE_FOG_COLOR, 0, 0, 0, 0};
struct prog_instruction *newInst, *inst;
- const GLuint origLen = fprog->NumInstructions;
+ const GLuint origLen = fprog->a.NumInstructions;
const GLuint newLen = origLen + 5;
GLuint i;
GLint fogPRefOpt, fogColorRef; /* state references */
@@ -278,7 +278,7 @@ _mesa_append_fog_code(struct gl_context *ctx, struct gl_program *fprog,
}
/* Copy orig instructions into new instruction buffer */
- _mesa_copy_instructions(newInst, fprog->Instructions, origLen);
+ _mesa_copy_instructions(newInst, fprog->a.Instructions, origLen);
/* PARAM fogParamsRefOpt = internal optimized fog params; */
fogPRefOpt
@@ -288,13 +288,13 @@ _mesa_append_fog_code(struct gl_context *ctx, struct gl_program *fprog,
= _mesa_add_state_reference(fprog->Parameters, fogColorState);
/* TEMP colorTemp; */
- colorTemp = fprog->NumTemporaries++;
+ colorTemp = fprog->a.NumTemporaries++;
/* TEMP fogFactorTemp; */
- fogFactorTemp = fprog->NumTemporaries++;
+ fogFactorTemp = fprog->a.NumTemporaries++;
/* Scan program to find where result.color is written */
inst = newInst;
- for (i = 0; i < fprog->NumInstructions; i++) {
+ for (i = 0; i < fprog->a.NumInstructions; i++) {
if (inst->Opcode == OPCODE_END)
break;
if (inst->DstReg.File == PROGRAM_OUTPUT &&
@@ -403,11 +403,11 @@ _mesa_append_fog_code(struct gl_context *ctx, struct gl_program *fprog,
inst++;
/* free old instructions */
- _mesa_free_instructions(fprog->Instructions, origLen);
+ _mesa_free_instructions(fprog->a.Instructions, origLen);
/* install new instructions */
- fprog->Instructions = newInst;
- fprog->NumInstructions = inst - newInst;
+ fprog->a.Instructions = newInst;
+ fprog->a.NumInstructions = inst - newInst;
fprog->info.inputs_read |= VARYING_BIT_FOGC;
assert(fprog->info.outputs_written & (1 << FRAG_RESULT_COLOR));
}
@@ -445,8 +445,8 @@ _mesa_count_texture_indirections(struct gl_program *prog)
GLbitfield aluTemps = 0x0;
GLuint i;
- for (i = 0; i < prog->NumInstructions; i++) {
- const struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ const struct prog_instruction *inst = prog->a.Instructions + i;
if (is_texture_instruction(inst)) {
if (((inst->SrcReg[0].File == PROGRAM_TEMPORARY) &&
@@ -474,7 +474,7 @@ _mesa_count_texture_indirections(struct gl_program *prog)
tempsOutput |= (1 << inst->DstReg.Index);
}
- prog->NumTexIndirections = indirections;
+ prog->a.NumTexIndirections = indirections;
}
@@ -486,9 +486,9 @@ void
_mesa_count_texture_instructions(struct gl_program *prog)
{
GLuint i;
- prog->NumTexInstructions = 0;
- for (i = 0; i < prog->NumInstructions; i++) {
- prog->NumTexInstructions += is_texture_instruction(prog->Instructions + i);
+ prog->a.NumTexInstructions = 0;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ prog->a.NumTexInstructions += is_texture_instruction(prog->a.Instructions + i);
}
}
@@ -517,8 +517,8 @@ _mesa_remove_output_reads(struct gl_program *prog, gl_register_file type)
outputMap[i] = -1;
/* look for instructions which read from varying vars */
- for (i = 0; i < prog->NumInstructions; i++) {
- struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ struct prog_instruction *inst = prog->a.Instructions + i;
const GLuint numSrc = _mesa_num_inst_src_regs(inst->Opcode);
GLuint j;
for (j = 0; j < numSrc; j++) {
@@ -542,8 +542,8 @@ _mesa_remove_output_reads(struct gl_program *prog, gl_register_file type)
return; /* nothing to be done */
/* look for instructions which write to the varying vars identified above */
- for (i = 0; i < prog->NumInstructions; i++) {
- struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ struct prog_instruction *inst = prog->a.Instructions + i;
if (inst->DstReg.File == type &&
outputMap[inst->DstReg.Index] >= 0) {
/* change inst to write to the temp reg, instead of the varying */
@@ -559,8 +559,8 @@ _mesa_remove_output_reads(struct gl_program *prog, gl_register_file type)
/* Look for END instruction and insert the new varying writes */
endPos = -1;
- for (i = 0; i < prog->NumInstructions; i++) {
- struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ struct prog_instruction *inst = prog->a.Instructions + i;
if (inst->Opcode == OPCODE_END) {
endPos = i;
_mesa_insert_instructions(prog, i, numVaryingReads);
@@ -571,7 +571,7 @@ _mesa_remove_output_reads(struct gl_program *prog, gl_register_file type)
assert(endPos >= 0);
/* insert new MOV instructions here */
- inst = prog->Instructions + endPos;
+ inst = prog->a.Instructions + endPos;
for (var = 0; var < VARYING_SLOT_MAX; var++) {
if (outputMap[var] >= 0) {
/* MOV VAR[var], TEMP[tmp]; */
@@ -598,8 +598,8 @@ _mesa_program_fragment_position_to_sysval(struct gl_program *prog)
prog->info.inputs_read &= ~BITFIELD64_BIT(VARYING_SLOT_POS);
prog->info.system_values_read |= 1 << SYSTEM_VALUE_FRAG_COORD;
- for (i = 0; i < prog->NumInstructions; i++) {
- struct prog_instruction *inst = prog->Instructions + i;
+ for (i = 0; i < prog->a.NumInstructions; i++) {
+ struct prog_instruction *inst = prog->a.Instructions + i;
const GLuint numSrc = _mesa_num_inst_src_regs(inst->Opcode);
GLuint j;
diff --git a/src/mesa/state_tracker/st_atifs_to_tgsi.c b/src/mesa/state_tracker/st_atifs_to_tgsi.c
index aaa7a4b..6176aa1 100644
--- a/src/mesa/state_tracker/st_atifs_to_tgsi.c
+++ b/src/mesa/state_tracker/st_atifs_to_tgsi.c
@@ -604,9 +604,9 @@ st_init_atifs_prog(struct gl_context *ctx, struct gl_program *prog)
_mesa_add_state_reference(prog->Parameters, fog_params_state);
_mesa_add_state_reference(prog->Parameters, fog_color);
- prog->NumInstructions = 0;
- prog->NumTemporaries = MAX_NUM_FRAGMENT_REGISTERS_ATI + 3; /* 3 input temps for arith ops */
- prog->NumParameters = MAX_NUM_FRAGMENT_CONSTANTS_ATI + 2; /* 2 state variables for fog */
+ prog->a.NumInstructions = 0;
+ prog->a.NumTemporaries = MAX_NUM_FRAGMENT_REGISTERS_ATI + 3; /* 3 input temps for arith ops */
+ prog->a.NumParameters = MAX_NUM_FRAGMENT_CONSTANTS_ATI + 2; /* 2 state variables for fog */
}
diff --git a/src/mesa/state_tracker/st_glsl_to_nir.cpp b/src/mesa/state_tracker/st_glsl_to_nir.cpp
index a412806..36531ad 100644
--- a/src/mesa/state_tracker/st_glsl_to_nir.cpp
+++ b/src/mesa/state_tracker/st_glsl_to_nir.cpp
@@ -417,9 +417,6 @@ st_nir_get_mesa_program(struct gl_context *ctx,
_mesa_log("\n\n");
}
- prog->Instructions = NULL;
- prog->NumInstructions = 0;
-
prog->SamplersUsed = shader->active_samplers;
prog->ShadowSamplers = shader->shadow_samplers;
prog->ExternalSamplersUsed = gl_external_samplers(shader);
diff --git a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
index 5b53c40..0cc3bf6 100644
--- a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
+++ b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
@@ -6499,9 +6499,6 @@ get_mesa_program_tgsi(struct gl_context *ctx,
_mesa_log("\n\n");
}
- prog->Instructions = NULL;
- prog->NumInstructions = 0;
-
do_set_program_inouts(shader->ir, prog, shader->Stage);
_mesa_copy_linked_program_data(shader_program, shader);
shrink_array_declarations(v->inputs, v->num_inputs,
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.c b/src/mesa/state_tracker/st_mesa_to_tgsi.c
index 9dc8f22..ee883e1 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.c
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.c
@@ -906,8 +906,8 @@ st_translate_mesa_program(
/* Declare address register.
*/
- if (program->NumAddressRegs > 0) {
- debug_assert( program->NumAddressRegs == 1 );
+ if (program->a.NumAddressRegs > 0) {
+ debug_assert( program->a.NumAddressRegs == 1 );
t->address[0] = ureg_DECL_address( ureg );
}
@@ -952,11 +952,11 @@ st_translate_mesa_program(
}
}
- if (program->IndirectRegisterFiles & (1 << PROGRAM_TEMPORARY)) {
+ if (program->a.IndirectRegisterFiles & (1 << PROGRAM_TEMPORARY)) {
/* If temps are accessed with indirect addressing, declare temporaries
* in sequential order. Else, we declare them on demand elsewhere.
*/
- for (i = 0; i < program->NumTemporaries; i++) {
+ for (i = 0; i < program->a.NumTemporaries; i++) {
/* XXX use TGSI_FILE_TEMPORARY_ARRAY when it's supported by ureg */
t->temps[i] = ureg_DECL_temporary( t->ureg );
}
@@ -987,7 +987,7 @@ st_translate_mesa_program(
* array.
*/
case PROGRAM_CONSTANT:
- if (program->IndirectRegisterFiles & PROGRAM_ANY_CONST)
+ if (program->a.IndirectRegisterFiles & PROGRAM_ANY_CONST)
t->constants[i] = ureg_DECL_constant( ureg, i );
else
t->constants[i] =
@@ -1019,8 +1019,8 @@ st_translate_mesa_program(
/* Emit each instruction in turn:
*/
- for (i = 0; i < program->NumInstructions; i++)
- compile_instruction(ctx, t, &program->Instructions[i]);
+ for (i = 0; i < program->a.NumInstructions; i++)
+ compile_instruction(ctx, t, &program->a.Instructions[i]);
out:
free(t->constants);
diff --git a/src/mesa/state_tracker/st_program.c b/src/mesa/state_tracker/st_program.c
index 0822509..1b85927 100644
--- a/src/mesa/state_tracker/st_program.c
+++ b/src/mesa/state_tracker/st_program.c
@@ -242,7 +242,7 @@ st_translate_vertex_program(struct st_context *st,
stvp->num_inputs = 0;
- if (stvp->Base.IsPositionInvariant)
+ if (stvp->Base.a.IsPositionInvariant)
_mesa_insert_mvp_code(st->ctx, &stvp->Base);
/*
diff --git a/src/mesa/swrast/s_fragprog.c b/src/mesa/swrast/s_fragprog.c
index 9bd357d..95f10e6 100644
--- a/src/mesa/swrast/s_fragprog.c
+++ b/src/mesa/swrast/s_fragprog.c
@@ -43,7 +43,7 @@ _swrast_use_fragment_program(struct gl_context *ctx)
{
struct gl_program *fp = ctx->FragmentProgram._Current;
return fp && !(fp == ctx->FragmentProgram._TexEnvProgram
- && fp->NumInstructions == 0);
+ && fp->a.NumInstructions == 0);
}
/**
diff --git a/src/mesa/tnl/t_vb_program.c b/src/mesa/tnl/t_vb_program.c
index 695821a..e426624 100644
--- a/src/mesa/tnl/t_vb_program.c
+++ b/src/mesa/tnl/t_vb_program.c
@@ -163,7 +163,7 @@ do_ndc_cliptest(struct gl_context *ctx, struct vp_stage_data *store)
*/
/** XXX NEW_SLANG _Enabled ??? */
if (ctx->Transform.ClipPlanesEnabled && (!ctx->VertexProgram._Enabled ||
- ctx->VertexProgram.Current->IsPositionInvariant)) {
+ ctx->VertexProgram.Current->a.IsPositionInvariant)) {
userclip( ctx,
VB->ClipPtr,
store->clipmask,
@@ -397,7 +397,7 @@ run_vp( struct gl_context *ctx, struct tnl_pipeline_stage *stage )
unmap_textures(ctx, program);
- if (program->IsPositionInvariant) {
+ if (program->a.IsPositionInvariant) {
/* We need the exact same transform as in the fixed function path here
* to guarantee invariance, depending on compiler optimization flags
* results could be different otherwise.
--
2.7.4
More information about the mesa-dev
mailing list