* @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".
#include "irgmod.h"
#include "iropt_dbg.h"
#include "debug.h"
+#include "array_t.h"
#include "error.h"
#include "tv_t.h"
/* 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;
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
/** 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);
}
} /* 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
}
/**
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.
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)
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
* @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;
* @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 */
/**
*/
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;
/* 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 */
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.
*
break;
}
return 1;
-}
+} /* is_real_follower */
/**
* Do one step in the race.
*/
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;
return X_prime;
} /* split */
-#endif /* NO_FOLLOWER */
/**
* Returns non-zero if the i'th input of a Phi node is live.
return 0;
}
return 1;
-}
+} /* type_is_neither_top_nor_const */
/**
* Collect nodes to the touched list.
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)
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);
}
}
} /* 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.
*
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 */
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;
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;
}
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.
*/
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) {
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;
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
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;
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;
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;
#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;
* @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);
* @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);
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.
} /* 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
*/
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)) {
}
}
}
-#endif
split_by(Y, env);
}
} /* propagate */
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);
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);
+ }
}
}
}
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);
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;
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);
+ }
}
}
}
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);
}
/**
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);
+ 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));
DBG_OPT_COMBO(irn, symc, FS_OPT_COMBO_CONST);
- exchange(irn, symc);
+ exchange_leader(irn, symc);
env->modified = 1;
}
} else if (is_Confirm(irn)) {
DBG_OPT_COMBO(irn, leader, FS_OPT_COMBO_FOLLOWER);
else
DBG_OPT_COMBO(irn, leader, FS_OPT_COMBO_CONGRUENT);
- exchange(irn, leader);
+ exchange_leader(irn, leader);
env->modified = 1;
}
}
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) {
} /* 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) {
/* 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));
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);