X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fcombo.c;h=67fcd415f094fa956993da40963eb696fe0230ee;hb=afbbc0b1ccd684c4c24bfd43d0f994123245f39f;hp=6ea1d311f62651cf0d410f817e353dcd50a589f9;hpb=3dcdff68956ab2202c202988d6a207bd08aa653a;p=libfirm diff --git a/ir/opt/combo.c b/ir/opt/combo.c index 6ea1d311f..67fcd415f 100644 --- a/ir/opt/combo.c +++ b/ir/opt/combo.c @@ -23,6 +23,13 @@ * @author Michael Beck * @version $Id$ * + * This is a slightly enhanced version of Cliff Clicks combo algorithm + * - support for commutative nodes is added, Add(a,b) and Add(b,a) ARE congruent + * - supports all Firm direct (by a data edge) identities except Mux + * (Mux can be a 2-input or 1-input identity, only 2-input is implemented yet) + * - supports Confirm nodes (handle them like Copies but do NOT remove them) + * - support for global congruences is implemented but not tested yet + * * Note further that we use the terminology from Click's work here, which is different * in some cases from Firm terminology. Especially, Click's type is a * Firm tarval/entity, nevertheless we call it type here for "maximum compatibility". @@ -48,7 +55,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" @@ -62,9 +71,6 @@ /* 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; @@ -169,6 +175,7 @@ typedef struct environment_t { int lambda_input; /**< Captured argument for lambda_partition(). */ char nonstd_cond; /**< Set, if a Condb note has a non-Cmp predecessor. */ char modified; /**< Set, if the graph was modified. */ + char commutative; /**< Set, if commutation nodes should be handled specially. */ #ifdef DEBUG_libfirm partition_t *dbg_list; /**< List of all partitions. */ #endif @@ -188,6 +195,9 @@ typedef void *(*what_func)(const node_t *node, environment_t *env); /** The debug module handle. */ DEBUG_ONLY(static firm_dbg_module_t *dbg;) +/** The what reason. */ +DEBUG_ONLY(static const char *what_reason;) + /** Next partition number. */ DEBUG_ONLY(static unsigned part_nr = 0); @@ -220,18 +230,70 @@ static void check_partition(const partition_t *T) { } } /* check_partition */ +/** + * check that all leader nodes in the partition have the same opcode. + */ +static void check_opcode(const partition_t *Z) { + node_t *node; + opcode_key_t key; + int first = 1; + + list_for_each_entry(node_t, node, &Z->Leader, node_list) { + ir_node *irn = node->node; + + if (first) { + key.code = get_irn_opcode(irn); + key.mode = get_irn_mode(irn); + key.arity = get_irn_arity(irn); + key.u.proj = 0; + key.u.ent = NULL; + + switch (get_irn_opcode(irn)) { + case iro_Proj: + key.u.proj = get_Proj_proj(irn); + break; + case iro_Sel: + key.u.ent = get_Sel_entity(irn); + break; + default: + break; + } + first = 0; + } else { + assert(key.code == get_irn_opcode(irn)); + assert(key.mode == get_irn_mode(irn)); + assert(key.arity == get_irn_arity(irn)); + + switch (get_irn_opcode(irn)) { + case iro_Proj: + assert(key.u.proj == get_Proj_proj(irn)); + break; + case iro_Sel: + assert(key.u.ent == get_Sel_entity(irn)); + break; + default: + break; + } + } + } +} /* check_opcode */ + 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); + if (! P->type_is_T_or_C) + check_opcode(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 } /** @@ -306,21 +368,21 @@ static void do_dump_list(const char *msg, const node_t *node, int ofs) { DB((dbg, LEVEL_3, "\n}\n")); #undef GET_LINK -} +} /* do_dump_list */ /** * Dumps a race list. */ static void dump_race_list(const char *msg, const node_t *list) { do_dump_list(msg, list, offsetof(node_t, race_next)); -} +} /* dump_race_list */ /** * Dumps a local list. */ static void dump_list(const char *msg, const node_t *list) { do_dump_list(msg, list, offsetof(node_t, next)); -} +} /* dump_list */ /** * Dump all partitions. @@ -331,13 +393,26 @@ static void dump_all_partitions(const environment_t *env) { DB((dbg, LEVEL_2, "All partitions\n===============\n")); for (P = env->dbg_list; P != NULL; P = P->dbg_next) dump_partition("", P); -} +} /* dump_all_partitions */ + +/** + * Sump a split list. + */ +static void dump_split_list(const partition_t *list) { + const partition_t *p; + + DB((dbg, LEVEL_2, "Split by %s produced = {\n", what_reason)); + for (p = list; p != NULL; p = p->split_next) + DB((dbg, LEVEL_2, "part%u, ", p->nr)); + DB((dbg, LEVEL_2, "\n}\n")); +} /* dump_split_list */ #else #define dump_partition(msg, part) #define dump_race_list(msg, list) #define dump_list(msg, list) #define dump_all_partitions(env) +#define dump_split_list(list) #endif #if defined(VERIFY_MONOTONE) && defined (DEBUG_libfirm) @@ -361,7 +436,7 @@ static void verify_type(const lattice_elem_t old_type, const lattice_elem_t new_ return; } panic("verify_type(): wrong translation from %+F to %+F", old_type, new_type); -} +} /* verify_type */ #else #define verify_type(old_type, new_type) #endif @@ -402,7 +477,7 @@ static void listmap_term(listmap_t *map) { * @param map the listmap * @param id the id to search for * - * @return the asociated listmap entry for the given id + * @return the associated listmap entry for the given id */ static listmap_entry_t *listmap_find(listmap_t *map, void *id) { listmap_entry_t key, *entry; @@ -428,7 +503,7 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id) { * @return a hash value for the given opcode map entry */ static unsigned opcode_hash(const opcode_key_t *entry) { - return (entry->mode - (ir_mode *)0) * 9 + entry->code + entry->u.proj * 3 + HASH_PTR(entry->u.ent); + return (entry->mode - (ir_mode *)0) * 9 + entry->code + entry->u.proj * 3 + HASH_PTR(entry->u.ent) + entry->arity; } /* opcode_hash */ /** @@ -499,6 +574,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; @@ -627,7 +703,6 @@ static void create_initial_partitions(ir_node *irn, void *ctx) { /* 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 */ @@ -813,12 +888,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. * @@ -913,7 +982,7 @@ static int is_real_follower(const ir_node *irn, int input) { break; } return 1; -} +} /* is_real_follower */ /** * Do one step in the race. @@ -1132,7 +1201,7 @@ static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) { */ if (transitions) { /* place partitions on the cprop list */ - if (X_prime->on_cprop == 0) { + if (X_prime->on_cprop == 0) { X_prime->cprop_next = env->cprop; env->cprop = X_prime; X_prime->on_cprop = 1; @@ -1150,7 +1219,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. @@ -1198,7 +1266,7 @@ static int type_is_neither_top_nor_const(const lattice_elem_t type) { return 0; } return 1; -} +} /* type_is_neither_top_nor_const */ /** * Collect nodes to the touched list. @@ -1233,6 +1301,11 @@ static void collect_touched(list_head *list, int idx, environment_t *env) { succ = edge->use; + /* only non-commutative nodes */ + if (env->commutative && + (idx == 0 || idx == 1) && is_op_commutative(get_irn_op(succ))) + continue; + /* ignore the "control input" for non-pinned nodes if we are running in GCSE mode */ if (idx < end_idx && get_irn_pinned(succ) != op_pin_state_pinned) @@ -1247,7 +1320,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_Eor || code == iro_Cmp) + if (code == iro_Sub || code == iro_Cmp) add_to_cprop(y, env); } @@ -1261,6 +1334,57 @@ static void collect_touched(list_head *list, int idx, environment_t *env) { } } /* collect_touched */ +/** + * Collect commutative nodes to the touched list. + * + * @param list the list which contains the nodes that must be evaluated + * @param env the environment + */ +static void collect_commutative_touched(list_head *list, environment_t *env) { + node_t *x, *y; + + list_for_each_entry(node_t, x, list, node_list) { + int num_edges; + + num_edges = get_irn_n_outs(x->node); + + x->next_edge = x->n_followers + 1; + + /* for all edges in x.L.def_use_{idx} */ + while (x->next_edge <= num_edges) { + const ir_def_use_edge *edge = &x->node->out[x->next_edge]; + ir_node *succ; + + /* check if we have necessary edges */ + if (edge->pos > 1) + break; + + ++x->next_edge; + if (edge->pos < 0) + continue; + + succ = edge->use; + + /* only commutative nodes */ + if (!is_op_commutative(get_irn_op(succ))) + continue; + + y = get_irn_node(succ); + if (is_constant_type(y->type)) { + ir_opcode code = get_irn_opcode(succ); + if (code == iro_Eor) + add_to_cprop(y, env); + } + + /* Partitions of constants should not be split simply because their Nodes have unequal + functions or incongruent inputs. */ + if (type_is_neither_top_nor_const(y->type)) { + add_to_touched(y, env); + } + } + } +} /* collect_commutative_touched */ + /** * Split the partitions if caused by the first entry on the worklist. * @@ -1277,6 +1401,44 @@ static void cause_splits(environment_t *env) { dump_partition("Cause_split: ", X); + if (env->commutative) { + /* handle commutative nodes first */ + + /* empty the touched set: already done, just clear the list */ + env->touched = NULL; + + collect_commutative_touched(&X->Leader, env); + collect_commutative_touched(&X->Follower, env); + + for (Z = env->touched; Z != NULL; Z = N) { + node_t *e; + node_t *touched = Z->touched; + unsigned n_touched = Z->n_touched; + + assert(Z->touched != NULL); + + /* beware, split might change Z */ + N = Z->touched_next; + + /* remove it from the touched set */ + Z->on_touched = 0; + + /* Empty local Z.touched. */ + for (e = touched; e != NULL; e = e->next) { + assert(e->is_follower == 0); + e->on_touched = 0; + } + Z->touched = NULL; + Z->n_touched = 0; + + if (0 < n_touched && n_touched < Z->n_leader) { + DB((dbg, LEVEL_2, "Split part%d by touched\n", Z->nr)); + split(&Z, touched, env); + } else + assert(n_touched <= Z->n_leader); + } + } + /* combine temporary leader and follower list */ for (idx = -1; idx <= X->max_user_inputs; ++idx) { /* empty the touched set: already done, just clear the list */ @@ -1359,7 +1521,7 @@ static partition_t *split_by_what(partition_t *X, what_func What, S = iter->list; /* Add SPLIT( X, S ) to P. */ - DB((dbg, LEVEL_2, "Split part%d by what\n", X->nr)); + DB((dbg, LEVEL_2, "Split part%d by WHAT = %s\n", X->nr, what_reason)); R = split(&X, S, env); R->split_next = *P; *P = R; @@ -1412,7 +1574,13 @@ static void *lambda_partition(const node_t *node, environment_t *env) { int i = env->lambda_input; if (i >= get_irn_arity(node->node)) { - /* we are outside the allowed range */ + /* + * We are outside the allowed range: This can happen even + * if we have split by opcode first: doing so might move Followers + * to Leaders and those will have a different opcode! + * Note that in this case the partition is on the cprop list and will be + * split again. + */ return NULL; } @@ -1427,6 +1595,58 @@ static void *lambda_partition(const node_t *node, environment_t *env) { return p->part; } /* lambda_partition */ +/** lambda n.(n[i].partition) for commutative nodes */ +static void *lambda_commutative_partition(const node_t *node, environment_t *env) { + ir_node *irn = node->node; + ir_node *skipped = skip_Proj(irn); + ir_node *pred, *left, *right; + node_t *p; + partition_t *pl, *pr; + int i = env->lambda_input; + + if (i >= get_irn_arity(node->node)) { + /* + * We are outside the allowed range: This can happen even + * if we have split by opcode first: doing so might move Followers + * to Leaders and those will have a different opcode! + * Note that in this case the partition is on the cprop list and will be + * split again. + */ + return NULL; + } + + /* ignore the "control input" for non-pinned nodes + if we are running in GCSE mode */ + if (i < env->end_idx && get_irn_pinned(skipped) != op_pin_state_pinned) + return NULL; + + if (i == -1) { + pred = get_irn_n(skipped, i); + p = get_irn_node(pred); + return p->part; + } + + if (is_op_commutative(get_irn_op(irn))) { + /* normalize partition order by returning the "smaller" on input 0, + the "bigger" on input 1. */ + left = get_binop_left(irn); + pl = get_irn_node(left)->part; + right = get_binop_right(irn); + pr = get_irn_node(right)->part; + + if (i == 0) + return pl < pr ? pl : pr; + else + return pl > pr ? pl : pr; + } else { + /* a not split out Follower */ + pred = get_irn_n(irn, i); + p = get_irn_node(pred); + + return p->part; + } +} /* lambda_commutative_partition */ + /** * Returns true if a type is a constant. */ @@ -1456,8 +1676,9 @@ static void split_by(partition_t *X, environment_t *env) { return; } - DB((dbg, LEVEL_2, "WHAT = lambda n.(n.type) on part%d\n", X->nr)); + DEBUG_ONLY(what_reason = "lambda n.(n.type)";) P = split_by_what(X, lambda_type, &P, env); + dump_split_list(P); /* adjust the type tags, we have split partitions by type */ for (I = P; I != NULL; I = I->split_next) { @@ -1474,8 +1695,9 @@ static void split_by(partition_t *X, environment_t *env) { if (! Y->type_is_T_or_C) { partition_t *Q = NULL; - DB((dbg, LEVEL_2, "WHAT = lambda n.(n.opcode) on part%d\n", Y->nr)); + DEBUG_ONLY(what_reason = "lambda n.(n.opcode)";) Q = split_by_what(Y, lambda_opcode, &Q, env); + dump_split_list(Q); do { partition_t *Z = Q; @@ -1485,6 +1707,11 @@ static void split_by(partition_t *X, environment_t *env) { const node_t *first = get_first_node(Z); int arity = get_irn_arity(first->node); partition_t *R, *S; + what_func what = lambda_partition; + DEBUG_ONLY(char buf[64];) + + if (env->commutative && is_op_commutative(get_irn_op(first->node))) + what = lambda_commutative_partition; /* * BEWARE: during splitting by input 2 for instance we might @@ -1501,8 +1728,10 @@ static void split_by(partition_t *X, environment_t *env) { R = R->split_next; if (Z_prime->n_leader > 1) { env->lambda_input = input; - DB((dbg, LEVEL_2, "WHAT = lambda n.(n[%d].partition) on part%d\n", input, Z_prime->nr)); - S = split_by_what(Z_prime, lambda_partition, &S, env); + DEBUG_ONLY(snprintf(buf, sizeof(buf), "lambda n.(n[%d].partition)", input);) + DEBUG_ONLY(what_reason = buf;) + S = split_by_what(Z_prime, what, &S, env); + dump_split_list(S); } else { Z_prime->split_next = S; S = Z_prime; @@ -1774,7 +2003,8 @@ static void compute_Sub(node_t *node) { 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 breaks AND we get from the argument partitions 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; @@ -1815,7 +2045,8 @@ static void compute_Eor(node_t *node) { 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 breaks AND we get from the argument partitions 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; @@ -1896,7 +2127,8 @@ 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. + this breaks AND we get from the argument partitions 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; @@ -2056,18 +2288,18 @@ static void compute_Confirm(node_t *node) { * @param node the node */ static void compute_Max(node_t *node) { - ir_node *op = node->node; - node_t *l = get_irn_node(get_binop_left(op)); - node_t *r = get_irn_node(get_binop_right(op)); - lattice_elem_t a = l->type; - lattice_elem_t b = r->type; + ir_node *op = node->node; + node_t *l = get_irn_node(get_binop_left(op)); + node_t *r = get_irn_node(get_binop_right(op)); + lattice_elem_t a = l->type; + lattice_elem_t b = r->type; if (a.tv == tarval_top || b.tv == tarval_top) { node->type.tv = tarval_top; } else if (is_con(a) && is_con(b)) { /* both nodes are constants, we can probably do something */ if (a.tv == b.tv) { - /* this case handles symconsts as well */ + /* this case handles SymConsts as well */ node->type = a; } else { ir_mode *mode = get_irn_mode(op); @@ -2100,18 +2332,18 @@ static void compute_Max(node_t *node) { * @param node the node */ static void compute_Min(node_t *node) { - ir_node *op = node->node; - node_t *l = get_irn_node(get_binop_left(op)); - node_t *r = get_irn_node(get_binop_right(op)); - lattice_elem_t a = l->type; - lattice_elem_t b = r->type; + ir_node *op = node->node; + node_t *l = get_irn_node(get_binop_left(op)); + node_t *r = get_irn_node(get_binop_right(op)); + lattice_elem_t a = l->type; + lattice_elem_t b = r->type; if (a.tv == tarval_top || b.tv == tarval_top) { node->type.tv = tarval_top; } else if (is_con(a) && is_con(b)) { /* both nodes are constants, we can probably do something */ if (a.tv == b.tv) { - /* this case handles symconsts as well */ + /* this case handles SymConsts as well */ node->type = a; } else { ir_mode *mode = get_irn_mode(op); @@ -2279,7 +2511,7 @@ static node_t *identity_Sub(node_t *node) { if (b->type.tv == get_mode_null(mode)) return get_irn_node(get_Sub_left(sub)); return node; -} /* identity_Mul */ +} /* identity_Sub */ /** * Calculates the Identity for And nodes. @@ -2444,9 +2676,8 @@ static void segregate_def_use_chain_1(const ir_node *follower, node_t *leader) { } /* segregate_def_use_chain_1 */ /** - * Node follower is a (new) follower of leader, segregate Leader - * out edges. If follower is a n-congruent Input identity, all follower - * inputs congruent to follower are also leader. + * Node follower is a (new) follower segregate its Leader + * out edges. * * @param follower the follower IR node */ @@ -2555,13 +2786,9 @@ 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 (y->type.tv != tarval_top && ! is_con(y->type)) { @@ -2580,7 +2807,6 @@ static void propagate(environment_t *env) { } } } -#endif split_by(Y, env); } } /* propagate */ @@ -2620,7 +2846,7 @@ static int can_exchange(ir_node *pred) { int i, k; /* if the predecessor block has more than one - reachable outputs we cannot remove the block */ + reachable outputs we cannot remove the block */ k = 0; for (i = get_irn_n_outs(pred) - 1; i >= 0; --i) { ir_node *proj = get_irn_out(pred, i); @@ -2658,19 +2884,22 @@ static void apply_cf(ir_node *block, void *ctx) { env->modified = 1; for (i = n - 1; i >= 0; --i) { - ir_node *pred = get_Block_cfgpred(block, i); - 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); + 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); + } } } } @@ -2680,6 +2909,7 @@ static void apply_cf(ir_node *block, void *ctx) { 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); @@ -2693,6 +2923,8 @@ static void apply_cf(ir_node *block, void *ctx) { if (can_exchange(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; @@ -2709,18 +2941,21 @@ static void apply_cf(ir_node *block, void *ctx) { if (node->type.tv == tarval_reachable) { in_X[k++] = pred; } else { - 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); + 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); + } } } } @@ -2741,6 +2976,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 { @@ -2759,6 +2995,7 @@ static void apply_cf(ir_node *block, void *ctx) { 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; @@ -2775,6 +3012,7 @@ static void apply_cf(ir_node *block, void *ctx) { if (can_exchange(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; @@ -2783,6 +3021,27 @@ static void apply_cf(ir_node *block, void *ctx) { set_irn_in(block, k, in_X); env->modified = 1; } +} /* apply_cf */ + +/** + * Exchange a node by its leader. + * Beware: in rare cases the mode might be wrong here, for instance + * AddP(x, NULL) is a follower of x, but with different mode. + * Fix it here. + */ +static void exchange_leader(ir_node *irn, ir_node *leader) { + ir_mode *mode = get_irn_mode(irn); + if (mode != get_irn_mode(leader)) { + /* The conv is a no-op, so we are fre to place in + * either in the block of the leader OR in irn's block. + * Propably placing it into leaders block might reduce + * the number of Conv due to CSE. */ + ir_node *block = get_nodes_block(leader); + dbg_info *dbg = get_irn_dbg_info(irn); + + leader = new_rd_Conv(dbg, current_ir_graph, block, leader, mode); + } + exchange(irn, leader); } /** @@ -2830,11 +3089,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 */ + /* 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; } @@ -2855,18 +3115,20 @@ 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)); - exchange(irn, c); + DBG_OPT_COMBO(irn, c, FS_OPT_COMBO_CONST); + exchange_leader(irn, c); env->modified = 1; } } else if (is_entity(node->type.sym.entity_p)) { if (! is_SymConst(irn)) { - /* can be replaced by a Symconst */ + /* can be replaced by a SymConst */ ir_node *symc = new_r_SymConst(current_ir_graph, block->node, get_irn_mode(irn), node->type.sym, symconst_addr_ent); set_irn_node(symc, node); node->node = symc; DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, symc)); - exchange(irn, symc); + DBG_OPT_COMBO(irn, symc, FS_OPT_COMBO_CONST); + exchange_leader(irn, symc); env->modified = 1; } } else if (is_Confirm(irn)) { @@ -2876,7 +3138,11 @@ 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)); - exchange(irn, 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_leader(irn, leader); env->modified = 1; } } @@ -2902,7 +3168,7 @@ static void apply_end(ir_node *end, environment_t *env) { if (! is_Block(ka)) node = get_irn_node(get_nodes_block(ka)); - if (node->type.tv != tarval_unreachable) + if (node->type.tv != tarval_unreachable && !is_Bad(ka)) in[j++] = ka; } if (j != n) { @@ -2948,11 +3214,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) { @@ -2965,7 +3233,6 @@ void combo(ir_graph *irg) { /* register a debug mask */ FIRM_DBG_REGISTER(dbg, "firm.opt.combo"); - //firm_dbg_set_mask(dbg, SET_LEVEL_3); DB((dbg, LEVEL_1, "Doing COMBO for %+F\n", irg)); @@ -2982,12 +3249,12 @@ void combo(ir_graph *irg) { env.end_idx = get_opt_global_cse() ? 0 : -1; env.lambda_input = 0; env.nonstd_cond = 0; + env.commutative = 1; 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);