/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-** All rights reserved.
-**
-** Authors: Christian Schaefer, Goetz Lindenmaier
-**
-** iropt --- optimizations intertwined with IR construction.
+* All rights reserved.
+*
+* Authors: Christian Schaefer, Goetz Lindenmaier
+*
+* iropt --- optimizations intertwined with IR construction.
*/
/* $Id$ */
/* Make types visible to allow most efficient access */
# include "entity_t.h"
-/* Trivial inlineable routine for copy propagation.
- Does follow Ids, needed to optimize inlined code. */
-static inline ir_node *
+/* Trivial INLINEable routine for copy propagation.
+ Does follow Ids, needed to optimize INLINEd code. */
+static INLINE ir_node *
follow_Id (ir_node *n)
{
while (get_irn_op (n) == op_Id) n = get_Id_pred (n);
return n;
}
-static inline tarval *
+static INLINE tarval *
value_of (ir_node *n)
{
if ((n != NULL) && (get_irn_op(n) == op_Const))
case iro_SymConst:
if ((get_SymConst_kind(n) == size) &&
(get_type_state(get_SymConst_type(n))) == layout_fixed)
- res = tarval_from_long (mode_i, get_type_size(get_SymConst_type(n)));
+ res = tarval_from_long (mode_Is, get_type_size(get_SymConst_type(n)));
break;
case iro_Add:
if (ta && tb && (get_irn_mode(a) == get_irn_mode(b))
- && (get_irn_mode(a) != mode_p)) {
+ && (get_irn_mode(a) != mode_P)) {
res = tarval_add (ta, tb);
}
break;
case iro_Sub:
if (ta && tb && (get_irn_mode(a) == get_irn_mode(b))
- && (get_irn_mode(a) != mode_p)) {
+ && (get_irn_mode(a) != mode_P)) {
res = tarval_sub (ta, tb);
} else if (a == b) {
res = tarval_mode_null [get_irn_modecode (n)];
only 1 is used.
There are several case where we can evaluate a Cmp node:
1. The nodes compared are both the same. If we compare for
- equal, this will return true, else it will return false.
- This step relies on cse.
+ equal, greater equal, ... this will return true, else it
+ will return false. This step relies on cse.
2. The predecessors of Cmp are target values. We can evaluate
the Cmp.
3. The predecessors are Allocs or void* constants. Allocs never
ir_node *aba = skip_nop(skip_Proj(ab));
if ( ( (/* aa is ProjP and aaa is Alloc */
(get_irn_op(aa) == op_Proj)
- && (get_irn_mode(aa) == mode_p)
+ && (get_irn_mode(aa) == mode_P)
&& (get_irn_op(aaa) == op_Alloc))
&& ( (/* ab is constant void */
(get_irn_op(ab) == op_Const)
- && (get_irn_mode(ab) == mode_p)
- && (get_Const_tarval(ab) == tarval_p_void))
+ && (get_irn_mode(ab) == mode_P)
+ && (get_Const_tarval(ab) == tarval_P_void))
|| (/* ab is other Alloc */
(get_irn_op(ab) == op_Proj)
- && (get_irn_mode(ab) == mode_p)
+ && (get_irn_mode(ab) == mode_P)
&& (get_irn_op(aba) == op_Alloc)
&& (aaa != aba))))
|| (/* aa is void and aba is Alloc */
(get_irn_op(aa) == op_Const)
- && (get_irn_mode(aa) == mode_p)
- && (get_Const_tarval(aa) == tarval_p_void)
+ && (get_irn_mode(aa) == mode_P)
+ && (get_Const_tarval(aa) == tarval_P_void)
&& (get_irn_op(ab) == op_Proj)
- && (get_irn_mode(ab) == mode_p)
+ && (get_irn_mode(ab) == mode_P)
&& (get_irn_op(aba) == op_Alloc)))
/* 3.: */
res = tarval_from_long (mode_b, get_Proj_proj(n) & irpn_Ne);
/* returns 1 if the a and b are pointers to different locations. */
-bool
+static bool
different_identity (ir_node *a, ir_node *b)
{
- assert (get_irn_mode (a) == mode_p
- && get_irn_mode (b) == mode_p);
+ assert (get_irn_mode (a) == mode_P
+ && get_irn_mode (b) == mode_P);
if (get_irn_op (a) == op_Proj && get_irn_op(b) == op_Proj) {
ir_node *a1 = get_Proj_pred (a);
Remaining Phi nodes are just Ids. */
if ((get_Block_n_cfgpreds(n) == 1) &&
(get_irn_op(get_Block_cfgpred(n, 0)) == op_Jmp) &&
- (get_opt_control_flow())) {
+ (get_opt_control_flow_straightening())) {
n = get_nodes_Block(get_Block_cfgpred(n, 0)); DBG_OPT_STG;
+
} else if ((get_Block_n_cfgpreds(n) == 2) &&
- (get_opt_control_flow())) {
+ (get_opt_control_flow_weak_simplification())) {
/* Test whether Cond jumps twice to this block
@@@ we could do this also with two loops finding two preds from several ones. */
a = get_Block_cfgpred(n, 0);
if ((get_irn_op(a) == op_Proj) &&
(get_irn_op(b) == op_Proj) &&
(get_Proj_pred(a) == get_Proj_pred(b)) &&
- (get_irn_op(get_Proj_pred(a)) == op_Cond)) {
+ (get_irn_op(get_Proj_pred(a)) == op_Cond) &&
+ (get_irn_mode(get_Cond_selector(get_Proj_pred(a))) == mode_b)) {
/* Also a single entry Block following a single exit Block. Phis have
twice the same operand and will be optimized away. */
n = get_nodes_Block(a); DBG_OPT_IFSIM;
set_Tuple_pred(n, 2, a);
}
break;
- /* GL: Why are they skipped? DivMod allocates new nodes --> it's
- treated in transform node.
- case iro_Mod, Quot, DivMod
- */
+ /*
+ case iro_Mod, Quot, DivMod
+ DivMod allocates new nodes --> it's treated in transform node.
+ What about Quot, DivMod?
+ */
case iro_And:
if (a == b) {
n = a; /* And has it's own neutral element */
n_preds = get_Phi_n_preds(n);
block = get_nodes_Block(n);
+ /* @@@ fliegt 'raus, sollte aber doch immer wahr sein!!!
+ assert(get_irn_arity(block) == n_preds && "phi in wrong block!"); */
if ((is_Bad(block)) || /* Control dead */
(block == current_ir_graph->start_block)) /* There should be no Phi nodes */
return new_Bad(); /* in the Start Block. */
}
} else if (get_irn_mode(n) == mode_X &&
is_Bad(get_nodes_Block(n))) {
- /* Remove dead control flow. */
+ /* Remove dead control flow -- early gigo. */
n = new_Bad();
}
}
/* We might generate an endless loop, so keep it alive. */
add_End_keepalive(get_irg_end(current_ir_graph), get_nodes_Block(n));
} else if (ta &&
- (get_irn_mode(a) == mode_I) &&
+ (get_irn_mode(a) == mode_Iu) &&
(get_Cond_kind(n) == dense) &&
(get_opt_unreachable_code())) {
/* I don't want to allow Tuples smaller than the biggest Proj.
else
set_Proj_proj(n, 0);
} else if ((get_irn_op(a) == op_Cond)
- && (get_irn_mode(get_Cond_selector(a)) == mode_I)
+ && (get_irn_mode(get_Cond_selector(a)) == mode_Iu)
&& value_of(a)
&& (get_Cond_kind(a) == dense)
&& (get_opt_unreachable_code())) {
/* The Cond is a Switch on a Constant */
- if (get_Proj_proj(n) == tv_val_CHIL(value_of(a))) {
+ if (get_Proj_proj(n) == tv_val_uInt(value_of(a))) {
/* The always taken branch, reuse the existing Jmp. */
if (!get_irn_link(a)) /* well, if it exists ;-> */
set_irn_link(a, new_r_Jmp(current_ir_graph, get_nodes_Block(n)));
(get_irn_mode(a) != get_irn_mode(b))) return 1;
/* compare if a's in and b's in are equal */
- /* GL: we optimize only nodes with in arrays of fixed sizes.
- if (get_irn_arity (a) != -2) {
- ins = get_irn_arity (a);
- if (ins != get_irn_arity (b)) return 1;
- ain = get_irn_in (a);
- bin = get_irn_in (b);
- }
- */
if (get_irn_arity (a) != get_irn_arity(b))
return 1;
|| (get_irn_sel_attr(a).ent->name != get_irn_sel_attr(b).ent->name)
|| (get_irn_sel_attr(a).ent->owner != get_irn_sel_attr(b).ent->owner)
|| (get_irn_sel_attr(a).ent->ld_name != get_irn_sel_attr(b).ent->ld_name)
- || (get_irn_sel_attr(a).ent->type != get_irn_sel_attr(b).ent->type)
- || (get_irn_sel_attr(a).ltyp != get_irn_sel_attr(b).ltyp);
+ || (get_irn_sel_attr(a).ent->type != get_irn_sel_attr(b).ent->type);
case iro_Phi:
return get_irn_phi_attr (a) != get_irn_phi_attr (b);
default: ;
/* Return the canonical node computing the same value as n.
Looks up the node in a hash table. */
-static inline ir_node *
+static INLINE ir_node *
identify (pset *value_table, ir_node *n)
{
ir_node *o = NULL;
/* During construction we set the pinned flag in the graph right when the
optimizatin is performed. The flag turning on procedure global cse could
be changed between two allocations. This way we are safe. */
-static inline ir_node *
+static INLINE ir_node *
identify_cons (pset *value_table, ir_node *n) {
ir_node *old = n;
n = identify(value_table, n);
/* garbage in, garbage out. If a node has a dead input, i.e., the
Bad node is input to the node, return the Bad node. */
-static inline ir_node *
+static INLINE ir_node *
gigo (ir_node *node)
{
int i;
projects / libfirm / blobdiff