* @file
* @brief Cliff Click's Combined Analysis/Optimization
* @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
#include "irpass.h"
#include "tv_t.h"
#include "irtools.h"
+#include "opt_manage.h"
#include "irprintf.h"
#include "irdump.h"
* An opcode map key.
*/
struct opcode_key_t {
- unsigned code; /**< The Firm opcode. */
- ir_mode *mode; /**< The mode of all nodes in the partition. */
- int arity; /**< The arity of this opcode (needed for Phi etc. */
- union {
- long proj; /**< For Proj nodes, its proj number */
- ir_entity *ent; /**< For Sel Nodes, its entity */
- int intVal; /**< For Conv/Div Nodes: strict/remainderless */
- unsigned uintVal;/**< for Builtin: the kind */
- ir_node *block; /**< for Block: itself */
- void *ptr; /**< generic pointer for hash/cmp */
- } u;
+ ir_node *irn; /**< An IR node representing this opcode. */
};
/**
DEBUG_ONLY(static const char *what_reason;)
/** Next partition number. */
-DEBUG_ONLY(static unsigned part_nr = 0);
+DEBUG_ONLY(static unsigned part_nr = 0;)
/** The tarval returned by Unknown nodes: set to either tarval_bad OR tarval_top. */
static ir_tarval *tarval_UNKNOWN;
/* forward */
static node_t *identity(node_t *node);
+/**
+ * Compare two opcode representatives.
+ */
+static int cmp_irn_opcode(const ir_node *a, const ir_node *b)
+{
+ int arity;
+
+ if ((get_irn_op(a) != get_irn_op(b)) ||
+ (get_irn_mode(a) != get_irn_mode(b)))
+ return 1;
+
+ /* compare if a's in and b's in are of equal length */
+ arity = get_irn_arity(a);
+ if (arity != get_irn_arity(b))
+ return 1;
+
+ if (is_Block(a)) {
+ /*
+ * Some ugliness here: Two Blocks having the same
+ * IJmp predecessor would be congruent, which of course is wrong.
+ * We fix it by never letting blocks be congruent
+ * which cannot be detected by combo either.
+ */
+ return 1;
+ }
+
+ /*
+ * here, we already know that the nodes are identical except their
+ * attributes
+ */
+ if (a->op->ops.node_cmp_attr)
+ return a->op->ops.node_cmp_attr(a, b);
+
+ return 0;
+} /* cmp_irn_opcode */
+
#ifdef CHECK_PARTITIONS
/**
* Check a partition.
*/
static void check_opcode(const partition_t *Z)
{
- node_t *node;
- opcode_key_t key;
- int first = 1;
+ node_t *node;
+ const ir_node *repr = NULL;
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;
- case iro_Conv:
- key.u.intVal = get_Conv_strict(irn);
- break;
- case iro_Div:
- key.mode = get_Div_resmode(irn);
- key.u.intVal = get_Div_no_remainder(irn);
- break;
- case iro_Mod:
- key.mode = get_Mod_resmode(irn);
- break;
- case iro_Block:
- key.u.block = irn;
- break;
- case iro_Load:
- key.mode = get_Load_mode(irn);
- break;
- case iro_Builtin:
- key.u.intVal = get_Builtin_kind(irn);
- break;
- default:
- break;
- }
- first = 0;
+ if (repr == NULL) {
+ repr = irn;
} else {
- assert((unsigned)key.code == get_irn_opcode(irn));
- assert(key.arity == get_irn_arity(irn));
-
- switch (get_irn_opcode(irn)) {
- case iro_Proj:
- assert(key.mode == get_irn_mode(irn));
- assert(key.u.proj == get_Proj_proj(irn));
- break;
- case iro_Sel:
- assert(key.mode == get_irn_mode(irn));
- assert(key.u.ent == get_Sel_entity(irn));
- break;
- case iro_Conv:
- assert(key.mode == get_irn_mode(irn));
- assert(key.u.intVal == get_Conv_strict(irn));
- break;
- case iro_Div:
- assert(key.mode == get_Div_resmode(irn));
- assert(key.u.intVal == get_Div_no_remainder(irn));
- break;
- case iro_Mod:
- assert(key.mode == get_Mod_resmode(irn));
- break;
- case iro_Block:
- assert(key.mode == get_irn_mode(irn));
- assert(key.u.block == irn);
- break;
- case iro_Load:
- assert(key.mode == get_Load_mode(irn));
- break;
- case iro_Builtin:
- assert(key.mode == get_irn_mode(irn));
- assert(key.u.intVal == (int) get_Builtin_kind(irn));
- break;
- default:
- assert(key.mode == get_irn_mode(irn));
- break;
- }
+ assert(cmp_irn_opcode(repr, irn) == 0);
}
}
} /* check_opcode */
*/
static unsigned opcode_hash(const opcode_key_t *entry)
{
- return (unsigned)(PTR_TO_INT(entry->mode) * 9 + entry->code + entry->u.proj * 3 + HASH_PTR(entry->u.ptr) + entry->arity);
+ /* we cannot use the ir ops hash function here, because it hashes the
+ * predecessors. */
+ const ir_node *n = entry->irn;
+ ir_opcode code = get_irn_opcode(n);
+ ir_mode *mode = get_irn_mode(n);
+ unsigned hash = (unsigned)(PTR_TO_INT(mode) * 9 + code) + get_irn_arity(n);
+
+ if (code == iro_Const)
+ hash ^= (unsigned)HASH_PTR(get_Const_tarval(n));
+ else if (code == iro_Proj)
+ hash += (unsigned)get_Proj_proj(n);
+ return hash;
} /* opcode_hash */
/**
const opcode_key_t *o2 = (opcode_key_t*)key;
(void) size;
- return o1->code != o2->code || o1->mode != o2->mode ||
- o1->arity != o2->arity ||
- o1->u.proj != o2->u.proj ||
- o1->u.intVal != o2->u.intVal || /* this already checks uIntVal */
- o1->u.ptr != o2->u.ptr;
+
+ return cmp_irn_opcode(o1->irn, o2->irn);
} /* cmp_opcode */
/**
(void) ctx;
if (is_Phi(irn)) {
- add_Block_phi(get_nodes_block(irn), irn);
+ ir_node *block = get_nodes_block(irn);
+ add_Block_phi(block, irn);
}
} /* init_block_phis */
if (y->on_cprop == 0) {
partition_t *Y = y->part;
ir_node *irn = y->node;
+ ir_node *skipped = skip_Proj(irn);
/* place Conds and all its Projs on the cprop_X list */
- if (is_Cond(skip_Proj(irn)))
+ if (is_Cond(skipped) || is_Switch(skipped))
list_add_tail(&y->cprop_list, &Y->cprop_X);
else
list_add_tail(&y->cprop_list, &Y->cprop);
irn = y->node;
if (get_irn_mode(irn) == mode_T) {
/* mode_T nodes always produce tarval_bottom, so we must explicitly
- add it's Proj's to get constant evaluation to work */
+ * add its Projs to get constant evaluation to work */
int i;
for (i = get_irn_n_outs(irn) - 1; i >= 0; --i) {
static void *lambda_opcode(const node_t *node, environment_t *env)
{
opcode_key_t key, *entry;
- ir_node *irn = node->node;
-
- 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;
- case iro_Conv:
- key.u.intVal = get_Conv_strict(irn);
- break;
- case iro_Div:
- key.u.intVal = get_Div_no_remainder(irn);
- break;
- case iro_Block:
- /*
- * Some ugliness here: Two Blocks having the same
- * IJmp predecessor would be congruent, which of course is wrong.
- * We fix it by never letting blocks be congruent
- * which cannot be detected by combo either.
- */
- key.u.block = irn;
- break;
- case iro_Load:
- key.mode = get_Load_mode(irn);
- break;
- case iro_Builtin:
- key.u.intVal = get_Builtin_kind(irn);
- break;
- default:
- break;
- }
+ key.irn = node->node;
entry = (opcode_key_t*)set_insert(env->opcode2id_map, &key, sizeof(key), opcode_hash(&key));
return entry;
dump_partition("split_by", X);
if (X->n_leader == 1) {
- /* we have only one leader, no need to split, just check it's type */
+ /* we have only one leader, no need to split, just check its type */
node_t *x = get_first_node(X);
X->type_is_T_or_C = x->type.tv == tarval_top || is_con(x->type);
return;
int i;
ir_node *block = node->node;
- if (block == get_irg_start_block(current_ir_graph) || has_Block_entity(block)) {
+ if (block == get_irg_start_block(current_ir_graph) || get_Block_entity(block) != NULL) {
/* start block and labelled blocks are always reachable */
node->type.tv = tarval_reachable;
return;
*/
static void compute_Cmp(node_t *node)
{
- ir_node *cmp = node->node;
- node_t *l = get_irn_node(get_Cmp_left(cmp));
- node_t *r = get_irn_node(get_Cmp_right(cmp));
- lattice_elem_t a = l->type;
- lattice_elem_t b = r->type;
- ir_mode *mode = get_irn_mode(get_Cmp_left(cmp));
-
- if (a.tv == tarval_top || b.tv == tarval_top) {
- node->type.tv = tarval_top;
- } else if (r->part == l->part) {
- /* both nodes congruent, we can probably do something */
- if (mode_is_float(mode)) {
- /* beware of NaN's */
- node->type.tv = tarval_bottom;
- } else {
- node->type.tv = tarval_b_true;
- }
- } else if (is_con(a) && is_con(b)) {
- node->type.tv = tarval_b_true;
- } else {
- node->type.tv = tarval_bottom;
- }
-} /* compute_Cmp */
-
-/**
- * (Re-)compute the type for a Proj(Cmp).
- *
- * @param node the node
- * @param cond the predecessor Cmp node
- */
-static void compute_Proj_Cmp(node_t *node, ir_node *cmp)
-{
- ir_node *proj = node->node;
- node_t *l = get_irn_node(get_Cmp_left(cmp));
- node_t *r = get_irn_node(get_Cmp_right(cmp));
- lattice_elem_t a = l->type;
- lattice_elem_t b = r->type;
- pn_Cmp pnc = get_Proj_pn_cmp(proj);
+ ir_node *cmp = node->node;
+ node_t *l = get_irn_node(get_Cmp_left(cmp));
+ node_t *r = get_irn_node(get_Cmp_right(cmp));
+ lattice_elem_t a = l->type;
+ lattice_elem_t b = r->type;
+ ir_relation relation = get_Cmp_relation(cmp);
ir_tarval *tv;
if (a.tv == tarval_top || b.tv == tarval_top) {
* consistent with compute_Cmp, so don't do anything for floats)
*/
} else if (r->part == l->part && !mode_is_float(get_irn_mode(l->node))) {
- tv = pnc & pn_Cmp_Eq ? tarval_b_true : tarval_b_false;
+ tv = relation & ir_relation_equal ? tarval_b_true : tarval_b_false;
- /* if the node was ONCE evaluated by all constants, but now
+ /* if the node was ONCE evaluated to a constant, but now
this breaks AND we get from the argument partitions a different
- result, switch to bottom.
+ result, ensure monotony by fall to bottom.
This happens because initially all nodes are in the same partition ... */
- if (node->type.tv != tv)
+ if (node->type.tv == tarval_bottom)
+ tv = tarval_bottom;
+ else if (node->type.tv != tv && is_constant_type(node->type))
tv = tarval_bottom;
node->type.tv = tv;
} else {
node->type.tv = tarval_bottom;
}
-} /* compute_Proj_Cmp */
+}
/**
* (Re-)compute the type for a Proj(Cond).
if (node->type.tv == tarval_reachable)
return;
- if (get_irn_mode(sel) == mode_b) {
- /* an IF */
- if (pnc == pn_Cond_true) {
- if (selector->type.tv == tarval_b_false) {
- node->type.tv = tarval_unreachable;
- } else if (selector->type.tv == tarval_b_true) {
- node->type.tv = tarval_reachable;
- } else if (selector->type.tv == tarval_bottom) {
- node->type.tv = tarval_reachable;
- } else {
- assert(selector->type.tv == tarval_top);
- if (tarval_UNKNOWN == tarval_top) {
- /* any condition based on Top is "!=" */
- node->type.tv = tarval_unreachable;
- } else {
- node->type.tv = tarval_unreachable;
- }
- }
+ if (pnc == pn_Cond_true) {
+ if (selector->type.tv == tarval_b_false) {
+ node->type.tv = tarval_unreachable;
+ } else if (selector->type.tv == tarval_b_true) {
+ node->type.tv = tarval_reachable;
+ } else if (selector->type.tv == tarval_bottom) {
+ node->type.tv = tarval_reachable;
} else {
- assert(pnc == pn_Cond_false);
-
- if (selector->type.tv == tarval_b_false) {
- node->type.tv = tarval_reachable;
- } else if (selector->type.tv == tarval_b_true) {
+ assert(selector->type.tv == tarval_top);
+ if (tarval_UNKNOWN == tarval_top) {
+ /* any condition based on Top is "!=" */
node->type.tv = tarval_unreachable;
- } else if (selector->type.tv == tarval_bottom) {
- node->type.tv = tarval_reachable;
} else {
- assert(selector->type.tv == tarval_top);
- if (tarval_UNKNOWN == tarval_top) {
- /* any condition based on Top is "!=" */
- node->type.tv = tarval_reachable;
- } else {
- node->type.tv = tarval_unreachable;
- }
+ node->type.tv = tarval_unreachable;
}
}
} else {
- /* an SWITCH */
- if (selector->type.tv == tarval_bottom) {
+ assert(pnc == pn_Cond_false);
+
+ if (selector->type.tv == tarval_b_false) {
node->type.tv = tarval_reachable;
- } else if (selector->type.tv == tarval_top) {
- if (tarval_UNKNOWN == tarval_top &&
- pnc == get_Cond_default_proj(cond)) {
- /* a switch based of Top is always "default" */
+ } else if (selector->type.tv == tarval_b_true) {
+ node->type.tv = tarval_unreachable;
+ } else if (selector->type.tv == tarval_bottom) {
+ node->type.tv = tarval_reachable;
+ } else {
+ assert(selector->type.tv == tarval_top);
+ if (tarval_UNKNOWN == tarval_top) {
+ /* any condition based on Top is "!=" */
node->type.tv = tarval_reachable;
} else {
node->type.tv = tarval_unreachable;
}
+ }
+ }
+} /* compute_Proj_Cond */
+
+static void compute_Proj_Switch(node_t *node, ir_node *switchn)
+{
+ ir_node *proj = node->node;
+ long pnc = get_Proj_proj(proj);
+ ir_node *sel = get_Switch_selector(switchn);
+ node_t *selector = get_irn_node(sel);
+
+ /* see long comment in compute_Proj_Cond */
+ if (node->type.tv == tarval_reachable)
+ return;
+
+ if (selector->type.tv == tarval_bottom) {
+ node->type.tv = tarval_reachable;
+ } else if (selector->type.tv == tarval_top) {
+ if (tarval_UNKNOWN == tarval_top && pnc == pn_Switch_default) {
+ /* a switch based of Top is always "default" */
+ node->type.tv = tarval_reachable;
} else {
- long value = get_tarval_long(selector->type.tv);
- if (pnc == get_Cond_default_proj(cond)) {
- /* default switch, have to check ALL other cases */
- int i;
-
- for (i = get_irn_n_outs(cond) - 1; i >= 0; --i) {
- ir_node *succ = get_irn_out(cond, i);
-
- if (succ == proj)
- continue;
- if (value == get_Proj_proj(succ)) {
- /* we found a match, will NOT take the default case */
- node->type.tv = tarval_unreachable;
- return;
- }
+ node->type.tv = tarval_unreachable;
+ }
+ } else {
+ long value = get_tarval_long(selector->type.tv);
+ const ir_switch_table *table = get_Switch_table(switchn);
+ size_t n_entries = ir_switch_table_get_n_entries(table);
+ size_t e;
+
+ for (e = 0; e < n_entries; ++e) {
+ const ir_switch_table_entry *entry
+ = ir_switch_table_get_entry_const(table, e);
+ ir_tarval *min = entry->min;
+ ir_tarval *max = entry->max;
+ if (min == max) {
+ if (selector->type.tv == min) {
+ node->type.tv = entry->pn == pnc
+ ? tarval_reachable : tarval_unreachable;
+ return;
}
- /* all cases checked, no match, will take default case */
- node->type.tv = tarval_reachable;
} else {
- /* normal case */
- node->type.tv = value == pnc ? tarval_reachable : tarval_unreachable;
+ long minval = get_tarval_long(min);
+ long maxval = get_tarval_long(max);
+ if (minval <= value && value <= maxval) {
+ node->type.tv = entry->pn == pnc
+ ? tarval_reachable : tarval_unreachable;
+ return;
+ }
}
}
+
+ /* no entry matched: default */
+ node->type.tv
+ = pnc == pn_Switch_default ? tarval_reachable : tarval_unreachable;
}
-} /* compute_Proj_Cond */
+}
/**
- * (Re-)compute the type for a Proj-Node.
- *
- * @param node the node
- */
+* (Re-)compute the type for a Proj-Node.
+*
+* @param node the node
+*/
static void compute_Proj(node_t *node)
{
- ir_node *proj = node->node;
+ir_node *proj = node->node;
ir_mode *mode = get_irn_mode(proj);
node_t *block = get_irn_node(get_nodes_block(skip_Proj(proj)));
ir_node *pred = get_Proj_pred(proj);
node->type.tv = tarval_top;
return;
}
- if (get_irn_node(pred)->type.tv == tarval_top && !is_Cond(pred)) {
+ if (get_irn_node(pred)->type.tv == tarval_top && !is_Cond(pred) && !is_Switch(pred)) {
/* if the predecessor is Top, its Proj follow */
node->type.tv = tarval_top;
return;
/* mode M is always bottom */
node->type.tv = tarval_bottom;
return;
+ } else if (mode == mode_X) {
+ /* handle mode_X nodes */
+ switch (get_irn_opcode(pred)) {
+ case iro_Start:
+ /* the Proj_X from the Start is always reachable.
+ However this is already handled at the top. */
+ node->type.tv = tarval_reachable;
+ return;
+ case iro_Cond:
+ compute_Proj_Cond(node, pred);
+ return;
+ case iro_Switch:
+ compute_Proj_Switch(node, pred);
+ return;
+ default:
+ break;
+ }
}
- if (mode != mode_X) {
- if (is_Cmp(pred))
- compute_Proj_Cmp(node, pred);
- else
- default_compute(node);
- return;
- }
- /* handle mode_X nodes */
- switch (get_irn_opcode(pred)) {
- case iro_Start:
- /* the Proj_X from the Start is always reachable.
- However this is already handled at the top. */
- node->type.tv = tarval_reachable;
- break;
- case iro_Cond:
- compute_Proj_Cond(node, pred);
- break;
- default:
- default_compute(node);
- }
+ default_compute(node);
} /* compute_Proj */
/**
ir_node *confirm = node->node;
node_t *pred = get_irn_node(get_Confirm_value(confirm));
- if (get_Confirm_cmp(confirm) == pn_Cmp_Eq) {
+ if (get_Confirm_relation(confirm) == ir_relation_equal) {
node_t *bound = get_irn_node(get_Confirm_bound(confirm));
if (is_con(bound->type)) {
*/
static int can_exchange(ir_node *pred, ir_node *block)
{
- if (is_Start(pred) || has_Block_entity(block))
+ if (is_Start(pred) || get_Block_entity(block) != NULL)
return 0;
else if (is_Jmp(pred))
return 1;
+ else if (is_Raise(pred)) {
+ /* Raise is a tuple and usually has only one reachable ProjX,
+ * but it must not be eliminated like a Jmp */
+ return 0;
+ }
else if (get_irn_mode(pred) == mode_T) {
/* if the predecessor block has more than one
reachable outputs we cannot remove the block */
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);
+ ir_node *pred_block = get_nodes_block(skip_Proj(pred));
+ if (!is_Bad(pred_block)) {
+ node_t *pred_bl = get_irn_node(pred_block);
+
+ 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 */
+ if (block == get_irg_end_block(current_ir_graph)) {
+ /* Analysis found out that the end block is unreachable,
+ * hence we remove all its control flow predecessors. */
set_irn_in(block, 0, NULL);
}
return;
} 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);
+ ir_node *pred_block = get_nodes_block(skip_Proj(pred));
+ if (!is_Bad(pred_block)) {
+ node_t *pred_bl = get_irn_node(pred_block);
+
+ if (!is_Bad(pred_bl->node) && 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);
+ }
}
}
}
node_t *block = get_irn_node(get_nodes_block(irn));
if (block->type.tv == tarval_unreachable) {
- ir_node *bad = get_irg_bad(current_ir_graph);
+ ir_graph *irg = get_irn_irg(irn);
+ ir_mode *mode = get_irn_mode(node->node);
+ ir_node *bad = new_r_Bad(irg, mode);
/* here, bad might already have a node, but this can be safely ignored
as long as bad has at least ONE valid node */
/* leave or Jmp */
ir_node *cond = get_Proj_pred(irn);
- if (is_Cond(cond)) {
+ if (is_Cond(cond) || is_Switch(cond)) {
if (only_one_reachable_proj(cond)) {
ir_node *jmp = new_r_Jmp(block->node);
set_irn_node(jmp, node);
exchange(irn, jmp);
env->modified = 1;
} else {
- node_t *sel = get_irn_node(get_Cond_selector(cond));
- ir_tarval *tv = sel->type.tv;
-
- if (is_tarval(tv) && tarval_is_constant(tv)) {
- /* The selector is a constant, but more
- * than one output is active: An unoptimized
- * case found. */
- env->unopt_cf = 1;
+ if (is_Switch(cond)) {
+ node_t *sel = get_irn_node(get_Switch_selector(cond));
+ ir_tarval *tv = sel->type.tv;
+
+ if (is_tarval(tv) && tarval_is_constant(tv)) {
+ /* The selector is a constant, but more
+ * than one output is active: An unoptimized
+ * case found. */
+ env->unopt_cf = 1;
+ }
}
}
}
/* fix the keep alive */
for (i = j = 0; i < n; i++) {
- ir_node *ka = get_End_keepalive(end, i);
- node_t *node = get_irn_node(ka);
+ ir_node *ka = get_End_keepalive(end, i);
+ ir_node *block;
+ node_t *node;
- if (! is_Block(ka))
- node = get_irn_node(get_nodes_block(ka));
+ if (is_Bad(ka))
+ continue;
+ if (!is_Block(ka)) {
+ block = get_nodes_block(ka);
+ if (is_Bad(block))
+ continue;
+ } else {
+ block = ka;
+ }
- if (node->type.tv != tarval_unreachable && !is_Bad(ka))
+ node = get_irn_node(block);
+ if (node->type.tv != tarval_unreachable)
in[j++] = ka;
}
if (j != n) {
ir_nodeset_destroy(&set);
} /* add_memory_keeps */
-void combo(ir_graph *irg)
+static ir_graph_state_t do_combo(ir_graph *irg)
{
environment_t env;
ir_node *initial_bl;
env.commutative = 1;
env.opt_unknown = 1;
- assure_irg_outs(irg);
- assure_cf_loop(irg);
-
/* we have our own value_of function */
set_value_of_func(get_node_tarval);
set_compute_functions();
- DEBUG_ONLY(part_nr = 0);
+ DEBUG_ONLY(part_nr = 0;)
ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK | IR_RESOURCE_PHI_LIST);
irg_walk_graph(irg, create_initial_partitions, init_block_phis, &env);
/* set the hook: from now, every node has a partition and a type */
- DEBUG_ONLY(set_dump_node_vcgattr_hook(dump_partition_hook));
+ DEBUG_ONLY(set_dump_node_vcgattr_hook(dump_partition_hook);)
/* all nodes on the initial partition have type Top */
env.initial->type_is_T_or_C = 1;
DB((dbg, LEVEL_1, "Unoptimized Control Flow left"));
}
- if (env.modified) {
- /* control flow might changed */
- set_irg_outs_inconsistent(irg);
- set_irg_extblk_inconsistent(irg);
- set_irg_doms_inconsistent(irg);
- set_irg_loopinfo_inconsistent(irg);
- set_irg_entity_usage_state(irg, ir_entity_usage_not_computed);
- }
-
ir_free_resources(irg, IR_RESOURCE_IRN_LINK | IR_RESOURCE_PHI_LIST);
/* remove the partition hook */
- DEBUG_ONLY(set_dump_node_vcgattr_hook(NULL));
+ DEBUG_ONLY(set_dump_node_vcgattr_hook(NULL);)
DEL_ARR_F(env.kept_memory);
del_set(env.opcode2id_map);
/* restore value_of() default behavior */
set_value_of_func(NULL);
current_ir_graph = rem;
+
+ return 0; // cannot guarantee anything
} /* combo */
+static optdesc_t opt_combo = {
+ "combo",
+ IR_GRAPH_STATE_NO_BADS | IR_GRAPH_STATE_CONSISTENT_OUTS | IR_GRAPH_STATE_CONSISTENT_LOOPINFO,
+ do_combo,
+};
+
+void combo(ir_graph *irg)
+{
+ perform_irg_optimization(irg, &opt_combo);
+}
+
/* Creates an ir_graph pass for combo. */
ir_graph_pass_t *combo_pass(const char *name)
{