X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fcombo.c;h=b930563ad1610fea43c55338d430df3631483c25;hb=66a85ef5ee56713b80b444e55963354ff923f0f0;hp=972bca5c8920e8b0e1a167ec17df08bf2c533af2;hpb=a5d5f207f602198e3a9d809f431ea1855dc86fb7;p=libfirm diff --git a/ir/opt/combo.c b/ir/opt/combo.c index 972bca5c8..b930563ad 100644 --- a/ir/opt/combo.c +++ b/ir/opt/combo.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -83,6 +83,7 @@ #include "irnodeset.h" #include "irpass.h" #include "tv_t.h" +#include "irtools.h" #include "irprintf.h" #include "irdump.h" @@ -105,17 +106,7 @@ typedef void (*compute_func)(node_t *node); * An opcode map key. */ 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 */ - int intVal; /**< For Conv/Div Nodes: strict/remainderless */ - unsigned uintVal;/**< for Builtin: the kind */ - ir_node *block; /**< for Block: itself */ - void *ptr; /**< generic pointer for hash/cmp */ - } u; + ir_node *irn; /**< An IR node representing this opcode. */ }; /** @@ -138,7 +129,7 @@ typedef struct listmap_t { * have to use this union. */ typedef union { - tarval *tv; + ir_tarval *tv; symconst_symbol sym; } lattice_elem_t; @@ -230,11 +221,47 @@ DEBUG_ONLY(static const char *what_reason;) DEBUG_ONLY(static unsigned part_nr = 0); /** The tarval returned by Unknown nodes: set to either tarval_bad OR tarval_top. */ -static tarval *tarval_UNKNOWN; +static ir_tarval *tarval_UNKNOWN; /* forward */ static node_t *identity(node_t *node); +/** + * Compare two opcode representatives. + */ +static int cmp_irn_opcode(const ir_node *a, const ir_node *b) +{ + int arity; + + if ((get_irn_op(a) != get_irn_op(b)) || + (get_irn_mode(a) != get_irn_mode(b))) + return 1; + + /* compare if a's in and b's in are of equal length */ + arity = get_irn_arity(a); + if (arity != get_irn_arity(b)) + return 1; + + if (is_Block(a)) { + /* + * Some ugliness here: Two Blocks having the same + * IJmp predecessor would be congruent, which of course is wrong. + * We fix it by never letting blocks be congruent + * which cannot be detected by combo either. + */ + return 1; + } + + /* + * here, we already know that the nodes are identical except their + * attributes + */ + if (a->op->ops.node_cmp_attr) + return a->op->ops.node_cmp_attr(a, b); + + return 0; +} /* cmp_irn_opcode */ + #ifdef CHECK_PARTITIONS /** * Check a partition. @@ -264,76 +291,16 @@ static void check_partition(const partition_t *T) */ static void check_opcode(const partition_t *Z) { - node_t *node; - opcode_key_t key; - int first = 1; + node_t *node; + const ir_node *repr = NULL; list_for_each_entry(node_t, node, &Z->Leader, node_list) { ir_node *irn = node->node; - if (first) { - key.code = get_irn_opcode(irn); - key.mode = get_irn_mode(irn); - key.arity = get_irn_arity(irn); - key.u.proj = 0; - key.u.ent = NULL; - - switch (get_irn_opcode(irn)) { - case iro_Proj: - key.u.proj = get_Proj_proj(irn); - break; - case iro_Sel: - key.u.ent = get_Sel_entity(irn); - break; - case iro_Conv: - key.u.intVal = get_Conv_strict(irn); - break; - case iro_Div: - key.u.intVal = get_Div_no_remainder(irn); - break; - case iro_Block: - key.u.block = irn; - break; - case iro_Load: - key.mode = get_Load_mode(irn); - break; - case iro_Builtin: - key.u.intVal = get_Builtin_kind(irn); - break; - default: - break; - } - first = 0; + if (repr == NULL) { + repr = irn; } else { - assert((unsigned)key.code == get_irn_opcode(irn)); - assert(key.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; - case iro_Conv: - assert(key.u.intVal == get_Conv_strict(irn)); - break; - case iro_Div: - assert(key.u.intVal == get_Div_no_remainder(irn)); - break; - case iro_Block: - assert(key.u.block == irn); - break; - case iro_Load: - assert(key.mode == get_Load_mode(irn)); - break; - case iro_Builtin: - assert(key.u.intVal == (int) get_Builtin_kind(irn)); - break; - default: - break; - } + assert(cmp_irn_opcode(repr, irn) == 0); } } } /* check_opcode */ @@ -534,8 +501,8 @@ static void verify_type(const lattice_elem_t old_type, node_t *node) */ static int listmap_cmp_ptr(const void *elt, const void *key, size_t size) { - const listmap_entry_t *e1 = elt; - const listmap_entry_t *e2 = key; + const listmap_entry_t *e1 = (listmap_entry_t*)elt; + const listmap_entry_t *e2 = (listmap_entry_t*)key; (void) size; return e1->id != e2->id; @@ -577,7 +544,7 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id) key.id = id; key.list = NULL; key.next = NULL; - entry = set_insert(map->map, &key, sizeof(key), HASH_PTR(id)); + entry = (listmap_entry_t*)set_insert(map->map, &key, sizeof(key), HASH_PTR(id)); if (entry->list == NULL) { /* a new entry, put into the list */ @@ -596,7 +563,18 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id) */ 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.ptr) + entry->arity; + /* we cannot use the ir ops hash function here, because it hashes the + * predecessors. */ + const ir_node *n = entry->irn; + ir_opcode code = get_irn_opcode(n); + ir_mode *mode = get_irn_mode(n); + unsigned hash = (unsigned)(PTR_TO_INT(mode) * 9 + code) + get_irn_arity(n); + + if (code == iro_Const) + hash ^= (unsigned)HASH_PTR(get_Const_tarval(n)); + else if (code == iro_Proj) + hash += (unsigned)get_Proj_proj(n); + return hash; } /* opcode_hash */ /** @@ -604,15 +582,12 @@ static unsigned opcode_hash(const opcode_key_t *entry) */ static int cmp_opcode(const void *elt, const void *key, size_t size) { - const opcode_key_t *o1 = elt; - const opcode_key_t *o2 = key; + const opcode_key_t *o1 = (opcode_key_t*)elt; + const opcode_key_t *o2 = (opcode_key_t*)key; (void) size; - return o1->code != o2->code || o1->mode != o2->mode || - o1->arity != o2->arity || - o1->u.proj != o2->u.proj || - o1->u.intVal != o2->u.intVal || /* this already checks uIntVal */ - o1->u.ptr != o2->u.ptr; + + return cmp_irn_opcode(o1->irn, o2->irn); } /* cmp_opcode */ /** @@ -620,8 +595,8 @@ static int cmp_opcode(const void *elt, const void *key, size_t size) */ static int cmp_def_use_edge(const void *a, const void *b) { - const ir_def_use_edge *ea = a; - const ir_def_use_edge *eb = b; + const ir_def_use_edge *ea = (const ir_def_use_edge*)a; + const ir_def_use_edge *eb = (const ir_def_use_edge*)b; /* no overrun, because range is [-1, MAXINT] */ return ea->pos - eb->pos; @@ -660,7 +635,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 ir_tarval *get_node_tarval(const ir_node *irn) { lattice_elem_t type = get_node_type(irn); @@ -783,7 +758,7 @@ static node_t *create_partition_node(ir_node *irn, partition_t *part, environmen */ static void create_initial_partitions(ir_node *irn, void *ctx) { - environment_t *env = ctx; + environment_t *env = (environment_t*)ctx; partition_t *part = env->initial; node_t *node; @@ -805,7 +780,8 @@ static void init_block_phis(ir_node *irn, void *ctx) (void) ctx; if (is_Phi(irn)) { - add_Block_phi(get_nodes_block(irn), irn); + ir_node *block = get_nodes_block(irn); + add_Block_phi(block, irn); } } /* init_block_phis */ @@ -870,7 +846,7 @@ static void add_to_cprop(node_t *y, environment_t *env) irn = y->node; if (get_irn_mode(irn) == mode_T) { /* mode_T nodes always produce tarval_bottom, so we must explicitly - add it's Proj's to get constant evaluation to work */ + * add its Projs to get constant evaluation to work */ int i; for (i = get_irn_n_outs(irn) - 1; i >= 0; --i) { @@ -1464,7 +1440,7 @@ static void collect_touched(list_head *list, int idx, environment_t *env) continue; if (is_constant_type(y->type)) { - ir_opcode code = get_irn_opcode(succ); + unsigned code = get_irn_opcode(succ); if (code == iro_Sub || code == iro_Cmp) add_to_cprop(y, env); } @@ -1517,7 +1493,7 @@ static void collect_commutative_touched(list_head *list, environment_t *env) y = get_irn_node(succ); if (is_constant_type(y->type)) { - ir_opcode code = get_irn_opcode(succ); + unsigned code = get_irn_opcode(succ); if (code == iro_Eor) add_to_cprop(y, env); } @@ -1723,47 +1699,10 @@ static void *lambda_type(const node_t *node, environment_t *env) static void *lambda_opcode(const node_t *node, environment_t *env) { opcode_key_t key, *entry; - ir_node *irn = node->node; - - key.code = get_irn_opcode(irn); - key.mode = get_irn_mode(irn); - key.arity = get_irn_arity(irn); - key.u.proj = 0; - key.u.ent = NULL; - switch (get_irn_opcode(irn)) { - case iro_Proj: - key.u.proj = get_Proj_proj(irn); - break; - case iro_Sel: - key.u.ent = get_Sel_entity(irn); - break; - case iro_Conv: - key.u.intVal = get_Conv_strict(irn); - break; - case iro_Div: - key.u.intVal = get_Div_no_remainder(irn); - break; - case iro_Block: - /* - * Some ugliness here: Two Blocks having the same - * IJmp predecessor would be congruent, which of course is wrong. - * We fix it by never letting blocks be congruent - * which cannot be detected by combo either. - */ - key.u.block = irn; - break; - case iro_Load: - key.mode = get_Load_mode(irn); - break; - case iro_Builtin: - key.u.intVal = get_Builtin_kind(irn); - break; - default: - break; - } + key.irn = node->node; - entry = set_insert(env->opcode2id_map, &key, sizeof(key), opcode_hash(&key)); + entry = (opcode_key_t*)set_insert(env->opcode2id_map, &key, sizeof(key), opcode_hash(&key)); return entry; } /* lambda_opcode */ @@ -1875,7 +1814,7 @@ static void split_by(partition_t *X, environment_t *env) dump_partition("split_by", X); if (X->n_leader == 1) { - /* we have only one leader, no need to split, just check it's type */ + /* we have only one leader, no need to split, just check its type */ node_t *x = get_first_node(X); X->type_is_T_or_C = x->type.tv == tarval_top || is_con(x->type); return; @@ -2213,7 +2152,7 @@ static void compute_Sub(node_t *node) node_t *r = get_irn_node(get_Sub_right(sub)); lattice_elem_t a = l->type; lattice_elem_t b = r->type; - tarval *tv; + ir_tarval *tv; if (a.tv == tarval_top || b.tv == tarval_top) { node->type.tv = tarval_top; @@ -2260,7 +2199,7 @@ static void compute_Eor(node_t *node) node_t *r = get_irn_node(get_Eor_right(eor)); lattice_elem_t a = l->type; lattice_elem_t b = r->type; - tarval *tv; + ir_tarval *tv; if (a.tv == tarval_top || b.tv == tarval_top) { node->type.tv = tarval_top; @@ -2291,44 +2230,45 @@ static void compute_Eor(node_t *node) } /* compute_Eor */ /** - * (Re-)compute the type for a Proj(Cmp). + * (Re-)compute the type for Cmp. * * @param node the node - * @param cond the predecessor Cmp node */ -static void compute_Proj_Cmp(node_t *node, ir_node *cmp) +static void compute_Cmp(node_t *node) { - ir_node *proj = node->node; - node_t *l = get_irn_node(get_Cmp_left(cmp)); - node_t *r = get_irn_node(get_Cmp_right(cmp)); - lattice_elem_t a = l->type; - lattice_elem_t b = r->type; - pn_Cmp pnc = get_Proj_proj(proj); - tarval *tv; + ir_node *cmp = node->node; + node_t *l = get_irn_node(get_Cmp_left(cmp)); + node_t *r = get_irn_node(get_Cmp_right(cmp)); + lattice_elem_t a = l->type; + lattice_elem_t b = r->type; + ir_relation relation = get_Cmp_relation(cmp); + ir_tarval *tv; if (a.tv == tarval_top || b.tv == tarval_top) { node->type.tv = tarval_undefined; } else if (is_con(a) && is_con(b)) { default_compute(node); - } else if (r->part == l->part && - (!mode_is_float(get_irn_mode(l->node)) || pnc == pn_Cmp_Lt || pnc == pn_Cmp_Gt)) { - /* - * BEWARE: a == a is NOT always True for floating Point values, as - * NaN != NaN is defined, so we must check this here. - */ - tv = pnc & pn_Cmp_Eq ? tarval_b_true: tarval_b_false; - /* if the node was ONCE evaluated by all constants, but now + /* + * BEWARE: a == a is NOT always True for floating Point values, as + * NaN != NaN is defined, so we must check this here. + * (while for some pnc we could still optimize we have to stay + * consistent with compute_Cmp, so don't do anything for floats) + */ + } else if (r->part == l->part && !mode_is_float(get_irn_mode(l->node))) { + tv = relation & ir_relation_equal ? tarval_b_true : tarval_b_false; + + /* if the node was ONCE evaluated to a constant, but now this breaks AND we get from the argument partitions a different - result, switch to bottom. + result, ensure monotony by fall to bottom. This happens because initially all nodes are in the same partition ... */ - if (node->type.tv != tv) + if (node->type.tv != tv && is_constant_type(node->type)) tv = tarval_bottom; node->type.tv = tv; } else { node->type.tv = tarval_bottom; } -} /* compute_Proj_Cmp */ +} /** * (Re-)compute the type for a Proj(Cond). @@ -2498,28 +2438,23 @@ static void compute_Proj(node_t *node) /* mode M is always bottom */ node->type.tv = tarval_bottom; return; + } else if (mode == mode_X) { + /* handle mode_X nodes */ + switch (get_irn_opcode(pred)) { + case iro_Start: + /* the Proj_X from the Start is always reachable. + However this is already handled at the top. */ + node->type.tv = tarval_reachable; + return; + case iro_Cond: + compute_Proj_Cond(node, pred); + return; + default: + break; + } } - if (mode != mode_X) { - if (is_Cmp(pred)) - compute_Proj_Cmp(node, pred); - else - default_compute(node); - return; - } - /* handle mode_X nodes */ - switch (get_irn_opcode(pred)) { - case iro_Start: - /* the Proj_X from the Start is always reachable. - However this is already handled at the top. */ - node->type.tv = tarval_reachable; - break; - case iro_Cond: - compute_Proj_Cond(node, pred); - break; - default: - default_compute(node); - } + default_compute(node); } /* compute_Proj */ /** @@ -2532,7 +2467,7 @@ static void compute_Confirm(node_t *node) ir_node *confirm = node->node; node_t *pred = get_irn_node(get_Confirm_value(confirm)); - if (get_Confirm_cmp(confirm) == pn_Cmp_Eq) { + if (get_Confirm_relation(confirm) == ir_relation_equal) { node_t *bound = get_irn_node(get_Confirm_bound(confirm)); if (is_con(bound->type)) { @@ -2566,7 +2501,7 @@ static void compute(node_t *node) return; #endif - if (is_no_Block(irn)) { + if (!is_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)); @@ -2584,7 +2519,7 @@ static void compute(node_t *node) } /* compute */ /* - * Identity functions: Note that one might thing that identity() is just a + * Identity functions: Note that one might think that identity() is just a * synonym for equivalent_node(). While this is true, we cannot use it for the algorithm * here, because it expects that the identity node is one of the inputs, which is NOT * always true for equivalent_node() which can handle (and does sometimes) DAGs. @@ -2626,11 +2561,11 @@ static node_t *identity_Phi(node_t *node) */ static node_t *identity_comm_zero_binop(node_t *node) { - ir_node *op = node->node; - node_t *a = get_irn_node(get_binop_left(op)); - node_t *b = get_irn_node(get_binop_right(op)); - ir_mode *mode = get_irn_mode(op); - tarval *zero; + ir_node *op = node->node; + node_t *a = get_irn_node(get_binop_left(op)); + node_t *b = get_irn_node(get_binop_right(op)); + ir_mode *mode = get_irn_mode(op); + ir_tarval *zero; /* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */ if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic)) @@ -2651,10 +2586,10 @@ static node_t *identity_comm_zero_binop(node_t *node) */ 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; + ir_node *op = node->node; + node_t *b = get_irn_node(get_binop_right(op)); + ir_mode *mode = get_irn_mode(b->node); + ir_tarval *zero; /* node: no input should be tarval_top, else the binop would be also * Top and not being split. */ @@ -2669,11 +2604,11 @@ static node_t *identity_shift(node_t *node) */ static node_t *identity_Mul(node_t *node) { - ir_node *op = node->node; - node_t *a = get_irn_node(get_Mul_left(op)); - node_t *b = get_irn_node(get_Mul_right(op)); - ir_mode *mode = get_irn_mode(op); - tarval *one; + ir_node *op = node->node; + node_t *a = get_irn_node(get_Mul_left(op)); + node_t *b = get_irn_node(get_Mul_right(op)); + ir_mode *mode = get_irn_mode(op); + ir_tarval *one; /* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */ if (mode_is_float(mode) && (get_irg_fp_model(current_ir_graph) & fp_strict_algebraic)) @@ -2714,10 +2649,10 @@ static node_t *identity_Sub(node_t *node) */ static node_t *identity_And(node_t *node) { - ir_node *and = node->node; - node_t *a = get_irn_node(get_And_left(and)); - node_t *b = get_irn_node(get_And_right(and)); - tarval *neutral = get_mode_all_one(get_irn_mode(and)); + ir_node *andnode = node->node; + node_t *a = get_irn_node(get_And_left(andnode)); + node_t *b = get_irn_node(get_And_right(andnode)); + ir_tarval *neutral = get_mode_all_one(get_irn_mode(andnode)); /* node: no input should be tarval_top, else the And would be also * Top and not being split. */ @@ -3052,7 +2987,7 @@ static int can_exchange(ir_node *pred, ir_node *block) */ static void apply_cf(ir_node *block, void *ctx) { - environment_t *env = ctx; + environment_t *env = (environment_t*)ctx; node_t *node = get_irn_node(block); int i, j, k, n; ir_node **ins, **in_X; @@ -3067,18 +3002,21 @@ static void apply_cf(ir_node *block, void *ctx) ir_node *pred = get_Block_cfgpred(block, i); if (! is_Bad(pred)) { - node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred))); - - if (pred_bl->flagged == 0) { - pred_bl->flagged = 3; - - if (pred_bl->type.tv == tarval_reachable) { - /* - * We will remove an edge from block to its pred. - * This might leave the pred block as an endless loop - */ - if (! is_backedge(block, i)) - keep_alive(pred_bl->node); + ir_node *pred_block = get_nodes_block(skip_Proj(pred)); + if (!is_Bad(pred_block)) { + node_t *pred_bl = get_irn_node(pred_block); + + if (pred_bl->flagged == 0) { + pred_bl->flagged = 3; + + if (pred_bl->type.tv == tarval_reachable) { + /* + * We will remove an edge from block to its pred. + * This might leave the pred block as an endless loop + */ + if (! is_backedge(block, i)) + keep_alive(pred_bl->node); + } } } } @@ -3088,7 +3026,9 @@ static void apply_cf(ir_node *block, void *ctx) finds out the opposite :-) */ if (block != get_irg_end_block(current_ir_graph)) { /* mark dead blocks */ - set_Block_dead(block); + //set_Block_dead(block); + //ir_graph *irg = get_irn_irg(block); + //exchange(block, get_irg_bad(irg)); DB((dbg, LEVEL_1, "Removing dead %+F\n", block)); } else { /* the endblock is unreachable */ @@ -3123,18 +3063,21 @@ static void apply_cf(ir_node *block, void *ctx) } else { DB((dbg, LEVEL_1, "Removing dead input %d from %+F (%+F)\n", i, block, pred)); if (! is_Bad(pred)) { - node_t *pred_bl = get_irn_node(get_nodes_block(skip_Proj(pred))); - - if (pred_bl->flagged == 0) { - pred_bl->flagged = 3; - - if (pred_bl->type.tv == tarval_reachable) { - /* - * We will remove an edge from block to its pred. - * This might leave the pred block as an endless loop - */ - if (! is_backedge(block, i)) - keep_alive(pred_bl->node); + ir_node *pred_block = get_nodes_block(skip_Proj(pred)); + if (!is_Bad(pred_block)) { + node_t *pred_bl = get_irn_node(pred_block); + + if (!is_Bad(pred_bl->node) && pred_bl->flagged == 0) { + pred_bl->flagged = 3; + + if (pred_bl->type.tv == tarval_reachable) { + /* + * We will remove an edge from block to its pred. + * This might leave the pred block as an endless loop + */ + if (! is_backedge(block, i)) + keep_alive(pred_bl->node); + } } } } @@ -3151,8 +3094,8 @@ static void apply_cf(ir_node *block, void *ctx) next = get_Phi_next(phi); if (is_tarval(node->type.tv) && tarval_is_constant(node->type.tv)) { /* this Phi is replaced by a constant */ - tarval *tv = node->type.tv; - ir_node *c = new_Const(tv); + ir_tarval *tv = node->type.tv; + ir_node *c = new_r_Const(current_ir_graph, tv); set_irn_node(c, node); node->node = c; @@ -3221,8 +3164,20 @@ static void exchange_leader(ir_node *irn, ir_node *leader) * 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, block, leader, mode); + ir_node *nlead = new_rd_Conv(dbg, block, leader, mode); + + if (nlead != leader) { + /* Note: this newly create irn has no node info because + * it is created after the analysis. However, this node + * replaces the node irn and should not be visited again, + * so set its visited count to the count of irn. + * Otherwise we might visited this node more than once if + * irn had more than one user. + */ + set_irn_node(nlead, NULL); + set_irn_visited(nlead, get_irn_visited(irn)); + leader = nlead; + } } exchange(irn, leader); } /* exchange_leader */ @@ -3261,7 +3216,7 @@ static int all_users_are_dead(const ir_node *irn) */ static void find_kept_memory(ir_node *irn, void *ctx) { - environment_t *env = ctx; + environment_t *env = (environment_t*)ctx; node_t *node, *block; if (get_irn_mode(irn) != mode_M) @@ -3287,7 +3242,7 @@ static void find_kept_memory(ir_node *irn, void *ctx) */ static void apply_result(ir_node *irn, void *ctx) { - environment_t *env = ctx; + environment_t *env = (environment_t*)ctx; node_t *node = get_irn_node(irn); if (is_Block(irn) || is_End(irn) || is_Bad(irn)) { @@ -3356,8 +3311,8 @@ static void apply_result(ir_node *irn, void *ctx) exchange(irn, jmp); env->modified = 1; } else { - node_t *sel = get_irn_node(get_Cond_selector(cond)); - tarval *tv = sel->type.tv; + node_t *sel = get_irn_node(get_Cond_selector(cond)); + ir_tarval *tv = sel->type.tv; if (is_tarval(tv) && tarval_is_constant(tv)) { /* The selector is a constant, but more @@ -3371,7 +3326,7 @@ static void apply_result(ir_node *irn, void *ctx) } else { /* normal data node */ if (is_tarval(node->type.tv) && tarval_is_constant(node->type.tv)) { - tarval *tv = node->type.tv; + ir_tarval *tv = node->type.tv; /* * Beware: never replace mode_T nodes by constants. Currently we must mark @@ -3379,7 +3334,7 @@ static void apply_result(ir_node *irn, void *ctx) */ if (! is_Const(irn) && get_irn_mode(irn) != mode_T) { /* can be replaced by a constant */ - ir_node *c = new_Const(tv); + ir_node *c = new_r_Const(current_ir_graph, tv); set_irn_node(c, node); node->node = c; DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, c)); @@ -3444,20 +3399,29 @@ static void apply_result(ir_node *irn, void *ctx) static void apply_end(ir_node *end, environment_t *env) { int i, j, n = get_End_n_keepalives(end); - ir_node **in; + ir_node **in = NULL; 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); + ir_node *ka = get_End_keepalive(end, i); + ir_node *block; + node_t *node; - if (! is_Block(ka)) - node = get_irn_node(get_nodes_block(ka)); + if (is_Bad(ka)) + continue; + if (!is_Block(ka)) { + block = get_nodes_block(ka); + if (is_Bad(block)) + continue; + } else { + block = ka; + } - if (node->type.tv != tarval_unreachable && !is_Bad(ka)) + node = get_irn_node(block); + if (node->type.tv != tarval_unreachable) in[j++] = ka; } if (j != n) { @@ -3473,10 +3437,10 @@ static void apply_end(ir_node *end, environment_t *env) */ static void set_compute_functions(void) { - int i; + size_t i, n; /* set the default compute function */ - for (i = get_irp_n_opcodes() - 1; i >= 0; --i) { + for (i = 0, n = get_irp_n_opcodes(); i < n; ++i) { ir_op *op = get_irp_opcode(i); op->ops.generic = (op_func)default_compute; } @@ -3491,6 +3455,7 @@ static void set_compute_functions(void) SET(Sub); SET(Eor); SET(SymConst); + SET(Cmp); SET(Proj); SET(Confirm); SET(Return); @@ -3501,10 +3466,11 @@ static void set_compute_functions(void) /** * Add memory keeps. */ -static void add_memory_keeps(ir_node **kept_memory, int len) +static void add_memory_keeps(ir_node **kept_memory, size_t len) { ir_node *end = get_irg_end(current_ir_graph); int i; + size_t idx; ir_nodeset_t set; ir_nodeset_init(&set); @@ -3513,8 +3479,8 @@ static void add_memory_keeps(ir_node **kept_memory, int len) for (i = get_End_n_keepalives(end) - 1; i >= 0; --i) ir_nodeset_insert(&set, get_End_keepalive(end, i)); - for (i = len - 1; i >= 0; --i) { - ir_node *ka = kept_memory[i]; + for (idx = 0; idx < len; ++idx) { + ir_node *ka = kept_memory[idx]; if (! ir_nodeset_contains(&set, ka)) { add_End_keepalive(end, ka); @@ -3529,7 +3495,7 @@ void combo(ir_graph *irg) ir_node *initial_bl; node_t *start; ir_graph *rem = current_ir_graph; - int len; + size_t len; current_ir_graph = irg;