X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbelower.c;h=87bdea31670141bb1586098dd558a5ec5e348c81;hb=f804d333c7b5459c3c1a6bfc188ecdc54346be73;hp=1acdc0ad254c1ccb41294bbcd60818ac9b64efdc;hpb=6aa46484be1dc63021ade76137a88ad8281e049f;p=libfirm diff --git a/ir/be/belower.c b/ir/be/belower.c index 1acdc0ad2..87bdea316 100644 --- a/ir/be/belower.c +++ b/ir/be/belower.c @@ -14,6 +14,7 @@ #include #include "ircons.h" +#include "debug.h" #include "bearch.h" #include "belower.h" @@ -25,6 +26,12 @@ #include "iredges_t.h" #include "irgwalk.h" +#ifdef _WIN32 +#include +#else +#include +#endif + #undef is_Perm #define is_Perm(arch_env, irn) (arch_irn_classify(arch_env, irn) == arch_irn_class_perm) @@ -164,21 +171,34 @@ static perm_cycle_t *get_perm_cycle(perm_cycle_t *cycle, reg_pair_t *pairs, int int cur_pair_idx = start; int n_pairs_done = get_n_checked_pairs(pairs, n); int idx; + perm_type_t cycle_tp = PERM_CYCLE; + + /* We could be right in the middle of a chain, so we need to find the start */ + while (head != cur_idx) { + /* goto previous register in cycle or chain */ + cur_pair_idx = get_pairidx_for_regidx(pairs, n, head, 1); + + if (cur_pair_idx < 0) { + cycle_tp = PERM_CHAIN; + break; + } + else { + head = pairs[cur_pair_idx].in_reg->index; + start = cur_pair_idx; + } + } /* assume worst case: all remaining pairs build a cycle or chain */ - cycle->elems = calloc(n - n_pairs_done, sizeof(cycle->elems[0])); + cycle->elems = xcalloc((n - n_pairs_done) * 2, sizeof(cycle->elems[0])); cycle->n_elems = 2; /* initial number of elements is 2 */ cycle->elems[0] = pairs[start].in_reg; cycle->elems[1] = pairs[start].out_reg; - cycle->type = PERM_CHAIN; /* default is CHAIN, only changed when we found a cycle */ - - /* mark the first pair as checked */ - pairs[start].checked = 1; - n_pairs_done++; + cycle->type = cycle_tp; + cur_idx = pairs[start].out_reg->index; idx = 2; /* check for cycle or end of a chain */ - while (cur_idx != head && n_pairs_done < n) { + while (cur_idx != head) { /* goto next register in cycle or chain */ cur_pair_idx = get_pairidx_for_regidx(pairs, n, cur_idx, 0); @@ -191,16 +211,24 @@ static perm_cycle_t *get_perm_cycle(perm_cycle_t *cycle, reg_pair_t *pairs, int if (cur_idx != head) { cycle->elems[idx++] = pairs[cur_pair_idx].out_reg; cycle->n_elems++; - - n_pairs_done++; } else { /* we are there where we started -> CYCLE */ cycle->type = PERM_CYCLE; } + } + + /* mark all pairs having one in/out register with cycle in common as checked */ + for (idx = 0; idx < cycle->n_elems; idx++) { + cur_pair_idx = get_pairidx_for_regidx(pairs, n, cycle->elems[idx]->index, 0); - /* mark the pair as checked */ - pairs[cur_pair_idx].checked = 1; + if (cur_pair_idx >= 0) + pairs[cur_pair_idx].checked = 1; + + cur_pair_idx = get_pairidx_for_regidx(pairs, n, cycle->elems[idx]->index, 1); + + if (cur_pair_idx >= 0) + pairs[cur_pair_idx].checked = 1; } return cycle; @@ -224,7 +252,7 @@ static void lower_perm_node(ir_node *irn, void *walk_env) { reg_pair_t *pairs; const ir_edge_t *edge; perm_cycle_t *cycle; - int n, i, pn, do_copy; + int n, i, pn, do_copy, j; ir_node *sched_point, *block, *in[2]; ir_node *arg1, *arg2, *res1, *res2; ir_node *cpyxchg = NULL; @@ -248,7 +276,7 @@ static void lower_perm_node(ir_node *irn, void *walk_env) { assert(n == get_irn_n_edges(irn) && "perm's in and out numbers different"); reg_class = arch_get_irn_register(arch_env, get_irn_n(irn, 0))->reg_class; - pairs = calloc(n, sizeof(pairs[0])); + pairs = alloca(n * sizeof(pairs[0])); /* build the list of register pairs (in, out) */ i = 0; @@ -302,9 +330,15 @@ static void lower_perm_node(ir_node *irn, void *walk_env) { /* go to the first not-checked pair */ while (pairs[i].checked) i++; - cycle = calloc(1, sizeof(*cycle)); + cycle = xcalloc(1, sizeof(*cycle)); cycle = get_perm_cycle(cycle, pairs, n, i); + DB((mod, LEVEL_1, "%+F: following %s created:\n ", irn, cycle->type == PERM_CHAIN ? "chain" : "cycle")); + for (j = 0; j < cycle->n_elems; j++) { + DB((mod, LEVEL_1, " %s", cycle->elems[j]->name)); + } + DB((mod, LEVEL_1, "\n")); + /* We don't need to do anything if we have a Perm with two elements which represents a cycle, because those nodes already represent exchange nodes */ @@ -377,7 +411,7 @@ static void lower_perm_node(ir_node *irn, void *walk_env) { DBG((mod, LEVEL_1, "replacing %+F with %+F, placed new node after %+F\n", irn, cpyxchg, sched_point)); } -// free(cycle->elems); + free(cycle->elems); free(cycle); } @@ -395,16 +429,16 @@ static void lower_perm_node(ir_node *irn, void *walk_env) { * @param call The Call node * @param walk_env The walker environment */ -static void lower_call_node(ir_node *call, void *walk_env) { - lower_env_t *env = walk_env; - const arch_env_t *arch_env = env->chord_env->main_env->arch_env; - firm_dbg_module_t *mod = env->dbg_module; +static void lower_call_node(ir_node *call, const void *walk_env) { + const arch_env_t *arch_env = walk_env; + int bitset_idx = 0; + int set_size = 0; + arch_isa_t *isa = arch_env_get_isa(arch_env); + const ir_node *proj_T = NULL; + ir_node *block = get_nodes_block(call); const arch_register_class_t *reg_class; - int i, j, set_size = 0, pn, keep_arity; - arch_isa_t *isa = arch_env_get_isa(arch_env); - const ir_node *proj_T = NULL; - ir_node **in_keep, *block = get_nodes_block(call); - ir_node *last_proj = NULL; + int i, j, pn, keep_arity; + ir_node **in_keep; bitset_t *proj_set; const ir_edge_t *edge; const arch_register_t *reg; @@ -415,7 +449,7 @@ static void lower_call_node(ir_node *call, void *walk_env) { set_size += arch_register_class_n_regs(reg_class); } - in_keep = malloc(set_size * sizeof(ir_node *)); + in_keep = xmalloc(set_size * sizeof(ir_node *)); proj_set = bitset_malloc(set_size); bitset_clear_all(proj_set); @@ -428,28 +462,19 @@ static void lower_call_node(ir_node *call, void *walk_env) { /* set all used arguments */ if (proj_T) { - - foreach_out_edge(proj_T, edge) { - ir_node *proj = get_edge_src_irn(edge); + ir_node *proj = get_edge_src_irn(edge); assert(is_Proj(proj)); - bitset_set(proj_set, get_Proj_proj(get_edge_src_irn(edge))); - - /* - * Filter out the last proj in the schedule. - * After that one, we have to insert the Keep node. - */ - if(!last_proj || sched_comes_after(last_proj, proj)) - last_proj = proj; - + pn = isa->impl->handle_call_proj(isa, proj, 0); + bitset_set(proj_set, pn); } } else { proj_T = new_r_Proj(current_ir_graph, block, call, mode_T, pn_Call_T_result); } - /* Create for each caller save register a proj (keep node arguement) */ + /* Create for each caller save register a proj (keep node argument) */ /* if this proj is not already present */ for (i = 0; i < arch_isa_get_n_reg_class(isa); i++) { @@ -463,23 +488,22 @@ static void lower_call_node(ir_node *call, void *walk_env) { /* only check caller save registers */ if (arch_register_type_is(reg, caller_saved)) { - pn = isa->impl->get_projnum_for_register(isa, reg); - if (!bitset_is_set(proj_set, pn)) { - ir_node *proj = new_r_Proj(current_ir_graph, block, (ir_node *)proj_T, mode_Is, pn); + /* Only create new proj, iff not already present */ + if (!bitset_is_set(proj_set, bitset_idx)) { + ir_node *proj = new_r_Proj(current_ir_graph, block, (ir_node *)proj_T, mode_Is, bitset_idx); + + pn = isa->impl->handle_call_proj(isa, proj, 1); in_keep[keep_arity++] = proj; - sched_add_after(last_proj, proj); - last_proj = proj; } + + bitset_idx++; } } /* ok, we found some caller save register which are not in use but must be saved */ if (keep_arity) { - ir_node *keep; - - keep = be_new_Keep(reg_class, current_ir_graph, block, keep_arity, in_keep); - sched_add_after(last_proj, keep); + be_new_Keep(reg_class, current_ir_graph, block, keep_arity, in_keep); } } @@ -537,9 +561,8 @@ static void lower_spill_reload(ir_node *irn, void *walk_env) { * @param irn The node to be checked for lowering * @param walk_env The walker environment */ -static void lower_nodes_before_ra_walker(ir_node *irn, void *walk_env) { - lower_env_t *env = walk_env; - const arch_env_t *arch_env = env->chord_env->main_env->arch_env; +static void lower_nodes_before_sched_walker(ir_node *irn, const void *walk_env) { + const arch_env_t *arch_env = walk_env; if (!is_Block(irn) && !is_Proj(irn)) { if (is_Call(arch_env, irn)) { @@ -573,22 +596,20 @@ static void lower_nodes_after_ra_walker(ir_node *irn, void *walk_env) { return; } + + /** * Walks over all blocks in an irg and performs lowering need - * to be done before register allocation (e.g. call lowering). + * to be done before scheduling (e.g. call lowering). * * @param chord_env The chordal environment containing the irg * @param do_copy 1 == resolve cycles with a free reg if available */ -void lower_nodes_before_ra(be_chordal_env_t *chord_env, int do_copy) { - lower_env_t env; +void lower_nodes_before_sched(ir_graph *irg, const void *env) { + irg_walk_blkwise_graph(irg, NULL, lower_nodes_before_sched_walker, (void *)env); +} - env.chord_env = chord_env; - env.do_copy = do_copy; - env.dbg_module = firm_dbg_register("ir.be.lower"); - irg_walk_blkwise_graph(chord_env->irg, NULL, lower_nodes_before_ra_walker, &env); -} /** * Walks over all blocks in an irg and performs lowering need to be @@ -602,7 +623,7 @@ void lower_nodes_after_ra(be_chordal_env_t *chord_env, int do_copy) { env.chord_env = chord_env; env.do_copy = do_copy; - env.dbg_module = firm_dbg_register("ir.be.lower"); + env.dbg_module = firm_dbg_register("firm.be.lower"); irg_walk_blkwise_graph(chord_env->irg, NULL, lower_nodes_after_ra_walker, &env); }