* @author Michael Beck
* @version $Id$
*
- * Note that the current implementation lack the leaders/followers
- * support.
- *
* 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 "irop.h"
#include "irouts.h"
#include "irgmod.h"
+#include "iropt_dbg.h"
#include "debug.h"
#include "error.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
typedef struct node_t node_t;
typedef struct partition_t partition_t;
struct opcode_key_t {
ir_opcode 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 */
list_head cprop_list; /**< Double-linked partition.cprop list. */
partition_t *part; /**< points to the partition this node belongs to */
node_t *next; /**< Next node on local list (partition.touched, fallen). */
+ node_t *race_next; /**< Next node on race list. */
lattice_elem_t type; /**< The associated lattice element "type". */
int max_user_input; /**< Maximum input number of Def-Use edges. */
int next_edge; /**< Index of the next Def-Use edge to use. */
- int n_followers; /**< Number of followers in the outs set. */
+ int n_followers; /**< Number of Follower in the outs set. */
unsigned on_touched:1; /**< Set, if this node is on the partition.touched set. */
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 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. */
};
/**
* A partition containing congruent nodes.
*/
struct partition_t {
- list_head leaders; /**< The head of partition leader node list. */
- list_head followers; /**< The head of partition followers node list. */
+ list_head Leader; /**< The head of partition Leader node list. */
+ list_head Follower; /**< The head of partition Follower node list. */
list_head cprop; /**< The head of partition.cprop list. */
partition_t *wl_next; /**< Next entry in the work list if any. */
partition_t *touched_next; /**< Points to the next partition in the touched set. */
partition_t *cprop_next; /**< Points to the next partition in the cprop list. */
partition_t *split_next; /**< Points to the next partition in the list that must be split by split_by(). */
node_t *touched; /**< The partition.touched set of this partition. */
- unsigned n_leaders; /**< Number of entries in this partition.leaders. */
+ unsigned n_leader; /**< Number of entries in this partition.Leader. */
unsigned n_touched; /**< Number of entries in the partition.touched. */
int max_user_inputs; /**< Maximum number of user inputs of all entries. */
unsigned on_worklist:1; /**< Set, if this partition is in the work list. */
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);
+
+#ifdef CHECK_PARTITIONS
+/**
+ * Check a partition.
+ */
+static void check_partition(const partition_t *T) {
+ node_t *node;
+ unsigned n = 0;
+
+ 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;
+ }
+ assert(n == T->n_leader);
+
+ 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 lattice_elem_t get_partition_type(const partition_t *X);
DB((dbg, LEVEL_2, "%s part%u%s (%u, %+F) {\n ",
msg, part->nr, part->type_is_T_or_C ? "*" : "",
- part->n_leaders, type));
- list_for_each_entry(node_t, node, &part->leaders, node_list) {
+ part->n_leader, type));
+ list_for_each_entry(node_t, node, &part->Leader, node_list) {
DB((dbg, LEVEL_2, "%s%+F", first ? "" : ", ", node->node));
first = 0;
}
- if (! list_empty(&part->followers)) {
- DB((dbg, LEVEL_2, "\n---\n"));
+ if (! list_empty(&part->Follower)) {
+ DB((dbg, LEVEL_2, "\n---\n "));
first = 1;
- list_for_each_entry(node_t, node, &part->followers, node_list) {
+ list_for_each_entry(node_t, node, &part->Follower, node_list) {
DB((dbg, LEVEL_2, "%s%+F", first ? "" : ", ", node->node));
first = 0;
}
DB((dbg, LEVEL_2, "\n}\n"));
} /* dump_partition */
+/**
+ * Dumps a list.
+ */
+static void do_dump_list(const char *msg, const node_t *node, int ofs) {
+ const node_t *p;
+ int first = 1;
+
+#define GET_LINK(p, ofs) *((const node_t **)((char *)(p) + (ofs)))
+
+ DB((dbg, LEVEL_3, "%s = {\n ", msg));
+ for (p = node; p != NULL; p = GET_LINK(p, ofs)) {
+ DB((dbg, LEVEL_3, "%s%+F", first ? "" : ", ", p->node));
+ first = 0;
+ }
+ DB((dbg, LEVEL_3, "\n}\n"));
+
+#undef GET_LINK
+}
+
+/**
+ * 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));
+}
+
+/**
+ * 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 all partitions.
*/
#else
#define dump_partition(msg, part)
+#define dump_race_list(msg, list)
+#define dump_list(msg, list)
#define dump_all_partitions(env)
#endif
(void) size;
return o1->code != o2->code || o1->mode != o2->mode ||
+ o1->arity != o2->arity ||
o1->u.proj != o2->u.proj || o1->u.ent != o2->u.ent;
} /* cmp_opcode */
X->wl_next = env->worklist;
X->on_worklist = 1;
env->worklist = X;
-}
+} /* add_to_worklist */
/**
* Create a new empty partition.
static INLINE partition_t *new_partition(environment_t *env) {
partition_t *part = obstack_alloc(&env->obst, sizeof(*part));
- INIT_LIST_HEAD(&part->leaders);
- INIT_LIST_HEAD(&part->followers);
+ INIT_LIST_HEAD(&part->Leader);
+ INIT_LIST_HEAD(&part->Follower);
INIT_LIST_HEAD(&part->cprop);
part->wl_next = NULL;
part->touched_next = NULL;
part->cprop_next = NULL;
part->split_next = NULL;
part->touched = NULL;
- part->n_leaders = 0;
+ part->n_leader = 0;
part->n_touched = 0;
part->max_user_inputs = 0;
part->on_worklist = 0;
* Get the first node from a partition.
*/
static INLINE node_t *get_first_node(const partition_t *X) {
- return list_entry(X->leaders.next, node_t, node_list);
-}
+ return list_entry(X->Leader.next, node_t, node_list);
+} /* get_first_node */
/**
* Return the type of a partition (assuming partition is non-empty and
*/
static node_t *create_partition_node(ir_node *irn, partition_t *part, environment_t *env) {
/* create a partition node and place it in the partition */
- node_t *node = obstack_alloc(&env->obst, sizeof(*node));
+ node_t *node = obstack_alloc(&env->obst, sizeof(*node));
INIT_LIST_HEAD(&node->node_list);
INIT_LIST_HEAD(&node->cprop_list);
node->node = irn;
node->part = part;
node->next = NULL;
+ node->race_next = NULL;
node->type.tv = tarval_top;
node->max_user_input = 0;
node->next_edge = 0;
node->on_cprop = 0;
node->on_fallen = 0;
node->is_follower = 0;
+ node->by_all_const = 0;
+ node->flagged = 0;
set_irn_node(irn, node);
- list_add_tail(&node->node_list, &part->leaders);
- ++part->n_leaders;
+ list_add_tail(&node->node_list, &part->Leader);
+ ++part->n_leader;
return node;
} /* create_partition_node */
if (is_Block(irn)) {
set_Block_phis(irn, NULL);
}
-}
+} /* init_block_phis */
/**
* Post-Walker, initialize all Nodes' type to U or top and place
if (is_Phi(irn)) {
add_Block_phi(get_nodes_block(irn), irn);
- }
-} /* create_initial_partitions */
+ } 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;
-/**
- * Add a partition to the touched set if not already there.
- *
- * @param part the partition
- * @param env the environment
- */
-static INLINE void add_to_touched(partition_t *part, environment_t *env) {
- if (part->on_touched == 0) {
- part->touched_next = env->touched;
- env->touched = part;
- part->on_touched = 1;
}
-} /* add_to_touched */
+} /* create_initial_partitions */
/**
- * Add a node to the entry.partition.touched set if not already there.
+ * Add a node to the entry.partition.touched set and
+ * node->partition to the touched set if not already there.
*
- * @param y a node
+ * @param y a node
+ * @param env the environment
*/
-static INLINE void add_to_partition_touched(node_t *y) {
+static INLINE void add_to_touched(node_t *y, environment_t *env) {
if (y->on_touched == 0) {
partition_t *part = y->part;
part->touched = y;
y->on_touched = 1;
++part->n_touched;
+
+ if (part->on_touched == 0) {
+ part->touched_next = env->touched;
+ env->touched = part;
+ part->on_touched = 1;
+ }
+
+ check_list(part->touched, part);
}
-} /* add_to_partition_touched */
+} /* add_to_touched */
+
+/**
+ * Place a node on the cprop list.
+ *
+ * @param y the node
+ * @param env the environment
+ */
+static void add_to_cprop(node_t *y, environment_t *env) {
+ /* Add y to y.partition.cprop. */
+ if (y->on_cprop == 0) {
+ partition_t *Y = y->part;
+
+ list_add_tail(&y->cprop_list, &Y->cprop);
+ y->on_cprop = 1;
+
+ DB((dbg, LEVEL_3, "Add %+F to part%u.cprop\n", y->node, Y->nr));
+
+ /* place its partition on the cprop list */
+ if (Y->on_cprop == 0) {
+ Y->cprop_next = env->cprop;
+ env->cprop = Y;
+ Y->on_cprop = 1;
+ }
+ }
+ if (get_irn_mode(y->node) == mode_T) {
+ /* mode_T nodes always produce tarval_bottom, so we must explicitly
+ add it's Proj's to get constant evaluation to work */
+ int i;
+
+ for (i = get_irn_n_outs(y->node) - 1; i >= 0; --i) {
+ node_t *proj = get_irn_node(get_irn_out(y->node, i));
+
+ add_to_cprop(proj, env);
+ }
+ } else if (is_Block(y->node)) {
+ /* Due to the way we handle Phi's, we must place all Phis of a block on the list
+ * if someone placed the block. The Block is only placed if the reachability
+ * changes, and this must be re-evaluated in compute_Phi(). */
+ ir_node *phi;
+ for (phi = get_Block_phis(y->node); phi != NULL; phi = get_Phi_next(phi)) {
+ node_t *p = get_irn_node(phi);
+ add_to_cprop(p, env);
+ }
+ }
+} /* add_to_cprop */
/**
* Update the worklist: If Z is on worklist then add Z' to worklist.
* @param env the environment
*/
static void update_worklist(partition_t *Z, partition_t *Z_prime, environment_t *env) {
- if (Z->on_worklist || Z_prime->n_leaders < Z->n_leaders) {
+ if (Z->on_worklist || Z_prime->n_leader < Z->n_leader) {
add_to_worklist(Z_prime, env);
} else {
add_to_worklist(Z, env);
} /* update_worklist */
/**
- * Split a partition by a local list.
+ * Make all inputs to x no longer be F.def_use edges.
+ *
+ * @param x the node
+ */
+static void move_edges_to_leader(node_t *x) {
+ ir_node *irn = x->node;
+ int i, j, k;
+
+ for (i = get_irn_arity(irn) - 1; i >= 0; --i) {
+ node_t *pred = get_irn_node(get_irn_n(irn, i));
+ ir_node *p;
+ int n;
+
+ p = pred->node;
+ n = get_irn_n_outs(p);
+ for (j = 1; j <= pred->n_followers; ++j) {
+ if (p->out[j].pos == i && p->out[j].use == irn) {
+ /* found a follower edge to x, move it to the Leader */
+ ir_def_use_edge edge = p->out[j];
+
+ /* remove this edge from the Follower set */
+ p->out[j] = p->out[pred->n_followers];
+ --pred->n_followers;
+
+ /* sort it into the leader set */
+ for (k = pred->n_followers + 2; k <= n; ++k) {
+ if (p->out[k].pos >= edge.pos)
+ break;
+ p->out[k - 1] = p->out[k];
+ }
+ /* place the new edge here */
+ p->out[k - 1] = edge;
+
+ /* edge found and moved */
+ break;
+ }
+ }
+ }
+} /* move_edges_to_leader */
+
+/**
+ * Split a partition that has NO followers by a local list.
*
- * @param Z the Z partition to split
+ * @param Z partition to split
* @param g a (non-empty) node list
* @param env the environment
*
* @return a new partition containing the nodes of g
*/
-static partition_t *split(partition_t *Z, node_t *g, environment_t *env) {
+static partition_t *split_no_followers(partition_t *Z, node_t *g, environment_t *env) {
partition_t *Z_prime;
node_t *node;
unsigned n = 0;
- int max_input, max_arity, arity;
+ int max_input;
dump_partition("Splitting ", Z);
+ dump_list("by list ", g);
assert(g != NULL);
/* Remove g from Z. */
for (node = g; node != NULL; node = node->next) {
+ assert(node->part == Z);
list_del(&node->node_list);
++n;
}
- assert(n < Z->n_leaders);
- Z->n_leaders -= n;
+ assert(n < Z->n_leader);
+ Z->n_leader -= n;
- /* Move g to a new partition, Z\92. */
+ /* Move g to a new partition, Z'. */
Z_prime = new_partition(env);
- max_arity = max_input = 0;
+ max_input = 0;
for (node = g; node != NULL; node = node->next) {
- list_add(&node->node_list, &Z_prime->leaders);
+ list_add_tail(&node->node_list, &Z_prime->Leader);
node->part = Z_prime;
- arity = get_irn_arity(node->node);
- if (arity > max_arity)
- max_arity = arity;
if (node->max_user_input > max_input)
max_input = node->max_user_input;
}
Z_prime->max_user_inputs = max_input;
- Z_prime->n_leaders = n;
+ Z_prime->n_leader = n;
+
+ check_partition(Z);
+ check_partition(Z_prime);
- /* for now, copy the type info tag. it will be adjusted
- in split_by(). */
+ /* for now, copy the type info tag, it will be adjusted in split_by(). */
Z_prime->type_is_T_or_C = Z->type_is_T_or_C;
update_worklist(Z, Z_prime, env);
dump_partition("Now ", Z);
dump_partition("Created new ", Z_prime);
return Z_prime;
+} /* split_no_followers */
+
+/**
+ * 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);
+
+ 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.
+ */
+typedef struct step_env {
+ node_t *initial; /**< The initial node list. */
+ node_t *unwalked; /**< The unwalked node list. */
+ node_t *walked; /**< The walked node list. */
+ int index; /**< Next index of Follower use_def edge. */
+ 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.
+ */
+static int step(step_env *env) {
+ node_t *n;
+
+ if (env->initial != NULL) {
+ /* Move node from initial to unwalked */
+ n = env->initial;
+ env->initial = n->race_next;
+
+ n->race_next = env->unwalked;
+ env->unwalked = n;
+
+ return 0;
+ }
+
+ while (env->unwalked != NULL) {
+ /* 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(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->flagged & env->side) == 0) {
+ m->flagged |= env->side;
+
+ 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 */
+ env->unwalked = n->race_next;
+ n->race_next = env->walked;
+ env->walked = n;
+ env->index = 0;
+ }
+ return 1;
+} /* step */
+
+/**
+ * Clear the flags from a list and check for
+ * nodes that where touched from both sides.
+ *
+ * @param list the list
+ */
+static int clear_flags(node_t *list) {
+ int res = 0;
+ node_t *n;
+
+ 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 */
+
+/**
+ * Split a partition by a local list using the race.
+ *
+ * @param pX pointer to the partition to split, might be changed!
+ * @param gg a (non-empty) node list
+ * @param env the environment
+ *
+ * @return a new partition containing the nodes of gg
+ */
+static partition_t *split(partition_t **pX, node_t *gg, environment_t *env) {
+ partition_t *X = *pX;
+ partition_t *X_prime;
+ list_head tmp;
+ step_env env1, env2, *winner;
+ node_t *g, *h, *node, *t;
+ int max_input, transitions;
+ unsigned n;
+ DEBUG_ONLY(static int run = 0;)
+
+ DB((dbg, LEVEL_2, "Run %d ", run++));
+ if (list_empty(&X->Follower)) {
+ /* if the partition has NO follower, we can use the fast
+ splitting algorithm. */
+ return split_no_followers(X, gg, env);
+ }
+ /* else do the race */
+
+ dump_partition("Splitting ", X);
+ dump_list("by list ", gg);
+
+ INIT_LIST_HEAD(&tmp);
+
+ /* Remove gg from X.Leader and put into g */
+ g = NULL;
+ for (node = gg; node != NULL; node = node->next) {
+ assert(node->part == X);
+ assert(node->is_follower == 0);
+
+ list_del(&node->node_list);
+ list_add_tail(&node->node_list, &tmp);
+ node->race_next = g;
+ g = node;
+ }
+ /* produce h */
+ h = NULL;
+ list_for_each_entry(node_t, node, &X->Leader, node_list) {
+ node->race_next = h;
+ h = node;
+ }
+ /* restore X.Leader */
+ list_splice(&tmp, &X->Leader);
+
+ env1.initial = g;
+ env1.unwalked = NULL;
+ env1.walked = NULL;
+ env1.index = 0;
+ env1.side = 1;
+
+ env2.initial = h;
+ env2.unwalked = NULL;
+ env2.walked = NULL;
+ env2.index = 0;
+ env2.side = 2;
+
+ for (;;) {
+ if (step(&env1)) {
+ winner = &env1;
+ break;
+ }
+ if (step(&env2)) {
+ winner = &env2;
+ break;
+ }
+ }
+ assert(winner->initial == NULL);
+ assert(winner->unwalked == NULL);
+
+ /* clear flags from walked/unwalked */
+ 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);
+ 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_tail(&node->node_list, &X_prime->Follower);
+ } else {
+ 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;
+
+ /*
+ * 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) {
+ 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);
+
+ /* we have to ensure that the partition containing g is returned */
+ if (winner == &env2) {
+ *pX = X_prime;
+ return X;
+ }
+
+ return X_prime;
} /* split */
/**
return 0;
} /* is_constant_type */
-/**
- * Place a node on the cprop list.
- *
- * @param y the node
- * @param env the environment
- */
-static void add_node_to_cprop(node_t *y, environment_t *env) {
- /* Add y to y.partition.cprop. */
- if (y->on_cprop == 0) {
- partition_t *Y = y->part;
-
- list_add_tail(&y->cprop_list, &Y->cprop);
- y->on_cprop = 1;
-
- DB((dbg, LEVEL_3, "Add %+F to part%u.cprop\n", y->node, Y->nr));
-
- /* place its partition on the cprop list */
- if (Y->on_cprop == 0) {
- Y->cprop_next = env->cprop;
- env->cprop = Y;
- Y->on_cprop = 1;
- }
- }
- if (get_irn_mode(y->node) == mode_T) {
- /* mode_T nodes always produce tarval_bottom, so we must explicitly
- add it's Proj's to get constant evaluation to work */
- int i;
-
- for (i = get_irn_n_outs(y->node) - 1; i >= 0; --i) {
- node_t *proj = get_irn_node(get_irn_out(y->node, i));
-
- add_node_to_cprop(proj, env);
- }
- }
-
- if (is_Block(y->node)) {
- /* Due to the way we handle Phi's, we must place all Phis of a block on the list
- * if someone placed the block. The Block is only placed if the reachability
- * changes, and this must be re-evaluated in compute_Phi(). */
- ir_node *phi;
- for (phi = get_Block_phis(y->node); phi != NULL; phi = get_Phi_next(phi)) {
- node_t *p = get_irn_node(phi);
- add_node_to_cprop(p, env);
- }
- }
-} /* add_node_to_cprop */
-
/**
* Check whether a type is neither Top or a constant.
* Note: U is handled like Top here, R is a constant.
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)
+ continue;
+
if (is_constant_type(y->type)) {
ir_opcode code = get_irn_opcode(succ);
- if (code == iro_Sub || code == iro_Cmp)
- add_node_to_cprop(y, env);
+ if (code == iro_Sub || code == iro_Eor || code == iro_Cmp)
+ add_to_cprop(y, env);
}
/* Partitions of constants should not be split simply because their Nodes have unequal
- functions or incongruent inputs. */
+ functions or incongruent inputs. */
if (type_is_neither_top_nor_const(y->type) &&
(! is_Phi(y->node) || is_live_input(y->node, idx))) {
- partition_t *Y = y->part;
- add_to_touched(Y, env);
- add_to_partition_touched(y);
+ add_to_touched(y, env);
}
}
}
-}
+} /* collect_touched */
+
/**
* Split the partitions if caused by the first entry on the worklist.
*
* @param env the environment
*/
static void cause_splits(environment_t *env) {
- partition_t *X, *Z;
- node_t *e;
+ partition_t *X, *Z, *N;
int idx;
/* remove the first partition from the worklist */
/* empty the touched set: already done, just clear the list */
env->touched = NULL;
- collect_touched(&X->leaders, idx, env);
- collect_touched(&X->followers, idx, env);
+ collect_touched(&X->Leader, idx, env);
+ collect_touched(&X->Follower, idx, 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;
- for (Z = env->touched; Z != NULL; Z = Z->touched_next) {
/* remove it from the touched set */
Z->on_touched = 0;
- if (Z->n_leaders != Z->n_touched) {
- DB((dbg, LEVEL_2, "Split part%d by touched\n", Z->nr));
- split(Z, Z->touched, env);
- }
/* Empty local Z.touched. */
- for (e = Z->touched; e != NULL; e = e->next) {
+ 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);
}
}
} /* cause_splits */
/* Let map be an empty mapping from the range of What to (local) list of Nodes. */
listmap_init(&map);
- list_for_each_entry(node_t, x, &X->leaders, node_list) {
+ list_for_each_entry(node_t, x, &X->Leader, node_list) {
void *id = What(x, env);
listmap_entry_t *entry;
/* Add SPLIT( X, S ) to P. */
DB((dbg, LEVEL_2, "Split part%d by what\n", X->nr));
- R = split(X, S, env);
+ R = split(&X, S, env);
R->split_next = *P;
*P = R;
}
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;
partition_t *I, *P = NULL;
int input;
- if (X->n_leaders == 1) {
+ dump_partition("split_by", X);
+
+ if (X->n_leader == 1) {
/* we have only one leader, no need to split, just check it's type */
node_t *x = get_first_node(X);
X->type_is_T_or_C = x->type.tv == tarval_top || is_con(x->type);
partition_t *Y = P;
P = P->split_next;
- if (Y->n_leaders > 1) {
- lattice_elem_t type = get_partition_type(Y);
-
+ if (Y->n_leader > 1) {
/* we do not want split the TOP or constant partitions */
- if (type.tv != tarval_top && !is_con(type)) {
+ 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));
partition_t *Z = Q;
Q = Q->split_next;
- if (Z->n_leaders > 1) {
+ if (Z->n_leader > 1) {
const node_t *first = get_first_node(Z);
int arity = get_irn_arity(first->node);
partition_t *R, *S;
partition_t *Z_prime = R;
R = R->split_next;
- if (Z_prime->n_leaders > 1) {
+ 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);
* 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 */
/**
node_t *r = get_irn_node(get_Sub_right(sub));
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 {
node->type.tv = tarval_bottom;
}
+ node->by_all_const = 1;
} else if (r->part == l->part &&
(!mode_is_float(get_irn_mode(l->node)))) {
- if (node->type.tv == tarval_top) {
- /*
- * BEWARE: a - a is NOT always 0 for floating Point values, as
- * NaN op NaN = NaN, so we must check this here.
- */
- ir_mode *mode = get_irn_mode(sub);
- node->type.tv = get_mode_null(mode);
+ /*
+ * BEWARE: a - a is NOT always 0 for floating Point values, as
+ * NaN op NaN = NaN, so we must check this here.
+ */
+ ir_mode *mode = get_irn_mode(sub);
+ 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_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_Sub */
+} /* 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;
lattice_elem_t a = l->type;
lattice_elem_t b = r->type;
pn_Cmp pnc = get_Proj_proj(proj);
+ 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;
} else if (r->part == l->part &&
(!mode_is_float(get_irn_mode(l->node)) || pnc == pn_Cmp_Lt || pnc == pn_Cmp_Gt)) {
- if (node->type.tv == tarval_top) {
- /*
- * BEWARE: a == a is NOT always True for floating Point values, as
- * NaN != NaN is defined, so we must check this here.
- */
- node->type.tv = new_tarval_from_long(pnc & pn_Cmp_Eq, mode_b);
- } else {
- node->type.tv = tarval_bottom;
- }
+ /*
+ * BEWARE: a == a is NOT always True for floating Point values, as
+ * 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.
+ 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;
}
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_Mul:
+ return identity_Mul(node);
case iro_Add:
- return identity_Add(node);
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:
return identity_Sub(node);
- case iro_And:
- return identity_Add(node);
case iro_Confirm:
return identity_Confirm(node);
case iro_Mux:
} /* identity */
/**
- * Node follower is a (new) follower of leader, segregate leaders
+ * Node follower is a (new) follower of leader, segregate Leader
* out edges.
*/
static void segregate_def_use_chain_1(const ir_node *follower, node_t *leader) {
- ir_node *l = leader->node;
+ ir_node *l = leader->node;
int j, i, n = get_irn_n_outs(l);
+ DB((dbg, LEVEL_2, "%+F is a follower of %+F\n", follower, leader->node));
/* The leader edges must remain sorted, but follower edges can
be unsorted. */
for (i = leader->n_followers + 1; i <= n; ++i) {
l->out[j + 1] = l->out[j];
++leader->n_followers;
l->out[leader->n_followers] = t;
-
- /* note: a node might be a n-fold follower, for instance
- * if x = max(a,a), so no break here. */
+ break;
}
}
} /* segregate_def_use_chain_1 */
/**
- * Node follower is a (new) follower of leader, segregate leaders
+ * 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.
+ *
+ * @param follower the follower IR node
*/
-static void segregate_def_use_chain(const ir_node *follower, node_t *leader) {
- ir_op *op = get_irn_op(follower);
-
- if (op == op_Phi || op == op_Mux || op == op_Max || op == op_Min) {
- /* n-Congruent Input Identity */
- int i;
+static void segregate_def_use_chain(const ir_node *follower) {
+ int i;
- DB((dbg, LEVEL_2, "n-Congruent follower %+F\n", follower));
- for (i = get_irn_arity(follower) - 1; i >= 0; --i) {
- node_t *pred = get_irn_node(get_irn_n(follower, i));
+ for (i = get_irn_arity(follower) - 1; i >= 0; --i) {
+ node_t *pred = get_irn_node(get_irn_n(follower, i));
- if (pred->part == leader->part)
- segregate_def_use_chain_1(follower, pred);
- }
- } else {
- /* 1-Congruent Input Identity */
- segregate_def_use_chain_1(follower, leader);
+ segregate_def_use_chain_1(follower, pred);
}
} /* segregate_def_use_chain */
int i;
while (env->cprop != NULL) {
+ void *oldopcode = NULL;
+
/* remove the first partition X from cprop */
X = env->cprop;
X->on_cprop = 0;
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);
list_del(&x->cprop_list);
x->on_cprop = 0;
+ if (x->is_follower && identity(x) == x) {
+ /* check the opcode first */
+ if (oldopcode == NULL) {
+ oldopcode = lambda_opcode(get_first_node(X), env);
+ }
+ if (oldopcode != lambda_opcode(x, env)) {
+ if (x->on_fallen == 0) {
+ /* different opcode -> x falls out of this partition */
+ x->next = fallen;
+ x->on_fallen = 1;
+ fallen = x;
+ ++n_fallen;
+ DB((dbg, LEVEL_2, "Add node %+F to fallen\n", x->node));
+ }
+ }
+
+ /* x will make the follower -> leader transition */
+ follower_to_leader(x);
+ }
+
/* compute a new type for x */
old_type = x->type;
DB((dbg, LEVEL_3, "computing type of %+F\n", x->node));
node_t *y = get_irn_node(succ);
/* Add y to y.partition.cprop. */
- add_node_to_cprop(y, env);
+ add_to_cprop(y, env);
}
}
}
- if (n_fallen > 0 && n_fallen != X->n_leaders) {
+ 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);
+ 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;
}
- /* remove the nodes from the fallen list */
+ /* remove the flags from the fallen list */
for (x = fallen; x != NULL; x = x->next)
x->on_fallen = 0;
- if (0 && old_type_was_T_or_C) {
+ if (old_type_was_T_or_C) {
node_t *y, *tmp;
- list_for_each_entry_safe(node_t, y, tmp, &Y->leaders, node_list) {
- node_t *eq_node = y;
- if (! is_con(y->type))
- eq_node = identity(y);
+ if (Y->on_worklist == 0)
+ add_to_worklist(Y, env);
- if (eq_node != y) {
- /* move to followers */
- list_del(&y->node_list);
- --Y->n_leaders;
+ /* 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)) {
+ node_t *eq_node = identity(y);
- list_add_tail(&y->node_list, &Y->followers);
- segregate_def_use_chain(y->node, eq_node);
+ if (eq_node != y && eq_node->part == y->part) {
+ DB((dbg, LEVEL_2, "Node %+F is a follower of %+F\n", y->node, eq_node->node));
+ /* move to Follower */
+ y->is_follower = 1;
+ list_del(&y->node_list);
+ list_add_tail(&y->node_list, &Y->Follower);
+ --Y->n_leader;
+
+ segregate_def_use_chain(y->node);
+ }
}
}
}
static ir_node *get_leader(node_t *node) {
partition_t *part = node->part;
- if (part->n_leaders > 1) {
- DB((dbg, LEVEL_2, "Found congruence class for %+F\n", node->node));
+ if (part->n_leader > 1 || 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 get_first_node(part)->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 :-) */
+ 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;
}
- if (node->type.tv == tarval_unreachable) {
- /* mark dead blocks */
- set_Block_dead(block);
- 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\n", phi, 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;
}
if (is_tarval(node->type.tv) && tarval_is_constant(node->type.tv)) {
tarval *tv = node->type.tv;
- if (! is_Const(irn)) {
+ /*
+ * Beware: never replace mode_T nodes by constants. Currently we must mark
+ * mode_T nodes with constants, but do NOT replace them.
+ */
+ if (! is_Const(irn) && get_irn_mode(irn) != mode_T) {
/* can be replaced by a constant */
ir_node *c = new_r_Const(current_ir_graph, block->node, get_tarval_mode(tv), tv);
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;
}
+ } else if (is_Confirm(irn)) {
+ /* Confirms are always follower, but do not kill them here */
} else {
ir_node *leader = get_leader(node);
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;
}
}
} /* apply_result */
+/**
+ * Fix the keep-alives by deleting unreachable ones.
+ */
+static void apply_end(ir_node *end, environment_t *env) {
+ int i, j, n = get_End_n_keepalives(end);
+ ir_node **in;
+
+ if (n > 0)
+ NEW_ARR_A(ir_node *, in, n);
+
+ /* 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);
+
+ if (! is_Block(ka))
+ node = get_irn_node(get_nodes_block(ka));
+
+ if (node->type.tv != tarval_unreachable)
+ in[j++] = ka;
+ }
+ if (j != n) {
+ set_End_keepalives(end, j, in);
+ env->modified = 1;
+ }
+} /* apply_end */
+
#define SET(code) op_##code->ops.generic = (op_func)compute_##code
/**
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) {
/* register a debug mask */
FIRM_DBG_REGISTER(dbg, "firm.opt.combo");
- firm_dbg_set_mask(dbg, SET_LEVEL_3);
+ //firm_dbg_set_mask(dbg, SET_LEVEL_3);
DB((dbg, LEVEL_1, "Doing COMBO for %+F\n", 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;
Place the START Node on its local worklist. */
initial_bl = get_irg_start_block(irg);
start = get_irn_node(initial_bl);
- add_node_to_cprop(start, &env);
+ add_to_cprop(start, &env);
do {
propagate(&env);
} 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);
/* apply the result */
irg_block_walk_graph(irg, NULL, apply_cf, &env);
irg_walk_graph(irg, NULL, apply_result, &env);
+ apply_end(get_irg_end(irg), &env);
if (env.modified) {
/* control flow might changed */
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);