#include <assert.h>
#include "iroptimize.h"
-#include "archop.h"
#include "irflag.h"
#include "ircons.h"
#include "list.h"
#include "array_t.h"
#include "error.h"
#include "irnodeset.h"
-
+#include "irpass.h"
#include "tv_t.h"
#include "irprintf.h"
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;
};
partition_t *touched; /**< the touched set. */
partition_t *initial; /**< The initial partition. */
set *opcode2id_map; /**< The opcodeMode->id map. */
- pmap *type2id_map; /**< The type->id map. */
ir_node **kept_memory; /**< Array of memory nodes that must be kept. */
int end_idx; /**< -1 for local and 0 for global congruences. */
int lambda_input; /**< Captured argument for lambda_partition(). */
key.u.intVal = get_Conv_strict(irn);
break;
case iro_Div:
- key.u.intVal = is_Div_remainderless(irn);
+ 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;
} else {
- assert(key.code == get_irn_opcode(irn));
+ assert((unsigned)key.code == get_irn_opcode(irn));
assert(key.mode == get_irn_mode(irn));
assert(key.arity == get_irn_arity(irn));
assert(key.u.intVal == get_Conv_strict(irn));
break;
case iro_Div:
- assert(key.u.intVal == is_Div_remainderless(irn));
+ 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(leader != node && leader->part == node->part);
}
}
+#else
+ (void) env;
#endif
}
* Check list.
*/
static void do_check_list(const node_t *list, int ofs, const partition_t *Z) {
- const node_t *e;
+#ifndef NDEBUG
+ 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
+#else
+ (void) list;
+ (void) ofs;
+ (void) Z;
+#endif
} /* ido_check_list */
/**
* @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) + entry->arity;
+ return (entry->mode - (ir_mode *)0) * 9 + entry->code + entry->u.proj * 3 + HASH_PTR(entry->u.ptr) + entry->arity;
} /* opcode_hash */
/**
(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 ||
- o1->u.intVal != o2->u.intVal;
+ o1->u.proj != o2->u.proj ||
+ o1->u.intVal != o2->u.intVal || /* this already checks uIntVal */
+ o1->u.ptr != o2->u.ptr;
} /* cmp_opcode */
/**
* @return a newly allocated partition
*/
static inline partition_t *new_partition(environment_t *env) {
- partition_t *part = obstack_alloc(&env->obst, sizeof(*part));
+ partition_t *part = OALLOC(&env->obst, partition_t);
INIT_LIST_HEAD(&part->Leader);
INIT_LIST_HEAD(&part->Follower);
*/
static node_t *create_partition_node(ir_node *irn, partition_t *part, environment_t *env) {
/* create a partition node and place it in the partition */
- node_t *node = obstack_alloc(&env->obst, sizeof(*node));
+ node_t *node = OALLOC(&env->obst, node_t);
INIT_LIST_HEAD(&node->node_list);
INIT_LIST_HEAD(&node->cprop_list);
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;
/**
* Collect commutative nodes to the touched list.
*
- * @param X the partition of the list
* @param list the list which contains the nodes that must be evaluated
* @param env the environment
*/
-static void collect_commutative_touched(partition_t *X, list_head *list, environment_t *env) {
- int first = 1;
- int both_input = 0;
+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) {
/* 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)) {
- int other_idx = edge->pos ^ 1;
- node_t *other = get_irn_node(get_irn_n(succ, other_idx));
- int equal = X == other->part;
-
- /*
- * Note: op(a, a) is NOT congruent to op(a, b).
- * So, either all touch nodes must have both inputs congruent,
- * or not. We decide this by the first occurred node.
- */
- if (first) {
- first = 0;
- both_input = equal;
- }
- if (both_input == equal)
- add_to_touched(y, env);
+ add_to_touched(y, env);
}
}
}
/* empty the touched set: already done, just clear the list */
env->touched = NULL;
- collect_commutative_touched(X, &X->Leader, env);
- collect_commutative_touched(X, &X->Follower, env);
+ 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;
+ node_t *e, *n;
+ node_t *touched = Z->touched;
+ node_t *touched_aa = NULL;
+ node_t *touched_ab = NULL;
+ unsigned n_touched_aa = 0;
+ unsigned n_touched_ab = 0;
assert(Z->touched != NULL);
Z->on_touched = 0;
/* Empty local Z.touched. */
- for (e = touched; e != NULL; e = e->next) {
+ for (e = touched; e != NULL; e = n) {
+ node_t *left = get_irn_node(get_irn_n(e->node, 0));
+ node_t *right = get_irn_node(get_irn_n(e->node, 1));
+
assert(e->is_follower == 0);
e->on_touched = 0;
+ n = e->next;
+
+ /*
+ * Note: op(a, a) is NOT congruent to op(a, b).
+ * So, we must split the touched list.
+ */
+ if (left->part == right->part) {
+ e->next = touched_aa;
+ touched_aa = e;
+ ++n_touched_aa;
+ } else {
+ e->next = touched_ab;
+ touched_ab = e;
+ ++n_touched_ab;
+ }
}
+ assert(n_touched_aa + n_touched_ab == Z->n_touched);
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);
+ if (0 < n_touched_aa && n_touched_aa < Z->n_leader) {
+ partition_t *Z_prime = Z;
+ DB((dbg, LEVEL_2, "Split part%d by touched_aa\n", Z_prime->nr));
+ split(&Z_prime, touched_aa, env);
} else
- assert(n_touched <= Z->n_leader);
+ assert(n_touched_aa <= Z->n_leader);
+
+ if (0 < n_touched_ab && n_touched_ab < Z->n_leader) {
+ partition_t *Z_prime = Z;
+ DB((dbg, LEVEL_2, "Split part%d by touched_ab\n", Z_prime->nr));
+ split(&Z_prime, touched_ab, env);
+ } else
+ assert(n_touched_ab <= Z->n_leader);
}
}
key.u.intVal = get_Conv_strict(irn);
break;
case iro_Div:
- key.u.intVal = is_Div_remainderless(irn);
+ 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;
pred = i == -1 ? get_irn_n(skipped, i) : get_irn_n(node->node, i);
p = get_irn_node(pred);
-
return p->part;
} /* lambda_partition */
int i;
ir_node *block = node->node;
- if (block == get_irg_start_block(current_ir_graph)) {
- /* start block is always reachable */
+ if (block == get_irg_start_block(current_ir_graph) || has_Block_entity(block)) {
+ /* start block and labelled blocks are always reachable */
node->type.tv = tarval_reachable;
return;
}
* It would be safe to compute Top IF it can be assured, that only Cmp
* 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...
+ * (jump threading for instance) might replace them by Phib's...
*/
node->type.tv = tarval_UNKNOWN;
} /* compute_Unknown */
node->type.tv = tarval_reachable;
} else if (selector->type.tv == tarval_top) {
if (tarval_UNKNOWN == tarval_top &&
- pnc == get_Cond_defaultProj(cond)) {
+ pnc == get_Cond_default_proj(cond)) {
/* a switch based of Top is always "default" */
node->type.tv = tarval_reachable;
} else {
}
} else {
long value = get_tarval_long(selector->type.tv);
- if (pnc == get_Cond_defaultProj(cond)) {
+ if (pnc == get_Cond_default_proj(cond)) {
/* default switch, have to check ALL other cases */
int i;
node->type = pred->type;
} /* compute_Confirm */
-/**
- * (Re-)compute the type for a Max.
- *
- * @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;
-
- 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 */
- node->type = a;
- } else {
- ir_mode *mode = get_irn_mode(op);
- tarval *tv_min = get_mode_min(mode);
-
- if (a.tv == tv_min)
- node->type = b;
- else if (b.tv == tv_min)
- node->type = a;
- else if (is_tarval(a.tv) && is_tarval(b.tv)) {
- if (tarval_cmp(a.tv, b.tv) & pn_Cmp_Gt)
- node->type.tv = a.tv;
- else
- node->type.tv = b.tv;
- } else {
- node->type.tv = tarval_bad;
- }
- }
- } else if (r->part == l->part) {
- /* both nodes congruent, we can probably do something */
- node->type = a;
- } else {
- node->type.tv = tarval_bottom;
- }
-} /* compute_Max */
-
-/**
- * (Re-)compute the type for a Min.
- *
- * @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;
-
- 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 */
- node->type = a;
- } else {
- ir_mode *mode = get_irn_mode(op);
- tarval *tv_max = get_mode_max(mode);
-
- if (a.tv == tv_max)
- node->type = b;
- else if (b.tv == tv_max)
- node->type = a;
- else if (is_tarval(a.tv) && is_tarval(b.tv)) {
- if (tarval_cmp(a.tv, b.tv) & pn_Cmp_Gt)
- node->type.tv = a.tv;
- else
- node->type.tv = b.tv;
- } else {
- node->type.tv = tarval_bad;
- }
- }
- } else if (r->part == l->part) {
- /* both nodes congruent, we can probably do something */
- node->type = a;
- } else {
- node->type.tv = tarval_bottom;
- }
-} /* compute_Min */
-
/**
* (Re-)compute the type for a given node.
*
return node;
} /* identity_Mux */
-/**
- * Calculates the Identity for Min nodes.
- */
-static node_t *identity_Min(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 *tv_max;
-
- if (a->part == b->part) {
- /* leader of multiple predecessors */
- return a;
- }
-
- /* works even with NaN */
- tv_max = get_mode_max(mode);
- if (a->type.tv == tv_max)
- return b;
- if (b->type.tv == tv_max)
- return a;
- return node;
-} /* identity_Min */
-
-/**
- * Calculates the Identity for Max nodes.
- */
-static node_t *identity_Max(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 *tv_min;
-
- if (a->part == b->part) {
- /* leader of multiple predecessors */
- return a;
- }
-
- /* works even with NaN */
- tv_min = get_mode_min(mode);
- if (a->type.tv == tv_min)
- return b;
- if (b->type.tv == tv_min)
- return a;
- return node;
-} /* identity_Max */
-
/**
* Calculates the Identity for nodes.
*/
return identity_Confirm(node);
case iro_Mux:
return identity_Mux(node);
- case iro_Min:
- return identity_Min(node);
- case iro_Max:
- return identity_Max(node);
default:
return node;
}
* Return non-zero if the control flow predecessor node pred
* is the only reachable control flow exit of its block.
*
- * @param pred the control flow exit
+ * @param pred the control flow exit
+ * @param block the destination block
*/
-static int can_exchange(ir_node *pred) {
- if (is_Start(pred))
+static int can_exchange(ir_node *pred, ir_node *block) {
+ if (is_Start(pred) || has_Block_entity(block))
return 0;
else if (is_Jmp(pred))
return 1;
/* only one predecessor combine */
ir_node *pred = skip_Proj(get_Block_cfgpred(block, 0));
- if (can_exchange(pred)) {
+ if (can_exchange(pred, block)) {
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);
/* this Block has only one live predecessor */
ir_node *pred = skip_Proj(in_X[0]);
- if (can_exchange(pred)) {
+ if (can_exchange(pred, block)) {
ir_node *new_block = get_nodes_block(pred);
DBG_OPT_COMBO(block, new_block, FS_OPT_COMBO_CF);
exchange(block, new_block);
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);
+ leader = new_rd_Conv(dbg, block, leader, mode);
}
exchange(irn, leader);
} /* exchange_leader */
if (is_Cond(cond)) {
if (only_one_reachable_proj(cond)) {
- ir_node *jmp = new_r_Jmp(current_ir_graph, block->node);
+ ir_node *jmp = new_r_Jmp(block->node);
set_irn_node(jmp, node);
node->node = jmp;
DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, jmp));
} else if (is_entity(node->type.sym.entity_p)) {
if (! is_SymConst(irn)) {
/* 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);
+ ir_node *symc = new_r_SymConst(current_ir_graph, get_irn_mode(irn), node->type.sym, symconst_addr_ent);
set_irn_node(symc, node);
node->node = symc;
SET(Return);
SET(End);
SET(Call);
-
- if (op_Max != NULL)
- SET(Max);
- if (op_Min != NULL)
- SET(Min);
} /* set_compute_functions */
/**
env.dbg_list = NULL;
#endif
env.opcode2id_map = new_set(cmp_opcode, iro_Last * 4);
- env.type2id_map = pmap_create();
env.kept_memory = NEW_ARR_F(ir_node *, 0);
env.end_idx = get_opt_global_cse() ? 0 : -1;
env.lambda_input = 0;
set_irg_extblk_inconsistent(irg);
set_irg_doms_inconsistent(irg);
set_irg_loopinfo_inconsistent(irg);
+ set_irg_entity_usage_state(irg, ir_entity_usage_not_computed);
}
ir_free_resources(irg, IR_RESOURCE_IRN_LINK | IR_RESOURCE_PHI_LIST);
DEBUG_ONLY(set_dump_node_vcgattr_hook(NULL));
DEL_ARR_F(env.kept_memory);
- pmap_destroy(env.type2id_map);
del_set(env.opcode2id_map);
obstack_free(&env.obst, NULL);
set_value_of_func(NULL);
current_ir_graph = rem;
} /* combo */
+
+/* Creates an ir_graph pass for combo. */
+ir_graph_pass_t *combo_pass(const char *name)
+{
+ return def_graph_pass(name ? name : "combo", combo);
+} /* combo_pass */