# include "irflag_t.h"
# include "firmstat.h"
# include "irarch.h"
+# include "hashptr.h"
/* Make types visible to allow most efficient access */
# include "entity_t.h"
+# ifdef DO_HEAPANALYSIS
+/* heapanal can't cope with NoMems */
+# else /* if defined DO_HEAPANALYSIS */
+# define USE_NOMEM
+# endif /* defined DO_HEAPANALYSIS */
+
/**
* Trivial INLINEable routine for copy propagation.
* Does follow Ids, needed to optimize INLINEd code.
ab = get_Cmp_right(a);
proj_nr = get_Proj_proj(n);
- if (aa == ab) { /* 1.: */
+ if (aa == ab && !mode_is_float(get_irn_mode(aa))) { /* 1.: */
+ /* BEWARE: a == a is NOT always True for floating Point!!! */
/* This is a trick with the bits used for encoding the Cmp
Proj numbers, the following statement is not the same:
return new_tarval_from_long (proj_nr == Eq, mode_b) */
if (n_mode == b_mode) {
if (n_mode == mode_b) {
n = b; /* Convb(Conv*(xxxb(...))) == xxxb(...) */
- DBG_OPT_ALGSIM1(oldn, a, b, n);
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
}
else if (mode_is_int(n_mode) || mode_is_character(n_mode)) {
if (smaller_mode(b_mode, a_mode)){
n = b; /* ConvS(ConvL(xxxS(...))) == xxxS(...) */
- DBG_OPT_ALGSIM1(oldn, a, b, n);
+ DBG_OPT_ALGSIM1(oldn, a, b, n);
}
}
}
return n;
}
+/**
+ * A Cast may be removed if the type of the previous node
+ * is already to type of the Cast.
+ */
static ir_node *equivalent_node_Cast(ir_node *n) {
ir_node *pred = get_Cast_op(n);
if (get_irn_type(pred) == get_Cast_type(n))
return n;
}
+/* Several optimizations:
+ - no Phi in start block.
+ - remove Id operators that are inputs to Phi
+ - fold Phi-nodes, iff they have only one predecessor except
+ themselves.
+*/
static ir_node *equivalent_node_Phi(ir_node *n)
{
- /* Several optimizations:
- - no Phi in start block.
- - remove Id operators that are inputs to Phi
- - fold Phi-nodes, iff they have only one predecessor except
- themselves.
- */
int i, n_preds;
ir_node *oldn = n;
} /* end switch */
}
+/**
+ * Transform AddP(P, ConvIs(Iu)), AddP(P, ConvIu(Is)) and
+ * SubP(P, ConvIs(Iu)), SubP(P, ConvIu(Is)) if possible.
+ */
+static ir_node *transform_node_AddSub(ir_node *n)
+{
+ ir_mode *mode = get_irn_mode(n);
+
+ if (mode_is_reference(mode)) {
+ ir_node *left = get_binop_left(n);
+ ir_node *right = get_binop_right(n);
+ int ref_bits = get_mode_size_bits(mode);
+
+ if (get_irn_op(left) == op_Conv) {
+ ir_mode *mode = get_irn_mode(left);
+ int bits = get_mode_size_bits(mode);
+
+ if (ref_bits == bits &&
+ mode_is_int(mode) &&
+ get_mode_arithmetic(mode) == irma_twos_complement) {
+ ir_node *pre = get_Conv_op(left);
+ ir_mode *pre_mode = get_irn_mode(pre);
+
+ if (mode_is_int(pre_mode) &&
+ get_mode_size_bits(pre_mode) == bits &&
+ get_mode_arithmetic(pre_mode) == irma_twos_complement) {
+ /* ok, this conv just changes to sign, moreover the calculation
+ * is done with same number of bits as our address mode, so
+ * we can ignore the conv as address calculation can be viewed
+ * as either signed or unsigned
+ */
+ set_binop_left(n, pre);
+ }
+ }
+ }
+
+ if (get_irn_op(right) == op_Conv) {
+ ir_mode *mode = get_irn_mode(right);
+ int bits = get_mode_size_bits(mode);
+
+ if (ref_bits == bits &&
+ mode_is_int(mode) &&
+ get_mode_arithmetic(mode) == irma_twos_complement) {
+ ir_node *pre = get_Conv_op(right);
+ ir_mode *pre_mode = get_irn_mode(pre);
+
+ if (mode_is_int(pre_mode) &&
+ get_mode_size_bits(pre_mode) == bits &&
+ get_mode_arithmetic(pre_mode) == irma_twos_complement) {
+ /* ok, this conv just changes to sign, moreover the calculation
+ * is done with same number of bits as our address mode, so
+ * we can ignore the conv as address calculation can be viewed
+ * as either signed or unsigned
+ */
+ set_binop_right(n, pre);
+ }
+ }
+ }
+ }
+ return n;
+}
+
+#define transform_node_Add transform_node_AddSub
+#define transform_node_Sub transform_node_AddSub
+
/** Do architecture dependend optimizations on Mul nodes */
static ir_node *transform_node_Mul(ir_node *n) {
return arch_dep_replace_mul_with_shifts(n);
return n;
}
+/**
+ * Transform an Eor.
+ */
static ir_node *transform_node_Eor(ir_node *n)
{
ir_node *a = get_Eor_left(n);
if (get_irn_op(pred) == op_Const && get_Const_type(pred) != tp) {
n = new_rd_Const_type(NULL, current_ir_graph, get_nodes_block(pred), get_irn_mode(pred),
- get_Const_tarval(pred), tp);
+ get_Const_tarval(pred), tp);
} else if ((get_irn_op(pred) == op_SymConst) && (get_SymConst_value_type(pred) != tp)) {
n = new_rd_SymConst_type(NULL, current_ir_graph, get_nodes_block(pred), get_SymConst_symbol(pred),
- get_SymConst_kind(pred), tp);
+ get_SymConst_kind(pred), tp);
}
return n;
}
* Transform a Div/Mod/DivMod with a non-zero constant. Must be
* done here instead of equivalent node because it creates new
* nodes.
- * Removes the exceptions and routes the memory to the initial mem.
+ * Removes the exceptions and routes the memory to the NoMem node.
*
* Further, it optimizes jump tables by removing all impossible cases.
*/
if (proj_nr == pn_Div_X_except) {
/* we found an exception handler, remove it */
return new_Bad();
- }
- else {
- /* the memory Proj can be removed */
+ } else {
+ /* the memory Proj can be removed */
ir_node *res = get_Div_mem(n);
- set_Div_mem(n, get_irg_initial_mem(current_ir_graph));
-
- if (proj_nr == pn_Div_M)
+# ifdef USE_NOMEM
+ set_Div_mem(n, get_irg_no_mem(current_ir_graph));
+# endif /* defined USE_NOMEM */
+ if (proj_nr == pn_Div_M)
return res;
}
}
if (proj_nr == pn_Mod_X_except) {
/* we found an exception handler, remove it */
return new_Bad();
- }
- else {
- /* the memory Proj can be removed */
+ } else {
+ /* the memory Proj can be removed */
ir_node *res = get_Mod_mem(n);
- set_Mod_mem(n, get_irg_initial_mem(current_ir_graph));
+# ifdef USE_NOMEM
+ set_Mod_mem(n, get_irg_no_mem(current_ir_graph));
+# endif /* defined USE_NOMEM */
if (proj_nr == pn_Mod_M)
- return res;
+ return res;
}
}
break;
return new_Bad();
}
else {
- /* the memory Proj can be removed */
+ /* the memory Proj can be removed */
ir_node *res = get_DivMod_mem(n);
- set_DivMod_mem(n, get_irg_initial_mem(current_ir_graph));
+# ifdef USE_NOMEM
+ set_DivMod_mem(n, get_irg_no_mem(current_ir_graph));
+# endif /* defined USE_NOMEM */
if (proj_nr == pn_DivMod_M)
- return res;
+ return res;
}
}
break;
break
switch (op->code) {
+ CASE(Add);
+ CASE(Sub);
CASE(Mul);
CASE(Div);
CASE(Mod);
return (get_irn_call_attr(a) != get_irn_call_attr(b));
}
-/** Compares the attributes of two FuncCall nodes. */
-static int node_cmp_attr_FuncCall(ir_node *a, ir_node *b)
-{
- return (get_irn_funccall_attr(a) != get_irn_funccall_attr(b));
-}
-
/** Compares the attributes of two Sel nodes. */
static int node_cmp_attr_Sel(ir_node *a, ir_node *b)
{
CASE(Free);
CASE(SymConst);
CASE(Call);
- CASE(FuncCall);
CASE(Sel);
CASE(Phi);
CASE(Cast);
return 0;
}
-#define ADDR_TO_VAL(p) (((unsigned)(p)) >> 3)
-
/*
* Calculate a hash value of a node.
*/
if (node->op == op_Const) {
/* special value for const, as they only differ in their tarval. */
- h = ADDR_TO_VAL(node->attr.con.tv);
- h = 9*h + ADDR_TO_VAL(get_irn_mode(node));
+ h = HASH_PTR(node->attr.con.tv);
+ h = 9*h + HASH_PTR(get_irn_mode(node));
} else if (node->op == op_SymConst) {
/* special value for const, as they only differ in their symbol. */
- h = ADDR_TO_VAL(node->attr.i.sym.type_p);
- h = 9*h + ADDR_TO_VAL(get_irn_mode(node));
+ h = HASH_PTR(node->attr.i.sym.type_p);
+ h = 9*h + HASH_PTR(get_irn_mode(node));
} else {
/* hash table value = 9*(9*(9*(9*(9*arity+in[0])+in[1])+ ...)+mode)+code */
/* consider all in nodes... except the block if not a control flow. */
for (i = is_cfop(node) ? -1 : 0; i < irn_arity; i++) {
- h = 9*h + ADDR_TO_VAL(get_irn_intra_n(node, i));
+ h = 9*h + HASH_PTR(get_irn_intra_n(node, i));
}
/* ...mode,... */
- h = 9*h + ADDR_TO_VAL(get_irn_mode(node));
+ h = 9*h + HASH_PTR(get_irn_mode(node));
/* ...and code */
- h = 9*h + ADDR_TO_VAL(get_irn_op(node));
+ h = 9*h + HASH_PTR(get_irn_op(node));
}
return h;
oldn = alloca(node_size);
memcpy(oldn, n, node_size);
- CLONE_ARR_A(ir_node *, oldn->in, n->in);
+ CLONE_ARR_A(ir_node *, oldn->in, n->in);
- /* ARG, copy the in array, we need it for statistics */
- memcpy(oldn->in, n->in, ARR_LEN(n->in) * sizeof(n->in[0]));
+ /* ARG, copy the in array, we need it for statistics */
+ memcpy(oldn->in, n->in, ARR_LEN(n->in) * sizeof(n->in[0]));
/* evaluation was successful -- replace the node. */
obstack_free (current_ir_graph->obst, n);
n = new_Const (get_tarval_mode (tv), tv);
- if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv))
- set_Const_type(n, old_tp);
+ if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv))
+ set_Const_type(n, old_tp);
DBG_OPT_CSTEVAL(oldn, n);
return n;
}
/* evaluation was successful -- replace the node. */
n = new_Const (get_tarval_mode (tv), tv);
- if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv))
- set_Const_type(n, old_tp);
+ if (old_tp && get_type_mode(old_tp) == get_tarval_mode (tv))
+ set_Const_type(n, old_tp);
DBG_OPT_CSTEVAL(oldn, n);
return n;