r200/i915/st/mesa/compiler: use common inputs read field

And set set inputs_read directly in shader_info.

To avoid regressions between changes this change is a squashed
version of the following patches.

st/mesa changes where:
Reviewed-by: Marek Olšák <[email protected]>

Reviewed-by: Jason Ekstrand <[email protected]>

30 files changed, 81 insertions, 79 deletions

diff --git a/src/compiler/glsl/ir_set_program_inouts.cpp b/src/compiler/glsl/ir_set_program_inouts.cpp
index e68ecfb11cd..4529b6c3cd5 100644
--- a/src/compiler/glsl/ir_set_program_inouts.cpp
+++ b/src/compiler/glsl/ir_set_program_inouts.cpp
@@ -24,13 +24,13 @@
 /**
  * \file ir_set_program_inouts.cpp
  *
- * Sets the InputsRead and OutputsWritten of Mesa programs.
+ * Sets the inputs_read and OutputsWritten of Mesa programs.
  *
  * Mesa programs (gl_program, not gl_shader_program) have a set of
  * flags indicating which varyings are read and written.  Computing
  * which are actually read from some sort of backend code can be
  * tricky when variable array indexing involved.  So this pass
- * provides support for setting InputsRead and OutputsWritten right
+ * provides support for setting inputs_read and OutputsWritten right
  * from the GLSL IR.
  */
 
