X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fcombo.c;h=099091c7efddcfd20b701d91dc5c7c7aa6acce10;hb=0cc8bfc863da28d3799e9eca1d1765d564b6e573;hp=a50b288347e3f30b24e5fd3948df63742204c356;hpb=e30e5834fd8c1c3a7d28fc66e99b91a84993bde8;p=libfirm diff --git a/ir/opt/combo.c b/ir/opt/combo.c index a50b28834..099091c7e 100644 --- a/ir/opt/combo.c +++ b/ir/opt/combo.c @@ -48,7 +48,9 @@ #include "irop.h" #include "irouts.h" #include "irgmod.h" +#include "iropt_dbg.h" #include "debug.h" +#include "array_t.h" #include "error.h" #include "tv_t.h" @@ -57,14 +59,11 @@ #include "irdump.h" /* define this to check that all type translations are monotone */ -#define VERIFY_MONOTONE +#undef VERIFY_MONOTONE /* define this to check the consistency of partitions */ #define CHECK_PARTITIONS -/* define this to disable followers (may be buggy) */ -#undef NO_FOLLOWER - typedef struct node_t node_t; typedef struct partition_t partition_t; typedef struct opcode_key_t opcode_key_t; @@ -128,8 +127,8 @@ struct node_t { unsigned on_cprop:1; /**< Set, if this node is on the partition.cprop list. */ unsigned on_fallen:1; /**< Set, if this node is on the fallen list. */ unsigned is_follower:1; /**< Set, if this node is a follower. */ - unsigned is_flagged:1; /**< Set, if this node was visited by the race. */ unsigned by_all_const:1; /**< Set, if this node was once evaluated by all constants. */ + unsigned flagged:2; /**< 2 Bits, set if this node was visited by race 1 or 2. */ }; /** @@ -167,7 +166,8 @@ typedef struct environment_t { pmap *type2id_map; /**< The type->id map. */ int end_idx; /**< -1 for local and 0 for global congruences. */ int lambda_input; /**< Captured argument for lambda_partition(). */ - int modified; /**< Set, if the graph was modified. */ + char nonstd_cond; /**< Set, if a Condb note has a non-Cmp predecessor. */ + char modified; /**< Set, if the graph was modified. */ #ifdef DEBUG_libfirm partition_t *dbg_list; /**< List of all partitions. */ #endif @@ -190,6 +190,9 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg;) /** Next partition number. */ DEBUG_ONLY(static unsigned part_nr = 0); +/** The tarval returned by Unknown nodes. */ +static tarval *tarval_UNKNOWN; + /* forward */ static node_t *identity(node_t *node); @@ -203,7 +206,7 @@ static void check_partition(const partition_t *T) { list_for_each_entry(node_t, node, &T->Leader, node_list) { assert(node->is_follower == 0); - assert(node->is_flagged == 0); + assert(node->flagged == 0); assert(node->part == T); ++n; } @@ -211,11 +214,27 @@ static void check_partition(const partition_t *T) { list_for_each_entry(node_t, node, &T->Follower, node_list) { assert(node->is_follower == 1); - assert(node->is_flagged == 0); + assert(node->flagged == 0); assert(node->part == T); } } /* check_partition */ +static void check_all_partitions(environment_t *env) { + partition_t *P; + node_t *node; + +#ifdef DEBUG_libfirm + for (P = env->dbg_list; P != NULL; P = P->dbg_next) { + check_partition(P); + list_for_each_entry(node_t, node, &P->Follower, node_list) { + node_t *leader = identity(node); + + assert(leader != node && leader->part == node->part); + } + } +#endif +} + /** * Check list. */ @@ -239,6 +258,7 @@ static void check_list(const node_t *list, const partition_t *Z) { #else #define check_partition(T) #define check_list(list, Z) +#define check_all_partitions(env) #endif /* CHECK_PARTITIONS */ #ifdef DEBUG_libfirm @@ -480,6 +500,7 @@ static INLINE tarval *get_node_tarval(const ir_node *irn) { */ static INLINE void add_to_worklist(partition_t *X, environment_t *env) { assert(X->on_worklist == 0); + DB((dbg, LEVEL_2, "Adding part%d to worklist\n", X->nr)); X->wl_next = env->worklist; X->on_worklist = 1; env->worklist = X; @@ -568,7 +589,7 @@ static node_t *create_partition_node(ir_node *irn, partition_t *part, environmen node->on_fallen = 0; node->is_follower = 0; node->by_all_const = 0; - node->is_flagged = 0; + node->flagged = 0; set_irn_node(irn, node); list_add_tail(&node->node_list, &part->Leader); @@ -604,6 +625,11 @@ static void create_initial_partitions(ir_node *irn, void *ctx) { if (is_Phi(irn)) { add_Block_phi(get_nodes_block(irn), irn); + } else if (is_Cond(irn)) { + /* check if all Cond's have a Cmp predecessor. */ + if (get_irn_mode(irn) == mode_b && !is_Cmp(skip_Proj(get_Cond_selector(irn)))) + env->nonstd_cond = 1; + } } /* create_initial_partitions */ @@ -789,12 +815,6 @@ static partition_t *split_no_followers(partition_t *Z, node_t *g, environment_t return Z_prime; } /* split_no_followers */ -#ifdef NO_FOLLOWER - -#define split(Z, g, env) split_no_followers(*(Z), g, env) - -#else - /** * Make the Follower -> Leader transition for a node. * @@ -819,6 +839,7 @@ typedef struct step_env { node_t *unwalked; /**< The unwalked node list. */ node_t *walked; /**< The walked node list. */ int index; /**< Next index of Follower use_def edge. */ + unsigned side; /**< side number. */ } step_env; /** @@ -828,12 +849,64 @@ typedef struct step_env { * @param input number of the input */ static int is_real_follower(const ir_node *irn, int input) { - if (input == 1 && is_Confirm(irn)) { - /* return the Confirm bound input */ - return 0; + node_t *pred; + + switch (get_irn_opcode(irn)) { + case iro_Confirm: + if (input == 1) { + /* ignore the Confirm bound input */ + return 0; + } + break; + case iro_Mux: + if (input == 0) { + /* ignore the Mux sel input */ + return 0; + } + break; + case iro_Phi: { + /* dead inputs are not follower edges */ + ir_node *block = get_nodes_block(irn); + node_t *pred = get_irn_node(get_Block_cfgpred(block, input)); + + if (pred->type.tv == tarval_unreachable) + return 0; + break; } - if (input == 0 && is_Mux(irn)) { - /* ignore the Mux sel input */ + case iro_Sub: + case iro_Shr: + case iro_Shl: + case iro_Shrs: + case iro_Rotl: + if (input == 1) { + /* only a Sub x,0 / Shift x,0 might be a follower */ + return 0; + } + break; + case iro_Add: + case iro_Or: + case iro_Eor: + pred = get_irn_node(get_irn_n(irn, input)); + if (is_tarval(pred->type.tv) && tarval_is_null(pred->type.tv)) + return 0; + break; + case iro_Mul: + pred = get_irn_node(get_irn_n(irn, input)); + if (is_tarval(pred->type.tv) && tarval_is_one(pred->type.tv)) + return 0; + break; + case iro_And: + pred = get_irn_node(get_irn_n(irn, input)); + if (is_tarval(pred->type.tv) && tarval_is_all_one(pred->type.tv)) + return 0; + break; + case iro_Min: + case iro_Max: + /* all inputs are followers */ + return 1; + default: + assert(!"opcode not implemented yet"); + break; } return 1; } @@ -879,15 +952,18 @@ static int step(step_env *env) { if (m->part != n->part) continue; - if (m->is_flagged == 0) { - m->is_flagged = 1; + if ((m->flagged & env->side) == 0) { + m->flagged |= env->side; - /* visited the first time */ - /* add m to unwalked not as first node (we might still need to - check for more follower node */ - m->race_next = n->race_next; - n->race_next = m; - return 0; + if (m->flagged != 3) { + /* visited the first time */ + /* add m to unwalked not as first node (we might still need to + check for more follower node */ + m->race_next = n->race_next; + n->race_next = m; + return 0; + } + /* else already visited by the other side and on the other list */ } } /* move n to walked */ @@ -905,11 +981,20 @@ static int step(step_env *env) { * * @param list the list */ -static void clear_flags(node_t *list) { +static int clear_flags(node_t *list) { + int res = 0; node_t *n; - for (n = list; n != NULL; n = n->race_next) - n->is_flagged = 0; + for (n = list; n != NULL; n = n->race_next) { + if (n->flagged == 3) { + /* we reach a follower from both sides, this will split congruent + * inputs and make it a leader. */ + follower_to_leader(n); + res = 1; + } + n->flagged = 0; + } + return res; } /* clear_flags */ /** @@ -927,7 +1012,7 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) { list_head tmp; step_env env1, env2, *winner; node_t *g, *h, *node, *t; - int max_input; + int max_input, transitions; unsigned n; DEBUG_ONLY(static int run = 0;) @@ -968,11 +1053,13 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) { env1.unwalked = NULL; env1.walked = NULL; env1.index = 0; + env1.side = 1; env2.initial = h; env2.unwalked = NULL; env2.walked = NULL; env2.index = 0; + env2.side = 2; for (;;) { if (step(&env1)) { @@ -988,10 +1075,10 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) { assert(winner->unwalked == NULL); /* clear flags from walked/unwalked */ - clear_flags(env1.unwalked); - clear_flags(env1.walked); - clear_flags(env2.unwalked); - clear_flags(env2.walked); + transitions = clear_flags(env1.unwalked); + transitions |= clear_flags(env1.walked); + transitions |= clear_flags(env2.unwalked); + transitions |= clear_flags(env2.walked); dump_race_list("winner ", winner->walked); @@ -1023,8 +1110,10 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) { * loose its congruence, so we need to check this case for all follower. */ list_for_each_entry_safe(node_t, node, t, &X_prime->Follower, node_list) { - if (identity(node) == node) + if (identity(node) == node) { follower_to_leader(node); + transitions = 1; + } } check_partition(X); @@ -1033,6 +1122,19 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) { /* X' is the smaller part */ add_to_worklist(X_prime, env); + /* + * If there where follower to leader transitions, ensure that the nodes + * can be split out if necessary. + */ + if (transitions) { + /* place partitions on the cprop list */ + if (X_prime->on_cprop == 0) { + X_prime->cprop_next = env->cprop; + env->cprop = X_prime; + X_prime->on_cprop = 1; + } + } + dump_partition("Now ", X); dump_partition("Created new ", X_prime); @@ -1044,7 +1146,6 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) { return X_prime; } /* split */ -#endif /* NO_FOLLOWER */ /** * Returns non-zero if the i'th input of a Phi node is live. @@ -1141,7 +1242,7 @@ static void collect_touched(list_head *list, int idx, environment_t *env) { if (is_constant_type(y->type)) { ir_opcode code = get_irn_opcode(succ); - if (code == iro_Sub || code == iro_Cmp) + if (code == iro_Sub || code == iro_Eor || code == iro_Cmp) add_to_cprop(y, env); } @@ -1496,10 +1597,8 @@ static void compute_Unknown(node_t *node) { * nodes are inputs to Conds. We check that first. * This is the way Frontends typically build Firm, but some optimizations * (cond_eval for instance) might replace them by Phib's... - * - * For now, we compute bottom here. */ - node->type.tv = tarval_bottom; + node->type.tv = tarval_UNKNOWN; } /* compute_Unknown */ /** @@ -1680,6 +1779,47 @@ static void compute_Sub(node_t *node) { } } /* compute_Sub */ +/** + * (Re-)compute the type for an Eor. Special case: both nodes are congruent. + * + * @param node the node + */ +static void compute_Eor(node_t *node) { + ir_node *eor = node->node; + node_t *l = get_irn_node(get_Eor_left(eor)); + node_t *r = get_irn_node(get_Eor_right(eor)); + lattice_elem_t a = l->type; + lattice_elem_t b = r->type; + tarval *tv; + + if (a.tv == tarval_top || b.tv == tarval_top) { + node->type.tv = tarval_top; + } else if (is_con(a) && is_con(b)) { + if (is_tarval(a.tv) && is_tarval(b.tv)) { + node->type.tv = tarval_eor(a.tv, b.tv); + } else if (is_tarval(a.tv) && tarval_is_null(a.tv)) { + node->type = b; + } else if (is_tarval(b.tv) && tarval_is_null(b.tv)) { + node->type = a; + } else { + node->type.tv = tarval_bottom; + } + node->by_all_const = 1; + } else if (r->part == l->part) { + ir_mode *mode = get_irn_mode(eor); + tv = get_mode_null(mode); + + /* if the node was ONCE evaluated by all constants, but now + this breakes AND we cat by partition a different result, switch to bottom. + This happens because initially all nodes are in the same partition ... */ + if (node->by_all_const && node->type.tv != tv) + tv = tarval_bottom; + node->type.tv = tv; + } else { + node->type.tv = tarval_bottom; + } +} /* compute_Eor */ + /** * (Re-)compute the type for Cmp. * @@ -1693,7 +1833,15 @@ static void compute_Cmp(node_t *node) { lattice_elem_t b = r->type; if (a.tv == tarval_top || b.tv == tarval_top) { +#ifdef WITH_UNKNOWN + /* + * Top is congruent to any other value, we can + * calculate the compare result. + */ + node->type.tv = tarval_b_true; +#else node->type.tv = tarval_top; +#endif } else if (is_con(a) && is_con(b)) { /* both nodes are constants, we can probably do something */ node->type.tv = tarval_b_true; @@ -1721,7 +1869,13 @@ static void compute_Proj_Cmp(node_t *node, ir_node *cmp) { tarval *tv; if (a.tv == tarval_top || b.tv == tarval_top) { +#ifdef WITH_UNKNOWN + /* see above */ + tv = new_tarval_from_long((pnc & pn_Cmp_Eq) ^ pn_Cmp_Eq, mode_b); + goto not_equal; +#else node->type.tv = tarval_top; +#endif } else if (is_con(a) && is_con(b)) { default_compute(node); node->by_all_const = 1; @@ -1732,6 +1886,9 @@ static void compute_Proj_Cmp(node_t *node, ir_node *cmp) { * NaN != NaN is defined, so we must check this here. */ tv = new_tarval_from_long(pnc & pn_Cmp_Eq, mode_b); +#ifdef WITH_UNKNOWN +not_equal: +#endif /* if the node was ONCE evaluated by all constants, but now this breakes AND we cat by partition a different result, switch to bottom. @@ -2059,8 +2216,22 @@ static node_t *identity_comm_zero_binop(node_t *node) { return node; } /* identity_comm_zero_binop */ -#define identity_Add identity_comm_zero_binop -#define identity_Or identity_comm_zero_binop +/** + * Calculates the Identity for Shift nodes. + */ +static node_t *identity_shift(node_t *node) { + ir_node *op = node->node; + node_t *b = get_irn_node(get_binop_right(op)); + ir_mode *mode = get_irn_mode(b->node); + tarval *zero; + + /* node: no input should be tarval_top, else the binop would be also + * Top and not being split. */ + zero = get_mode_null(mode); + if (b->type.tv == zero) + return get_irn_node(get_binop_left(op)); + return node; +} /* identity_shift */ /** * Calculates the Identity for Mul nodes. @@ -2215,12 +2386,17 @@ static node_t *identity(node_t *node) { switch (get_irn_opcode(irn)) { case iro_Phi: return identity_Phi(node); - case iro_Add: - return identity_Add(node); case iro_Mul: return identity_Mul(node); + case iro_Add: case iro_Or: - return identity_Or(node); + case iro_Eor: + return identity_comm_zero_binop(node); + case iro_Shr: + case iro_Shl: + case iro_Shrs: + case iro_Rotl: + return identity_shift(node); case iro_And: return identity_And(node); case iro_Sub: @@ -2362,6 +2538,11 @@ static void propagate(environment_t *env) { if (n_fallen > 0 && n_fallen != X->n_leader) { DB((dbg, LEVEL_2, "Splitting part%d by fallen\n", X->nr)); Y = split(&X, fallen, env); + /* + * We have split out fallen node. The type of the result + * partition is NOT set yet. + */ + Y->type_is_T_or_C = 0; } else { Y = X; } @@ -2369,17 +2550,12 @@ static void propagate(environment_t *env) { for (x = fallen; x != NULL; x = x->next) x->on_fallen = 0; -#ifndef NO_FOLLOWER if (old_type_was_T_or_C) { node_t *y, *tmp; - if (Y->on_worklist == 0) - add_to_worklist(Y, env); - /* check if some nodes will make the leader -> follower transition */ list_for_each_entry_safe(node_t, y, tmp, &Y->Leader, node_list) { - if (!is_Phi(y->node) && - y->type.tv != tarval_top && ! is_con(y->type)) { + if (y->type.tv != tarval_top && ! is_con(y->type)) { node_t *eq_node = identity(y); if (eq_node != y && eq_node->part == y->part) { @@ -2395,7 +2571,6 @@ static void propagate(environment_t *env) { } } } -#endif split_by(Y, env); } } /* propagate */ @@ -2409,8 +2584,9 @@ static ir_node *get_leader(node_t *node) { partition_t *part = node->part; if (part->n_leader > 1 || node->is_follower) { - if (node->is_follower) + if (node->is_follower) { DB((dbg, LEVEL_2, "Replacing follower %+F\n", node->node)); + } else DB((dbg, LEVEL_2, "Found congruence class for %+F\n", node->node)); @@ -2453,7 +2629,7 @@ static int can_exchange(ir_node *pred) { return 1; } return 0; -} +} /* can_exchange */ /** * Block Post-Walker, apply the analysis results on control flow by @@ -2466,26 +2642,55 @@ static void apply_cf(ir_node *block, void *ctx) { ir_node **ins, **in_X; ir_node *phi, *next; - if (block == get_irg_end_block(current_ir_graph) || - block == get_irg_start_block(current_ir_graph)) { + n = get_Block_n_cfgpreds(block); + + if (node->type.tv == tarval_unreachable) { + env->modified = 1; + + for (i = n - 1; i >= 0; --i) { + ir_node *pred = get_Block_cfgpred(block, i); + + if (! is_Bad(pred)) { + node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred))); + + if (pred_bl->flagged == 0) { + pred_bl->flagged = 3; + + if (pred_bl->type.tv == tarval_reachable) { + /* + * We will remove an edge from block to its pred. + * This might leave the pred block as an endless loop + */ + if (! is_backedge(block, i)) + keep_alive(pred_bl->node); + } + } + } + } + /* the EndBlock is always reachable even if the analysis finds out the opposite :-) */ + if (block != get_irg_end_block(current_ir_graph)) { + /* mark dead blocks */ + set_Block_dead(block); + DB((dbg, LEVEL_1, "Removing dead %+F\n", block)); + } else { + /* the endblock is unreachable */ + set_irn_in(block, 0, NULL); + } return; } - if (node->type.tv == tarval_unreachable) { - /* mark dead blocks */ - set_Block_dead(block); - return; - } - - n = get_Block_n_cfgpreds(block); if (n == 1) { /* only one predecessor combine */ ir_node *pred = skip_Proj(get_Block_cfgpred(block, 0)); if (can_exchange(pred)) { - exchange(block, get_nodes_block(pred)); + ir_node *new_block = get_nodes_block(pred); + DB((dbg, LEVEL_1, "Fuse %+F with %+F\n", block, new_block)); + DBG_OPT_COMBO(block, new_block, FS_OPT_COMBO_CF); + exchange(block, new_block); + node->node = new_block; env->modified = 1; } return; @@ -2499,6 +2704,24 @@ static void apply_cf(ir_node *block, void *ctx) { if (node->type.tv == tarval_reachable) { in_X[k++] = pred; + } else { + DB((dbg, LEVEL_1, "Removing dead input %d from %+F (%+F)\n", i, block, pred)); + if (! is_Bad(pred)) { + node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred))); + + if (pred_bl->flagged == 0) { + pred_bl->flagged = 3; + + if (pred_bl->type.tv == tarval_reachable) { + /* + * We will remove an edge from block to its pred. + * This might leave the pred block as an endless loop + */ + if (! is_backedge(block, i)) + keep_alive(pred_bl->node); + } + } + } } } if (k >= n) @@ -2517,6 +2740,7 @@ static void apply_cf(ir_node *block, void *ctx) { set_irn_node(c, node); node->node = c; DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", phi, c)); + DBG_OPT_COMBO(phi, c, FS_OPT_COMBO_CONST); exchange(phi, c); env->modified = 1; } else { @@ -2528,13 +2752,16 @@ static void apply_cf(ir_node *block, void *ctx) { ins[j++] = get_Phi_pred(phi, i); } } - if (j <= 1) { + if (j == 1) { /* this Phi is replaced by a single predecessor */ ir_node *s = ins[0]; + node_t *phi_node = get_irn_node(phi); node->node = s; DB((dbg, LEVEL_1, "%+F is replaced by %+F because of cf change\n", phi, s)); + DBG_OPT_COMBO(phi, s, FS_OPT_COMBO_FOLLOWER); exchange(phi, s); + phi_node->node = s; env->modified = 1; } else { set_irn_in(phi, j, ins); @@ -2543,12 +2770,15 @@ static void apply_cf(ir_node *block, void *ctx) { } } - if (k <= 1) { + if (k == 1) { /* this Block has only one live predecessor */ ir_node *pred = skip_Proj(in_X[0]); if (can_exchange(pred)) { - exchange(block, get_nodes_block(pred)); + ir_node *new_block = get_nodes_block(pred); + DBG_OPT_COMBO(block, new_block, FS_OPT_COMBO_CF); + exchange(block, new_block); + node->node = new_block; env->modified = 1; } } else { @@ -2581,14 +2811,17 @@ static void apply_result(ir_node *irn, void *ctx) { env->modified = 1; } else if (node->type.tv == tarval_unreachable) { - ir_node *bad = get_irg_bad(current_ir_graph); - - /* see comment above */ - set_irn_node(bad, node); - node->node = bad; - DB((dbg, LEVEL_1, "%+F is unreachable\n", irn)); - exchange(irn, bad); - env->modified = 1; + /* don't kick away Unknown */ + if (! is_Unknown(irn)) { + ir_node *bad = get_irg_bad(current_ir_graph); + + /* see comment above */ + set_irn_node(bad, node); + node->node = bad; + DB((dbg, LEVEL_1, "%+F is unreachable\n", irn)); + exchange(irn, bad); + env->modified = 1; + } } else if (get_irn_mode(irn) == mode_X) { if (is_Proj(irn)) { @@ -2599,11 +2832,12 @@ static void apply_result(ir_node *irn, void *ctx) { node_t *sel = get_irn_node(get_Cond_selector(cond)); if (is_tarval(sel->type.tv) && tarval_is_constant(sel->type.tv)) { - /* Cond selector is a constant, make a Jmp */ - ir_node *jmp = new_r_Jmp(current_ir_graph, block->node); + /* Cond selector is a constant and the Proj is reachable, make a Jmp */ + ir_node *jmp = new_r_Jmp(current_ir_graph, block->node); set_irn_node(jmp, node); node->node = jmp; DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, jmp)); + DBG_OPT_COMBO(irn, jmp, FS_OPT_COMBO_CF); exchange(irn, jmp); env->modified = 1; } @@ -2624,6 +2858,7 @@ static void apply_result(ir_node *irn, void *ctx) { set_irn_node(c, node); node->node = c; DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, c)); + DBG_OPT_COMBO(irn, c, FS_OPT_COMBO_CONST); exchange(irn, c); env->modified = 1; } @@ -2635,6 +2870,7 @@ static void apply_result(ir_node *irn, void *ctx) { node->node = symc; DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, symc)); + DBG_OPT_COMBO(irn, symc, FS_OPT_COMBO_CONST); exchange(irn, symc); env->modified = 1; } @@ -2645,6 +2881,10 @@ static void apply_result(ir_node *irn, void *ctx) { if (leader != irn) { DB((dbg, LEVEL_1, "%+F from part%d is replaced by %+F\n", irn, node->part->nr, leader)); + if (node->is_follower) + DBG_OPT_COMBO(irn, leader, FS_OPT_COMBO_FOLLOWER); + else + DBG_OPT_COMBO(irn, leader, FS_OPT_COMBO_CONGRUENT); exchange(irn, leader); env->modified = 1; } @@ -2668,17 +2908,11 @@ static void apply_end(ir_node *end, environment_t *env) { ir_node *ka = get_End_keepalive(end, i); node_t *node = get_irn_node(ka); - /* Use the is_flagged bit to mark already visited nodes. - * This should not be ready but better safe than sorry. */ - if (node->is_flagged == 0) { - node->is_flagged = 1; - - if (! is_Block(ka)) - node = get_irn_node(get_nodes_block(ka)); + if (! is_Block(ka)) + node = get_irn_node(get_nodes_block(ka)); - if (node->type.tv != tarval_unreachable) - in[j++] = ka; - } + if (node->type.tv != tarval_unreachable && !is_Bad(ka)) + in[j++] = ka; } if (j != n) { set_End_keepalives(end, j, in); @@ -2708,6 +2942,7 @@ static void set_compute_functions(void) { SET(Phi); SET(Add); SET(Sub); + SET(Eor); SET(SymConst); SET(Cmp); SET(Proj); @@ -2722,11 +2957,13 @@ static void set_compute_functions(void) { } /* set_compute_functions */ static int dump_partition_hook(FILE *F, ir_node *n, ir_node *local) { +#ifdef DEBUG_libfirm ir_node *irn = local != NULL ? local : n; node_t *node = get_irn_node(irn); ir_fprintf(F, "info2 : \"partition %u type %+F\"\n", node->part->nr, node->type); return 1; +#endif } void combo(ir_graph *irg) { @@ -2755,9 +2992,11 @@ void combo(ir_graph *irg) { env.type2id_map = pmap_create(); env.end_idx = get_opt_global_cse() ? 0 : -1; env.lambda_input = 0; + env.nonstd_cond = 0; env.modified = 0; assure_irg_outs(irg); + assure_cf_loop(irg); /* we have our own value_of function */ set_value_of_func(get_node_tarval); @@ -2765,11 +3004,19 @@ void combo(ir_graph *irg) { set_compute_functions(); DEBUG_ONLY(part_nr = 0); + ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK); + /* create the initial partition and place it on the work list */ env.initial = new_partition(&env); add_to_worklist(env.initial, &env); irg_walk_graph(irg, init_block_phis, create_initial_partitions, &env); +#ifdef WITH_UNKNOWN + tarval_UNKNOWN = env.nonstd_cond ? tarval_bad : tarval_top; +#else + tarval_UNKNOWN = tarval_bad; +#endif + /* all nodes on the initial partition have type Top */ env.initial->type_is_T_or_C = 1; @@ -2786,6 +3033,7 @@ void combo(ir_graph *irg) { } while (env.cprop != NULL || env.worklist != NULL); dump_all_partitions(&env); + check_all_partitions(&env); #if 0 set_dump_node_vcgattr_hook(dump_partition_hook); @@ -2808,6 +3056,8 @@ void combo(ir_graph *irg) { set_irg_loopinfo_inconsistent(irg); } + ir_free_resources(irg, IR_RESOURCE_IRN_LINK); + pmap_destroy(env.type2id_map); del_set(env.opcode2id_map); obstack_free(&env.obst, NULL);