X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fcombo.c;h=19d0b907546bc2de9dd9e4a495dfc6990aab47e2;hb=83d1882a9e3dd5f74aa87c6fdb534516c75cb857;hp=196364c23c6da7f1d0fcd4603fb92fba42c9e943;hpb=19e61a7a308980f38359b1bae6d01e4b24e8a7a8;p=libfirm diff --git a/ir/opt/combo.c b/ir/opt/combo.c index 196364c23..19d0b9075 100644 --- a/ir/opt/combo.c +++ b/ir/opt/combo.c @@ -23,13 +23,42 @@ * @author Michael Beck * @version $Id$ * + * This is a slightly enhanced version of Cliff Clicks combo algorithm + * - support for commutative nodes is added, Add(a,b) and Add(b,a) ARE congruent + * - supports all Firm direct (by a data edge) identities except Mux + * (Mux can be a 2-input or 1-input identity, only 2-input is implemented yet) + * - supports Confirm nodes (handle them like Copies but do NOT remove them) + * - let Cmp nodes calculate Top like all othe data nodes: this would let + * Mux nodes to calculate Unknown instead of taking the true result + * - let Cond(Top) always select FALSE/default: This is tricky. Nodes are only reavaluated + * IFF the predecessor changed its type. Because nodes are initialized with Top + * this never happens, let all Proj(Cond) be unreachable. + * We avoid this condition by the same way we work around Phi: whenever a Block + * node is placed on the list, place its Cond nodes (and because they are Tuple + * all its Proj-nodes either on the cprop list) + * Especially, this changes the meaning of Click's example: + * + * int main() { + * int x; + * + * if (x == 2) + * printf("x == 2\n"); + * if (x == 3) + * printf("x == 3\n"); + * } + * + * Would print: + * x == 2 + * x == 3 + * + * using Click's version while is silent with our. + * - support for global congruences is implemented but not tested yet + * * Note further that we use the terminology from Click's work here, which is different * in some cases from Firm terminology. Especially, Click's type is a * Firm tarval/entity, nevertheless we call it type here for "maximum compatibility". */ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif +#include "config.h" #include @@ -48,7 +77,9 @@ #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" @@ -57,9 +88,14 @@ #include "irdump.h" /* define this to check that all type translations are monotone */ -#define VERIFY_MONOTONE +#undef VERIFY_MONOTONE -#undef NO_FOLLOWER +/* define this to check the consistency of partitions */ +#define CHECK_PARTITIONS + + +/* allow optimization of non-strict programs */ +#define WITH_UNKNOWN typedef struct node_t node_t; typedef struct partition_t partition_t; @@ -75,6 +111,7 @@ typedef void (*compute_func)(node_t *node); 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 */ @@ -123,8 +160,9 @@ struct node_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. */ + node_t *cond; /**< if this is a Block node, points to its Cond if any */ }; /** @@ -162,7 +200,8 @@ typedef struct environment_t { 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 modified; /**< Set, if the graph was modified. */ + char commutative; /**< Set, if commutation nodes should be handled specially. */ #ifdef DEBUG_libfirm partition_t *dbg_list; /**< List of all partitions. */ #endif @@ -182,11 +221,135 @@ typedef void *(*what_func)(const node_t *node, environment_t *env); /** The debug module handle. */ DEBUG_ONLY(static firm_dbg_module_t *dbg;) +/** The what reason. */ +DEBUG_ONLY(static const char *what_reason;) + /** Next partition number. */ DEBUG_ONLY(static unsigned part_nr = 0); +/** 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 */ + +/** + * check that all leader nodes in the partition have the same opcode. + */ +static void check_opcode(const partition_t *Z) { + node_t *node; + opcode_key_t key; + int first = 1; + + list_for_each_entry(node_t, node, &Z->Leader, node_list) { + ir_node *irn = node->node; + + if (first) { + key.code = get_irn_opcode(irn); + key.mode = get_irn_mode(irn); + key.arity = get_irn_arity(irn); + key.u.proj = 0; + key.u.ent = NULL; + + switch (get_irn_opcode(irn)) { + case iro_Proj: + key.u.proj = get_Proj_proj(irn); + break; + case iro_Sel: + key.u.ent = get_Sel_entity(irn); + break; + default: + break; + } + first = 0; + } else { + assert(key.code == get_irn_opcode(irn)); + assert(key.mode == get_irn_mode(irn)); + assert(key.arity == get_irn_arity(irn)); + + switch (get_irn_opcode(irn)) { + case iro_Proj: + assert(key.u.proj == get_Proj_proj(irn)); + break; + case iro_Sel: + assert(key.u.ent == get_Sel_entity(irn)); + break; + default: + break; + } + } + } +} /* check_opcode */ + +static void check_all_partitions(environment_t *env) { +#ifdef DEBUG_libfirm + partition_t *P; + node_t *node; + + for (P = env->dbg_list; P != NULL; P = P->dbg_next) { + check_partition(P); + if (! P->type_is_T_or_C) + check_opcode(P); + list_for_each_entry(node_t, node, &P->Follower, node_list) { + node_t *leader = identity(node); + + assert(leader != node && leader->part == node->part); + } + } +#endif +} + +/** + * 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); +static inline lattice_elem_t get_partition_type(const partition_t *X); /** * Dump partition to output. @@ -231,21 +394,21 @@ static void do_dump_list(const char *msg, const node_t *node, int ofs) { DB((dbg, LEVEL_3, "\n}\n")); #undef GET_LINK -} +} /* do_dump_list */ /** * Dumps a race list. */ static void dump_race_list(const char *msg, const node_t *list) { do_dump_list(msg, list, offsetof(node_t, race_next)); -} +} /* dump_race_list */ /** * Dumps a local list. */ static void dump_list(const char *msg, const node_t *list) { do_dump_list(msg, list, offsetof(node_t, next)); -} +} /* dump_list */ /** * Dump all partitions. @@ -256,13 +419,37 @@ static void dump_all_partitions(const environment_t *env) { DB((dbg, LEVEL_2, "All partitions\n===============\n")); for (P = env->dbg_list; P != NULL; P = P->dbg_next) dump_partition("", P); -} +} /* dump_all_partitions */ + +/** + * Sump a split list. + */ +static void dump_split_list(const partition_t *list) { + const partition_t *p; + + DB((dbg, LEVEL_2, "Split by %s produced = {\n", what_reason)); + for (p = list; p != NULL; p = p->split_next) + DB((dbg, LEVEL_2, "part%u, ", p->nr)); + DB((dbg, LEVEL_2, "\n}\n")); +} /* dump_split_list */ + +/** + * Dump partition and type for a node. + */ +static int dump_partition_hook(FILE *F, ir_node *n, ir_node *local) { + 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; +} /* dump_partition_hook */ #else #define dump_partition(msg, part) #define dump_race_list(msg, list) #define dump_list(msg, list) #define dump_all_partitions(env) +#define dump_split_list(list) #endif #if defined(VERIFY_MONOTONE) && defined (DEBUG_libfirm) @@ -286,7 +473,7 @@ static void verify_type(const lattice_elem_t old_type, const lattice_elem_t new_ return; } panic("verify_type(): wrong translation from %+F to %+F", old_type, new_type); -} +} /* verify_type */ #else #define verify_type(old_type, new_type) #endif @@ -327,7 +514,7 @@ static void listmap_term(listmap_t *map) { * @param map the listmap * @param id the id to search for * - * @return the asociated listmap entry for the given id + * @return the associated listmap entry for the given id */ static listmap_entry_t *listmap_find(listmap_t *map, void *id) { listmap_entry_t key, *entry; @@ -353,7 +540,7 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id) { * @return a hash value for the given opcode map entry */ static unsigned opcode_hash(const opcode_key_t *entry) { - return (entry->mode - (ir_mode *)0) * 9 + entry->code + entry->u.proj * 3 + HASH_PTR(entry->u.ent); + return (entry->mode - (ir_mode *)0) * 9 + entry->code + entry->u.proj * 3 + HASH_PTR(entry->u.ent) + entry->arity; } /* opcode_hash */ /** @@ -365,6 +552,7 @@ static int cmp_opcode(const void *elt, const void *key, size_t size) { (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 */ @@ -399,7 +587,7 @@ static void sort_irn_outs(node_t *node) { * * @return the associated type of this node */ -static INLINE lattice_elem_t get_node_type(const ir_node *irn) { +static inline lattice_elem_t get_node_type(const ir_node *irn) { return get_irn_node(irn)->type; } /* get_node_type */ @@ -410,7 +598,7 @@ static INLINE lattice_elem_t get_node_type(const ir_node *irn) { * * @return the associated type of this node */ -static INLINE tarval *get_node_tarval(const ir_node *irn) { +static inline tarval *get_node_tarval(const ir_node *irn) { lattice_elem_t type = get_node_type(irn); if (is_tarval(type.tv)) @@ -421,8 +609,9 @@ static INLINE tarval *get_node_tarval(const ir_node *irn) { /** * Add a partition to the worklist. */ -static INLINE void add_to_worklist(partition_t *X, environment_t *env) { +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; @@ -435,7 +624,7 @@ static INLINE void add_to_worklist(partition_t *X, environment_t *env) { * * @return a newly allocated partition */ -static INLINE partition_t *new_partition(environment_t *env) { +static inline partition_t *new_partition(environment_t *env) { partition_t *part = obstack_alloc(&env->obst, sizeof(*part)); INIT_LIST_HEAD(&part->Leader); @@ -465,9 +654,9 @@ static INLINE partition_t *new_partition(environment_t *env) { /** * Get the first node from a partition. */ -static INLINE node_t *get_first_node(const partition_t *X) { +static inline node_t *get_first_node(const partition_t *X) { 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 @@ -477,7 +666,7 @@ static INLINE node_t *get_first_node(const partition_t *X) { * * @return the type of the first element of the partition */ -static INLINE lattice_elem_t get_partition_type(const partition_t *X) { +static inline lattice_elem_t get_partition_type(const partition_t *X) { const node_t *first = get_first_node(X); return first->type; } /* get_partition_type */ @@ -510,8 +699,9 @@ static node_t *create_partition_node(ir_node *irn, partition_t *part, environmen node->on_cprop = 0; node->on_fallen = 0; node->is_follower = 0; - node->is_flagged = 0; node->by_all_const = 0; + node->flagged = 0; + node->cond = NULL; set_irn_node(irn, node); list_add_tail(&node->node_list, &part->Leader); @@ -529,7 +719,7 @@ static void init_block_phis(ir_node *irn, void *env) { if (is_Block(irn)) { set_Block_phis(irn, NULL); } -} +} /* init_block_phis */ /** * Post-Walker, initialize all Nodes' type to U or top and place @@ -547,29 +737,22 @@ static void create_initial_partitions(ir_node *irn, void *ctx) { if (is_Phi(irn)) { add_Block_phi(get_nodes_block(irn), irn); - } -} /* create_initial_partitions */ + } else if (is_Cond(irn)) { + node_t *block = get_irn_node(get_nodes_block(irn)); -/** - * 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; + /* link every block with its Cond node if any */ + block->cond = node; } -} /* 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; @@ -577,8 +760,64 @@ static INLINE void add_to_partition_touched(node_t *y) { 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_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); + } + /* same for Conds: they must be re-evaluated due to the way we handle Top */ + if (y->cond != NULL) + add_to_cprop(y->cond, env); } -} /* add_to_partition_touched */ +} /* add_to_cprop */ /** * Update the worklist: If Z is on worklist then add Z' to worklist. @@ -596,10 +835,51 @@ static void update_worklist(partition_t *Z, partition_t *Z_prime, environment_t } } /* update_worklist */ +/** + * 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 * @@ -612,31 +892,35 @@ static partition_t *split_no_followers(partition_t *Z, node_t *g, environment_t 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_leader); Z->n_leader -= n; - /* Move g to a new partition, Z’. */ + /* Move g to a new partition, Z'. */ 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; } Z_prime->max_user_inputs = max_input; - Z_prime->n_leader = n; + Z_prime->n_leader = n; - /* for now, copy the type info tag. it will be adjusted - in split_by(). */ + check_partition(Z); + check_partition(Z_prime); + + /* 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); @@ -646,24 +930,102 @@ static partition_t *split_no_followers(partition_t *Z, node_t *g, environment_t 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. */ typedef struct step_env { - node_t *initial; /**< The initial node list. */ - node_t *unwalked; /**< The unwalked node list. */ - node_t *unwalked_last; /**< Points to the last element of the unwalked node list. */ - node_t *walked; /**< The walked node list. */ - int index; /**< Next index of Follower use_def edge. */ - int n_leader; /**< number of Leader in initial. */ + 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; +} /* is_real_follower */ + /** * Do one step in the race. */ @@ -672,11 +1034,8 @@ static int step(step_env *env) { if (env->initial != NULL) { /* Move node from initial to unwalked */ - n = env->initial; - env->initial = n->race_next; - - if (env->unwalked_last == NULL) - env->unwalked_last = n; + n = env->initial; + env->initial = n->race_next; n->race_next = env->unwalked; env->unwalked = n; @@ -688,28 +1047,38 @@ static int step(step_env *env) { /* 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 */ - m->race_next = NULL; - if (env->unwalked == NULL) { - env->unwalked = m; - } else { - env->unwalked_last->race_next = m; + 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; } - env->unwalked_last = m; - return 0; + /* else already visited by the other side and on the other list */ } } /* move n to walked */ @@ -722,33 +1091,47 @@ static int step(step_env *env) { } /* 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 */ /** * Split a partition by a local list using the race. * - * @param X the partition to split + * @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 *X, node_t *gg, environment_t *env) { +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; - int max_input, n, m; + step_env senv[2]; + node_t *g, *h, *node, *t; + int max_input, transitions, winner, shf; + 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. */ @@ -763,89 +1146,145 @@ static partition_t *split(partition_t *X, node_t *gg, environment_t *env) { /* 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_del(&node->node_list); 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.initial = g; - env1.unwalked = NULL; - env1.unwalked_last = NULL; - env1.walked = NULL; - env1.index = 0; - env1.n_leader = n; - - env2.initial = h; - env2.unwalked = NULL; - env2.unwalked_last = NULL; - env2.walked = NULL; - env2.index = 0; - env2.n_leader = m; - + senv[0].initial = g; + senv[0].unwalked = NULL; + senv[0].walked = NULL; + senv[0].index = 0; + senv[0].side = 1; + + senv[1].initial = h; + senv[1].unwalked = NULL; + senv[1].walked = NULL; + senv[1].index = 0; + senv[1].side = 2; + + /* + * Some informations on the race that are not stated clearly in Click's + * thesis. + * 1) A follower stays on the side that reach him first. + * 2) If the other side reches a follower, if will be converted to + * a leader. /This must be done after the race is over, else the + * edges we are iterating on are renumbered./ + * 3) /New leader might end up on both sides./ + * 4) /If one side ends up with new Leaders, we must ensure that + * they can split out by opcode, hence we have to put _every_ + * partition with new Leader nodes on the cprop list, as + * opcode splitting is done by split_by() at the end of + * constant propagation./ + */ for (;;) { - if (step(&env1)) { - winner = &env1; + if (step(&senv[0])) { + winner = 0; break; } - if (step(&env2)) { - winner = &env2; + if (step(&senv[1])) { + winner = 1; break; } } - assert(winner->initial == NULL); - assert(winner->unwalked == NULL); + assert(senv[winner].initial == NULL); + assert(senv[winner].unwalked == NULL); /* clear flags from walked/unwalked */ - clear_flags(env1.unwalked); - clear_flags(env1.walked); - clear_flags(env2.unwalked); - clear_flags(env2.walked); + shf = winner; + transitions = clear_flags(senv[0].unwalked) << shf; + transitions |= clear_flags(senv[0].walked) << shf; + shf ^= 1; + transitions |= clear_flags(senv[1].unwalked) << shf; + transitions |= clear_flags(senv[1].walked) << shf; - dump_race_list("winner ", winner->walked); + dump_race_list("winner ", senv[winner].walked); - /* Move walked_{winner} to a new partition, X’. */ - X_prime = new_partition(env); + /* Move walked_{winner} to a new partition, X'. */ + X_prime = new_partition(env); max_input = 0; - for (node = winner->walked; node != NULL; node = node->race_next) { + n = 0; + for (node = senv[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; } - node->part = X_prime; 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 -= winner->n_leader; + X->n_leader -= X_prime->n_leader; - /* 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(). */ X_prime->type_is_T_or_C = X->type_is_T_or_C; - update_worklist(X, X_prime, env); + /* + * 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 & 1) { + /* place winner partition 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; + } + } + if (transitions & 2) { + /* place other partition on the cprop list */ + if (X->on_cprop == 0) { + X->cprop_next = env->cprop; + env->cprop = X; + X->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 != 0) { + *pX = X_prime; + return X; + } + return X_prime; } /* split */ -#endif /* NO_FOLLOWER */ /** * Returns non-zero if the i'th input of a Phi node is live. @@ -876,53 +1315,6 @@ static int is_constant_type(lattice_elem_t type) { 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. @@ -940,7 +1332,7 @@ static int type_is_neither_top_nor_const(const lattice_elem_t type) { return 0; } return 1; -} +} /* type_is_neither_top_nor_const */ /** * Collect nodes to the touched list. @@ -958,14 +1350,14 @@ static void collect_touched(list_head *list, int idx, environment_t *env) { 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) @@ -975,37 +1367,97 @@ static void collect_touched(list_head *list, int idx, environment_t *env) { succ = edge->use; + /* only non-commutative nodes */ + if (env->commutative && + (idx == 0 || idx == 1) && is_op_commutative(get_irn_op(succ))) + continue; + /* ignore the "control input" for non-pinned nodes if we are running in GCSE mode */ if (idx < end_idx && get_irn_pinned(succ) != op_pin_state_pinned) 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); + 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 */ + +/** + * Collect commutative nodes to the touched list. + * + * @param list the list which contains the nodes that must be evaluated + * @param env the environment + */ +static void collect_commutative_touched(list_head *list, environment_t *env) { + node_t *x, *y; + + list_for_each_entry(node_t, x, list, node_list) { + int num_edges; + + num_edges = get_irn_n_outs(x->node); + + x->next_edge = x->n_followers + 1; + + /* for all edges in x.L.def_use_{idx} */ + while (x->next_edge <= num_edges) { + const ir_def_use_edge *edge = &x->node->out[x->next_edge]; + ir_node *succ; + + /* check if we have necessary edges */ + if (edge->pos > 1) + break; + + ++x->next_edge; + if (edge->pos < 0) + continue; + + succ = edge->use; + + /* only commutative nodes */ + if (!is_op_commutative(get_irn_op(succ))) + continue; + + y = get_irn_node(succ); + if (is_constant_type(y->type)) { + ir_opcode code = get_irn_opcode(succ); + if (code == iro_Eor) + add_to_cprop(y, env); + } + + /* Partitions of constants should not be split simply because their Nodes have unequal + functions or incongruent inputs. */ + if (type_is_neither_top_nor_const(y->type)) { + add_to_touched(y, env); + } + } + } +} /* collect_commutative_touched */ + /** * Split the partitions if caused by the first entry on the worklist. * * @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 */ @@ -1015,6 +1467,44 @@ static void cause_splits(environment_t *env) { dump_partition("Cause_split: ", X); + if (env->commutative) { + /* handle commutative nodes first */ + + /* empty the touched set: already done, just clear the list */ + env->touched = NULL; + + collect_commutative_touched(&X->Leader, env); + collect_commutative_touched(&X->Follower, env); + + for (Z = env->touched; Z != NULL; Z = N) { + node_t *e; + node_t *touched = Z->touched; + unsigned n_touched = Z->n_touched; + + assert(Z->touched != NULL); + + /* beware, split might change Z */ + N = Z->touched_next; + + /* remove it from the touched set */ + Z->on_touched = 0; + + /* Empty local Z.touched. */ + for (e = touched; e != NULL; e = e->next) { + assert(e->is_follower == 0); + e->on_touched = 0; + } + Z->touched = NULL; + Z->n_touched = 0; + + if (0 < n_touched && n_touched < Z->n_leader) { + DB((dbg, LEVEL_2, "Split part%d by touched\n", Z->nr)); + split(&Z, touched, env); + } else + assert(n_touched <= Z->n_leader); + } + } + /* combine temporary leader and follower list */ for (idx = -1; idx <= X->max_user_inputs; ++idx) { /* empty the touched set: already done, just clear the list */ @@ -1023,20 +1513,32 @@ static void cause_splits(environment_t *env) { collect_touched(&X->Leader, idx, env); collect_touched(&X->Follower, idx, env); - for (Z = env->touched; Z != NULL; Z = Z->touched_next) { + for (Z = env->touched; Z != NULL; Z = N) { + node_t *e; + node_t *touched = Z->touched; + unsigned n_touched = Z->n_touched; + + assert(Z->touched != NULL); + + /* beware, split might change Z */ + N = Z->touched_next; + /* remove it from the touched set */ Z->on_touched = 0; - if (Z->n_leader != 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 */ @@ -1085,8 +1587,8 @@ static partition_t *split_by_what(partition_t *X, what_func What, S = iter->list; /* Add SPLIT( X, S ) to P. */ - DB((dbg, LEVEL_2, "Split part%d by what\n", X->nr)); - R = split(X, S, env); + DB((dbg, LEVEL_2, "Split part%d by WHAT = %s\n", X->nr, what_reason)); + R = split(&X, S, env); R->split_next = *P; *P = R; } @@ -1111,6 +1613,7 @@ static void *lambda_opcode(const node_t *node, environment_t *env) { 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; @@ -1137,7 +1640,13 @@ static void *lambda_partition(const node_t *node, environment_t *env) { int i = env->lambda_input; if (i >= get_irn_arity(node->node)) { - /* we are outside the allowed range */ + /* + * We are outside the allowed range: This can happen even + * if we have split by opcode first: doing so might move Followers + * to Leaders and those will have a different opcode! + * Note that in this case the partition is on the cprop list and will be + * split again. + */ return NULL; } @@ -1152,8 +1661,61 @@ static void *lambda_partition(const node_t *node, environment_t *env) { return p->part; } /* lambda_partition */ +/** lambda n.(n[i].partition) for commutative nodes */ +static void *lambda_commutative_partition(const node_t *node, environment_t *env) { + ir_node *irn = node->node; + ir_node *skipped = skip_Proj(irn); + ir_node *pred, *left, *right; + node_t *p; + partition_t *pl, *pr; + int i = env->lambda_input; + + if (i >= get_irn_arity(node->node)) { + /* + * We are outside the allowed range: This can happen even + * if we have split by opcode first: doing so might move Followers + * to Leaders and those will have a different opcode! + * Note that in this case the partition is on the cprop list and will be + * split again. + */ + return NULL; + } + + /* ignore the "control input" for non-pinned nodes + if we are running in GCSE mode */ + if (i < env->end_idx && get_irn_pinned(skipped) != op_pin_state_pinned) + return NULL; + + if (i == -1) { + pred = get_irn_n(skipped, i); + p = get_irn_node(pred); + return p->part; + } + + if (is_op_commutative(get_irn_op(irn))) { + /* normalize partition order by returning the "smaller" on input 0, + the "bigger" on input 1. */ + left = get_binop_left(irn); + pl = get_irn_node(left)->part; + right = get_binop_right(irn); + pr = get_irn_node(right)->part; + + if (i == 0) + return pl < pr ? pl : pr; + else + return pl > pr ? pl : pr; + } else { + /* a not split out Follower */ + pred = get_irn_n(irn, i); + p = get_irn_node(pred); + + return p->part; + } +} /* lambda_commutative_partition */ + /** - * Returns true if a type is a constant. + * Returns true if a type is a constant (and NOT Top + * or Bottom). */ static int is_con(const lattice_elem_t type) { /* be conservative */ @@ -1181,8 +1743,9 @@ static void split_by(partition_t *X, environment_t *env) { return; } - DB((dbg, LEVEL_2, "WHAT = lambda n.(n.type) on part%d\n", X->nr)); + DEBUG_ONLY(what_reason = "lambda n.(n.type)";) P = split_by_what(X, lambda_type, &P, env); + dump_split_list(P); /* adjust the type tags, we have split partitions by type */ for (I = P; I != NULL; I = I->split_next) { @@ -1199,8 +1762,9 @@ static void split_by(partition_t *X, environment_t *env) { if (! Y->type_is_T_or_C) { partition_t *Q = NULL; - DB((dbg, LEVEL_2, "WHAT = lambda n.(n.opcode) on part%d\n", Y->nr)); + DEBUG_ONLY(what_reason = "lambda n.(n.opcode)";) Q = split_by_what(Y, lambda_opcode, &Q, env); + dump_split_list(Q); do { partition_t *Z = Q; @@ -1210,6 +1774,11 @@ static void split_by(partition_t *X, environment_t *env) { const node_t *first = get_first_node(Z); int arity = get_irn_arity(first->node); partition_t *R, *S; + what_func what = lambda_partition; + DEBUG_ONLY(char buf[64];) + + if (env->commutative && is_op_commutative(get_irn_op(first->node))) + what = lambda_commutative_partition; /* * BEWARE: during splitting by input 2 for instance we might @@ -1226,8 +1795,10 @@ static void split_by(partition_t *X, environment_t *env) { R = R->split_next; if (Z_prime->n_leader > 1) { env->lambda_input = input; - DB((dbg, LEVEL_2, "WHAT = lambda n.(n[%d].partition) on part%d\n", input, Z_prime->nr)); - S = split_by_what(Z_prime, lambda_partition, &S, env); + DEBUG_ONLY(snprintf(buf, sizeof(buf), "lambda n.(n[%d].partition)", input);) + DEBUG_ONLY(what_reason = buf;) + S = split_by_what(Z_prime, what, &S, env); + dump_split_list(S); } else { Z_prime->split_next = S; S = Z_prime; @@ -1327,10 +1898,8 @@ static void compute_Unknown(node_t *node) { * 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 */ /** @@ -1344,6 +1913,18 @@ static void compute_Jmp(node_t *node) { node->type = block->type; } /* compute_Jmp */ +/** + * (Re-)compute the type for the Return node. + * + * @param node the node + */ +static void compute_Return(node_t *node) { + /* The Return node is NOT dead if it is in a reachable block. + * This is already checked in compute(). so we can return + * Reachable here. */ + node->type.tv = tarval_reachable; +} /* compute_Return */ + /** * (Re-)compute the type for the End node. * @@ -1352,7 +1933,7 @@ static void compute_Jmp(node_t *node) { static void compute_End(node_t *node) { /* the End node is NOT dead of course */ node->type.tv = tarval_reachable; -} +} /* compute_End */ /** * (Re-)compute the type for a SymConst node. @@ -1501,7 +2082,8 @@ static void compute_Sub(node_t *node) { tv = get_mode_null(mode); /* if the node was ONCE evaluated by all constants, but now - this breakes AND we cat by partition a different result, switch to bottom. + this breaks AND we get from the argument partitions a different + result, switch to bottom. This happens because initially all nodes are in the same partition ... */ if (node->by_all_const && node->type.tv != tv) tv = tarval_bottom; @@ -1511,6 +2093,48 @@ static void compute_Sub(node_t *node) { } } /* 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 breaks AND we get from the argument partitions a different + result, switch to bottom. + This happens because initially all nodes are in the same partition ... */ + if (node->by_all_const && node->type.tv != tv) + tv = tarval_bottom; + node->type.tv = tv; + } else { + node->type.tv = tarval_bottom; + } +} /* compute_Eor */ + /** * (Re-)compute the type for Cmp. * @@ -1525,16 +2149,16 @@ static void compute_Cmp(node_t *node) { if (a.tv == tarval_top || b.tv == tarval_top) { node->type.tv = tarval_top; - } else if (is_con(a) && is_con(b)) { - /* both nodes are constants, we can probably do something */ - node->type.tv = tarval_b_true; } else if (r->part == l->part) { /* both nodes congruent, we can probably do something */ node->type.tv = tarval_b_true; + } else if (is_con(a) && is_con(b)) { + /* both nodes are constants, we can probably do something */ + node->type.tv = tarval_b_true; } else { node->type.tv = tarval_bottom; } -} /* compute_Proj_Cmp */ +} /* compute_Cmp */ /** * (Re-)compute the type for a Proj(Cmp). @@ -1552,7 +2176,7 @@ static void compute_Proj_Cmp(node_t *node, ir_node *cmp) { tarval *tv; if (a.tv == tarval_top || b.tv == tarval_top) { - node->type.tv = tarval_top; + node->type.tv = tarval_undefined; } else if (is_con(a) && is_con(b)) { default_compute(node); node->by_all_const = 1; @@ -1562,10 +2186,11 @@ static void compute_Proj_Cmp(node_t *node, ir_node *cmp) { * 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); + tv = pnc & pn_Cmp_Eq ? tarval_b_true: tarval_b_false; /* if the node was ONCE evaluated by all constants, but now - this breakes AND we cat by partition a different result, switch to bottom. + this breaks AND we get from the argument partitions a different + result, switch to bottom. This happens because initially all nodes are in the same partition ... */ if (node->by_all_const && node->type.tv != tv) tv = tarval_bottom; @@ -1598,6 +2223,7 @@ static void compute_Proj_Cond(node_t *node, ir_node *cond) { node->type.tv = tarval_reachable; } else { assert(selector->type.tv == tarval_top); + /* any condition based on Top is "!=" */ node->type.tv = tarval_unreachable; } } else { @@ -1611,7 +2237,8 @@ static void compute_Proj_Cond(node_t *node, ir_node *cond) { node->type.tv = tarval_reachable; } else { assert(selector->type.tv == tarval_top); - node->type.tv = tarval_unreachable; + /* any condition based on Top is "!=" */ + node->type.tv = tarval_reachable; } } } else { @@ -1619,7 +2246,11 @@ static void compute_Proj_Cond(node_t *node, ir_node *cond) { if (selector->type.tv == tarval_bottom) { node->type.tv = tarval_reachable; } else if (selector->type.tv == tarval_top) { - node->type.tv = tarval_unreachable; + if (pnc == get_Cond_defaultProj(cond)) { + /* a switch based of Top is always "default" */ + node->type.tv = tarval_reachable; + } else + node->type.tv = tarval_unreachable; } else { long value = get_tarval_long(selector->type.tv); if (pnc == get_Cond_defaultProj(cond)) { @@ -1663,7 +2294,7 @@ static void compute_Proj(node_t *node) { node->type.tv = tarval_top; return; } - if (get_irn_node(pred)->type.tv == tarval_top) { + if (get_irn_node(pred)->type.tv == tarval_top && !is_Cond(pred)) { /* if the predecessor is Top, its Proj follow */ node->type.tv = tarval_top; return; @@ -1725,18 +2356,18 @@ static void compute_Confirm(node_t *node) { * @param node the node */ static void compute_Max(node_t *node) { - ir_node *op = node->node; - node_t *l = get_irn_node(get_binop_left(op)); - node_t *r = get_irn_node(get_binop_right(op)); - lattice_elem_t a = l->type; - lattice_elem_t b = r->type; + ir_node *op = node->node; + node_t *l = get_irn_node(get_binop_left(op)); + node_t *r = get_irn_node(get_binop_right(op)); + lattice_elem_t a = l->type; + lattice_elem_t b = r->type; if (a.tv == tarval_top || b.tv == tarval_top) { node->type.tv = tarval_top; } else if (is_con(a) && is_con(b)) { /* both nodes are constants, we can probably do something */ if (a.tv == b.tv) { - /* this case handles symconsts as well */ + /* this case handles SymConsts as well */ node->type = a; } else { ir_mode *mode = get_irn_mode(op); @@ -1769,18 +2400,18 @@ static void compute_Max(node_t *node) { * @param node the node */ static void compute_Min(node_t *node) { - ir_node *op = node->node; - node_t *l = get_irn_node(get_binop_left(op)); - node_t *r = get_irn_node(get_binop_right(op)); - lattice_elem_t a = l->type; - lattice_elem_t b = r->type; + ir_node *op = node->node; + node_t *l = get_irn_node(get_binop_left(op)); + node_t *r = get_irn_node(get_binop_right(op)); + lattice_elem_t a = l->type; + lattice_elem_t b = r->type; if (a.tv == tarval_top || b.tv == tarval_top) { node->type.tv = tarval_top; } else if (is_con(a) && is_con(b)) { /* both nodes are constants, we can probably do something */ if (a.tv == b.tv) { - /* this case handles symconsts as well */ + /* this case handles SymConsts as well */ node->type = a; } else { ir_mode *mode = get_irn_mode(op); @@ -1813,14 +2444,18 @@ static void compute_Min(node_t *node) { * @param node the node */ static void compute(node_t *node) { + ir_node *irn = node->node; compute_func func; - if (is_no_Block(node->node)) { - node_t *block = get_irn_node(get_nodes_block(node->node)); + if (is_no_Block(irn)) { + /* for pinned nodes, check its control input */ + if (get_irn_pinned(skip_Proj(irn)) == op_pin_state_pinned) { + node_t *block = get_irn_node(get_nodes_block(irn)); - if (block->type.tv == tarval_unreachable) { - node->type.tv = tarval_top; - return; + if (block->type.tv == tarval_unreachable) { + node->type.tv = tarval_top; + return; + } } } @@ -1890,8 +2525,22 @@ static node_t *identity_comm_zero_binop(node_t *node) { 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. @@ -1934,7 +2583,7 @@ static node_t *identity_Sub(node_t *node) { if (b->type.tv == get_mode_null(mode)) return get_irn_node(get_Sub_left(sub)); return node; -} /* identity_Mul */ +} /* identity_Sub */ /** * Calculates the Identity for And nodes. @@ -1969,18 +2618,23 @@ static node_t *identity_Confirm(node_t *node) { */ 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 */ @@ -2041,12 +2695,17 @@ static node_t *identity(node_t *node) { 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: @@ -2069,7 +2728,7 @@ static node_t *identity(node_t *node) { * 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)); @@ -2083,94 +2742,27 @@ static void segregate_def_use_chain_1(const ir_node *follower, node_t *leader) { 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 Leader - * out edges. If follower is a n-congruent Input identity, all follower - * inputs congruent to follower are also leader. + * Node follower is a (new) follower segregate its Leader + * out edges. + * + * @param follower the follower IR node */ -static void segregate_def_use_chain(const ir_node *follower, node_t *leader) { - ir_op *op = get_irn_op(follower); - - if (op == op_Phi) { - /* n-Congruent Input Identity for Phi's */ - int i; - ir_node *block = get_nodes_block(follower); - - DB((dbg, LEVEL_2, "n-Congruent follower %+F\n", follower)); - for (i = get_irn_arity(follower) - 1; i >= 0; --i) { - node_t *pred_X = get_irn_node(get_Block_cfgpred(block, i)); - - /* beware: we are NOT followers of dead inputs */ - if (pred_X->type.tv == tarval_reachable) { - node_t *pred = get_irn_node(get_irn_n(follower, i)); - - if (pred->part == leader->part) - segregate_def_use_chain_1(follower, pred); - } - } - } else if (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 */ -/** - * Make all inputs to x from inside X no longer be F.def_use edges. - */ -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; - } - } - } -} - /** * Propagate constant evaluation. * @@ -2200,32 +2792,28 @@ static void propagate(environment_t *env) { 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) { - /* 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); } if (oldopcode != lambda_opcode(x, env)) { - /* 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)); + 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)); + } } - /* 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 */ @@ -2250,14 +2838,19 @@ static void propagate(environment_t *env) { 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_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; } @@ -2265,29 +2858,27 @@ static void propagate(environment_t *env) { 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; /* check if some nodes will make the leader -> follower transition */ list_for_each_entry_safe(node_t, y, tmp, &Y->Leader, node_list) { - if (! is_con(y->type)) { + if (y->type.tv != tarval_top && ! is_con(y->type)) { node_t *eq_node = identity(y); - if (eq_node != y) { + 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; - list_add_tail(&y->node_list, &Y->Follower); - segregate_def_use_chain(y->node, eq_node); + segregate_def_use_chain(y->node); } } } } -#endif split_by(Y, env); } } /* propagate */ @@ -2301,7 +2892,11 @@ static ir_node *get_leader(node_t *node) { partition_t *part = node->part; if (part->n_leader > 1 || node->is_follower) { - DB((dbg, LEVEL_2, "Found congruence class for %+F\n", node->node)); + 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; } @@ -2323,7 +2918,7 @@ static int can_exchange(ir_node *pred) { int i, k; /* if the predecessor block has more than one - reachable outputs we cannot remove the block */ + reachable outputs we cannot remove the block */ k = 0; for (i = get_irn_n_outs(pred) - 1; i >= 0; --i) { ir_node *proj = get_irn_out(pred, i); @@ -2342,7 +2937,7 @@ static int can_exchange(ir_node *pred) { return 1; } return 0; -} +} /* can_exchange */ /** * Block Post-Walker, apply the analysis results on control flow by @@ -2355,26 +2950,55 @@ static void apply_cf(ir_node *block, void *ctx) { 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; @@ -2388,6 +3012,24 @@ static void apply_cf(ir_node *block, void *ctx) { 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) @@ -2406,6 +3048,7 @@ static void apply_cf(ir_node *block, void *ctx) { 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 { @@ -2417,13 +3060,16 @@ static void apply_cf(ir_node *block, void *ctx) { 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); @@ -2432,18 +3078,42 @@ static void apply_cf(ir_node *block, void *ctx) { } } - 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 { set_irn_in(block, k, in_X); env->modified = 1; } +} /* apply_cf */ + +/** + * Exchange a node by its leader. + * Beware: in rare cases the mode might be wrong here, for instance + * AddP(x, NULL) is a follower of x, but with different mode. + * Fix it here. + */ +static void exchange_leader(ir_node *irn, ir_node *leader) { + ir_mode *mode = get_irn_mode(irn); + if (mode != get_irn_mode(leader)) { + /* The conv is a no-op, so we are fre to place in + * either in the block of the leader OR in irn's block. + * Probably placing it into leaders block might reduce + * the number of Conv due to CSE. */ + ir_node *block = get_nodes_block(leader); + dbg_info *dbg = get_irn_dbg_info(irn); + + leader = new_rd_Conv(dbg, current_ir_graph, block, leader, mode); + } + exchange(irn, leader); } /** @@ -2470,14 +3140,17 @@ static void apply_result(ir_node *irn, void *ctx) { 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)) { @@ -2488,11 +3161,12 @@ static void apply_result(ir_node *irn, void *ctx) { 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; } @@ -2513,33 +3187,88 @@ static void apply_result(ir_node *irn, void *ctx) { set_irn_node(c, node); node->node = c; DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, c)); - exchange(irn, c); + DBG_OPT_COMBO(irn, c, FS_OPT_COMBO_CONST); + exchange_leader(irn, c); env->modified = 1; } } else if (is_entity(node->type.sym.entity_p)) { if (! is_SymConst(irn)) { - /* can be replaced by a Symconst */ + /* can be replaced by a SymConst */ ir_node *symc = new_r_SymConst(current_ir_graph, block->node, get_irn_mode(irn), node->type.sym, symconst_addr_ent); set_irn_node(symc, node); node->node = symc; DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, symc)); - exchange(irn, symc); + DBG_OPT_COMBO(irn, symc, FS_OPT_COMBO_CONST); + exchange_leader(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)); - exchange(irn, leader); - env->modified = 1; + int non_strict_phi = 0; + + /* + * Beware: Do not remove Phi(Unknown, ..., x, ..., Unknown) + * as this might create non-strict programs. + */ + if (node->is_follower && is_Phi(irn) && !is_Unknown(leader)) { + int i; + + for (i = get_Phi_n_preds(irn) - 1; i >= 0; --i) { + ir_node *pred = get_Phi_pred(irn, i); + + if (is_Unknown(pred)) { + non_strict_phi = 1; + break; + } + } + } + if (! non_strict_phi) { + 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_leader(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 && !is_Bad(ka)) + 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 /** @@ -2562,10 +3291,12 @@ static void set_compute_functions(void) { SET(Phi); SET(Add); SET(Sub); + SET(Eor); SET(SymConst); SET(Cmp); SET(Proj); SET(Confirm); + SET(Return); SET(End); if (op_Max != NULL) @@ -2575,14 +3306,6 @@ static void set_compute_functions(void) { } /* set_compute_functions */ -static int dump_partition_hook(FILE *F, ir_node *n, ir_node *local) { - 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; -} - void combo(ir_graph *irg) { environment_t env; ir_node *initial_bl; @@ -2593,7 +3316,6 @@ void combo(ir_graph *irg) { /* register a debug mask */ FIRM_DBG_REGISTER(dbg, "firm.opt.combo"); - //firm_dbg_set_mask(dbg, SET_LEVEL_3); DB((dbg, LEVEL_1, "Doing COMBO for %+F\n", irg)); @@ -2609,9 +3331,11 @@ void combo(ir_graph *irg) { env.type2id_map = pmap_create(); env.end_idx = get_opt_global_cse() ? 0 : -1; env.lambda_input = 0; + env.commutative = 1; env.modified = 0; assure_irg_outs(irg); + assure_cf_loop(irg); /* we have our own value_of function */ set_value_of_func(get_node_tarval); @@ -2619,11 +3343,22 @@ void combo(ir_graph *irg) { 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); + /* set the hook: from now, every node has a partition and a type */ + DEBUG_ONLY(set_dump_node_vcgattr_hook(dump_partition_hook)); + +#ifdef WITH_UNKNOWN + tarval_UNKNOWN = 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; @@ -2631,7 +3366,7 @@ void combo(ir_graph *irg) { 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); @@ -2640,18 +3375,16 @@ void combo(ir_graph *irg) { } 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); dump_ir_block_graph(irg, "-partition"); - set_dump_node_vcgattr_hook(NULL); -#else - (void)dump_partition_hook; #endif /* 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 */ @@ -2661,6 +3394,11 @@ void combo(ir_graph *irg) { set_irg_loopinfo_inconsistent(irg); } + ir_free_resources(irg, IR_RESOURCE_IRN_LINK); + + /* remove the partition hook */ + DEBUG_ONLY(set_dump_node_vcgattr_hook(NULL)); + pmap_destroy(env.type2id_map); del_set(env.opcode2id_map); obstack_free(&env.obst, NULL);