From ae3436d195e2b57bf8bea2fcb0eb714be8834ee9 Mon Sep 17 00:00:00 2001 From: Matthias Braun Date: Tue, 31 Jul 2012 14:24:13 +0200 Subject: [PATCH] use C99 to cleanup code --- ir/be/sparc/sparc_emitter.c | 84 ++++++++++++++----------------------- 1 file changed, 31 insertions(+), 53 deletions(-) diff --git a/ir/be/sparc/sparc_emitter.c b/ir/be/sparc/sparc_emitter.c index fdc211944..5c4d3a830 100644 --- a/ir/be/sparc/sparc_emitter.c +++ b/ir/be/sparc/sparc_emitter.c @@ -300,9 +300,7 @@ static bool emits_multiple_instructions(const ir_node *node) static bool uses_reg(const ir_node *node, const arch_register_t *reg) { int arity = get_irn_arity(node); - int i; - - for (i = 0; i < arity; ++i) { + for (int i = 0; i < arity; ++i) { const arch_register_t *in_reg = arch_get_irn_register_in(node, i); if (reg == in_reg) return true; @@ -313,8 +311,7 @@ static bool uses_reg(const ir_node *node, const arch_register_t *reg) static bool writes_reg(const ir_node *node, const arch_register_t *reg) { unsigned n_outs = arch_get_irn_n_outs(node); - unsigned o; - for (o = 0; o < n_outs; ++o) { + for (unsigned o = 0; o < n_outs; ++o) { const arch_register_t *out_reg = arch_get_irn_register_out(node, o); if (out_reg == reg) return true; @@ -352,8 +349,7 @@ static bool can_move_into_delayslot(const ir_node *node, const ir_node *to) } else { /* the node must not use our computed values */ int arity = get_irn_arity(to); - int i; - for (i = 0; i < arity; ++i) { + for (int i = 0; i < arity; ++i) { ir_node *in = get_irn_n(to, i); if (skip_Proj(in) == node) return false; @@ -565,13 +561,12 @@ static void fill_delay_slot(void) static void emit_sparc_Div(const ir_node *node, char const *const insn) { - /* can we get the delay count of the wr instruction somewhere? */ - unsigned wry_delay_count = 3; - unsigned i; - sparc_emitf(node, "wr %S0, 0, %%y"); - for (i = 0; i < wry_delay_count; ++i) { + /* TODO: we should specify number of delayslots in an architecture + * specification */ + unsigned wry_delay_count = 3; + for (unsigned i = 0; i < wry_delay_count; ++i) { fill_delay_slot(); } @@ -649,8 +644,6 @@ static void memperm_emit_spill_registers(const ir_node *node, int n_spilled, /* Restore register l0 or both l0 and l1, depending on n_spilled. */ static void memperm_emit_restore_registers(const ir_node *node, int n_spilled) { - unsigned sp_change; - if (n_spilled == 2) { /* Restore register l1. */ sparc_emitf(node, "ld [%%sp%+d], %%l1", SPARC_MIN_STACKSIZE + SPARC_REGISTER_SIZE); @@ -660,7 +653,7 @@ static void memperm_emit_restore_registers(const ir_node *node, int n_spilled) sparc_emitf(node, "ld [%%sp%+d], %%l0", SPARC_MIN_STACKSIZE); /* Restore stack pointer. */ - sp_change = get_aligned_sp_change(2); + unsigned sp_change = get_aligned_sp_change(2); sparc_emitf(node, "add %%sp, %u, %%sp", sp_change); } @@ -701,11 +694,10 @@ static void memperm_emit_swap(const ir_node *node, ir_entity *ent1, /* Find the index of ent in ents or return -1 if not found. */ static int get_index(ir_entity **ents, int n, ir_entity *ent) { - int i; - - for (i = 0; i < n; ++i) + for (int i = 0; i < n; ++i) { if (ents[i] == ent) return i; + } return -1; } @@ -732,22 +724,20 @@ static void emit_be_MemPerm(const ir_node *node) int *n_users = ALLOCANZ(int, max_size); /* n_spilled records the number of spilled registers, either 1 or 2. */ int n_spilled = 0; - int i, n, oidx; /* This implementation currently only works with frame pointers. */ ir_graph *irg = get_irn_irg(node); be_stack_layout_t *layout = be_get_irg_stack_layout(irg); assert(!layout->sp_relative && "MemPerms currently do not work without frame pointers"); - for (i = 0; i < max_size; ++i) { + for (int i = 0; i < max_size; ++i) { sourceof[i] = i; } - for (i = n = 0; i < memperm_arity; ++i) { + int n = 0; + for (int i = 0; i < memperm_arity; ++i) { ir_entity *out = be_get_MemPerm_out_entity(node, i); ir_entity *in = be_get_MemPerm_in_entity(node, i); - int oidx; /* Out index */ - int iidx; /* In index */ /* Insert into entities to be able to operate on unique indices. */ if (get_index(entities, n, out) == -1) @@ -755,15 +745,15 @@ static void emit_be_MemPerm(const ir_node *node) if (get_index(entities, n, in) == -1) entities[n++] = in; - oidx = get_index(entities, n, out); - iidx = get_index(entities, n, in); + int oidx = get_index(entities, n, out); + int iidx = get_index(entities, n, in); sourceof[oidx] = iidx; /* Remember the source. */ ++n_users[iidx]; /* Increment number of users of this entity. */ } /* First do all the copies. */ - for (oidx = 0; oidx < n; /* empty */) { + for (int oidx = 0; oidx < n; /* empty */) { int iidx = sourceof[oidx]; /* Nothing to do for fix points. @@ -797,9 +787,8 @@ static void emit_be_MemPerm(const ir_node *node) } /* The rest are cycles. */ - for (oidx = 0; oidx < n; /* empty */) { + for (int oidx = 0; oidx < n; /* empty */) { int iidx = sourceof[oidx]; - int tidx; /* Nothing to do for fix points. */ if (iidx == oidx) { @@ -816,7 +805,7 @@ static void emit_be_MemPerm(const ir_node *node) } memperm_emit_swap(node, entities[iidx], entities[oidx]); - tidx = sourceof[iidx]; + int tidx = sourceof[iidx]; /* Mark as done. */ sourceof[iidx] = iidx; @@ -827,7 +816,7 @@ static void emit_be_MemPerm(const ir_node *node) #ifdef DEBUG_libfirm /* Only fix points should remain. */ - for (i = 0; i < max_size; ++i) { + for (int i = 0; i < max_size; ++i) { assert(sourceof[i] == i); } #endif @@ -945,8 +934,6 @@ static void emit_sparc_branch(const ir_node *node, get_cc_func get_cc) ir_relation relation = attr->relation; const ir_node *proj_true = NULL; const ir_node *proj_false = NULL; - const ir_node *block; - const ir_node *next_block; foreach_out_edge(node, edge) { ir_node *proj = get_edge_src_irn(edge); @@ -959,10 +946,10 @@ static void emit_sparc_branch(const ir_node *node, get_cc_func get_cc) } /* for now, the code works for scheduled and non-schedules blocks */ - block = get_nodes_block(node); + const ir_node *block = get_nodes_block(node); /* we have a block schedule */ - next_block = (ir_node*)get_irn_link(block); + const ir_node *next_block = (ir_node*)get_irn_link(block); if (get_irn_link(proj_true) == next_block) { /* exchange both proj's so the second one can be omitted */ @@ -1061,9 +1048,8 @@ static void emit_be_Copy(const ir_node *node) if (mode_is_float(mode)) { unsigned bits = get_mode_size_bits(mode); int n = bits > 32 ? bits > 64 ? 3 : 1 : 0; - int i; emit_fmov(node, src_reg, dst_reg); - for (i = 0; i < n; ++i) { + for (int i = 0; i < n; ++i) { src_reg = get_next_fp_reg(src_reg); dst_reg = get_next_fp_reg(dst_reg); emit_fmov(node, src_reg, dst_reg); @@ -1152,12 +1138,10 @@ static ir_node *find_next_delay_slot(ir_node *from) static bool block_needs_label(const ir_node *block, const ir_node *sched_prev) { - int n_cfgpreds; - if (get_Block_entity(block) != NULL) return true; - n_cfgpreds = get_Block_n_cfgpreds(block); + int n_cfgpreds = get_Block_n_cfgpreds(block); if (n_cfgpreds == 0) { return false; } else if (n_cfgpreds > 1) { @@ -1177,12 +1161,11 @@ static bool block_needs_label(const ir_node *block, const ir_node *sched_prev) */ static void sparc_emit_block(ir_node *block, ir_node *prev) { - ir_node *next_delay_slot; - bool needs_label = block_needs_label(block, prev); + bool needs_label = block_needs_label(block, prev); be_gas_begin_block(block, needs_label); - next_delay_slot = find_next_delay_slot(sched_first(block)); + ir_node *next_delay_slot = find_next_delay_slot(sched_first(block)); if (next_delay_slot != NULL) delay_slot_filler = pick_delay_slot_for(next_delay_slot); @@ -1222,42 +1205,37 @@ static void sparc_emit_func_epilog(ir_graph *irg) static void sparc_gen_labels(ir_node *block, void *env) { - ir_node *pred; - int n = get_Block_n_cfgpreds(block); (void) env; + int n = get_Block_n_cfgpreds(block); for (n--; n >= 0; n--) { - pred = get_Block_cfgpred(block, n); + ir_node *pred = get_Block_cfgpred(block, n); set_irn_link(pred, block); // link the pred of a block (which is a jmp) } } void sparc_emit_routine(ir_graph *irg) { - ir_node **block_schedule; - size_t i; - size_t n; - heights = heights_new(irg); /* register all emitter functions */ sparc_register_emitters(); /* create the block schedule. For now, we don't need it earlier. */ - block_schedule = be_create_block_schedule(irg); + ir_node **block_schedule = be_create_block_schedule(irg); sparc_emit_func_prolog(irg); irg_block_walk_graph(irg, sparc_gen_labels, NULL, NULL); /* inject block scheduling links & emit code of each block */ - n = ARR_LEN(block_schedule); - for (i = 0; i < n; ++i) { + size_t n = ARR_LEN(block_schedule); + for (size_t i = 0; i < n; ++i) { ir_node *block = block_schedule[i]; ir_node *next_block = i+1 < n ? block_schedule[i+1] : NULL; set_irn_link(block, next_block); } - for (i = 0; i < n; ++i) { + for (size_t i = 0; i < n; ++i) { ir_node *block = block_schedule[i]; ir_node *prev = i>=1 ? block_schedule[i-1] : NULL; if (block == get_irg_end_block(irg)) -- 2.20.1