On Tue, Sep 15, 2015 at 9:42 PM, Rob Clark <robdcl...@gmail.com> wrote:
> On Tue, Sep 15, 2015 at 8:48 PM, Connor Abbott <cwabbo...@gmail.com> wrote:
>> On Tue, Sep 15, 2015 at 7:33 PM, Rob Clark <robdcl...@gmail.com> wrote:
>>> From: Rob Clark <robcl...@freedesktop.org>
>>>
>>> Rename print_var_state to print_state, and stuff FILE ptr into the state
>>> object. This avoids passing around an extra parameter everywhere.
>>>
>>> Signed-off-by: Rob Clark <robcl...@freedesktop.org>
>>> ---
>>> src/glsl/nir/nir_print.c | 95
>>> +++++++++++++++++++++++++++---------------------
>>> 1 file changed, 54 insertions(+), 41 deletions(-)
>>>
>>> diff --git a/src/glsl/nir/nir_print.c b/src/glsl/nir/nir_print.c
>>> index 69cadba..405dbf3 100644
>>> --- a/src/glsl/nir/nir_print.c
>>> +++ b/src/glsl/nir/nir_print.c
>>> @@ -37,6 +37,7 @@ print_tabs(unsigned num_tabs, FILE *fp)
>>> }
>>>
>>> typedef struct {
>>> + FILE *fp;
>>> /** map from nir_variable -> printable name */
>>> struct hash_table *ht;
>>>
>>> @@ -45,7 +46,7 @@ typedef struct {
>>>
>>> /* an index used to make new non-conflicting names */
>>> unsigned index;
>>> -} print_var_state;
>>> +} print_state;
>>>
>>> static void
>>> print_register(nir_register *reg, FILE *fp)
>>> @@ -206,8 +207,10 @@ print_alu_instr(nir_alu_instr *instr, FILE *fp)
>>> }
>>>
>>> static void
>>> -print_var_decl(nir_variable *var, print_var_state *state, FILE *fp)
>>> +print_var_decl(nir_variable *var, print_state *state)
>>> {
>>> + FILE *fp = state->fp;
>>> +
>>> fprintf(fp, "decl_var ");
>>>
>>> const char *const cent = (var->data.centroid) ? "centroid " : "";
>>> @@ -253,7 +256,7 @@ print_var_decl(nir_variable *var, print_var_state
>>> *state, FILE *fp)
>>> }
>>>
>>> static void
>>> -print_var(nir_variable *var, print_var_state *state, FILE *fp)
>>> +print_var(nir_variable *var, print_state *state, FILE *fp)
>>
>> You should remove the fp argument from here...
>>
>>> {
>>> const char *name;
>>> if (state) {
>>> @@ -269,13 +272,13 @@ print_var(nir_variable *var, print_var_state *state,
>>> FILE *fp)
>>> }
>>>
>>> static void
>>> -print_deref_var(nir_deref_var *deref, print_var_state *state, FILE *fp)
>>> +print_deref_var(nir_deref_var *deref, print_state *state, FILE *fp)
>>
>> and here...
>>
>>> {
>>> print_var(deref->var, state, fp);
>>> }
>>>
>>> static void
>>> -print_deref_array(nir_deref_array *deref, print_var_state *state, FILE *fp)
>>> +print_deref_array(nir_deref_array *deref, print_state *state, FILE *fp)
>>
>> and here...
>>
>>> {
>>> fprintf(fp, "[");
>>> switch (deref->deref_array_type) {
>>> @@ -296,13 +299,13 @@ print_deref_array(nir_deref_array *deref,
>>> print_var_state *state, FILE *fp)
>>>
>>> static void
>>> print_deref_struct(nir_deref_struct *deref, const struct glsl_type
>>> *parent_type,
>>> - print_var_state *state, FILE *fp)
>>> + print_state *state, FILE *fp)
>>
>> and here...
>>
>>> {
>>> fprintf(fp, ".%s", glsl_get_struct_elem_name(parent_type,
>>> deref->index));
>>> }
>>>
>>> static void
>>> -print_deref(nir_deref_var *deref, print_var_state *state, FILE *fp)
>>> +print_deref(nir_deref_var *deref, print_state *state, FILE *fp)
>>
>> and here...
>>
>>> {
>>> nir_deref *tail = &deref->deref;
>>> nir_deref *pretail = NULL;
>>> @@ -335,7 +338,7 @@ print_deref(nir_deref_var *deref, print_var_state
>>> *state, FILE *fp)
>>> }
>>>
>>> static void
>>> -print_intrinsic_instr(nir_intrinsic_instr *instr, print_var_state *state,
>>> +print_intrinsic_instr(nir_intrinsic_instr *instr, print_state *state,
>>> FILE *fp)
>>
>> and here...
>>
>>> {
>>> unsigned num_srcs = nir_intrinsic_infos[instr->intrinsic].num_srcs;
>>> @@ -380,7 +383,7 @@ print_intrinsic_instr(nir_intrinsic_instr *instr,
>>> print_var_state *state,
>>> }
>>>
>>> static void
>>> -print_tex_instr(nir_tex_instr *instr, print_var_state *state, FILE *fp)
>>> +print_tex_instr(nir_tex_instr *instr, print_state *state, FILE *fp)
>>> {
>>> print_dest(&instr->dest, fp);
>>>
>>> @@ -499,7 +502,7 @@ print_tex_instr(nir_tex_instr *instr, print_var_state
>>> *state, FILE *fp)
>>> }
>>>
>>> static void
>>> -print_call_instr(nir_call_instr *instr, print_var_state *state, FILE *fp)
>>> +print_call_instr(nir_call_instr *instr, print_state *state, FILE *fp)
>>
>> and here. Either doing the entire refactor or leaving it alone is
>> better than leaving things in an inconsistent state.
>
> well, it is slightly less straightforward than you think, since
> nir_print_instr() calls into some of these w/ null state but non-null
> fp..
>
> probably some more of them can be converted over over with a bit more
> time spent untangling it.. and/or I can re-work nir_print_instr() to
> use the state object.. but I was trying to avoid re-writing the whole
> thing..
Ah, right. I would just have nir_print_instr create a state with a
NULL hash table and then change the check to if (state->ht). It made a
lot more sense to pass through a NULL state when the state only
pertained to variables, but here you've changed it to store the fp as
well.
>
> BR,
> -R
>
>>
>>> {
>>> fprintf(fp, "call %s ", instr->callee->function->name);
>>>
>>> @@ -594,7 +597,7 @@ print_parallel_copy_instr(nir_parallel_copy_instr
>>> *instr, FILE *fp)
>>> }
>>>
>>> static void
>>> -print_instr(const nir_instr *instr, print_var_state *state, unsigned tabs,
>>> FILE *fp)
>>> +print_instr(const nir_instr *instr, print_state *state, unsigned tabs,
>>> FILE *fp)
>>> {
>>> print_tabs(tabs, fp);
>>>
>>> @@ -650,12 +653,14 @@ compare_block_index(const void *p1, const void *p2)
>>> return (int) block1->index - (int) block2->index;
>>> }
>>>
>>> -static void print_cf_node(nir_cf_node *node, print_var_state *state,
>>> - unsigned tabs, FILE *fp);
>>> +static void print_cf_node(nir_cf_node *node, print_state *state,
>>> + unsigned tabs);
>>>
>>> static void
>>> -print_block(nir_block *block, print_var_state *state, unsigned tabs, FILE
>>> *fp)
>>> +print_block(nir_block *block, print_state *state, unsigned tabs)
>>> {
>>> + FILE *fp = state->fp;
>>> +
>>> print_tabs(tabs, fp);
>>> fprintf(fp, "block block_%u:\n", block->index);
>>>
>>> @@ -697,51 +702,54 @@ print_block(nir_block *block, print_var_state *state,
>>> unsigned tabs, FILE *fp)
>>> }
>>>
>>> static void
>>> -print_if(nir_if *if_stmt, print_var_state *state, unsigned tabs, FILE *fp)
>>> +print_if(nir_if *if_stmt, print_state *state, unsigned tabs)
>>> {
>>> + FILE *fp = state->fp;
>>> +
>>> print_tabs(tabs, fp);
>>> fprintf(fp, "if ");
>>> print_src(&if_stmt->condition, fp);
>>> fprintf(fp, " {\n");
>>> foreach_list_typed(nir_cf_node, node, node, &if_stmt->then_list) {
>>> - print_cf_node(node, state, tabs + 1, fp);
>>> + print_cf_node(node, state, tabs + 1);
>>> }
>>> print_tabs(tabs, fp);
>>> fprintf(fp, "} else {\n");
>>> foreach_list_typed(nir_cf_node, node, node, &if_stmt->else_list) {
>>> - print_cf_node(node, state, tabs + 1, fp);
>>> + print_cf_node(node, state, tabs + 1);
>>> }
>>> print_tabs(tabs, fp);
>>> fprintf(fp, "}\n");
>>> }
>>>
>>> static void
>>> -print_loop(nir_loop *loop, print_var_state *state, unsigned tabs, FILE *fp)
>>> +print_loop(nir_loop *loop, print_state *state, unsigned tabs)
>>> {
>>> + FILE *fp = state->fp;
>>> +
>>> print_tabs(tabs, fp);
>>> fprintf(fp, "loop {\n");
>>> foreach_list_typed(nir_cf_node, node, node, &loop->body) {
>>> - print_cf_node(node, state, tabs + 1, fp);
>>> + print_cf_node(node, state, tabs + 1);
>>> }
>>> print_tabs(tabs, fp);
>>> fprintf(fp, "}\n");
>>> }
>>>
>>> static void
>>> -print_cf_node(nir_cf_node *node, print_var_state *state, unsigned int tabs,
>>> - FILE *fp)
>>> +print_cf_node(nir_cf_node *node, print_state *state, unsigned int tabs)
>>> {
>>> switch (node->type) {
>>> case nir_cf_node_block:
>>> - print_block(nir_cf_node_as_block(node), state, tabs, fp);
>>> + print_block(nir_cf_node_as_block(node), state, tabs);
>>> break;
>>>
>>> case nir_cf_node_if:
>>> - print_if(nir_cf_node_as_if(node), state, tabs, fp);
>>> + print_if(nir_cf_node_as_if(node), state, tabs);
>>> break;
>>>
>>> case nir_cf_node_loop:
>>> - print_loop(nir_cf_node_as_loop(node), state, tabs, fp);
>>> + print_loop(nir_cf_node_as_loop(node), state, tabs);
>>> break;
>>>
>>> default:
>>> @@ -750,8 +758,10 @@ print_cf_node(nir_cf_node *node, print_var_state
>>> *state, unsigned int tabs,
>>> }
>>>
>>> static void
>>> -print_function_impl(nir_function_impl *impl, print_var_state *state, FILE
>>> *fp)
>>> +print_function_impl(nir_function_impl *impl, print_state *state)
>>> {
>>> + FILE *fp = state->fp;
>>> +
>>> fprintf(fp, "\nimpl %s ", impl->overload->function->name);
>>>
>>> for (unsigned i = 0; i < impl->num_params; i++) {
>>> @@ -772,7 +782,7 @@ print_function_impl(nir_function_impl *impl,
>>> print_var_state *state, FILE *fp)
>>>
>>> foreach_list_typed(nir_variable, var, node, &impl->locals) {
>>> fprintf(fp, "\t");
>>> - print_var_decl(var, state, fp);
>>> + print_var_decl(var, state);
>>> }
>>>
>>> foreach_list_typed(nir_register, reg, node, &impl->registers) {
>>> @@ -783,7 +793,7 @@ print_function_impl(nir_function_impl *impl,
>>> print_var_state *state, FILE *fp)
>>> nir_index_blocks(impl);
>>>
>>> foreach_list_typed(nir_cf_node, node, node, &impl->body) {
>>> - print_cf_node(node, state, 1, fp);
>>> + print_cf_node(node, state, 1);
>>> }
>>>
>>> fprintf(fp, "\tblock block_%u:\n}\n\n", impl->end_block->index);
>>> @@ -791,8 +801,10 @@ print_function_impl(nir_function_impl *impl,
>>> print_var_state *state, FILE *fp)
>>>
>>> static void
>>> print_function_overload(nir_function_overload *overload,
>>> - print_var_state *state, FILE *fp)
>>> + print_state *state)
>>> {
>>> + FILE *fp = state->fp;
>>> +
>>> fprintf(fp, "decl_overload %s ", overload->function->name);
>>>
>>> for (unsigned i = 0; i < overload->num_params; i++) {
>>> @@ -826,22 +838,23 @@ print_function_overload(nir_function_overload
>>> *overload,
>>> fprintf(fp, "\n");
>>>
>>> if (overload->impl != NULL) {
>>> - print_function_impl(overload->impl, state, fp);
>>> + print_function_impl(overload->impl, state);
>>> return;
>>> }
>>> }
>>>
>>> static void
>>> -print_function(nir_function *func, print_var_state *state, FILE *fp)
>>> +print_function(nir_function *func, print_state *state)
>>> {
>>> foreach_list_typed(nir_function_overload, overload, node,
>>> &func->overload_list) {
>>> - print_function_overload(overload, state, fp);
>>> + print_function_overload(overload, state);
>>> }
>>> }
>>>
>>> static void
>>> -init_print_state(print_var_state *state)
>>> +init_print_state(print_state *state, nir_shader *shader, FILE *fp)
>>> {
>>> + state->fp = fp;
>>> state->ht = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
>>> _mesa_key_pointer_equal);
>>> state->syms = _mesa_set_create(NULL, _mesa_key_hash_string,
>>> @@ -850,7 +863,7 @@ init_print_state(print_var_state *state)
>>> }
>>>
>>> static void
>>> -destroy_print_state(print_var_state *state)
>>> +destroy_print_state(print_state *state)
>>> {
>>> _mesa_hash_table_destroy(state->ht, NULL);
>>> _mesa_set_destroy(state->syms, NULL);
>>> @@ -859,27 +872,27 @@ destroy_print_state(print_var_state *state)
>>> void
>>> nir_print_shader(nir_shader *shader, FILE *fp)
>>> {
>>> - print_var_state state;
>>> - init_print_state(&state);
>>> + print_state state;
>>> + init_print_state(&state, shader, fp);
>>>
>>> foreach_list_typed(nir_variable, var, node, &shader->uniforms) {
>>> - print_var_decl(var, &state, fp);
>>> + print_var_decl(var, &state);
>>> }
>>>
>>> foreach_list_typed(nir_variable, var, node, &shader->inputs) {
>>> - print_var_decl(var, &state, fp);
>>> + print_var_decl(var, &state);
>>> }
>>>
>>> foreach_list_typed(nir_variable, var, node, &shader->outputs) {
>>> - print_var_decl(var, &state, fp);
>>> + print_var_decl(var, &state);
>>> }
>>>
>>> foreach_list_typed(nir_variable, var, node, &shader->globals) {
>>> - print_var_decl(var, &state, fp);
>>> + print_var_decl(var, &state);
>>> }
>>>
>>> foreach_list_typed(nir_variable, var, node, &shader->system_values) {
>>> - print_var_decl(var, &state, fp);
>>> + print_var_decl(var, &state);
>>> }
>>>
>>> foreach_list_typed(nir_register, reg, node, &shader->registers) {
>>> @@ -887,7 +900,7 @@ nir_print_shader(nir_shader *shader, FILE *fp)
>>> }
>>>
>>> foreach_list_typed(nir_function, func, node, &shader->functions) {
>>> - print_function(func, &state, fp);
>>> + print_function(func, &state);
>>> }
>>>
>>> destroy_print_state(&state);
>>> --
>>> 2.4.3
>>>
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/mesa-dev