@@ -83,10 +83,10 @@ mark(struct gl_program *prog, ir_variable *var, int offset, int len,
 {
    /* As of GLSL 1.20, varyings can only be floats, floating-point
     * vectors or matrices, or arrays of them.  For Mesa programs using
-    * InputsRead/OutputsWritten, everything but matrices uses one
+    * inputs_read/OutputsWritten, everything but matrices uses one
     * slot, while matrices use a slot per column.  Presumably
     * something doing a more clever packing would use something other
-    * than InputsRead/OutputsWritten.
+    * than inputs_read/OutputsWritten.
     */
 
    for (int i = 0; i < len; i++) {
@@ -113,7 +113,7 @@ mark(struct gl_program *prog, ir_variable *var, int offset, int len,
          if (is_patch_generic)
             prog->PatchInputsRead |= bitfield;
          else
-            prog->InputsRead |= bitfield;
+            prog->info.inputs_read |= bitfield;
 
          /* double inputs read is only for vertex inputs */
          if (stage == MESA_SHADER_VERTEX &&
@@ -426,7 +426,7 @@ do_set_program_inouts(exec_list *instructions, struct gl_program *prog,
 {
    ir_set_program_inouts_visitor v(prog, shader_stage);
 
-   prog->InputsRead = 0;
+   prog->info.inputs_read = 0;
    prog->OutputsWritten = 0;
    prog->SecondaryOutputsWritten = 0;
    prog->OutputsRead = 0;
diff --git a/src/compiler/shader_info.c b/src/compiler/shader_info.c
index 34aaf9f21fd..2d4292e0a4d 100644
--- a/src/compiler/shader_info.c
+++ b/src/compiler/shader_info.c
@@ -30,7 +30,6 @@ copy_shader_info(const struct gl_shader_program *shader_prog,
 {
    shader_info *info = &sh->Program->info;
 
-   info->inputs_read = sh->Program->InputsRead;
    info->double_inputs_read = sh->Program->DoubleInputsRead;
    info->outputs_written = sh->Program->OutputsWritten;
    info->outputs_read = sh->Program->OutputsRead;
diff --git a/src/mesa/drivers/dri/i915/i915_fragprog.c b/src/mesa/drivers/dri/i915/i915_fragprog.c
index ae230711a7b..a57125412ea 100644
--- a/src/mesa/drivers/dri/i915/i915_fragprog.c
+++ b/src/mesa/drivers/dri/i915/i915_fragprog.c
@@ -1032,7 +1032,7 @@ fixup_depth_write(struct i915_fragment_program *p)
 static void
 check_texcoord_mapping(struct i915_fragment_program *p)
 {
-   GLbitfield64 inputs = p->FragProg.InputsRead;
+   GLbitfield64 inputs = p->FragProg.info.inputs_read;
    unsigned unit = 0;
 
    for (unsigned i = 0; i < p->ctx->Const.MaxTextureCoordUnits; i++) {
@@ -1059,7 +1059,7 @@ check_texcoord_mapping(struct i915_fragment_program *p)
 static void
 check_wpos(struct i915_fragment_program *p)
 {
-   GLbitfield64 inputs = p->FragProg.InputsRead;
+   GLbitfield64 inputs = p->FragProg.info.inputs_read;
    GLint i;
    unsigned unit = 0;
 
@@ -1257,7 +1257,7 @@ i915ValidateFragmentProgram(struct i915_context *i915)
    struct i915_fragment_program *p =
       (struct i915_fragment_program *) ctx->FragmentProgram._Current;
 
-   const GLbitfield64 inputsRead = p->FragProg.InputsRead;
+   const GLbitfield64 inputsRead = p->FragProg.info.inputs_read;
    GLuint s4 = i915->state.Ctx[I915_CTXREG_LIS4] & ~S4_VFMT_MASK;
    GLuint s2 = S2_TEXCOORD_NONE;
    int i, offset = 0;
diff --git a/src/mesa/drivers/dri/i915/i915_state.c b/src/mesa/drivers/dri/i915/i915_state.c
index 5a0bb3d5777..715db1fffa3 100644
--- a/src/mesa/drivers/dri/i915/i915_state.c
+++ b/src/mesa/drivers/dri/i915/i915_state.c
@@ -650,7 +650,7 @@ i915_update_sprite_point_enable(struct gl_context *ctx)
    /* _NEW_PROGRAM */
    struct i915_fragment_program *p =
       (struct i915_fragment_program *) ctx->FragmentProgram._Current;
-   const GLbitfield64 inputsRead = p->FragProg.InputsRead;
+   const GLbitfield64 inputsRead = p->FragProg.info.inputs_read;
    struct i915_context *i915 = i915_context(ctx);
    GLuint s4 = i915->state.Ctx[I915_CTXREG_LIS4] & ~S4_VFMT_MASK;
    GLuint coord_replace_bits = 0x0;
diff --git a/src/mesa/drivers/dri/i915/intel_tris.c b/src/mesa/drivers/dri/i915/intel_tris.c
index 683d5a679c9..36cba22780b 100644
--- a/src/mesa/drivers/dri/i915/intel_tris.c
+++ b/src/mesa/drivers/dri/i915/intel_tris.c
@@ -436,7 +436,7 @@ intel_draw_point(struct intel_context *intel, intelVertexPtr v0)
  ***********************************************************************/
 
 /* Currently not working - VERT_ATTRIB_POINTSIZE isn't correctly
- * represented in the fragment program InputsRead field.
+ * represented in the fragment program info.inputs_read field.
  */
 static void
 intel_atten_point(struct intel_context *intel, intelVertexPtr v0)
@@ -956,7 +956,7 @@ intelChooseRenderState(struct gl_context * ctx)
       (ctx->Line.StippleFlag ? DD_LINE_STIPPLE : 0) |
       (ctx->Point._Attenuated ? DD_POINT_ATTEN : 0);
    const struct gl_program *fprog = ctx->FragmentProgram._Current;
-   bool have_wpos = (fprog && (fprog->InputsRead & VARYING_BIT_POS));
+   bool have_wpos = (fprog && (fprog->info.inputs_read & VARYING_BIT_POS));
    GLuint index = 0;
 
    if (INTEL_DEBUG & DEBUG_STATE)
diff --git a/src/mesa/drivers/dri/r200/r200_vertprog.c b/src/mesa/drivers/dri/r200/r200_vertprog.c
index 5f1b3b7c10f..b4574a7eed5 100644
--- a/src/mesa/drivers/dri/r200/r200_vertprog.c
+++ b/src/mesa/drivers/dri/r200/r200_vertprog.c
@@ -413,13 +413,13 @@ static GLboolean r200_translate_vertex_program(struct gl_context *ctx, struct r2
       return GL_FALSE;
 
 #if 0
-   if ((mesa_vp->InputsRead &
+   if ((mesa_vp->info.inputs_read &
       ~(VERT_BIT_POS | VERT_BIT_NORMAL | VERT_BIT_COLOR0 | VERT_BIT_COLOR1 |
       VERT_BIT_FOG | VERT_BIT_TEX0 | VERT_BIT_TEX1 | VERT_BIT_TEX2 |
       VERT_BIT_TEX3 | VERT_BIT_TEX4 | VERT_BIT_TEX5)) != 0) {
       if (R200_DEBUG & RADEON_FALLBACKS) {
 	 fprintf(stderr, "can't handle vert prog inputs 0x%x\n",
-	    mesa_vp->InputsRead);
+	    mesa_vp->info.inputs_read);
       }
       return GL_FALSE;
    }
@@ -491,42 +491,42 @@ static GLboolean r200_translate_vertex_program(struct gl_context *ctx, struct r2
    Haven't seen attr 14 used, maybe that's for the hw pointsize vec1 (which is
    not possibe to use with vertex progs as it is lacking in vert prog specification) */
 /* may look different when using idx buf / input_route instead of se_vtx_fmt? */
-   if (mesa_vp->InputsRead & VERT_BIT_POS) {
+   if (mesa_vp->info.inputs_read & VERT_BIT_POS) {
       vp->inputs[VERT_ATTRIB_POS] = 0;
       vp->inputmap_rev[0] = VERT_ATTRIB_POS;
       free_inputs &= ~(1 << 0);
       array_count++;
    }
-   if (mesa_vp->InputsRead & VERT_BIT_WEIGHT) {
+   if (mesa_vp->info.inputs_read & VERT_BIT_WEIGHT) {
       vp->inputs[VERT_ATTRIB_WEIGHT] = 12;
       vp->inputmap_rev[1] = VERT_ATTRIB_WEIGHT;
       array_count++;
    }
-   if (mesa_vp->InputsRead & VERT_BIT_NORMAL) {
+   if (mesa_vp->info.inputs_read & VERT_BIT_NORMAL) {
       vp->inputs[VERT_ATTRIB_NORMAL] = 1;
       vp->inputmap_rev[2] = VERT_ATTRIB_NORMAL;
       array_count++;
    }
-   if (mesa_vp->InputsRead & VERT_BIT_COLOR0) {
+   if (mesa_vp->info.inputs_read & VERT_BIT_COLOR0) {
       vp->inputs[VERT_ATTRIB_COLOR0] = 2;
       vp->inputmap_rev[4] = VERT_ATTRIB_COLOR0;
       free_inputs &= ~(1 << 2);
       array_count++;
    }
-   if (mesa_vp->InputsRead & VERT_BIT_COLOR1) {
+   if (mesa_vp->info.inputs_read & VERT_BIT_COLOR1) {
       vp->inputs[VERT_ATTRIB_COLOR1] = 3;
       vp->inputmap_rev[5] = VERT_ATTRIB_COLOR1;
       free_inputs &= ~(1 << 3);
       array_count++;
    }
-   if (mesa_vp->InputsRead & VERT_BIT_FOG) {
+   if (mesa_vp->info.inputs_read & VERT_BIT_FOG) {
       vp->inputs[VERT_ATTRIB_FOG] = 15; array_count++;
       vp->inputmap_rev[3] = VERT_ATTRIB_FOG;
       array_count++;
    }
    /* VERT_ATTRIB_TEX0-5 */
    for (i = 0; i <= 5; i++) {
-      if (mesa_vp->InputsRead & VERT_BIT_TEX(i)) {
+      if (mesa_vp->info.inputs_read & VERT_BIT_TEX(i)) {
 	 vp->inputs[VERT_ATTRIB_TEX(i)] = i + 6;
 	 vp->inputmap_rev[8 + i] = VERT_ATTRIB_TEX(i);
 	 free_inputs &= ~(1 << (i + 6));
@@ -535,7 +535,7 @@ static GLboolean r200_translate_vertex_program(struct gl_context *ctx, struct r2
    }
    /* using VERT_ATTRIB_TEX6/7 would be illegal */
    for (; i < VERT_ATTRIB_TEX_MAX; i++) {
-      if (mesa_vp->InputsRead & VERT_BIT_TEX(i)) {
+      if (mesa_vp->info.inputs_read & VERT_BIT_TEX(i)) {
           if (R200_DEBUG & RADEON_FALLBACKS) {
               fprintf(stderr, "texture attribute %d in vert prog\n", i);
           }
@@ -546,7 +546,7 @@ static GLboolean r200_translate_vertex_program(struct gl_context *ctx, struct r2
    for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; i++) {
       int j;
    /* completely ignore aliasing? */
-      if (mesa_vp->InputsRead & VERT_BIT_GENERIC(i)) {
+      if (mesa_vp->info.inputs_read & VERT_BIT_GENERIC(i)) {
 	 array_count++;
 	 if (array_count > 12) {
 	    if (R200_DEBUG & RADEON_FALLBACKS) {
diff --git a/src/mesa/main/context.c b/src/mesa/main/context.c
index 44b315eec65..65c1b6d0b38 100644
--- a/src/mesa/main/context.c
+++ b/src/mesa/main/context.c
@@ -743,7 +743,7 @@ check_context_limits(struct gl_context *ctx)
    assert(VARYING_SLOT_MAX <=
 	  (8 * sizeof(ctx->VertexProgram._Current->OutputsWritten)));
    assert(VARYING_SLOT_MAX <=
-	  (8 * sizeof(ctx->FragmentProgram._Current->InputsRead)));
+	  (8 * sizeof(ctx->FragmentProgram._Current->info.inputs_read)));
 
    /* shader-related checks */
    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
diff --git a/src/mesa/main/ffvertex_prog.c b/src/mesa/main/ffvertex_prog.c
index b318793fbb4..00409cc71df 100644
--- a/src/mesa/main/ffvertex_prog.c
+++ b/src/mesa/main/ffvertex_prog.c
@@ -159,7 +159,7 @@ static void make_state_key( struct gl_context *ctx, struct state_key *key )
 
    key->need_eye_coords = ctx->_NeedEyeCoords;
 
-   key->fragprog_inputs_read = fp->InputsRead;
+   key->fragprog_inputs_read = fp->info.inputs_read;
    key->varying_vp_inputs = ctx->varying_vp_inputs;
 
    if (ctx->RenderMode == GL_FEEDBACK) {
@@ -447,7 +447,7 @@ static struct ureg register_input( struct tnl_program *p, GLuint input )
    assert(input < VERT_ATTRIB_MAX);
 
    if (p->state->varying_vp_inputs & VERT_BIT(input)) {
-      p->program->InputsRead |= VERT_BIT(input);
+      p->program->info.inputs_read |= VERT_BIT(input);
       return make_ureg(PROGRAM_INPUT, input);
    }
    else {
@@ -1639,7 +1639,7 @@ create_new_program( const struct state_key *key,
    p.program->NumParameters =
    p.program->NumAttributes = p.program->NumAddressRegs = 0;
    p.program->Parameters = _mesa_new_parameter_list();
-   p.program->InputsRead = 0;
+   p.program->info.inputs_read = 0;
    p.program->OutputsWritten = 0;
 
    build_tnl_program( &p );
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index f03f64e129e..476ee2dae80 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -1922,7 +1922,6 @@ struct gl_program
 
    struct shader_info info;
 
-   GLbitfield64 InputsRead;     /**< Bitmask of which input regs are read */
    GLbitfield64 DoubleInputsRead;     /**< Bitmask of which input regs are read  and are doubles */
    GLbitfield64 OutputsWritten; /**< Bitmask of which output regs are written */
    GLbitfield64 SecondaryOutputsWritten; /**< Subset of OutputsWritten outputs written with non-zero index. */
diff --git a/src/mesa/main/state.h b/src/mesa/main/state.h
index 8b6f54b9ca8..7a6cdacf471 100644
--- a/src/mesa/main/state.h
+++ b/src/mesa/main/state.h
@@ -61,12 +61,12 @@ _mesa_need_secondary_color(const struct gl_context *ctx)
 
    if (ctx->VertexProgram._Current &&
        (ctx->VertexProgram._Current != ctx->VertexProgram._TnlProgram) &&
-       (ctx->VertexProgram._Current->InputsRead & VERT_BIT_COLOR1))
+       (ctx->VertexProgram._Current->info.inputs_read & VERT_BIT_COLOR1))
       return GL_TRUE;
 
    if (ctx->FragmentProgram._Current &&
        (ctx->FragmentProgram._Current != ctx->FragmentProgram._TexEnvProgram) &&
-       (ctx->FragmentProgram._Current->InputsRead & VARYING_BIT_COL1))
+       (ctx->FragmentProgram._Current->info.inputs_read & VARYING_BIT_COL1))
       return GL_TRUE;
 
    return GL_FALSE;
diff --git a/src/mesa/main/texstate.c b/src/mesa/main/texstate.c
index 95ea5bd58ee..56446c3af09 100644
--- a/src/mesa/main/texstate.c
+++ b/src/mesa/main/texstate.c
@@ -599,7 +599,7 @@ update_program_texture_state(struct gl_context *ctx, struct gl_program **prog,
    if (prog[MESA_SHADER_FRAGMENT]) {
       const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1;
       ctx->Texture._EnabledCoordUnits |=
-         (prog[MESA_SHADER_FRAGMENT]->InputsRead >> VARYING_SLOT_TEX0) &
+         (prog[MESA_SHADER_FRAGMENT]->info.inputs_read >> VARYING_SLOT_TEX0) &
          coordMask;
    }
 }
diff --git a/src/mesa/program/arbprogparse.c b/src/mesa/program/arbprogparse.c
index 51cefe33faa..53f661f64f4 100644
--- a/src/mesa/program/arbprogparse.c
+++ b/src/mesa/program/arbprogparse.c
@@ -107,7 +107,7 @@ _mesa_parse_arb_fragment_program(struct gl_context* ctx, GLenum target,
    program->NumNativeAluInstructions = prog.NumAluInstructions;
    program->NumNativeTexInstructions = prog.NumTexInstructions;
    program->NumNativeTexIndirections = prog.NumTexIndirections;
-   program->InputsRead      = prog.InputsRead;
+   program->info.inputs_read      = prog.info.inputs_read;
    program->OutputsWritten  = prog.OutputsWritten;
    program->IndirectRegisterFiles = prog.IndirectRegisterFiles;
    for (i = 0; i < MAX_TEXTURE_IMAGE_UNITS; i++) {
@@ -196,7 +196,7 @@ _mesa_parse_arb_vertex_program(struct gl_context *ctx, GLenum target,
    program->NumNativeParameters = prog.NumNativeParameters;
    program->NumNativeAttributes = prog.NumNativeAttributes;
    program->NumNativeAddressRegs = prog.NumNativeAddressRegs;
-   program->InputsRead     = prog.InputsRead;
+   program->info.inputs_read     = prog.info.inputs_read;
    program->OutputsWritten = prog.OutputsWritten;
    program->IndirectRegisterFiles = prog.IndirectRegisterFiles;
    program->IsPositionInvariant = (state.option.PositionInvariant)
diff --git a/src/mesa/program/prog_print.c b/src/mesa/program/prog_print.c
index 7a7d2745460..19d578579ee 100644
--- a/src/mesa/program/prog_print.c
+++ b/src/mesa/program/prog_print.c
@@ -208,7 +208,7 @@ arb_input_attrib_string(GLuint index, GLenum progType)
 
 
 /**
- * Print a vertex program's InputsRead field in human-readable format.
+ * Print a vertex program's inputs_read field in human-readable format.
  * For debugging.
  */
 void
@@ -226,7 +226,7 @@ _mesa_print_vp_inputs(GLbitfield inputs)
 
 
 /**
- * Print a fragment program's InputsRead field in human-readable format.
+ * Print a fragment program's inputs_read field in human-readable format.
  * For debugging.
  */
 void
@@ -872,7 +872,7 @@ _mesa_fprint_program_parameters(FILE *f,
    GLuint i;
 
    fprintf(f, "InputsRead: %" PRIx64 " (0b%s)\n",
-           (uint64_t) prog->InputsRead, binary(prog->InputsRead));
+           (uint64_t) prog->info.inputs_read, binary(prog->info.inputs_read));
    fprintf(f, "OutputsWritten: %" PRIx64 " (0b%s)\n",
            (uint64_t) prog->OutputsWritten, binary(prog->OutputsWritten));
    fprintf(f, "NumInstructions=%d\n", prog->NumInstructions);
diff --git a/src/mesa/program/prog_to_nir.c b/src/mesa/program/prog_to_nir.c
index f3c735e65b1..9c3ebc01644 100644
--- a/src/mesa/program/prog_to_nir.c
+++ b/src/mesa/program/prog_to_nir.c
@@ -889,9 +889,9 @@ setup_registers_and_variables(struct ptn_compile *c)
    struct nir_shader *shader = b->shader;
 
    /* Create input variables. */
-   const int num_inputs = util_last_bit64(c->prog->InputsRead);
+   const int num_inputs = util_last_bit64(c->prog->info.inputs_read);
    for (int i = 0; i < num_inputs; i++) {
-      if (!(c->prog->InputsRead & BITFIELD64_BIT(i)))
+      if (!(c->prog->info.inputs_read & BITFIELD64_BIT(i)))
          continue;
 
       nir_variable *var =
@@ -1051,7 +1051,6 @@ prog_to_nir(const struct gl_program *prog,
    s->info->num_abos = 0;
    s->info->num_ssbos = 0;
    s->info->num_images = 0;
-   s->info->inputs_read = prog->InputsRead;
    s->info->outputs_written = prog->OutputsWritten;
    s->info->system_values_read = prog->SystemValuesRead;
    s->info->uses_texture_gather = false;
diff --git a/src/mesa/program/program_parse.y b/src/mesa/program/program_parse.y
index 5294d58477a..2210c0ce8a8 100644
--- a/src/mesa/program/program_parse.y
+++ b/src/mesa/program/program_parse.y
@@ -752,7 +752,7 @@ srcReg: USED_IDENTIFIER /* temporaryReg | progParamSingle */
 	      break;
 	   case at_attrib:
 	      set_src_reg(& $$, PROGRAM_INPUT, s->attrib_binding);
-	      state->prog->InputsRead |= BITFIELD64_BIT($$.Base.Index);
+              state->prog->info.inputs_read |= BITFIELD64_BIT($$.Base.Index);
 
 	      if (!validate_inputs(& @1, state)) {
 		 YYERROR;
@@ -767,7 +767,7 @@ srcReg: USED_IDENTIFIER /* temporaryReg | progParamSingle */
 	| attribBinding
 	{
 	   set_src_reg(& $$, PROGRAM_INPUT, $1);
-	   state->prog->InputsRead |= BITFIELD64_BIT($$.Base.Index);
+           state->prog->info.inputs_read |= BITFIELD64_BIT($$.Base.Index);
 
 	   if (!validate_inputs(& @1, state)) {
 	      YYERROR;
@@ -2218,7 +2218,7 @@ set_src_reg_swz(struct asm_src_register *r, gl_register_file file, GLint index,
 int
 validate_inputs(struct YYLTYPE *locp, struct asm_parser_state *state)
 {
-   const GLbitfield64 inputs = state->prog->InputsRead | state->InputsBound;
+   const GLbitfield64 inputs = state->prog->info.inputs_read | state->InputsBound;
 
    if (((inputs & VERT_BIT_FF_ALL) & (inputs >> VERT_ATTRIB_GENERIC0)) != 0) {
       yyerror(locp, state, "illegal use of generic attribute and name attribute");
@@ -2588,7 +2588,8 @@ _mesa_parse_arb_program(struct gl_context *ctx, GLenum target, const GLubyte *st
    state->prog->NumInstructions++;
 
    state->prog->NumParameters = state->prog->Parameters->NumParameters;
-   state->prog->NumAttributes = _mesa_bitcount_64(state->prog->InputsRead);
+   state->prog->NumAttributes =
+      _mesa_bitcount_64(state->prog->info.inputs_read);
 
    /*
     * Initialize native counts to logical counts.  The device driver may
diff --git a/src/mesa/program/programopt.c b/src/mesa/program/programopt.c
index f51005d13d5..3c9839bf248 100644
--- a/src/mesa/program/programopt.c
+++ b/src/mesa/program/programopt.c
@@ -107,7 +107,7 @@ _mesa_insert_mvp_dp4_code(struct gl_context *ctx, struct gl_program *vprog)
    /* install new instructions */
    vprog->Instructions = newInst;
    vprog->NumInstructions = newLen;
-   vprog->InputsRead |= VERT_BIT_POS;
+   vprog->info.inputs_read |= VERT_BIT_POS;
    vprog->OutputsWritten |= BITFIELD64_BIT(VARYING_SLOT_POS);
 }
 
@@ -208,7 +208,7 @@ _mesa_insert_mvp_mad_code(struct gl_context *ctx, struct gl_program *vprog)
    /* install new instructions */
    vprog->Instructions = newInst;
    vprog->NumInstructions = newLen;
-   vprog->InputsRead |= VERT_BIT_POS;
+   vprog->info.inputs_read |= VERT_BIT_POS;
    vprog->OutputsWritten |= BITFIELD64_BIT(VARYING_SLOT_POS);
 }
 
@@ -238,7 +238,7 @@ _mesa_insert_mvp_code(struct gl_context *ctx, struct gl_program *vprog)
  * \param saturate True if writes to color outputs should be clamped to [0, 1]
  *
  * \note
- * This function sets \c VARYING_BIT_FOGC in \c fprog->Base.InputsRead.
+ * This function sets \c VARYING_BIT_FOGC in \c fprog->info.inputs_read.
  *
  * \todo With a little work, this function could be adapted to add fog code
  * to vertex programs too.
@@ -408,7 +408,7 @@ _mesa_append_fog_code(struct gl_context *ctx, struct gl_program *fprog,
    /* install new instructions */
    fprog->Instructions = newInst;
    fprog->NumInstructions = inst - newInst;
-   fprog->InputsRead |= VARYING_BIT_FOGC;
+   fprog->info.inputs_read |= VARYING_BIT_FOGC;
    assert(fprog->OutputsWritten & (1 << FRAG_RESULT_COLOR));
 }
 
@@ -592,10 +592,10 @@ _mesa_program_fragment_position_to_sysval(struct gl_program *prog)
    GLuint i;
 
    if (prog->Target != GL_FRAGMENT_PROGRAM_ARB ||
-       !(prog->InputsRead & BITFIELD64_BIT(VARYING_SLOT_POS)))
+       !(prog->info.inputs_read & BITFIELD64_BIT(VARYING_SLOT_POS)))
       return;
 
-   prog->InputsRead &= ~BITFIELD64_BIT(VARYING_SLOT_POS);
+   prog->info.inputs_read &= ~BITFIELD64_BIT(VARYING_SLOT_POS);
    prog->SystemValuesRead |= 1 << SYSTEM_VALUE_FRAG_COORD;
 
    for (i = 0; i < prog->NumInstructions; i++) {
diff --git a/src/mesa/state_tracker/st_atifs_to_tgsi.c b/src/mesa/state_tracker/st_atifs_to_tgsi.c
index ae08796dd51..2f2876b9a63 100644
--- a/src/mesa/state_tracker/st_atifs_to_tgsi.c
+++ b/src/mesa/state_tracker/st_atifs_to_tgsi.c
@@ -547,12 +547,12 @@ st_init_atifs_prog(struct gl_context *ctx, struct gl_program *prog)
    static const gl_state_index fog_color[STATE_LENGTH] =
       {STATE_FOG_COLOR, 0, 0, 0, 0};
 
-   prog->InputsRead = 0;
+   prog->info.inputs_read = 0;
    prog->OutputsWritten = BITFIELD64_BIT(FRAG_RESULT_COLOR);
    prog->SamplersUsed = 0;
    prog->Parameters = _mesa_new_parameter_list();
 
-   /* fill in InputsRead, SamplersUsed, TexturesUsed */
+   /* fill in inputs_read, SamplersUsed, TexturesUsed */
    for (pass = 0; pass < atifs->NumPasses; pass++) {
       for (r = 0; r < MAX_NUM_FRAGMENT_REGISTERS_ATI; r++) {
          struct atifs_setupinst *texinst = &atifs->SetupInst[pass][r];
@@ -560,14 +560,14 @@ st_init_atifs_prog(struct gl_context *ctx, struct gl_program *prog)
 
          if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP) {
             /* mark which texcoords are used */
-            prog->InputsRead |= BITFIELD64_BIT(VARYING_SLOT_TEX0 + pass_tex - GL_TEXTURE0_ARB);
+            prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_TEX0 + pass_tex - GL_TEXTURE0_ARB);
             /* by default there is 1:1 mapping between samplers and textures */
             prog->SamplersUsed |= (1 << r);
             /* the target is unknown here, it will be fixed in the draw call */
             prog->TexturesUsed[r] = TEXTURE_2D_BIT;
          } else if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP) {
             if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <= GL_TEXTURE7_ARB) {
-               prog->InputsRead |= BITFIELD64_BIT(VARYING_SLOT_TEX0 + pass_tex - GL_TEXTURE0_ARB);
+               prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_TEX0 + pass_tex - GL_TEXTURE0_ARB);
             }
          }
       }
@@ -581,12 +581,12 @@ st_init_atifs_prog(struct gl_context *ctx, struct gl_program *prog)
                for (arg = 0; arg < inst->ArgCount[optype]; arg++) {
                   GLint index = inst->SrcReg[optype][arg].Index;
                   if (index == GL_PRIMARY_COLOR_EXT) {
-                     prog->InputsRead |= BITFIELD64_BIT(VARYING_SLOT_COL0);
+                     prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_COL0);
                   } else if (index == GL_SECONDARY_INTERPOLATOR_ATI) {
                      /* note: ATI_fragment_shader.txt never specifies what
                       * GL_SECONDARY_INTERPOLATOR_ATI is, swrast uses
                       * VARYING_SLOT_COL1 for this input */
-                     prog->InputsRead |= BITFIELD64_BIT(VARYING_SLOT_COL1);
+                     prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_COL1);
                   }
                }
             }
@@ -594,7 +594,7 @@ st_init_atifs_prog(struct gl_context *ctx, struct gl_program *prog)
       }
    }
    /* we may need fog */
-   prog->InputsRead |= BITFIELD64_BIT(VARYING_SLOT_FOGC);
+   prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_FOGC);
 
    /* we always have the ATI_fs constants, and the fog params */
    for (i = 0; i < MAX_NUM_FRAGMENT_CONSTANTS_ATI; i++) {
diff --git a/src/mesa/state_tracker/st_atom_rasterizer.c b/src/mesa/state_tracker/st_atom_rasterizer.c
index 7f58c8b8a09..a97a5ac5bc3 100644
--- a/src/mesa/state_tracker/st_atom_rasterizer.c
+++ b/src/mesa/state_tracker/st_atom_rasterizer.c
@@ -183,7 +183,7 @@ static void update_raster_state( struct st_context *st )
       raster->sprite_coord_enable = ctx->Point.CoordReplace &
          ((1u << MAX_TEXTURE_COORD_UNITS) - 1);
       if (!st->needs_texcoord_semantic &&
-          fragProg->InputsRead & VARYING_BIT_PNTC) {
+          fragProg->info.inputs_read & VARYING_BIT_PNTC) {
          raster->sprite_coord_enable |=
             1 << st_get_generic_varying_index(st, VARYING_SLOT_PNTC);
       }
diff --git a/src/mesa/state_tracker/st_cb_drawtex.c b/src/mesa/state_tracker/st_cb_drawtex.c
index 2991a09f7de..85f9a5390a5 100644
--- a/src/mesa/state_tracker/st_cb_drawtex.c
+++ b/src/mesa/state_tracker/st_cb_drawtex.c
@@ -123,7 +123,7 @@ st_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,
    st_validate_state(st, ST_PIPELINE_RENDER);
 
    /* determine if we need vertex color */
-   if (ctx->FragmentProgram._Current->InputsRead & VARYING_BIT_COL0)
+   if (ctx->FragmentProgram._Current->info.inputs_read & VARYING_BIT_COL0)
       emitColor = GL_TRUE;
    else
       emitColor = GL_FALSE;
diff --git a/src/mesa/state_tracker/st_glsl_to_nir.cpp b/src/mesa/state_tracker/st_glsl_to_nir.cpp
index 303b36e9467..ef491941a29 100644
--- a/src/mesa/state_tracker/st_glsl_to_nir.cpp
+++ b/src/mesa/state_tracker/st_glsl_to_nir.cpp
@@ -80,7 +80,7 @@ st_nir_assign_vs_in_locations(struct gl_program *prog, nir_shader *nir)
 
    /* TODO de-duplicate w/ similar code in st_translate_vertex_program()? */
    for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
-      if ((prog->InputsRead & BITFIELD64_BIT(attr)) != 0) {
+      if ((prog->info.inputs_read & BITFIELD64_BIT(attr)) != 0) {
          input_to_index[attr] = num_inputs;
          num_inputs++;
          if ((prog->DoubleInputsRead & BITFIELD64_BIT(attr)) != 0) {
diff --git a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
index ff48f9935c9..dabd97fd84a 100644
--- a/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
+++ b/src/mesa/state_tracker/st_glsl_to_tgsi.cpp
@@ -6099,13 +6099,13 @@ st_translate_program(
       if (program->shader->info.EarlyFragmentTests)
          ureg_property(ureg, TGSI_PROPERTY_FS_EARLY_DEPTH_STENCIL, 1);
 
-      if (proginfo->InputsRead & VARYING_BIT_POS) {
+      if (proginfo->info.inputs_read & VARYING_BIT_POS) {
           /* Must do this after setting up t->inputs. */
           emit_wpos(st_context(ctx), t, proginfo, ureg,
                     program->wpos_transform_const);
       }
 
-      if (proginfo->InputsRead & VARYING_BIT_FACE)
+      if (proginfo->info.inputs_read & VARYING_BIT_FACE)
          emit_face_var(ctx, t);
 
       for (i = 0; i < numOutputs; i++) {
@@ -6505,7 +6505,7 @@ get_mesa_program_tgsi(struct gl_context *ctx,
    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,
-                             &prog->InputsRead, prog->DoubleInputsRead, &prog->PatchInputsRead);
+                             &prog->info.inputs_read, prog->DoubleInputsRead, &prog->PatchInputsRead);
    shrink_array_declarations(v->outputs, v->num_outputs,
                              &prog->OutputsWritten, 0ULL, &prog->PatchOutputsWritten);
    count_resources(v, prog);
@@ -6516,7 +6516,7 @@ get_mesa_program_tgsi(struct gl_context *ctx,
 
    /* This must be done before the uniform storage is associated. */
    if (shader->Stage == MESA_SHADER_FRAGMENT &&
-       (prog->InputsRead & VARYING_BIT_POS ||
+       (prog->info.inputs_read & VARYING_BIT_POS ||
         prog->SystemValuesRead & (1 << SYSTEM_VALUE_FRAG_COORD))) {
       static const gl_state_index wposTransformState[STATE_LENGTH] = {
          STATE_INTERNAL, STATE_FB_WPOS_Y_TRANSFORM
diff --git a/src/mesa/state_tracker/st_mesa_to_tgsi.c b/src/mesa/state_tracker/st_mesa_to_tgsi.c
index 9e3dd9c331a..18948d6a2c1 100644
--- a/src/mesa/state_tracker/st_mesa_to_tgsi.c
+++ b/src/mesa/state_tracker/st_mesa_to_tgsi.c
@@ -832,7 +832,7 @@ st_translate_mesa_program(
                                            interpMode[i]);
       }
 
-      if (program->InputsRead & VARYING_BIT_POS) {
+      if (program->info.inputs_read & VARYING_BIT_POS) {
          /* Must do this after setting up t->inputs, and before
           * emitting constant references, below:
           */
diff --git a/src/mesa/state_tracker/st_program.c b/src/mesa/state_tracker/st_program.c
index 09e8d43479d..5922e7ae7ad 100644
--- a/src/mesa/state_tracker/st_program.c
+++ b/src/mesa/state_tracker/st_program.c
@@ -250,7 +250,7 @@ st_translate_vertex_program(struct st_context *st,
     * and TGSI generic input indexes, plus input attrib semantic info.
     */
    for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
-      if ((stvp->Base.InputsRead & BITFIELD64_BIT(attr)) != 0) {
+      if ((stvp->Base.info.inputs_read & BITFIELD64_BIT(attr)) != 0) {
          input_to_index[attr] = stvp->num_inputs;
          stvp->index_to_input[stvp->num_inputs] = attr;
          stvp->num_inputs++;
@@ -614,7 +614,7 @@ st_translate_fragment_program(struct st_context *st,
    /*
     * Convert Mesa program inputs to TGSI input register semantics.
     */
-   inputsRead = stfp->Base.InputsRead;
+   inputsRead = stfp->Base.info.inputs_read;
    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
       if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
          const GLuint slot = fs_num_inputs++;
@@ -1225,7 +1225,7 @@ st_translate_program_common(struct st_context *st,
     * Convert Mesa program inputs to TGSI input register semantics.
     */
    for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
-      if ((prog->InputsRead & BITFIELD64_BIT(attr)) != 0) {
+      if ((prog->info.inputs_read & BITFIELD64_BIT(attr)) != 0) {
          const GLuint slot = num_inputs++;
 
          inputMapping[attr] = slot;
diff --git a/src/mesa/swrast/s_context.c b/src/mesa/swrast/s_context.c
index 3eb931fd3ad..a8c2ea3d90a 100644
--- a/src/mesa/swrast/s_context.c
+++ b/src/mesa/swrast/s_context.c
@@ -499,7 +499,7 @@ _swrast_update_active_attribs(struct gl_context *ctx)
     */
    if (_swrast_use_fragment_program(ctx)) {
       /* fragment program/shader */
-      attribsMask = ctx->FragmentProgram._Current->InputsRead;
+      attribsMask = ctx->FragmentProgram._Current->info.inputs_read;
       attribsMask &= ~VARYING_BIT_POS; /* WPOS is always handled specially */
    }
    else if (ctx->ATIFragmentShader._Enabled) {
diff --git a/src/mesa/swrast/s_fragprog.c b/src/mesa/swrast/s_fragprog.c
index 3530b50eecd..bb601db327c 100644
--- a/src/mesa/swrast/s_fragprog.c
+++ b/src/mesa/swrast/s_fragprog.c
@@ -265,7 +265,7 @@ _swrast_exec_fragment_program( struct gl_context *ctx, SWspan *span )
    const struct gl_program *program = ctx->FragmentProgram._Current;
 
    /* incoming colors should be floats */
-   if (program->InputsRead & VARYING_BIT_COL0) {
+   if (program->info.inputs_read & VARYING_BIT_COL0) {
       assert(span->array->ChanType == GL_FLOAT);
    }
 
diff --git a/src/mesa/tnl/t_context.c b/src/mesa/tnl/t_context.c
index 9b7982e854e..0319e855872 100644
--- a/src/mesa/tnl/t_context.c
+++ b/src/mesa/tnl/t_context.c
@@ -148,7 +148,7 @@ _tnl_InvalidateState( struct gl_context *ctx, GLuint new_state )
     */
    tnl->render_inputs_bitset = BITFIELD64_BIT(_TNL_ATTRIB_POS);
 
-   if (!fp || (fp->InputsRead & VARYING_BIT_COL0)) {
+   if (!fp || (fp->info.inputs_read & VARYING_BIT_COL0)) {
      tnl->render_inputs_bitset |= BITFIELD64_BIT(_TNL_ATTRIB_COLOR0);
    }
 
@@ -157,13 +157,13 @@ _tnl_InvalidateState( struct gl_context *ctx, GLuint new_state )
 
    for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
      if (ctx->Texture._EnabledCoordUnits & (1 << i) ||
-	 (fp && fp->InputsRead & VARYING_BIT_TEX(i))) {
+	 (fp && fp->info.inputs_read & VARYING_BIT_TEX(i))) {
        tnl->render_inputs_bitset |= BITFIELD64_BIT(_TNL_ATTRIB_TEX(i));
      }
    }
 
    if (ctx->Fog.Enabled
-       || (fp != NULL && (fp->InputsRead & VARYING_BIT_FOGC) != 0)) {
+       || (fp != NULL && (fp->info.inputs_read & VARYING_BIT_FOGC) != 0)) {
       /* Either fixed-function fog or a fragment program needs fog coord.
        */
       tnl->render_inputs_bitset |= BITFIELD64_BIT(_TNL_ATTRIB_FOG);
diff --git a/src/mesa/tnl/t_vb_program.c b/src/mesa/tnl/t_vb_program.c
index c0a48a0c565..1ed087c0fee 100644
--- a/src/mesa/tnl/t_vb_program.c
+++ b/src/mesa/tnl/t_vb_program.c
@@ -347,7 +347,7 @@ run_vp( struct gl_context *ctx, struct tnl_pipeline_stage *stage )
 
       /* the vertex array case */
       for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
-	 if (program->InputsRead & BITFIELD64_BIT(attr)) {
+	 if (program->info.inputs_read & BITFIELD64_BIT(attr)) {
 	    const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
 	    const GLuint size = VB->AttribPtr[attr]->size;
 	    const GLuint stride = VB->AttribPtr[attr]->stride;
diff --git a/src/mesa/vbo/vbo_attrib.h b/src/mesa/vbo/vbo_attrib.h
index 7b7d87af5e4..5ee77fe1920 100644
--- a/src/mesa/vbo/vbo_attrib.h
+++ b/src/mesa/vbo/vbo_attrib.h
@@ -79,7 +79,7 @@ enum {
 	VBO_ATTRIB_GENERIC14 = 31,
 	VBO_ATTRIB_GENERIC15 = 32,
 
-	/* XXX: in the vertex program InputsRead flag, we alias
+	/* XXX: in the vertex program inputs_read flag, we alias
 	 * materials and generics and use knowledge about the program
 	 * (whether it is a fixed-function emulation) to
 	 * differentiate.  Here we must keep them apart instead.
diff --git a/src/mesa/vbo/vbo_exec_draw.c b/src/mesa/vbo/vbo_exec_draw.c
index 19114daa6ad..3d1b2f71648 100644
--- a/src/mesa/vbo/vbo_exec_draw.c
+++ b/src/mesa/vbo/vbo_exec_draw.c
@@ -211,8 +211,10 @@ vbo_exec_bind_arrays( struct gl_context *ctx )
        * glVertexAttrib(0, val) calls to feed into the GENERIC0 input.
        * The original state gets essentially restored below.
        */
-      if ((ctx->VertexProgram._Current->InputsRead & VERT_BIT_POS) == 0 &&
-          (ctx->VertexProgram._Current->InputsRead & VERT_BIT_GENERIC0)) {
+      if ((ctx->VertexProgram._Current->info.inputs_read &
+           VERT_BIT_POS) == 0 &&
+          (ctx->VertexProgram._Current->info.inputs_read &
+           VERT_BIT_GENERIC0)) {
          swap_pos = true;
          exec->vtx.inputs[VERT_ATTRIB_GENERIC0] = exec->vtx.inputs[0];
          exec->vtx.attrsz[VERT_ATTRIB_GENERIC0] = exec->vtx.attrsz[0];
diff --git a/src/mesa/vbo/vbo_save_draw.c b/src/mesa/vbo/vbo_save_draw.c
index cb68e1d2583..2aa00952037 100644
--- a/src/mesa/vbo/vbo_save_draw.c
+++ b/src/mesa/vbo/vbo_save_draw.c
@@ -174,8 +174,10 @@ static void vbo_bind_vertex_list(struct gl_context *ctx,
        * In that case we effectively need to route the data from
        * glVertexAttrib(0, val) calls to feed into the GENERIC0 input.
        */
-      if ((ctx->VertexProgram._Current->InputsRead & VERT_BIT_POS) == 0 &&
-          (ctx->VertexProgram._Current->InputsRead & VERT_BIT_GENERIC0)) {
+      if ((ctx->VertexProgram._Current->info.inputs_read &
+           VERT_BIT_POS) == 0 &&
+          (ctx->VertexProgram._Current->info.inputs_read &
+           VERT_BIT_GENERIC0)) {
          save->inputs[VERT_ATTRIB_GENERIC0] = save->inputs[0];
          node_attrsz[VERT_ATTRIB_GENERIC0] = node_attrsz[0];
          node_attrtype[VERT_ATTRIB_GENERIC0] = node_attrtype[0];