(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 */
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) {
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;
*/
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).
/* 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;
+ 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)) {
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);
+ }
}
}
}
finds out the opposite :-) */
if (block != get_irg_end_block(current_ir_graph)) {
/* mark dead blocks */
- set_Block_dead(block);
+ //set_Block_dead(block);
+ //ir_graph *irg = get_irn_irg(block);
+ //exchange(block, get_irg_bad(irg));
DB((dbg, LEVEL_1, "Removing dead %+F\n", block));
} else {
/* the endblock is unreachable */
} 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);
+ }
}
}
}
/* 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) {