#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"
#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;
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 is flagged by step(). */
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. */
};
/**
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
/** 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);
list_for_each_entry(node_t, node, &T->Leader, node_list) {
assert(node->is_follower == 0);
+ assert(node->flagged == 0);
assert(node->part == T);
++n;
}
list_for_each_entry(node_t, node, &T->Follower, node_list) {
assert(node->is_follower == 1);
+ 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.
+ */
+static void do_check_list(const node_t *list, int ofs, const partition_t *Z) {
+ const node_t *e;
+
+#define NEXT(e) *((const node_t **)((char *)(e) + (ofs)))
+ for (e = list; e != NULL; e = NEXT(e)) {
+ assert(e->part == Z);
+ }
+#undef NEXT
+} /* ido_check_list */
+
+/**
+ * Check a local list.
+ */
+static void check_list(const node_t *list, const partition_t *Z) {
+ do_check_list(list, offsetof(node_t, next), Z);
+} /* check_list */
+
#else
#define check_partition(T)
+#define check_list(list, Z)
+#define check_all_partitions(env)
#endif /* CHECK_PARTITIONS */
#ifdef DEBUG_libfirm
*/
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;
node->on_cprop = 0;
node->on_fallen = 0;
node->is_follower = 0;
- node->is_flagged = 0;
node->by_all_const = 0;
+ node->flagged = 0;
set_irn_node(irn, node);
list_add_tail(&node->node_list, &part->Leader);
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 */
env->touched = part;
part->on_touched = 1;
}
+
+ check_list(part->touched, part);
}
} /* add_to_touched */
Z_prime = new_partition(env);
max_input = 0;
for (node = g; node != NULL; node = node->next) {
- list_add(&node->node_list, &Z_prime->Leader);
+ list_add_tail(&node->node_list, &Z_prime->Leader);
node->part = Z_prime;
if (node->max_user_input > max_input)
max_input = node->max_user_input;
return Z_prime;
} /* split_no_followers */
-#ifdef NO_FOLLOWER
+/**
+ * Make the Follower -> Leader transition for a node.
+ *
+ * @param n the node
+ */
+static void follower_to_leader(node_t *n) {
+ assert(n->is_follower == 1);
-#define split(Z, g, env) split_no_followers(*(Z), g, env)
-
-#else
+ DB((dbg, LEVEL_2, "%+F make the follower -> leader transition\n", n->node));
+ n->is_follower = 0;
+ move_edges_to_leader(n);
+ list_del(&n->node_list);
+ list_add_tail(&n->node_list, &n->part->Leader);
+ ++n->part->n_leader;
+} /* follower_to_leader */
/**
* The environment for one race step.
node_t *unwalked; /**< The unwalked node list. */
node_t *walked; /**< The walked node list. */
int index; /**< Next index of Follower use_def edge. */
- unsigned n_leader; /**< number of Leader in initial. */
+ unsigned side; /**< side number. */
} step_env;
+/**
+ * Return non-zero, if a input is a real follower
+ *
+ * @param irn the node to check
+ * @param input number of the input
+ */
+static int is_real_follower(const ir_node *irn, int input) {
+ 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;
+ }
+ 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;
+}
+
/**
* Do one step in the race.
*/
/* let n be the first node in unwalked */
n = env->unwalked;
while (env->index < n->n_followers) {
+ const ir_def_use_edge *edge = &n->node->out[1 + env->index];
+
/* let m be n.F.def_use[index] */
- node_t *m = get_irn_node(n->node->out[1 + env->index].use);
+ node_t *m = get_irn_node(edge->use);
assert(m->is_follower);
+ /*
+ * Some inputs, like the get_Confirm_bound are NOT
+ * real followers, sort them out.
+ */
+ if (! is_real_follower(m->node, edge->pos)) {
+ ++env->index;
+ continue;
+ }
++env->index;
/* only followers from our partition */
if (m->part != n->part)
continue;
- if (!m->is_flagged) {
- m->is_flagged = 1;
+ if ((m->flagged & env->side) == 0) {
+ m->flagged |= env->side;
- /* 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 */
} /* step */
/**
- * Clear the flags from a list.
+ * Clear the flags from a list and check for
+ * nodes that where touched from both sides.
*
* @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 */
/**
list_head tmp;
step_env env1, env2, *winner;
node_t *g, *h, *node, *t;
- int max_input;
- unsigned n, m;
+ int max_input, transitions;
+ unsigned n;
DEBUG_ONLY(static int run = 0;)
DB((dbg, LEVEL_2, "Run %d ", run++));
/* Remove gg from X.Leader and put into g */
g = NULL;
- n = 0;
for (node = gg; node != NULL; node = node->next) {
assert(node->part == X);
assert(node->is_follower == 0);
list_add_tail(&node->node_list, &tmp);
node->race_next = g;
g = node;
- ++n;
}
/* produce h */
h = NULL;
- m = 0;
list_for_each_entry(node_t, node, &X->Leader, node_list) {
node->race_next = h;
h = node;
- ++m;
}
/* restore X.Leader */
list_splice(&tmp, &X->Leader);
env1.unwalked = NULL;
env1.walked = NULL;
env1.index = 0;
- env1.n_leader = n;
+ env1.side = 1;
env2.initial = h;
env2.unwalked = NULL;
env2.walked = NULL;
env2.index = 0;
- env2.n_leader = m;
+ env2.side = 2;
for (;;) {
if (step(&env1)) {
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);
/* Move walked_{winner} to a new partition, X'. */
- X_prime = new_partition(env);
+ X_prime = new_partition(env);
max_input = 0;
+ n = 0;
for (node = winner->walked; node != NULL; node = node->race_next) {
list_del(&node->node_list);
node->part = X_prime;
if (node->is_follower) {
- list_add(&node->node_list, &X_prime->Follower);
+ list_add_tail(&node->node_list, &X_prime->Follower);
} else {
- list_add(&node->node_list, &X_prime->Leader);
- ++X_prime->n_leader;
+ list_add_tail(&node->node_list, &X_prime->Leader);
+ ++n;
}
if (node->max_user_input > max_input)
max_input = node->max_user_input;
}
+ X_prime->n_leader = n;
X_prime->max_user_inputs = max_input;
X->n_leader -= X_prime->n_leader;
/* for now, copy the type info tag, it will be adjusted in split_by(). */
X_prime->type_is_T_or_C = X->type_is_T_or_C;
- /* do the Follower -> Leader transition for nodes that loose congruent inputs */
+ /*
+ * Even if a follower was not checked by both sides, it might have
+ * 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) {
- /* we reach a follower from both sides, this will split congruent
- * inputs and make it a leader. */
- DB((dbg, LEVEL_2, "%+F make the follower -> leader transition\n", node->node));
- node->is_follower = 0;
- move_edges_to_leader(node);
- list_del(&node->node_list);
- list_add(&node->node_list, &X_prime->Leader);
- ++X_prime->n_leader;
+ follower_to_leader(node);
+ transitions = 1;
}
}
+
check_partition(X);
check_partition(X_prime);
/* 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);
return X_prime;
} /* split */
-#endif /* NO_FOLLOWER */
/**
* Returns non-zero if the i'th input of a Phi node is live.
if (idx == -1) {
/* leader edges start AFTER follower edges */
- x->next_edge = 1 + x->n_followers;
+ x->next_edge = x->n_followers + 1;
}
num_edges = get_irn_n_outs(x->node);
/* for all edges in x.L.def_use_{idx} */
while (x->next_edge <= num_edges) {
- ir_def_use_edge *edge = &x->node->out[x->next_edge];
- ir_node *succ;
+ const ir_def_use_edge *edge = &x->node->out[x->next_edge];
+ ir_node *succ;
/* check if we have necessary edges */
if (edge->pos > idx)
continue;
y = get_irn_node(succ);
+ assert(get_irn_n(succ, idx) == x->node);
/* ignore block edges touching followers */
if (idx == -1 && y->is_follower)
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);
}
Z->touched = NULL;
Z->n_touched = 0;
- if (n_touched > 0 && Z->n_leader != n_touched) {
+ 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);
}
}
} /* cause_splits */
* 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 */
/**
}
} /* 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.
*
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;
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;
* 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.
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.
*/
static node_t *identity_Mux(node_t *node) {
ir_node *mux = node->node;
- node_t *sel = get_irn_node(get_Mux_sel(mux));
node_t *t = get_irn_node(get_Mux_true(mux));
node_t *f = get_irn_node(get_Mux_false(mux));
+ /*node_t *sel; */
if (t->part == f->part)
return t;
+ /* for now, the 1-input identity is not supported */
+#if 0
+ sel = get_irn_node(get_Mux_sel(mux));
+
/* Mux sel input is mode_b, so it is always a tarval */
if (sel->type.tv == tarval_b_true)
return t;
if (sel->type.tv == tarval_b_false)
return f;
+#endif
return node;
} /* identity_Mux */
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:
while (! list_empty(&X->cprop)) {
/* remove the first Node x from X.cprop */
x = list_entry(X->cprop.next, node_t, cprop_list);
- assert(x->part == X);
+ //assert(x->part == X);
list_del(&x->cprop_list);
x->on_cprop = 0;
if (x->is_follower && identity(x) == x) {
- /* x will make the follower -> leader transition */
- DB((dbg, LEVEL_2, "%+F make the follower -> leader transition\n", x->node));
-
+ /* check the opcode first */
if (oldopcode == NULL) {
oldopcode = lambda_opcode(get_first_node(X), env);
}
}
}
- /* move x from X.Follower to X.Leader */
- list_del(&x->node_list);
- list_add_tail(&x->node_list, &X->Leader);
- x->is_follower = 0;
- X->n_leader++;
-
- /* Make all inputs to x from inside X no longer be F.def_use edges */
- move_edges_to_leader(x);
+ /* x will make the follower -> leader transition */
+ follower_to_leader(x);
}
/* compute a new type for x */
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;
}
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 */
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));
return 1;
}
return 0;
-}
+} /* can_exchange */
/**
* Block Post-Walker, apply the analysis results on control flow by
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 :-) */
- return;
- }
- if (node->type.tv == tarval_unreachable) {
- /* mark dead blocks */
- set_Block_dead(block);
+ 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;
}
- 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;
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)
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 {
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);
}
}
- 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 {
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)) {
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;
}
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;
}
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;
}
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;
}
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)
+ in[j++] = ka;
}
if (j != n) {
set_End_keepalives(end, j, in);
SET(Phi);
SET(Add);
SET(Sub);
+ SET(Eor);
SET(SymConst);
SET(Cmp);
SET(Proj);
} /* 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) {
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);
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;
} 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);
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);
projects / libfirm / blobdiff