/* SSA-PRE for trees.
|
/* SSA-PRE for trees.
|
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Contributed by Daniel Berlin <dan@dberlin.org> and Steven Bosscher
|
Contributed by Daniel Berlin <dan@dberlin.org> and Steven Bosscher
|
<stevenb@suse.de>
|
<stevenb@suse.de>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify
|
GCC is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3, or (at your option)
|
the Free Software Foundation; either version 3, or (at your option)
|
any later version.
|
any later version.
|
|
|
GCC is distributed in the hope that it will be useful,
|
GCC is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "tree-pretty-print.h"
|
#include "tree-pretty-print.h"
|
#include "gimple-pretty-print.h"
|
#include "gimple-pretty-print.h"
|
#include "tree-inline.h"
|
#include "tree-inline.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
#include "tree-dump.h"
|
#include "tree-dump.h"
|
#include "timevar.h"
|
#include "timevar.h"
|
#include "fibheap.h"
|
#include "fibheap.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "tree-iterator.h"
|
#include "tree-iterator.h"
|
#include "alloc-pool.h"
|
#include "alloc-pool.h"
|
#include "obstack.h"
|
#include "obstack.h"
|
#include "tree-pass.h"
|
#include "tree-pass.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "bitmap.h"
|
#include "bitmap.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "cfgloop.h"
|
#include "cfgloop.h"
|
#include "tree-ssa-sccvn.h"
|
#include "tree-ssa-sccvn.h"
|
#include "tree-scalar-evolution.h"
|
#include "tree-scalar-evolution.h"
|
#include "params.h"
|
#include "params.h"
|
#include "dbgcnt.h"
|
#include "dbgcnt.h"
|
|
|
/* TODO:
|
/* TODO:
|
|
|
1. Avail sets can be shared by making an avail_find_leader that
|
1. Avail sets can be shared by making an avail_find_leader that
|
walks up the dominator tree and looks in those avail sets.
|
walks up the dominator tree and looks in those avail sets.
|
This might affect code optimality, it's unclear right now.
|
This might affect code optimality, it's unclear right now.
|
2. Strength reduction can be performed by anticipating expressions
|
2. Strength reduction can be performed by anticipating expressions
|
we can repair later on.
|
we can repair later on.
|
3. We can do back-substitution or smarter value numbering to catch
|
3. We can do back-substitution or smarter value numbering to catch
|
commutative expressions split up over multiple statements.
|
commutative expressions split up over multiple statements.
|
*/
|
*/
|
|
|
/* For ease of terminology, "expression node" in the below refers to
|
/* For ease of terminology, "expression node" in the below refers to
|
every expression node but GIMPLE_ASSIGN, because GIMPLE_ASSIGNs
|
every expression node but GIMPLE_ASSIGN, because GIMPLE_ASSIGNs
|
represent the actual statement containing the expressions we care about,
|
represent the actual statement containing the expressions we care about,
|
and we cache the value number by putting it in the expression. */
|
and we cache the value number by putting it in the expression. */
|
|
|
/* Basic algorithm
|
/* Basic algorithm
|
|
|
First we walk the statements to generate the AVAIL sets, the
|
First we walk the statements to generate the AVAIL sets, the
|
EXP_GEN sets, and the tmp_gen sets. EXP_GEN sets represent the
|
EXP_GEN sets, and the tmp_gen sets. EXP_GEN sets represent the
|
generation of values/expressions by a given block. We use them
|
generation of values/expressions by a given block. We use them
|
when computing the ANTIC sets. The AVAIL sets consist of
|
when computing the ANTIC sets. The AVAIL sets consist of
|
SSA_NAME's that represent values, so we know what values are
|
SSA_NAME's that represent values, so we know what values are
|
available in what blocks. AVAIL is a forward dataflow problem. In
|
available in what blocks. AVAIL is a forward dataflow problem. In
|
SSA, values are never killed, so we don't need a kill set, or a
|
SSA, values are never killed, so we don't need a kill set, or a
|
fixpoint iteration, in order to calculate the AVAIL sets. In
|
fixpoint iteration, in order to calculate the AVAIL sets. In
|
traditional parlance, AVAIL sets tell us the downsafety of the
|
traditional parlance, AVAIL sets tell us the downsafety of the
|
expressions/values.
|
expressions/values.
|
|
|
Next, we generate the ANTIC sets. These sets represent the
|
Next, we generate the ANTIC sets. These sets represent the
|
anticipatable expressions. ANTIC is a backwards dataflow
|
anticipatable expressions. ANTIC is a backwards dataflow
|
problem. An expression is anticipatable in a given block if it could
|
problem. An expression is anticipatable in a given block if it could
|
be generated in that block. This means that if we had to perform
|
be generated in that block. This means that if we had to perform
|
an insertion in that block, of the value of that expression, we
|
an insertion in that block, of the value of that expression, we
|
could. Calculating the ANTIC sets requires phi translation of
|
could. Calculating the ANTIC sets requires phi translation of
|
expressions, because the flow goes backwards through phis. We must
|
expressions, because the flow goes backwards through phis. We must
|
iterate to a fixpoint of the ANTIC sets, because we have a kill
|
iterate to a fixpoint of the ANTIC sets, because we have a kill
|
set. Even in SSA form, values are not live over the entire
|
set. Even in SSA form, values are not live over the entire
|
function, only from their definition point onwards. So we have to
|
function, only from their definition point onwards. So we have to
|
remove values from the ANTIC set once we go past the definition
|
remove values from the ANTIC set once we go past the definition
|
point of the leaders that make them up.
|
point of the leaders that make them up.
|
compute_antic/compute_antic_aux performs this computation.
|
compute_antic/compute_antic_aux performs this computation.
|
|
|
Third, we perform insertions to make partially redundant
|
Third, we perform insertions to make partially redundant
|
expressions fully redundant.
|
expressions fully redundant.
|
|
|
An expression is partially redundant (excluding partial
|
An expression is partially redundant (excluding partial
|
anticipation) if:
|
anticipation) if:
|
|
|
1. It is AVAIL in some, but not all, of the predecessors of a
|
1. It is AVAIL in some, but not all, of the predecessors of a
|
given block.
|
given block.
|
2. It is ANTIC in all the predecessors.
|
2. It is ANTIC in all the predecessors.
|
|
|
In order to make it fully redundant, we insert the expression into
|
In order to make it fully redundant, we insert the expression into
|
the predecessors where it is not available, but is ANTIC.
|
the predecessors where it is not available, but is ANTIC.
|
|
|
For the partial anticipation case, we only perform insertion if it
|
For the partial anticipation case, we only perform insertion if it
|
is partially anticipated in some block, and fully available in all
|
is partially anticipated in some block, and fully available in all
|
of the predecessors.
|
of the predecessors.
|
|
|
insert/insert_aux/do_regular_insertion/do_partial_partial_insertion
|
insert/insert_aux/do_regular_insertion/do_partial_partial_insertion
|
performs these steps.
|
performs these steps.
|
|
|
Fourth, we eliminate fully redundant expressions.
|
Fourth, we eliminate fully redundant expressions.
|
This is a simple statement walk that replaces redundant
|
This is a simple statement walk that replaces redundant
|
calculations with the now available values. */
|
calculations with the now available values. */
|
|
|
/* Representations of value numbers:
|
/* Representations of value numbers:
|
|
|
Value numbers are represented by a representative SSA_NAME. We
|
Value numbers are represented by a representative SSA_NAME. We
|
will create fake SSA_NAME's in situations where we need a
|
will create fake SSA_NAME's in situations where we need a
|
representative but do not have one (because it is a complex
|
representative but do not have one (because it is a complex
|
expression). In order to facilitate storing the value numbers in
|
expression). In order to facilitate storing the value numbers in
|
bitmaps, and keep the number of wasted SSA_NAME's down, we also
|
bitmaps, and keep the number of wasted SSA_NAME's down, we also
|
associate a value_id with each value number, and create full blown
|
associate a value_id with each value number, and create full blown
|
ssa_name's only where we actually need them (IE in operands of
|
ssa_name's only where we actually need them (IE in operands of
|
existing expressions).
|
existing expressions).
|
|
|
Theoretically you could replace all the value_id's with
|
Theoretically you could replace all the value_id's with
|
SSA_NAME_VERSION, but this would allocate a large number of
|
SSA_NAME_VERSION, but this would allocate a large number of
|
SSA_NAME's (which are each > 30 bytes) just to get a 4 byte number.
|
SSA_NAME's (which are each > 30 bytes) just to get a 4 byte number.
|
It would also require an additional indirection at each point we
|
It would also require an additional indirection at each point we
|
use the value id. */
|
use the value id. */
|
|
|
/* Representation of expressions on value numbers:
|
/* Representation of expressions on value numbers:
|
|
|
Expressions consisting of value numbers are represented the same
|
Expressions consisting of value numbers are represented the same
|
way as our VN internally represents them, with an additional
|
way as our VN internally represents them, with an additional
|
"pre_expr" wrapping around them in order to facilitate storing all
|
"pre_expr" wrapping around them in order to facilitate storing all
|
of the expressions in the same sets. */
|
of the expressions in the same sets. */
|
|
|
/* Representation of sets:
|
/* Representation of sets:
|
|
|
The dataflow sets do not need to be sorted in any particular order
|
The dataflow sets do not need to be sorted in any particular order
|
for the majority of their lifetime, are simply represented as two
|
for the majority of their lifetime, are simply represented as two
|
bitmaps, one that keeps track of values present in the set, and one
|
bitmaps, one that keeps track of values present in the set, and one
|
that keeps track of expressions present in the set.
|
that keeps track of expressions present in the set.
|
|
|
When we need them in topological order, we produce it on demand by
|
When we need them in topological order, we produce it on demand by
|
transforming the bitmap into an array and sorting it into topo
|
transforming the bitmap into an array and sorting it into topo
|
order. */
|
order. */
|
|
|
/* Type of expression, used to know which member of the PRE_EXPR union
|
/* Type of expression, used to know which member of the PRE_EXPR union
|
is valid. */
|
is valid. */
|
|
|
enum pre_expr_kind
|
enum pre_expr_kind
|
{
|
{
|
NAME,
|
NAME,
|
NARY,
|
NARY,
|
REFERENCE,
|
REFERENCE,
|
CONSTANT
|
CONSTANT
|
};
|
};
|
|
|
typedef union pre_expr_union_d
|
typedef union pre_expr_union_d
|
{
|
{
|
tree name;
|
tree name;
|
tree constant;
|
tree constant;
|
vn_nary_op_t nary;
|
vn_nary_op_t nary;
|
vn_reference_t reference;
|
vn_reference_t reference;
|
} pre_expr_union;
|
} pre_expr_union;
|
|
|
typedef struct pre_expr_d
|
typedef struct pre_expr_d
|
{
|
{
|
enum pre_expr_kind kind;
|
enum pre_expr_kind kind;
|
unsigned int id;
|
unsigned int id;
|
pre_expr_union u;
|
pre_expr_union u;
|
} *pre_expr;
|
} *pre_expr;
|
|
|
#define PRE_EXPR_NAME(e) (e)->u.name
|
#define PRE_EXPR_NAME(e) (e)->u.name
|
#define PRE_EXPR_NARY(e) (e)->u.nary
|
#define PRE_EXPR_NARY(e) (e)->u.nary
|
#define PRE_EXPR_REFERENCE(e) (e)->u.reference
|
#define PRE_EXPR_REFERENCE(e) (e)->u.reference
|
#define PRE_EXPR_CONSTANT(e) (e)->u.constant
|
#define PRE_EXPR_CONSTANT(e) (e)->u.constant
|
|
|
static int
|
static int
|
pre_expr_eq (const void *p1, const void *p2)
|
pre_expr_eq (const void *p1, const void *p2)
|
{
|
{
|
const struct pre_expr_d *e1 = (const struct pre_expr_d *) p1;
|
const struct pre_expr_d *e1 = (const struct pre_expr_d *) p1;
|
const struct pre_expr_d *e2 = (const struct pre_expr_d *) p2;
|
const struct pre_expr_d *e2 = (const struct pre_expr_d *) p2;
|
|
|
if (e1->kind != e2->kind)
|
if (e1->kind != e2->kind)
|
return false;
|
return false;
|
|
|
switch (e1->kind)
|
switch (e1->kind)
|
{
|
{
|
case CONSTANT:
|
case CONSTANT:
|
return vn_constant_eq_with_type (PRE_EXPR_CONSTANT (e1),
|
return vn_constant_eq_with_type (PRE_EXPR_CONSTANT (e1),
|
PRE_EXPR_CONSTANT (e2));
|
PRE_EXPR_CONSTANT (e2));
|
case NAME:
|
case NAME:
|
return PRE_EXPR_NAME (e1) == PRE_EXPR_NAME (e2);
|
return PRE_EXPR_NAME (e1) == PRE_EXPR_NAME (e2);
|
case NARY:
|
case NARY:
|
return vn_nary_op_eq (PRE_EXPR_NARY (e1), PRE_EXPR_NARY (e2));
|
return vn_nary_op_eq (PRE_EXPR_NARY (e1), PRE_EXPR_NARY (e2));
|
case REFERENCE:
|
case REFERENCE:
|
return vn_reference_eq (PRE_EXPR_REFERENCE (e1),
|
return vn_reference_eq (PRE_EXPR_REFERENCE (e1),
|
PRE_EXPR_REFERENCE (e2));
|
PRE_EXPR_REFERENCE (e2));
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
static hashval_t
|
static hashval_t
|
pre_expr_hash (const void *p1)
|
pre_expr_hash (const void *p1)
|
{
|
{
|
const struct pre_expr_d *e = (const struct pre_expr_d *) p1;
|
const struct pre_expr_d *e = (const struct pre_expr_d *) p1;
|
switch (e->kind)
|
switch (e->kind)
|
{
|
{
|
case CONSTANT:
|
case CONSTANT:
|
return vn_hash_constant_with_type (PRE_EXPR_CONSTANT (e));
|
return vn_hash_constant_with_type (PRE_EXPR_CONSTANT (e));
|
case NAME:
|
case NAME:
|
return SSA_NAME_VERSION (PRE_EXPR_NAME (e));
|
return SSA_NAME_VERSION (PRE_EXPR_NAME (e));
|
case NARY:
|
case NARY:
|
return PRE_EXPR_NARY (e)->hashcode;
|
return PRE_EXPR_NARY (e)->hashcode;
|
case REFERENCE:
|
case REFERENCE:
|
return PRE_EXPR_REFERENCE (e)->hashcode;
|
return PRE_EXPR_REFERENCE (e)->hashcode;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Next global expression id number. */
|
/* Next global expression id number. */
|
static unsigned int next_expression_id;
|
static unsigned int next_expression_id;
|
|
|
/* Mapping from expression to id number we can use in bitmap sets. */
|
/* Mapping from expression to id number we can use in bitmap sets. */
|
DEF_VEC_P (pre_expr);
|
DEF_VEC_P (pre_expr);
|
DEF_VEC_ALLOC_P (pre_expr, heap);
|
DEF_VEC_ALLOC_P (pre_expr, heap);
|
static VEC(pre_expr, heap) *expressions;
|
static VEC(pre_expr, heap) *expressions;
|
static htab_t expression_to_id;
|
static htab_t expression_to_id;
|
static VEC(unsigned, heap) *name_to_id;
|
static VEC(unsigned, heap) *name_to_id;
|
|
|
/* Allocate an expression id for EXPR. */
|
/* Allocate an expression id for EXPR. */
|
|
|
static inline unsigned int
|
static inline unsigned int
|
alloc_expression_id (pre_expr expr)
|
alloc_expression_id (pre_expr expr)
|
{
|
{
|
void **slot;
|
void **slot;
|
/* Make sure we won't overflow. */
|
/* Make sure we won't overflow. */
|
gcc_assert (next_expression_id + 1 > next_expression_id);
|
gcc_assert (next_expression_id + 1 > next_expression_id);
|
expr->id = next_expression_id++;
|
expr->id = next_expression_id++;
|
VEC_safe_push (pre_expr, heap, expressions, expr);
|
VEC_safe_push (pre_expr, heap, expressions, expr);
|
if (expr->kind == NAME)
|
if (expr->kind == NAME)
|
{
|
{
|
unsigned version = SSA_NAME_VERSION (PRE_EXPR_NAME (expr));
|
unsigned version = SSA_NAME_VERSION (PRE_EXPR_NAME (expr));
|
/* VEC_safe_grow_cleared allocates no headroom. Avoid frequent
|
/* VEC_safe_grow_cleared allocates no headroom. Avoid frequent
|
re-allocations by using VEC_reserve upfront. There is no
|
re-allocations by using VEC_reserve upfront. There is no
|
VEC_quick_grow_cleared unfortunately. */
|
VEC_quick_grow_cleared unfortunately. */
|
VEC_reserve (unsigned, heap, name_to_id, num_ssa_names);
|
VEC_reserve (unsigned, heap, name_to_id, num_ssa_names);
|
VEC_safe_grow_cleared (unsigned, heap, name_to_id, num_ssa_names);
|
VEC_safe_grow_cleared (unsigned, heap, name_to_id, num_ssa_names);
|
gcc_assert (VEC_index (unsigned, name_to_id, version) == 0);
|
gcc_assert (VEC_index (unsigned, name_to_id, version) == 0);
|
VEC_replace (unsigned, name_to_id, version, expr->id);
|
VEC_replace (unsigned, name_to_id, version, expr->id);
|
}
|
}
|
else
|
else
|
{
|
{
|
slot = htab_find_slot (expression_to_id, expr, INSERT);
|
slot = htab_find_slot (expression_to_id, expr, INSERT);
|
gcc_assert (!*slot);
|
gcc_assert (!*slot);
|
*slot = expr;
|
*slot = expr;
|
}
|
}
|
return next_expression_id - 1;
|
return next_expression_id - 1;
|
}
|
}
|
|
|
/* Return the expression id for tree EXPR. */
|
/* Return the expression id for tree EXPR. */
|
|
|
static inline unsigned int
|
static inline unsigned int
|
get_expression_id (const pre_expr expr)
|
get_expression_id (const pre_expr expr)
|
{
|
{
|
return expr->id;
|
return expr->id;
|
}
|
}
|
|
|
static inline unsigned int
|
static inline unsigned int
|
lookup_expression_id (const pre_expr expr)
|
lookup_expression_id (const pre_expr expr)
|
{
|
{
|
void **slot;
|
void **slot;
|
|
|
if (expr->kind == NAME)
|
if (expr->kind == NAME)
|
{
|
{
|
unsigned version = SSA_NAME_VERSION (PRE_EXPR_NAME (expr));
|
unsigned version = SSA_NAME_VERSION (PRE_EXPR_NAME (expr));
|
if (VEC_length (unsigned, name_to_id) <= version)
|
if (VEC_length (unsigned, name_to_id) <= version)
|
return 0;
|
return 0;
|
return VEC_index (unsigned, name_to_id, version);
|
return VEC_index (unsigned, name_to_id, version);
|
}
|
}
|
else
|
else
|
{
|
{
|
slot = htab_find_slot (expression_to_id, expr, NO_INSERT);
|
slot = htab_find_slot (expression_to_id, expr, NO_INSERT);
|
if (!slot)
|
if (!slot)
|
return 0;
|
return 0;
|
return ((pre_expr)*slot)->id;
|
return ((pre_expr)*slot)->id;
|
}
|
}
|
}
|
}
|
|
|
/* Return the existing expression id for EXPR, or create one if one
|
/* Return the existing expression id for EXPR, or create one if one
|
does not exist yet. */
|
does not exist yet. */
|
|
|
static inline unsigned int
|
static inline unsigned int
|
get_or_alloc_expression_id (pre_expr expr)
|
get_or_alloc_expression_id (pre_expr expr)
|
{
|
{
|
unsigned int id = lookup_expression_id (expr);
|
unsigned int id = lookup_expression_id (expr);
|
if (id == 0)
|
if (id == 0)
|
return alloc_expression_id (expr);
|
return alloc_expression_id (expr);
|
return expr->id = id;
|
return expr->id = id;
|
}
|
}
|
|
|
/* Return the expression that has expression id ID */
|
/* Return the expression that has expression id ID */
|
|
|
static inline pre_expr
|
static inline pre_expr
|
expression_for_id (unsigned int id)
|
expression_for_id (unsigned int id)
|
{
|
{
|
return VEC_index (pre_expr, expressions, id);
|
return VEC_index (pre_expr, expressions, id);
|
}
|
}
|
|
|
/* Free the expression id field in all of our expressions,
|
/* Free the expression id field in all of our expressions,
|
and then destroy the expressions array. */
|
and then destroy the expressions array. */
|
|
|
static void
|
static void
|
clear_expression_ids (void)
|
clear_expression_ids (void)
|
{
|
{
|
VEC_free (pre_expr, heap, expressions);
|
VEC_free (pre_expr, heap, expressions);
|
}
|
}
|
|
|
static alloc_pool pre_expr_pool;
|
static alloc_pool pre_expr_pool;
|
|
|
/* Given an SSA_NAME NAME, get or create a pre_expr to represent it. */
|
/* Given an SSA_NAME NAME, get or create a pre_expr to represent it. */
|
|
|
static pre_expr
|
static pre_expr
|
get_or_alloc_expr_for_name (tree name)
|
get_or_alloc_expr_for_name (tree name)
|
{
|
{
|
struct pre_expr_d expr;
|
struct pre_expr_d expr;
|
pre_expr result;
|
pre_expr result;
|
unsigned int result_id;
|
unsigned int result_id;
|
|
|
expr.kind = NAME;
|
expr.kind = NAME;
|
expr.id = 0;
|
expr.id = 0;
|
PRE_EXPR_NAME (&expr) = name;
|
PRE_EXPR_NAME (&expr) = name;
|
result_id = lookup_expression_id (&expr);
|
result_id = lookup_expression_id (&expr);
|
if (result_id != 0)
|
if (result_id != 0)
|
return expression_for_id (result_id);
|
return expression_for_id (result_id);
|
|
|
result = (pre_expr) pool_alloc (pre_expr_pool);
|
result = (pre_expr) pool_alloc (pre_expr_pool);
|
result->kind = NAME;
|
result->kind = NAME;
|
PRE_EXPR_NAME (result) = name;
|
PRE_EXPR_NAME (result) = name;
|
alloc_expression_id (result);
|
alloc_expression_id (result);
|
return result;
|
return result;
|
}
|
}
|
|
|
static bool in_fre = false;
|
static bool in_fre = false;
|
|
|
/* An unordered bitmap set. One bitmap tracks values, the other,
|
/* An unordered bitmap set. One bitmap tracks values, the other,
|
expressions. */
|
expressions. */
|
typedef struct bitmap_set
|
typedef struct bitmap_set
|
{
|
{
|
bitmap_head expressions;
|
bitmap_head expressions;
|
bitmap_head values;
|
bitmap_head values;
|
} *bitmap_set_t;
|
} *bitmap_set_t;
|
|
|
#define FOR_EACH_EXPR_ID_IN_SET(set, id, bi) \
|
#define FOR_EACH_EXPR_ID_IN_SET(set, id, bi) \
|
EXECUTE_IF_SET_IN_BITMAP(&(set)->expressions, 0, (id), (bi))
|
EXECUTE_IF_SET_IN_BITMAP(&(set)->expressions, 0, (id), (bi))
|
|
|
#define FOR_EACH_VALUE_ID_IN_SET(set, id, bi) \
|
#define FOR_EACH_VALUE_ID_IN_SET(set, id, bi) \
|
EXECUTE_IF_SET_IN_BITMAP(&(set)->values, 0, (id), (bi))
|
EXECUTE_IF_SET_IN_BITMAP(&(set)->values, 0, (id), (bi))
|
|
|
/* Mapping from value id to expressions with that value_id. */
|
/* Mapping from value id to expressions with that value_id. */
|
DEF_VEC_P (bitmap_set_t);
|
DEF_VEC_P (bitmap_set_t);
|
DEF_VEC_ALLOC_P (bitmap_set_t, heap);
|
DEF_VEC_ALLOC_P (bitmap_set_t, heap);
|
static VEC(bitmap_set_t, heap) *value_expressions;
|
static VEC(bitmap_set_t, heap) *value_expressions;
|
|
|
/* Sets that we need to keep track of. */
|
/* Sets that we need to keep track of. */
|
typedef struct bb_bitmap_sets
|
typedef struct bb_bitmap_sets
|
{
|
{
|
/* The EXP_GEN set, which represents expressions/values generated in
|
/* The EXP_GEN set, which represents expressions/values generated in
|
a basic block. */
|
a basic block. */
|
bitmap_set_t exp_gen;
|
bitmap_set_t exp_gen;
|
|
|
/* The PHI_GEN set, which represents PHI results generated in a
|
/* The PHI_GEN set, which represents PHI results generated in a
|
basic block. */
|
basic block. */
|
bitmap_set_t phi_gen;
|
bitmap_set_t phi_gen;
|
|
|
/* The TMP_GEN set, which represents results/temporaries generated
|
/* The TMP_GEN set, which represents results/temporaries generated
|
in a basic block. IE the LHS of an expression. */
|
in a basic block. IE the LHS of an expression. */
|
bitmap_set_t tmp_gen;
|
bitmap_set_t tmp_gen;
|
|
|
/* The AVAIL_OUT set, which represents which values are available in
|
/* The AVAIL_OUT set, which represents which values are available in
|
a given basic block. */
|
a given basic block. */
|
bitmap_set_t avail_out;
|
bitmap_set_t avail_out;
|
|
|
/* The ANTIC_IN set, which represents which values are anticipatable
|
/* The ANTIC_IN set, which represents which values are anticipatable
|
in a given basic block. */
|
in a given basic block. */
|
bitmap_set_t antic_in;
|
bitmap_set_t antic_in;
|
|
|
/* The PA_IN set, which represents which values are
|
/* The PA_IN set, which represents which values are
|
partially anticipatable in a given basic block. */
|
partially anticipatable in a given basic block. */
|
bitmap_set_t pa_in;
|
bitmap_set_t pa_in;
|
|
|
/* The NEW_SETS set, which is used during insertion to augment the
|
/* The NEW_SETS set, which is used during insertion to augment the
|
AVAIL_OUT set of blocks with the new insertions performed during
|
AVAIL_OUT set of blocks with the new insertions performed during
|
the current iteration. */
|
the current iteration. */
|
bitmap_set_t new_sets;
|
bitmap_set_t new_sets;
|
|
|
/* A cache for value_dies_in_block_x. */
|
/* A cache for value_dies_in_block_x. */
|
bitmap expr_dies;
|
bitmap expr_dies;
|
|
|
/* True if we have visited this block during ANTIC calculation. */
|
/* True if we have visited this block during ANTIC calculation. */
|
unsigned int visited : 1;
|
unsigned int visited : 1;
|
|
|
/* True we have deferred processing this block during ANTIC
|
/* True we have deferred processing this block during ANTIC
|
calculation until its successor is processed. */
|
calculation until its successor is processed. */
|
unsigned int deferred : 1;
|
unsigned int deferred : 1;
|
|
|
/* True when the block contains a call that might not return. */
|
/* True when the block contains a call that might not return. */
|
unsigned int contains_may_not_return_call : 1;
|
unsigned int contains_may_not_return_call : 1;
|
} *bb_value_sets_t;
|
} *bb_value_sets_t;
|
|
|
#define EXP_GEN(BB) ((bb_value_sets_t) ((BB)->aux))->exp_gen
|
#define EXP_GEN(BB) ((bb_value_sets_t) ((BB)->aux))->exp_gen
|
#define PHI_GEN(BB) ((bb_value_sets_t) ((BB)->aux))->phi_gen
|
#define PHI_GEN(BB) ((bb_value_sets_t) ((BB)->aux))->phi_gen
|
#define TMP_GEN(BB) ((bb_value_sets_t) ((BB)->aux))->tmp_gen
|
#define TMP_GEN(BB) ((bb_value_sets_t) ((BB)->aux))->tmp_gen
|
#define AVAIL_OUT(BB) ((bb_value_sets_t) ((BB)->aux))->avail_out
|
#define AVAIL_OUT(BB) ((bb_value_sets_t) ((BB)->aux))->avail_out
|
#define ANTIC_IN(BB) ((bb_value_sets_t) ((BB)->aux))->antic_in
|
#define ANTIC_IN(BB) ((bb_value_sets_t) ((BB)->aux))->antic_in
|
#define PA_IN(BB) ((bb_value_sets_t) ((BB)->aux))->pa_in
|
#define PA_IN(BB) ((bb_value_sets_t) ((BB)->aux))->pa_in
|
#define NEW_SETS(BB) ((bb_value_sets_t) ((BB)->aux))->new_sets
|
#define NEW_SETS(BB) ((bb_value_sets_t) ((BB)->aux))->new_sets
|
#define EXPR_DIES(BB) ((bb_value_sets_t) ((BB)->aux))->expr_dies
|
#define EXPR_DIES(BB) ((bb_value_sets_t) ((BB)->aux))->expr_dies
|
#define BB_VISITED(BB) ((bb_value_sets_t) ((BB)->aux))->visited
|
#define BB_VISITED(BB) ((bb_value_sets_t) ((BB)->aux))->visited
|
#define BB_DEFERRED(BB) ((bb_value_sets_t) ((BB)->aux))->deferred
|
#define BB_DEFERRED(BB) ((bb_value_sets_t) ((BB)->aux))->deferred
|
#define BB_MAY_NOTRETURN(BB) ((bb_value_sets_t) ((BB)->aux))->contains_may_not_return_call
|
#define BB_MAY_NOTRETURN(BB) ((bb_value_sets_t) ((BB)->aux))->contains_may_not_return_call
|
|
|
|
|
/* Basic block list in postorder. */
|
/* Basic block list in postorder. */
|
static int *postorder;
|
static int *postorder;
|
|
|
/* This structure is used to keep track of statistics on what
|
/* This structure is used to keep track of statistics on what
|
optimization PRE was able to perform. */
|
optimization PRE was able to perform. */
|
static struct
|
static struct
|
{
|
{
|
/* The number of RHS computations eliminated by PRE. */
|
/* The number of RHS computations eliminated by PRE. */
|
int eliminations;
|
int eliminations;
|
|
|
/* The number of new expressions/temporaries generated by PRE. */
|
/* The number of new expressions/temporaries generated by PRE. */
|
int insertions;
|
int insertions;
|
|
|
/* The number of inserts found due to partial anticipation */
|
/* The number of inserts found due to partial anticipation */
|
int pa_insert;
|
int pa_insert;
|
|
|
/* The number of new PHI nodes added by PRE. */
|
/* The number of new PHI nodes added by PRE. */
|
int phis;
|
int phis;
|
|
|
/* The number of values found constant. */
|
/* The number of values found constant. */
|
int constified;
|
int constified;
|
|
|
} pre_stats;
|
} pre_stats;
|
|
|
static bool do_partial_partial;
|
static bool do_partial_partial;
|
static pre_expr bitmap_find_leader (bitmap_set_t, unsigned int, gimple);
|
static pre_expr bitmap_find_leader (bitmap_set_t, unsigned int, gimple);
|
static void bitmap_value_insert_into_set (bitmap_set_t, pre_expr);
|
static void bitmap_value_insert_into_set (bitmap_set_t, pre_expr);
|
static void bitmap_value_replace_in_set (bitmap_set_t, pre_expr);
|
static void bitmap_value_replace_in_set (bitmap_set_t, pre_expr);
|
static void bitmap_set_copy (bitmap_set_t, bitmap_set_t);
|
static void bitmap_set_copy (bitmap_set_t, bitmap_set_t);
|
static bool bitmap_set_contains_value (bitmap_set_t, unsigned int);
|
static bool bitmap_set_contains_value (bitmap_set_t, unsigned int);
|
static void bitmap_insert_into_set (bitmap_set_t, pre_expr);
|
static void bitmap_insert_into_set (bitmap_set_t, pre_expr);
|
static void bitmap_insert_into_set_1 (bitmap_set_t, pre_expr,
|
static void bitmap_insert_into_set_1 (bitmap_set_t, pre_expr,
|
unsigned int, bool);
|
unsigned int, bool);
|
static bitmap_set_t bitmap_set_new (void);
|
static bitmap_set_t bitmap_set_new (void);
|
static tree create_expression_by_pieces (basic_block, pre_expr, gimple_seq *,
|
static tree create_expression_by_pieces (basic_block, pre_expr, gimple_seq *,
|
gimple, tree);
|
gimple, tree);
|
static tree find_or_generate_expression (basic_block, pre_expr, gimple_seq *,
|
static tree find_or_generate_expression (basic_block, pre_expr, gimple_seq *,
|
gimple);
|
gimple);
|
static unsigned int get_expr_value_id (pre_expr);
|
static unsigned int get_expr_value_id (pre_expr);
|
|
|
/* We can add and remove elements and entries to and from sets
|
/* We can add and remove elements and entries to and from sets
|
and hash tables, so we use alloc pools for them. */
|
and hash tables, so we use alloc pools for them. */
|
|
|
static alloc_pool bitmap_set_pool;
|
static alloc_pool bitmap_set_pool;
|
static bitmap_obstack grand_bitmap_obstack;
|
static bitmap_obstack grand_bitmap_obstack;
|
|
|
/* To avoid adding 300 temporary variables when we only need one, we
|
/* To avoid adding 300 temporary variables when we only need one, we
|
only create one temporary variable, on demand, and build ssa names
|
only create one temporary variable, on demand, and build ssa names
|
off that. We do have to change the variable if the types don't
|
off that. We do have to change the variable if the types don't
|
match the current variable's type. */
|
match the current variable's type. */
|
static tree pretemp;
|
static tree pretemp;
|
static tree storetemp;
|
static tree storetemp;
|
static tree prephitemp;
|
static tree prephitemp;
|
|
|
/* Set of blocks with statements that have had their EH properties changed. */
|
/* Set of blocks with statements that have had their EH properties changed. */
|
static bitmap need_eh_cleanup;
|
static bitmap need_eh_cleanup;
|
|
|
/* Set of blocks with statements that have had their AB properties changed. */
|
/* Set of blocks with statements that have had their AB properties changed. */
|
static bitmap need_ab_cleanup;
|
static bitmap need_ab_cleanup;
|
|
|
/* The phi_translate_table caches phi translations for a given
|
/* The phi_translate_table caches phi translations for a given
|
expression and predecessor. */
|
expression and predecessor. */
|
|
|
static htab_t phi_translate_table;
|
static htab_t phi_translate_table;
|
|
|
/* A three tuple {e, pred, v} used to cache phi translations in the
|
/* A three tuple {e, pred, v} used to cache phi translations in the
|
phi_translate_table. */
|
phi_translate_table. */
|
|
|
typedef struct expr_pred_trans_d
|
typedef struct expr_pred_trans_d
|
{
|
{
|
/* The expression. */
|
/* The expression. */
|
pre_expr e;
|
pre_expr e;
|
|
|
/* The predecessor block along which we translated the expression. */
|
/* The predecessor block along which we translated the expression. */
|
basic_block pred;
|
basic_block pred;
|
|
|
/* The value that resulted from the translation. */
|
/* The value that resulted from the translation. */
|
pre_expr v;
|
pre_expr v;
|
|
|
/* The hashcode for the expression, pred pair. This is cached for
|
/* The hashcode for the expression, pred pair. This is cached for
|
speed reasons. */
|
speed reasons. */
|
hashval_t hashcode;
|
hashval_t hashcode;
|
} *expr_pred_trans_t;
|
} *expr_pred_trans_t;
|
typedef const struct expr_pred_trans_d *const_expr_pred_trans_t;
|
typedef const struct expr_pred_trans_d *const_expr_pred_trans_t;
|
|
|
/* Return the hash value for a phi translation table entry. */
|
/* Return the hash value for a phi translation table entry. */
|
|
|
static hashval_t
|
static hashval_t
|
expr_pred_trans_hash (const void *p)
|
expr_pred_trans_hash (const void *p)
|
{
|
{
|
const_expr_pred_trans_t const ve = (const_expr_pred_trans_t) p;
|
const_expr_pred_trans_t const ve = (const_expr_pred_trans_t) p;
|
return ve->hashcode;
|
return ve->hashcode;
|
}
|
}
|
|
|
/* Return true if two phi translation table entries are the same.
|
/* Return true if two phi translation table entries are the same.
|
P1 and P2 should point to the expr_pred_trans_t's to be compared.*/
|
P1 and P2 should point to the expr_pred_trans_t's to be compared.*/
|
|
|
static int
|
static int
|
expr_pred_trans_eq (const void *p1, const void *p2)
|
expr_pred_trans_eq (const void *p1, const void *p2)
|
{
|
{
|
const_expr_pred_trans_t const ve1 = (const_expr_pred_trans_t) p1;
|
const_expr_pred_trans_t const ve1 = (const_expr_pred_trans_t) p1;
|
const_expr_pred_trans_t const ve2 = (const_expr_pred_trans_t) p2;
|
const_expr_pred_trans_t const ve2 = (const_expr_pred_trans_t) p2;
|
basic_block b1 = ve1->pred;
|
basic_block b1 = ve1->pred;
|
basic_block b2 = ve2->pred;
|
basic_block b2 = ve2->pred;
|
|
|
/* If they are not translations for the same basic block, they can't
|
/* If they are not translations for the same basic block, they can't
|
be equal. */
|
be equal. */
|
if (b1 != b2)
|
if (b1 != b2)
|
return false;
|
return false;
|
return pre_expr_eq (ve1->e, ve2->e);
|
return pre_expr_eq (ve1->e, ve2->e);
|
}
|
}
|
|
|
/* Search in the phi translation table for the translation of
|
/* Search in the phi translation table for the translation of
|
expression E in basic block PRED.
|
expression E in basic block PRED.
|
Return the translated value, if found, NULL otherwise. */
|
Return the translated value, if found, NULL otherwise. */
|
|
|
static inline pre_expr
|
static inline pre_expr
|
phi_trans_lookup (pre_expr e, basic_block pred)
|
phi_trans_lookup (pre_expr e, basic_block pred)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct expr_pred_trans_d ept;
|
struct expr_pred_trans_d ept;
|
|
|
ept.e = e;
|
ept.e = e;
|
ept.pred = pred;
|
ept.pred = pred;
|
ept.hashcode = iterative_hash_hashval_t (pre_expr_hash (e), pred->index);
|
ept.hashcode = iterative_hash_hashval_t (pre_expr_hash (e), pred->index);
|
slot = htab_find_slot_with_hash (phi_translate_table, &ept, ept.hashcode,
|
slot = htab_find_slot_with_hash (phi_translate_table, &ept, ept.hashcode,
|
NO_INSERT);
|
NO_INSERT);
|
if (!slot)
|
if (!slot)
|
return NULL;
|
return NULL;
|
else
|
else
|
return ((expr_pred_trans_t) *slot)->v;
|
return ((expr_pred_trans_t) *slot)->v;
|
}
|
}
|
|
|
|
|
/* Add the tuple mapping from {expression E, basic block PRED} to
|
/* Add the tuple mapping from {expression E, basic block PRED} to
|
value V, to the phi translation table. */
|
value V, to the phi translation table. */
|
|
|
static inline void
|
static inline void
|
phi_trans_add (pre_expr e, pre_expr v, basic_block pred)
|
phi_trans_add (pre_expr e, pre_expr v, basic_block pred)
|
{
|
{
|
void **slot;
|
void **slot;
|
expr_pred_trans_t new_pair = XNEW (struct expr_pred_trans_d);
|
expr_pred_trans_t new_pair = XNEW (struct expr_pred_trans_d);
|
new_pair->e = e;
|
new_pair->e = e;
|
new_pair->pred = pred;
|
new_pair->pred = pred;
|
new_pair->v = v;
|
new_pair->v = v;
|
new_pair->hashcode = iterative_hash_hashval_t (pre_expr_hash (e),
|
new_pair->hashcode = iterative_hash_hashval_t (pre_expr_hash (e),
|
pred->index);
|
pred->index);
|
|
|
slot = htab_find_slot_with_hash (phi_translate_table, new_pair,
|
slot = htab_find_slot_with_hash (phi_translate_table, new_pair,
|
new_pair->hashcode, INSERT);
|
new_pair->hashcode, INSERT);
|
free (*slot);
|
free (*slot);
|
*slot = (void *) new_pair;
|
*slot = (void *) new_pair;
|
}
|
}
|
|
|
|
|
/* Add expression E to the expression set of value id V. */
|
/* Add expression E to the expression set of value id V. */
|
|
|
void
|
void
|
add_to_value (unsigned int v, pre_expr e)
|
add_to_value (unsigned int v, pre_expr e)
|
{
|
{
|
bitmap_set_t set;
|
bitmap_set_t set;
|
|
|
gcc_assert (get_expr_value_id (e) == v);
|
gcc_assert (get_expr_value_id (e) == v);
|
|
|
if (v >= VEC_length (bitmap_set_t, value_expressions))
|
if (v >= VEC_length (bitmap_set_t, value_expressions))
|
{
|
{
|
VEC_safe_grow_cleared (bitmap_set_t, heap, value_expressions,
|
VEC_safe_grow_cleared (bitmap_set_t, heap, value_expressions,
|
v + 1);
|
v + 1);
|
}
|
}
|
|
|
set = VEC_index (bitmap_set_t, value_expressions, v);
|
set = VEC_index (bitmap_set_t, value_expressions, v);
|
if (!set)
|
if (!set)
|
{
|
{
|
set = bitmap_set_new ();
|
set = bitmap_set_new ();
|
VEC_replace (bitmap_set_t, value_expressions, v, set);
|
VEC_replace (bitmap_set_t, value_expressions, v, set);
|
}
|
}
|
|
|
bitmap_insert_into_set_1 (set, e, v, true);
|
bitmap_insert_into_set_1 (set, e, v, true);
|
}
|
}
|
|
|
/* Create a new bitmap set and return it. */
|
/* Create a new bitmap set and return it. */
|
|
|
static bitmap_set_t
|
static bitmap_set_t
|
bitmap_set_new (void)
|
bitmap_set_new (void)
|
{
|
{
|
bitmap_set_t ret = (bitmap_set_t) pool_alloc (bitmap_set_pool);
|
bitmap_set_t ret = (bitmap_set_t) pool_alloc (bitmap_set_pool);
|
bitmap_initialize (&ret->expressions, &grand_bitmap_obstack);
|
bitmap_initialize (&ret->expressions, &grand_bitmap_obstack);
|
bitmap_initialize (&ret->values, &grand_bitmap_obstack);
|
bitmap_initialize (&ret->values, &grand_bitmap_obstack);
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return the value id for a PRE expression EXPR. */
|
/* Return the value id for a PRE expression EXPR. */
|
|
|
static unsigned int
|
static unsigned int
|
get_expr_value_id (pre_expr expr)
|
get_expr_value_id (pre_expr expr)
|
{
|
{
|
switch (expr->kind)
|
switch (expr->kind)
|
{
|
{
|
case CONSTANT:
|
case CONSTANT:
|
{
|
{
|
unsigned int id;
|
unsigned int id;
|
id = get_constant_value_id (PRE_EXPR_CONSTANT (expr));
|
id = get_constant_value_id (PRE_EXPR_CONSTANT (expr));
|
if (id == 0)
|
if (id == 0)
|
{
|
{
|
id = get_or_alloc_constant_value_id (PRE_EXPR_CONSTANT (expr));
|
id = get_or_alloc_constant_value_id (PRE_EXPR_CONSTANT (expr));
|
add_to_value (id, expr);
|
add_to_value (id, expr);
|
}
|
}
|
return id;
|
return id;
|
}
|
}
|
case NAME:
|
case NAME:
|
return VN_INFO (PRE_EXPR_NAME (expr))->value_id;
|
return VN_INFO (PRE_EXPR_NAME (expr))->value_id;
|
case NARY:
|
case NARY:
|
return PRE_EXPR_NARY (expr)->value_id;
|
return PRE_EXPR_NARY (expr)->value_id;
|
case REFERENCE:
|
case REFERENCE:
|
return PRE_EXPR_REFERENCE (expr)->value_id;
|
return PRE_EXPR_REFERENCE (expr)->value_id;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Remove an expression EXPR from a bitmapped set. */
|
/* Remove an expression EXPR from a bitmapped set. */
|
|
|
static void
|
static void
|
bitmap_remove_from_set (bitmap_set_t set, pre_expr expr)
|
bitmap_remove_from_set (bitmap_set_t set, pre_expr expr)
|
{
|
{
|
unsigned int val = get_expr_value_id (expr);
|
unsigned int val = get_expr_value_id (expr);
|
if (!value_id_constant_p (val))
|
if (!value_id_constant_p (val))
|
{
|
{
|
bitmap_clear_bit (&set->values, val);
|
bitmap_clear_bit (&set->values, val);
|
bitmap_clear_bit (&set->expressions, get_expression_id (expr));
|
bitmap_clear_bit (&set->expressions, get_expression_id (expr));
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
bitmap_insert_into_set_1 (bitmap_set_t set, pre_expr expr,
|
bitmap_insert_into_set_1 (bitmap_set_t set, pre_expr expr,
|
unsigned int val, bool allow_constants)
|
unsigned int val, bool allow_constants)
|
{
|
{
|
if (allow_constants || !value_id_constant_p (val))
|
if (allow_constants || !value_id_constant_p (val))
|
{
|
{
|
/* We specifically expect this and only this function to be able to
|
/* We specifically expect this and only this function to be able to
|
insert constants into a set. */
|
insert constants into a set. */
|
bitmap_set_bit (&set->values, val);
|
bitmap_set_bit (&set->values, val);
|
bitmap_set_bit (&set->expressions, get_or_alloc_expression_id (expr));
|
bitmap_set_bit (&set->expressions, get_or_alloc_expression_id (expr));
|
}
|
}
|
}
|
}
|
|
|
/* Insert an expression EXPR into a bitmapped set. */
|
/* Insert an expression EXPR into a bitmapped set. */
|
|
|
static void
|
static void
|
bitmap_insert_into_set (bitmap_set_t set, pre_expr expr)
|
bitmap_insert_into_set (bitmap_set_t set, pre_expr expr)
|
{
|
{
|
bitmap_insert_into_set_1 (set, expr, get_expr_value_id (expr), false);
|
bitmap_insert_into_set_1 (set, expr, get_expr_value_id (expr), false);
|
}
|
}
|
|
|
/* Copy a bitmapped set ORIG, into bitmapped set DEST. */
|
/* Copy a bitmapped set ORIG, into bitmapped set DEST. */
|
|
|
static void
|
static void
|
bitmap_set_copy (bitmap_set_t dest, bitmap_set_t orig)
|
bitmap_set_copy (bitmap_set_t dest, bitmap_set_t orig)
|
{
|
{
|
bitmap_copy (&dest->expressions, &orig->expressions);
|
bitmap_copy (&dest->expressions, &orig->expressions);
|
bitmap_copy (&dest->values, &orig->values);
|
bitmap_copy (&dest->values, &orig->values);
|
}
|
}
|
|
|
|
|
/* Free memory used up by SET. */
|
/* Free memory used up by SET. */
|
static void
|
static void
|
bitmap_set_free (bitmap_set_t set)
|
bitmap_set_free (bitmap_set_t set)
|
{
|
{
|
bitmap_clear (&set->expressions);
|
bitmap_clear (&set->expressions);
|
bitmap_clear (&set->values);
|
bitmap_clear (&set->values);
|
}
|
}
|
|
|
|
|
/* Generate an topological-ordered array of bitmap set SET. */
|
/* Generate an topological-ordered array of bitmap set SET. */
|
|
|
static VEC(pre_expr, heap) *
|
static VEC(pre_expr, heap) *
|
sorted_array_from_bitmap_set (bitmap_set_t set)
|
sorted_array_from_bitmap_set (bitmap_set_t set)
|
{
|
{
|
unsigned int i, j;
|
unsigned int i, j;
|
bitmap_iterator bi, bj;
|
bitmap_iterator bi, bj;
|
VEC(pre_expr, heap) *result;
|
VEC(pre_expr, heap) *result;
|
|
|
/* Pre-allocate roughly enough space for the array. */
|
/* Pre-allocate roughly enough space for the array. */
|
result = VEC_alloc (pre_expr, heap, bitmap_count_bits (&set->values));
|
result = VEC_alloc (pre_expr, heap, bitmap_count_bits (&set->values));
|
|
|
FOR_EACH_VALUE_ID_IN_SET (set, i, bi)
|
FOR_EACH_VALUE_ID_IN_SET (set, i, bi)
|
{
|
{
|
/* The number of expressions having a given value is usually
|
/* The number of expressions having a given value is usually
|
relatively small. Thus, rather than making a vector of all
|
relatively small. Thus, rather than making a vector of all
|
the expressions and sorting it by value-id, we walk the values
|
the expressions and sorting it by value-id, we walk the values
|
and check in the reverse mapping that tells us what expressions
|
and check in the reverse mapping that tells us what expressions
|
have a given value, to filter those in our set. As a result,
|
have a given value, to filter those in our set. As a result,
|
the expressions are inserted in value-id order, which means
|
the expressions are inserted in value-id order, which means
|
topological order.
|
topological order.
|
|
|
If this is somehow a significant lose for some cases, we can
|
If this is somehow a significant lose for some cases, we can
|
choose which set to walk based on the set size. */
|
choose which set to walk based on the set size. */
|
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, i);
|
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, i);
|
FOR_EACH_EXPR_ID_IN_SET (exprset, j, bj)
|
FOR_EACH_EXPR_ID_IN_SET (exprset, j, bj)
|
{
|
{
|
if (bitmap_bit_p (&set->expressions, j))
|
if (bitmap_bit_p (&set->expressions, j))
|
VEC_safe_push (pre_expr, heap, result, expression_for_id (j));
|
VEC_safe_push (pre_expr, heap, result, expression_for_id (j));
|
}
|
}
|
}
|
}
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Perform bitmapped set operation DEST &= ORIG. */
|
/* Perform bitmapped set operation DEST &= ORIG. */
|
|
|
static void
|
static void
|
bitmap_set_and (bitmap_set_t dest, bitmap_set_t orig)
|
bitmap_set_and (bitmap_set_t dest, bitmap_set_t orig)
|
{
|
{
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned int i;
|
unsigned int i;
|
|
|
if (dest != orig)
|
if (dest != orig)
|
{
|
{
|
bitmap_head temp;
|
bitmap_head temp;
|
bitmap_initialize (&temp, &grand_bitmap_obstack);
|
bitmap_initialize (&temp, &grand_bitmap_obstack);
|
|
|
bitmap_and_into (&dest->values, &orig->values);
|
bitmap_and_into (&dest->values, &orig->values);
|
bitmap_copy (&temp, &dest->expressions);
|
bitmap_copy (&temp, &dest->expressions);
|
EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi)
|
{
|
{
|
pre_expr expr = expression_for_id (i);
|
pre_expr expr = expression_for_id (i);
|
unsigned int value_id = get_expr_value_id (expr);
|
unsigned int value_id = get_expr_value_id (expr);
|
if (!bitmap_bit_p (&dest->values, value_id))
|
if (!bitmap_bit_p (&dest->values, value_id))
|
bitmap_clear_bit (&dest->expressions, i);
|
bitmap_clear_bit (&dest->expressions, i);
|
}
|
}
|
bitmap_clear (&temp);
|
bitmap_clear (&temp);
|
}
|
}
|
}
|
}
|
|
|
/* Subtract all values and expressions contained in ORIG from DEST. */
|
/* Subtract all values and expressions contained in ORIG from DEST. */
|
|
|
static bitmap_set_t
|
static bitmap_set_t
|
bitmap_set_subtract (bitmap_set_t dest, bitmap_set_t orig)
|
bitmap_set_subtract (bitmap_set_t dest, bitmap_set_t orig)
|
{
|
{
|
bitmap_set_t result = bitmap_set_new ();
|
bitmap_set_t result = bitmap_set_new ();
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned int i;
|
unsigned int i;
|
|
|
bitmap_and_compl (&result->expressions, &dest->expressions,
|
bitmap_and_compl (&result->expressions, &dest->expressions,
|
&orig->expressions);
|
&orig->expressions);
|
|
|
FOR_EACH_EXPR_ID_IN_SET (result, i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (result, i, bi)
|
{
|
{
|
pre_expr expr = expression_for_id (i);
|
pre_expr expr = expression_for_id (i);
|
unsigned int value_id = get_expr_value_id (expr);
|
unsigned int value_id = get_expr_value_id (expr);
|
bitmap_set_bit (&result->values, value_id);
|
bitmap_set_bit (&result->values, value_id);
|
}
|
}
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Subtract all the values in bitmap set B from bitmap set A. */
|
/* Subtract all the values in bitmap set B from bitmap set A. */
|
|
|
static void
|
static void
|
bitmap_set_subtract_values (bitmap_set_t a, bitmap_set_t b)
|
bitmap_set_subtract_values (bitmap_set_t a, bitmap_set_t b)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
bitmap_head temp;
|
bitmap_head temp;
|
|
|
bitmap_initialize (&temp, &grand_bitmap_obstack);
|
bitmap_initialize (&temp, &grand_bitmap_obstack);
|
|
|
bitmap_copy (&temp, &a->expressions);
|
bitmap_copy (&temp, &a->expressions);
|
EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi)
|
{
|
{
|
pre_expr expr = expression_for_id (i);
|
pre_expr expr = expression_for_id (i);
|
if (bitmap_set_contains_value (b, get_expr_value_id (expr)))
|
if (bitmap_set_contains_value (b, get_expr_value_id (expr)))
|
bitmap_remove_from_set (a, expr);
|
bitmap_remove_from_set (a, expr);
|
}
|
}
|
bitmap_clear (&temp);
|
bitmap_clear (&temp);
|
}
|
}
|
|
|
|
|
/* Return true if bitmapped set SET contains the value VALUE_ID. */
|
/* Return true if bitmapped set SET contains the value VALUE_ID. */
|
|
|
static bool
|
static bool
|
bitmap_set_contains_value (bitmap_set_t set, unsigned int value_id)
|
bitmap_set_contains_value (bitmap_set_t set, unsigned int value_id)
|
{
|
{
|
if (value_id_constant_p (value_id))
|
if (value_id_constant_p (value_id))
|
return true;
|
return true;
|
|
|
if (!set || bitmap_empty_p (&set->expressions))
|
if (!set || bitmap_empty_p (&set->expressions))
|
return false;
|
return false;
|
|
|
return bitmap_bit_p (&set->values, value_id);
|
return bitmap_bit_p (&set->values, value_id);
|
}
|
}
|
|
|
static inline bool
|
static inline bool
|
bitmap_set_contains_expr (bitmap_set_t set, const pre_expr expr)
|
bitmap_set_contains_expr (bitmap_set_t set, const pre_expr expr)
|
{
|
{
|
return bitmap_bit_p (&set->expressions, get_expression_id (expr));
|
return bitmap_bit_p (&set->expressions, get_expression_id (expr));
|
}
|
}
|
|
|
/* Replace an instance of value LOOKFOR with expression EXPR in SET. */
|
/* Replace an instance of value LOOKFOR with expression EXPR in SET. */
|
|
|
static void
|
static void
|
bitmap_set_replace_value (bitmap_set_t set, unsigned int lookfor,
|
bitmap_set_replace_value (bitmap_set_t set, unsigned int lookfor,
|
const pre_expr expr)
|
const pre_expr expr)
|
{
|
{
|
bitmap_set_t exprset;
|
bitmap_set_t exprset;
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
if (value_id_constant_p (lookfor))
|
if (value_id_constant_p (lookfor))
|
return;
|
return;
|
|
|
if (!bitmap_set_contains_value (set, lookfor))
|
if (!bitmap_set_contains_value (set, lookfor))
|
return;
|
return;
|
|
|
/* The number of expressions having a given value is usually
|
/* The number of expressions having a given value is usually
|
significantly less than the total number of expressions in SET.
|
significantly less than the total number of expressions in SET.
|
Thus, rather than check, for each expression in SET, whether it
|
Thus, rather than check, for each expression in SET, whether it
|
has the value LOOKFOR, we walk the reverse mapping that tells us
|
has the value LOOKFOR, we walk the reverse mapping that tells us
|
what expressions have a given value, and see if any of those
|
what expressions have a given value, and see if any of those
|
expressions are in our set. For large testcases, this is about
|
expressions are in our set. For large testcases, this is about
|
5-10x faster than walking the bitmap. If this is somehow a
|
5-10x faster than walking the bitmap. If this is somehow a
|
significant lose for some cases, we can choose which set to walk
|
significant lose for some cases, we can choose which set to walk
|
based on the set size. */
|
based on the set size. */
|
exprset = VEC_index (bitmap_set_t, value_expressions, lookfor);
|
exprset = VEC_index (bitmap_set_t, value_expressions, lookfor);
|
FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
|
{
|
{
|
if (bitmap_clear_bit (&set->expressions, i))
|
if (bitmap_clear_bit (&set->expressions, i))
|
{
|
{
|
bitmap_set_bit (&set->expressions, get_expression_id (expr));
|
bitmap_set_bit (&set->expressions, get_expression_id (expr));
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Return true if two bitmap sets are equal. */
|
/* Return true if two bitmap sets are equal. */
|
|
|
static bool
|
static bool
|
bitmap_set_equal (bitmap_set_t a, bitmap_set_t b)
|
bitmap_set_equal (bitmap_set_t a, bitmap_set_t b)
|
{
|
{
|
return bitmap_equal_p (&a->values, &b->values);
|
return bitmap_equal_p (&a->values, &b->values);
|
}
|
}
|
|
|
/* Replace an instance of EXPR's VALUE with EXPR in SET if it exists,
|
/* Replace an instance of EXPR's VALUE with EXPR in SET if it exists,
|
and add it otherwise. */
|
and add it otherwise. */
|
|
|
static void
|
static void
|
bitmap_value_replace_in_set (bitmap_set_t set, pre_expr expr)
|
bitmap_value_replace_in_set (bitmap_set_t set, pre_expr expr)
|
{
|
{
|
unsigned int val = get_expr_value_id (expr);
|
unsigned int val = get_expr_value_id (expr);
|
|
|
if (bitmap_set_contains_value (set, val))
|
if (bitmap_set_contains_value (set, val))
|
bitmap_set_replace_value (set, val, expr);
|
bitmap_set_replace_value (set, val, expr);
|
else
|
else
|
bitmap_insert_into_set (set, expr);
|
bitmap_insert_into_set (set, expr);
|
}
|
}
|
|
|
/* Insert EXPR into SET if EXPR's value is not already present in
|
/* Insert EXPR into SET if EXPR's value is not already present in
|
SET. */
|
SET. */
|
|
|
static void
|
static void
|
bitmap_value_insert_into_set (bitmap_set_t set, pre_expr expr)
|
bitmap_value_insert_into_set (bitmap_set_t set, pre_expr expr)
|
{
|
{
|
unsigned int val = get_expr_value_id (expr);
|
unsigned int val = get_expr_value_id (expr);
|
|
|
gcc_checking_assert (expr->id == get_or_alloc_expression_id (expr));
|
gcc_checking_assert (expr->id == get_or_alloc_expression_id (expr));
|
|
|
/* Constant values are always considered to be part of the set. */
|
/* Constant values are always considered to be part of the set. */
|
if (value_id_constant_p (val))
|
if (value_id_constant_p (val))
|
return;
|
return;
|
|
|
/* If the value membership changed, add the expression. */
|
/* If the value membership changed, add the expression. */
|
if (bitmap_set_bit (&set->values, val))
|
if (bitmap_set_bit (&set->values, val))
|
bitmap_set_bit (&set->expressions, expr->id);
|
bitmap_set_bit (&set->expressions, expr->id);
|
}
|
}
|
|
|
/* Print out EXPR to outfile. */
|
/* Print out EXPR to outfile. */
|
|
|
static void
|
static void
|
print_pre_expr (FILE *outfile, const pre_expr expr)
|
print_pre_expr (FILE *outfile, const pre_expr expr)
|
{
|
{
|
switch (expr->kind)
|
switch (expr->kind)
|
{
|
{
|
case CONSTANT:
|
case CONSTANT:
|
print_generic_expr (outfile, PRE_EXPR_CONSTANT (expr), 0);
|
print_generic_expr (outfile, PRE_EXPR_CONSTANT (expr), 0);
|
break;
|
break;
|
case NAME:
|
case NAME:
|
print_generic_expr (outfile, PRE_EXPR_NAME (expr), 0);
|
print_generic_expr (outfile, PRE_EXPR_NAME (expr), 0);
|
break;
|
break;
|
case NARY:
|
case NARY:
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
vn_nary_op_t nary = PRE_EXPR_NARY (expr);
|
vn_nary_op_t nary = PRE_EXPR_NARY (expr);
|
fprintf (outfile, "{%s,", tree_code_name [nary->opcode]);
|
fprintf (outfile, "{%s,", tree_code_name [nary->opcode]);
|
for (i = 0; i < nary->length; i++)
|
for (i = 0; i < nary->length; i++)
|
{
|
{
|
print_generic_expr (outfile, nary->op[i], 0);
|
print_generic_expr (outfile, nary->op[i], 0);
|
if (i != (unsigned) nary->length - 1)
|
if (i != (unsigned) nary->length - 1)
|
fprintf (outfile, ",");
|
fprintf (outfile, ",");
|
}
|
}
|
fprintf (outfile, "}");
|
fprintf (outfile, "}");
|
}
|
}
|
break;
|
break;
|
|
|
case REFERENCE:
|
case REFERENCE:
|
{
|
{
|
vn_reference_op_t vro;
|
vn_reference_op_t vro;
|
unsigned int i;
|
unsigned int i;
|
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
|
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
|
fprintf (outfile, "{");
|
fprintf (outfile, "{");
|
for (i = 0;
|
for (i = 0;
|
VEC_iterate (vn_reference_op_s, ref->operands, i, vro);
|
VEC_iterate (vn_reference_op_s, ref->operands, i, vro);
|
i++)
|
i++)
|
{
|
{
|
bool closebrace = false;
|
bool closebrace = false;
|
if (vro->opcode != SSA_NAME
|
if (vro->opcode != SSA_NAME
|
&& TREE_CODE_CLASS (vro->opcode) != tcc_declaration)
|
&& TREE_CODE_CLASS (vro->opcode) != tcc_declaration)
|
{
|
{
|
fprintf (outfile, "%s", tree_code_name [vro->opcode]);
|
fprintf (outfile, "%s", tree_code_name [vro->opcode]);
|
if (vro->op0)
|
if (vro->op0)
|
{
|
{
|
fprintf (outfile, "<");
|
fprintf (outfile, "<");
|
closebrace = true;
|
closebrace = true;
|
}
|
}
|
}
|
}
|
if (vro->op0)
|
if (vro->op0)
|
{
|
{
|
print_generic_expr (outfile, vro->op0, 0);
|
print_generic_expr (outfile, vro->op0, 0);
|
if (vro->op1)
|
if (vro->op1)
|
{
|
{
|
fprintf (outfile, ",");
|
fprintf (outfile, ",");
|
print_generic_expr (outfile, vro->op1, 0);
|
print_generic_expr (outfile, vro->op1, 0);
|
}
|
}
|
if (vro->op2)
|
if (vro->op2)
|
{
|
{
|
fprintf (outfile, ",");
|
fprintf (outfile, ",");
|
print_generic_expr (outfile, vro->op2, 0);
|
print_generic_expr (outfile, vro->op2, 0);
|
}
|
}
|
}
|
}
|
if (closebrace)
|
if (closebrace)
|
fprintf (outfile, ">");
|
fprintf (outfile, ">");
|
if (i != VEC_length (vn_reference_op_s, ref->operands) - 1)
|
if (i != VEC_length (vn_reference_op_s, ref->operands) - 1)
|
fprintf (outfile, ",");
|
fprintf (outfile, ",");
|
}
|
}
|
fprintf (outfile, "}");
|
fprintf (outfile, "}");
|
if (ref->vuse)
|
if (ref->vuse)
|
{
|
{
|
fprintf (outfile, "@");
|
fprintf (outfile, "@");
|
print_generic_expr (outfile, ref->vuse, 0);
|
print_generic_expr (outfile, ref->vuse, 0);
|
}
|
}
|
}
|
}
|
break;
|
break;
|
}
|
}
|
}
|
}
|
void debug_pre_expr (pre_expr);
|
void debug_pre_expr (pre_expr);
|
|
|
/* Like print_pre_expr but always prints to stderr. */
|
/* Like print_pre_expr but always prints to stderr. */
|
DEBUG_FUNCTION void
|
DEBUG_FUNCTION void
|
debug_pre_expr (pre_expr e)
|
debug_pre_expr (pre_expr e)
|
{
|
{
|
print_pre_expr (stderr, e);
|
print_pre_expr (stderr, e);
|
fprintf (stderr, "\n");
|
fprintf (stderr, "\n");
|
}
|
}
|
|
|
/* Print out SET to OUTFILE. */
|
/* Print out SET to OUTFILE. */
|
|
|
static void
|
static void
|
print_bitmap_set (FILE *outfile, bitmap_set_t set,
|
print_bitmap_set (FILE *outfile, bitmap_set_t set,
|
const char *setname, int blockindex)
|
const char *setname, int blockindex)
|
{
|
{
|
fprintf (outfile, "%s[%d] := { ", setname, blockindex);
|
fprintf (outfile, "%s[%d] := { ", setname, blockindex);
|
if (set)
|
if (set)
|
{
|
{
|
bool first = true;
|
bool first = true;
|
unsigned i;
|
unsigned i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
FOR_EACH_EXPR_ID_IN_SET (set, i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (set, i, bi)
|
{
|
{
|
const pre_expr expr = expression_for_id (i);
|
const pre_expr expr = expression_for_id (i);
|
|
|
if (!first)
|
if (!first)
|
fprintf (outfile, ", ");
|
fprintf (outfile, ", ");
|
first = false;
|
first = false;
|
print_pre_expr (outfile, expr);
|
print_pre_expr (outfile, expr);
|
|
|
fprintf (outfile, " (%04d)", get_expr_value_id (expr));
|
fprintf (outfile, " (%04d)", get_expr_value_id (expr));
|
}
|
}
|
}
|
}
|
fprintf (outfile, " }\n");
|
fprintf (outfile, " }\n");
|
}
|
}
|
|
|
void debug_bitmap_set (bitmap_set_t);
|
void debug_bitmap_set (bitmap_set_t);
|
|
|
DEBUG_FUNCTION void
|
DEBUG_FUNCTION void
|
debug_bitmap_set (bitmap_set_t set)
|
debug_bitmap_set (bitmap_set_t set)
|
{
|
{
|
print_bitmap_set (stderr, set, "debug", 0);
|
print_bitmap_set (stderr, set, "debug", 0);
|
}
|
}
|
|
|
/* Print out the expressions that have VAL to OUTFILE. */
|
/* Print out the expressions that have VAL to OUTFILE. */
|
|
|
void
|
void
|
print_value_expressions (FILE *outfile, unsigned int val)
|
print_value_expressions (FILE *outfile, unsigned int val)
|
{
|
{
|
bitmap_set_t set = VEC_index (bitmap_set_t, value_expressions, val);
|
bitmap_set_t set = VEC_index (bitmap_set_t, value_expressions, val);
|
if (set)
|
if (set)
|
{
|
{
|
char s[10];
|
char s[10];
|
sprintf (s, "%04d", val);
|
sprintf (s, "%04d", val);
|
print_bitmap_set (outfile, set, s, 0);
|
print_bitmap_set (outfile, set, s, 0);
|
}
|
}
|
}
|
}
|
|
|
|
|
DEBUG_FUNCTION void
|
DEBUG_FUNCTION void
|
debug_value_expressions (unsigned int val)
|
debug_value_expressions (unsigned int val)
|
{
|
{
|
print_value_expressions (stderr, val);
|
print_value_expressions (stderr, val);
|
}
|
}
|
|
|
/* Given a CONSTANT, allocate a new CONSTANT type PRE_EXPR to
|
/* Given a CONSTANT, allocate a new CONSTANT type PRE_EXPR to
|
represent it. */
|
represent it. */
|
|
|
static pre_expr
|
static pre_expr
|
get_or_alloc_expr_for_constant (tree constant)
|
get_or_alloc_expr_for_constant (tree constant)
|
{
|
{
|
unsigned int result_id;
|
unsigned int result_id;
|
unsigned int value_id;
|
unsigned int value_id;
|
struct pre_expr_d expr;
|
struct pre_expr_d expr;
|
pre_expr newexpr;
|
pre_expr newexpr;
|
|
|
expr.kind = CONSTANT;
|
expr.kind = CONSTANT;
|
PRE_EXPR_CONSTANT (&expr) = constant;
|
PRE_EXPR_CONSTANT (&expr) = constant;
|
result_id = lookup_expression_id (&expr);
|
result_id = lookup_expression_id (&expr);
|
if (result_id != 0)
|
if (result_id != 0)
|
return expression_for_id (result_id);
|
return expression_for_id (result_id);
|
|
|
newexpr = (pre_expr) pool_alloc (pre_expr_pool);
|
newexpr = (pre_expr) pool_alloc (pre_expr_pool);
|
newexpr->kind = CONSTANT;
|
newexpr->kind = CONSTANT;
|
PRE_EXPR_CONSTANT (newexpr) = constant;
|
PRE_EXPR_CONSTANT (newexpr) = constant;
|
alloc_expression_id (newexpr);
|
alloc_expression_id (newexpr);
|
value_id = get_or_alloc_constant_value_id (constant);
|
value_id = get_or_alloc_constant_value_id (constant);
|
add_to_value (value_id, newexpr);
|
add_to_value (value_id, newexpr);
|
return newexpr;
|
return newexpr;
|
}
|
}
|
|
|
/* Given a value id V, find the actual tree representing the constant
|
/* Given a value id V, find the actual tree representing the constant
|
value if there is one, and return it. Return NULL if we can't find
|
value if there is one, and return it. Return NULL if we can't find
|
a constant. */
|
a constant. */
|
|
|
static tree
|
static tree
|
get_constant_for_value_id (unsigned int v)
|
get_constant_for_value_id (unsigned int v)
|
{
|
{
|
if (value_id_constant_p (v))
|
if (value_id_constant_p (v))
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, v);
|
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, v);
|
|
|
FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
|
{
|
{
|
pre_expr expr = expression_for_id (i);
|
pre_expr expr = expression_for_id (i);
|
if (expr->kind == CONSTANT)
|
if (expr->kind == CONSTANT)
|
return PRE_EXPR_CONSTANT (expr);
|
return PRE_EXPR_CONSTANT (expr);
|
}
|
}
|
}
|
}
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Get or allocate a pre_expr for a piece of GIMPLE, and return it.
|
/* Get or allocate a pre_expr for a piece of GIMPLE, and return it.
|
Currently only supports constants and SSA_NAMES. */
|
Currently only supports constants and SSA_NAMES. */
|
static pre_expr
|
static pre_expr
|
get_or_alloc_expr_for (tree t)
|
get_or_alloc_expr_for (tree t)
|
{
|
{
|
if (TREE_CODE (t) == SSA_NAME)
|
if (TREE_CODE (t) == SSA_NAME)
|
return get_or_alloc_expr_for_name (t);
|
return get_or_alloc_expr_for_name (t);
|
else if (is_gimple_min_invariant (t))
|
else if (is_gimple_min_invariant (t))
|
return get_or_alloc_expr_for_constant (t);
|
return get_or_alloc_expr_for_constant (t);
|
else
|
else
|
{
|
{
|
/* More complex expressions can result from SCCVN expression
|
/* More complex expressions can result from SCCVN expression
|
simplification that inserts values for them. As they all
|
simplification that inserts values for them. As they all
|
do not have VOPs the get handled by the nary ops struct. */
|
do not have VOPs the get handled by the nary ops struct. */
|
vn_nary_op_t result;
|
vn_nary_op_t result;
|
unsigned int result_id;
|
unsigned int result_id;
|
vn_nary_op_lookup (t, &result);
|
vn_nary_op_lookup (t, &result);
|
if (result != NULL)
|
if (result != NULL)
|
{
|
{
|
pre_expr e = (pre_expr) pool_alloc (pre_expr_pool);
|
pre_expr e = (pre_expr) pool_alloc (pre_expr_pool);
|
e->kind = NARY;
|
e->kind = NARY;
|
PRE_EXPR_NARY (e) = result;
|
PRE_EXPR_NARY (e) = result;
|
result_id = lookup_expression_id (e);
|
result_id = lookup_expression_id (e);
|
if (result_id != 0)
|
if (result_id != 0)
|
{
|
{
|
pool_free (pre_expr_pool, e);
|
pool_free (pre_expr_pool, e);
|
e = expression_for_id (result_id);
|
e = expression_for_id (result_id);
|
return e;
|
return e;
|
}
|
}
|
alloc_expression_id (e);
|
alloc_expression_id (e);
|
return e;
|
return e;
|
}
|
}
|
}
|
}
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Return the folded version of T if T, when folded, is a gimple
|
/* Return the folded version of T if T, when folded, is a gimple
|
min_invariant. Otherwise, return T. */
|
min_invariant. Otherwise, return T. */
|
|
|
static pre_expr
|
static pre_expr
|
fully_constant_expression (pre_expr e)
|
fully_constant_expression (pre_expr e)
|
{
|
{
|
switch (e->kind)
|
switch (e->kind)
|
{
|
{
|
case CONSTANT:
|
case CONSTANT:
|
return e;
|
return e;
|
case NARY:
|
case NARY:
|
{
|
{
|
vn_nary_op_t nary = PRE_EXPR_NARY (e);
|
vn_nary_op_t nary = PRE_EXPR_NARY (e);
|
switch (TREE_CODE_CLASS (nary->opcode))
|
switch (TREE_CODE_CLASS (nary->opcode))
|
{
|
{
|
case tcc_binary:
|
case tcc_binary:
|
case tcc_comparison:
|
case tcc_comparison:
|
{
|
{
|
/* We have to go from trees to pre exprs to value ids to
|
/* We have to go from trees to pre exprs to value ids to
|
constants. */
|
constants. */
|
tree naryop0 = nary->op[0];
|
tree naryop0 = nary->op[0];
|
tree naryop1 = nary->op[1];
|
tree naryop1 = nary->op[1];
|
tree result;
|
tree result;
|
if (!is_gimple_min_invariant (naryop0))
|
if (!is_gimple_min_invariant (naryop0))
|
{
|
{
|
pre_expr rep0 = get_or_alloc_expr_for (naryop0);
|
pre_expr rep0 = get_or_alloc_expr_for (naryop0);
|
unsigned int vrep0 = get_expr_value_id (rep0);
|
unsigned int vrep0 = get_expr_value_id (rep0);
|
tree const0 = get_constant_for_value_id (vrep0);
|
tree const0 = get_constant_for_value_id (vrep0);
|
if (const0)
|
if (const0)
|
naryop0 = fold_convert (TREE_TYPE (naryop0), const0);
|
naryop0 = fold_convert (TREE_TYPE (naryop0), const0);
|
}
|
}
|
if (!is_gimple_min_invariant (naryop1))
|
if (!is_gimple_min_invariant (naryop1))
|
{
|
{
|
pre_expr rep1 = get_or_alloc_expr_for (naryop1);
|
pre_expr rep1 = get_or_alloc_expr_for (naryop1);
|
unsigned int vrep1 = get_expr_value_id (rep1);
|
unsigned int vrep1 = get_expr_value_id (rep1);
|
tree const1 = get_constant_for_value_id (vrep1);
|
tree const1 = get_constant_for_value_id (vrep1);
|
if (const1)
|
if (const1)
|
naryop1 = fold_convert (TREE_TYPE (naryop1), const1);
|
naryop1 = fold_convert (TREE_TYPE (naryop1), const1);
|
}
|
}
|
result = fold_binary (nary->opcode, nary->type,
|
result = fold_binary (nary->opcode, nary->type,
|
naryop0, naryop1);
|
naryop0, naryop1);
|
if (result && is_gimple_min_invariant (result))
|
if (result && is_gimple_min_invariant (result))
|
return get_or_alloc_expr_for_constant (result);
|
return get_or_alloc_expr_for_constant (result);
|
/* We might have simplified the expression to a
|
/* We might have simplified the expression to a
|
SSA_NAME for example from x_1 * 1. But we cannot
|
SSA_NAME for example from x_1 * 1. But we cannot
|
insert a PHI for x_1 unconditionally as x_1 might
|
insert a PHI for x_1 unconditionally as x_1 might
|
not be available readily. */
|
not be available readily. */
|
return e;
|
return e;
|
}
|
}
|
case tcc_reference:
|
case tcc_reference:
|
if (nary->opcode != REALPART_EXPR
|
if (nary->opcode != REALPART_EXPR
|
&& nary->opcode != IMAGPART_EXPR
|
&& nary->opcode != IMAGPART_EXPR
|
&& nary->opcode != VIEW_CONVERT_EXPR)
|
&& nary->opcode != VIEW_CONVERT_EXPR)
|
return e;
|
return e;
|
/* Fallthrough. */
|
/* Fallthrough. */
|
case tcc_unary:
|
case tcc_unary:
|
{
|
{
|
/* We have to go from trees to pre exprs to value ids to
|
/* We have to go from trees to pre exprs to value ids to
|
constants. */
|
constants. */
|
tree naryop0 = nary->op[0];
|
tree naryop0 = nary->op[0];
|
tree const0, result;
|
tree const0, result;
|
if (is_gimple_min_invariant (naryop0))
|
if (is_gimple_min_invariant (naryop0))
|
const0 = naryop0;
|
const0 = naryop0;
|
else
|
else
|
{
|
{
|
pre_expr rep0 = get_or_alloc_expr_for (naryop0);
|
pre_expr rep0 = get_or_alloc_expr_for (naryop0);
|
unsigned int vrep0 = get_expr_value_id (rep0);
|
unsigned int vrep0 = get_expr_value_id (rep0);
|
const0 = get_constant_for_value_id (vrep0);
|
const0 = get_constant_for_value_id (vrep0);
|
}
|
}
|
result = NULL;
|
result = NULL;
|
if (const0)
|
if (const0)
|
{
|
{
|
tree type1 = TREE_TYPE (nary->op[0]);
|
tree type1 = TREE_TYPE (nary->op[0]);
|
const0 = fold_convert (type1, const0);
|
const0 = fold_convert (type1, const0);
|
result = fold_unary (nary->opcode, nary->type, const0);
|
result = fold_unary (nary->opcode, nary->type, const0);
|
}
|
}
|
if (result && is_gimple_min_invariant (result))
|
if (result && is_gimple_min_invariant (result))
|
return get_or_alloc_expr_for_constant (result);
|
return get_or_alloc_expr_for_constant (result);
|
return e;
|
return e;
|
}
|
}
|
default:
|
default:
|
return e;
|
return e;
|
}
|
}
|
}
|
}
|
case REFERENCE:
|
case REFERENCE:
|
{
|
{
|
vn_reference_t ref = PRE_EXPR_REFERENCE (e);
|
vn_reference_t ref = PRE_EXPR_REFERENCE (e);
|
tree folded;
|
tree folded;
|
if ((folded = fully_constant_vn_reference_p (ref)))
|
if ((folded = fully_constant_vn_reference_p (ref)))
|
return get_or_alloc_expr_for_constant (folded);
|
return get_or_alloc_expr_for_constant (folded);
|
return e;
|
return e;
|
}
|
}
|
default:
|
default:
|
return e;
|
return e;
|
}
|
}
|
return e;
|
return e;
|
}
|
}
|
|
|
/* Translate the VUSE backwards through phi nodes in PHIBLOCK, so that
|
/* Translate the VUSE backwards through phi nodes in PHIBLOCK, so that
|
it has the value it would have in BLOCK. Set *SAME_VALID to true
|
it has the value it would have in BLOCK. Set *SAME_VALID to true
|
in case the new vuse doesn't change the value id of the OPERANDS. */
|
in case the new vuse doesn't change the value id of the OPERANDS. */
|
|
|
static tree
|
static tree
|
translate_vuse_through_block (VEC (vn_reference_op_s, heap) *operands,
|
translate_vuse_through_block (VEC (vn_reference_op_s, heap) *operands,
|
alias_set_type set, tree type, tree vuse,
|
alias_set_type set, tree type, tree vuse,
|
basic_block phiblock,
|
basic_block phiblock,
|
basic_block block, bool *same_valid)
|
basic_block block, bool *same_valid)
|
{
|
{
|
gimple phi = SSA_NAME_DEF_STMT (vuse);
|
gimple phi = SSA_NAME_DEF_STMT (vuse);
|
ao_ref ref;
|
ao_ref ref;
|
edge e = NULL;
|
edge e = NULL;
|
bool use_oracle;
|
bool use_oracle;
|
|
|
*same_valid = true;
|
*same_valid = true;
|
|
|
if (gimple_bb (phi) != phiblock)
|
if (gimple_bb (phi) != phiblock)
|
return vuse;
|
return vuse;
|
|
|
use_oracle = ao_ref_init_from_vn_reference (&ref, set, type, operands);
|
use_oracle = ao_ref_init_from_vn_reference (&ref, set, type, operands);
|
|
|
/* Use the alias-oracle to find either the PHI node in this block,
|
/* Use the alias-oracle to find either the PHI node in this block,
|
the first VUSE used in this block that is equivalent to vuse or
|
the first VUSE used in this block that is equivalent to vuse or
|
the first VUSE which definition in this block kills the value. */
|
the first VUSE which definition in this block kills the value. */
|
if (gimple_code (phi) == GIMPLE_PHI)
|
if (gimple_code (phi) == GIMPLE_PHI)
|
e = find_edge (block, phiblock);
|
e = find_edge (block, phiblock);
|
else if (use_oracle)
|
else if (use_oracle)
|
while (!stmt_may_clobber_ref_p_1 (phi, &ref))
|
while (!stmt_may_clobber_ref_p_1 (phi, &ref))
|
{
|
{
|
vuse = gimple_vuse (phi);
|
vuse = gimple_vuse (phi);
|
phi = SSA_NAME_DEF_STMT (vuse);
|
phi = SSA_NAME_DEF_STMT (vuse);
|
if (gimple_bb (phi) != phiblock)
|
if (gimple_bb (phi) != phiblock)
|
return vuse;
|
return vuse;
|
if (gimple_code (phi) == GIMPLE_PHI)
|
if (gimple_code (phi) == GIMPLE_PHI)
|
{
|
{
|
e = find_edge (block, phiblock);
|
e = find_edge (block, phiblock);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
else
|
else
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
if (e)
|
if (e)
|
{
|
{
|
if (use_oracle)
|
if (use_oracle)
|
{
|
{
|
bitmap visited = NULL;
|
bitmap visited = NULL;
|
/* Try to find a vuse that dominates this phi node by skipping
|
/* Try to find a vuse that dominates this phi node by skipping
|
non-clobbering statements. */
|
non-clobbering statements. */
|
vuse = get_continuation_for_phi (phi, &ref, &visited);
|
vuse = get_continuation_for_phi (phi, &ref, &visited);
|
if (visited)
|
if (visited)
|
BITMAP_FREE (visited);
|
BITMAP_FREE (visited);
|
}
|
}
|
else
|
else
|
vuse = NULL_TREE;
|
vuse = NULL_TREE;
|
if (!vuse)
|
if (!vuse)
|
{
|
{
|
/* If we didn't find any, the value ID can't stay the same,
|
/* If we didn't find any, the value ID can't stay the same,
|
but return the translated vuse. */
|
but return the translated vuse. */
|
*same_valid = false;
|
*same_valid = false;
|
vuse = PHI_ARG_DEF (phi, e->dest_idx);
|
vuse = PHI_ARG_DEF (phi, e->dest_idx);
|
}
|
}
|
/* ??? We would like to return vuse here as this is the canonical
|
/* ??? We would like to return vuse here as this is the canonical
|
upmost vdef that this reference is associated with. But during
|
upmost vdef that this reference is associated with. But during
|
insertion of the references into the hash tables we only ever
|
insertion of the references into the hash tables we only ever
|
directly insert with their direct gimple_vuse, hence returning
|
directly insert with their direct gimple_vuse, hence returning
|
something else would make us not find the other expression. */
|
something else would make us not find the other expression. */
|
return PHI_ARG_DEF (phi, e->dest_idx);
|
return PHI_ARG_DEF (phi, e->dest_idx);
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Like bitmap_find_leader, but checks for the value existing in SET1 *or*
|
/* Like bitmap_find_leader, but checks for the value existing in SET1 *or*
|
SET2. This is used to avoid making a set consisting of the union
|
SET2. This is used to avoid making a set consisting of the union
|
of PA_IN and ANTIC_IN during insert. */
|
of PA_IN and ANTIC_IN during insert. */
|
|
|
static inline pre_expr
|
static inline pre_expr
|
find_leader_in_sets (unsigned int val, bitmap_set_t set1, bitmap_set_t set2)
|
find_leader_in_sets (unsigned int val, bitmap_set_t set1, bitmap_set_t set2)
|
{
|
{
|
pre_expr result;
|
pre_expr result;
|
|
|
result = bitmap_find_leader (set1, val, NULL);
|
result = bitmap_find_leader (set1, val, NULL);
|
if (!result && set2)
|
if (!result && set2)
|
result = bitmap_find_leader (set2, val, NULL);
|
result = bitmap_find_leader (set2, val, NULL);
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Get the tree type for our PRE expression e. */
|
/* Get the tree type for our PRE expression e. */
|
|
|
static tree
|
static tree
|
get_expr_type (const pre_expr e)
|
get_expr_type (const pre_expr e)
|
{
|
{
|
switch (e->kind)
|
switch (e->kind)
|
{
|
{
|
case NAME:
|
case NAME:
|
return TREE_TYPE (PRE_EXPR_NAME (e));
|
return TREE_TYPE (PRE_EXPR_NAME (e));
|
case CONSTANT:
|
case CONSTANT:
|
return TREE_TYPE (PRE_EXPR_CONSTANT (e));
|
return TREE_TYPE (PRE_EXPR_CONSTANT (e));
|
case REFERENCE:
|
case REFERENCE:
|
return PRE_EXPR_REFERENCE (e)->type;
|
return PRE_EXPR_REFERENCE (e)->type;
|
case NARY:
|
case NARY:
|
return PRE_EXPR_NARY (e)->type;
|
return PRE_EXPR_NARY (e)->type;
|
}
|
}
|
gcc_unreachable();
|
gcc_unreachable();
|
}
|
}
|
|
|
/* Get a representative SSA_NAME for a given expression.
|
/* Get a representative SSA_NAME for a given expression.
|
Since all of our sub-expressions are treated as values, we require
|
Since all of our sub-expressions are treated as values, we require
|
them to be SSA_NAME's for simplicity.
|
them to be SSA_NAME's for simplicity.
|
Prior versions of GVNPRE used to use "value handles" here, so that
|
Prior versions of GVNPRE used to use "value handles" here, so that
|
an expression would be VH.11 + VH.10 instead of d_3 + e_6. In
|
an expression would be VH.11 + VH.10 instead of d_3 + e_6. In
|
either case, the operands are really values (IE we do not expect
|
either case, the operands are really values (IE we do not expect
|
them to be usable without finding leaders). */
|
them to be usable without finding leaders). */
|
|
|
static tree
|
static tree
|
get_representative_for (const pre_expr e)
|
get_representative_for (const pre_expr e)
|
{
|
{
|
tree exprtype;
|
tree exprtype;
|
tree name;
|
tree name;
|
unsigned int value_id = get_expr_value_id (e);
|
unsigned int value_id = get_expr_value_id (e);
|
|
|
switch (e->kind)
|
switch (e->kind)
|
{
|
{
|
case NAME:
|
case NAME:
|
return PRE_EXPR_NAME (e);
|
return PRE_EXPR_NAME (e);
|
case CONSTANT:
|
case CONSTANT:
|
return PRE_EXPR_CONSTANT (e);
|
return PRE_EXPR_CONSTANT (e);
|
case NARY:
|
case NARY:
|
case REFERENCE:
|
case REFERENCE:
|
{
|
{
|
/* Go through all of the expressions representing this value
|
/* Go through all of the expressions representing this value
|
and pick out an SSA_NAME. */
|
and pick out an SSA_NAME. */
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
bitmap_set_t exprs = VEC_index (bitmap_set_t, value_expressions,
|
bitmap_set_t exprs = VEC_index (bitmap_set_t, value_expressions,
|
value_id);
|
value_id);
|
FOR_EACH_EXPR_ID_IN_SET (exprs, i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (exprs, i, bi)
|
{
|
{
|
pre_expr rep = expression_for_id (i);
|
pre_expr rep = expression_for_id (i);
|
if (rep->kind == NAME)
|
if (rep->kind == NAME)
|
return PRE_EXPR_NAME (rep);
|
return PRE_EXPR_NAME (rep);
|
}
|
}
|
}
|
}
|
break;
|
break;
|
}
|
}
|
/* If we reached here we couldn't find an SSA_NAME. This can
|
/* If we reached here we couldn't find an SSA_NAME. This can
|
happen when we've discovered a value that has never appeared in
|
happen when we've discovered a value that has never appeared in
|
the program as set to an SSA_NAME, most likely as the result of
|
the program as set to an SSA_NAME, most likely as the result of
|
phi translation. */
|
phi translation. */
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"Could not find SSA_NAME representative for expression:");
|
"Could not find SSA_NAME representative for expression:");
|
print_pre_expr (dump_file, e);
|
print_pre_expr (dump_file, e);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
|
|
exprtype = get_expr_type (e);
|
exprtype = get_expr_type (e);
|
|
|
/* Build and insert the assignment of the end result to the temporary
|
/* Build and insert the assignment of the end result to the temporary
|
that we will return. */
|
that we will return. */
|
if (!pretemp || exprtype != TREE_TYPE (pretemp))
|
if (!pretemp || exprtype != TREE_TYPE (pretemp))
|
{
|
{
|
pretemp = create_tmp_reg (exprtype, "pretmp");
|
pretemp = create_tmp_reg (exprtype, "pretmp");
|
add_referenced_var (pretemp);
|
add_referenced_var (pretemp);
|
}
|
}
|
|
|
name = make_ssa_name (pretemp, gimple_build_nop ());
|
name = make_ssa_name (pretemp, gimple_build_nop ());
|
VN_INFO_GET (name)->value_id = value_id;
|
VN_INFO_GET (name)->value_id = value_id;
|
if (e->kind == CONSTANT)
|
if (e->kind == CONSTANT)
|
VN_INFO (name)->valnum = PRE_EXPR_CONSTANT (e);
|
VN_INFO (name)->valnum = PRE_EXPR_CONSTANT (e);
|
else
|
else
|
VN_INFO (name)->valnum = name;
|
VN_INFO (name)->valnum = name;
|
|
|
add_to_value (value_id, get_or_alloc_expr_for_name (name));
|
add_to_value (value_id, get_or_alloc_expr_for_name (name));
|
if (dump_file)
|
if (dump_file)
|
{
|
{
|
fprintf (dump_file, "Created SSA_NAME representative ");
|
fprintf (dump_file, "Created SSA_NAME representative ");
|
print_generic_expr (dump_file, name, 0);
|
print_generic_expr (dump_file, name, 0);
|
fprintf (dump_file, " for expression:");
|
fprintf (dump_file, " for expression:");
|
print_pre_expr (dump_file, e);
|
print_pre_expr (dump_file, e);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
|
|
return name;
|
return name;
|
}
|
}
|
|
|
|
|
|
|
static pre_expr
|
static pre_expr
|
phi_translate (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
|
phi_translate (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
|
basic_block pred, basic_block phiblock);
|
basic_block pred, basic_block phiblock);
|
|
|
/* Translate EXPR using phis in PHIBLOCK, so that it has the values of
|
/* Translate EXPR using phis in PHIBLOCK, so that it has the values of
|
the phis in PRED. Return NULL if we can't find a leader for each part
|
the phis in PRED. Return NULL if we can't find a leader for each part
|
of the translated expression. */
|
of the translated expression. */
|
|
|
static pre_expr
|
static pre_expr
|
phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
|
phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
|
basic_block pred, basic_block phiblock)
|
basic_block pred, basic_block phiblock)
|
{
|
{
|
switch (expr->kind)
|
switch (expr->kind)
|
{
|
{
|
case NARY:
|
case NARY:
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
bool changed = false;
|
bool changed = false;
|
vn_nary_op_t nary = PRE_EXPR_NARY (expr);
|
vn_nary_op_t nary = PRE_EXPR_NARY (expr);
|
vn_nary_op_t newnary = XALLOCAVAR (struct vn_nary_op_s,
|
vn_nary_op_t newnary = XALLOCAVAR (struct vn_nary_op_s,
|
sizeof_vn_nary_op (nary->length));
|
sizeof_vn_nary_op (nary->length));
|
memcpy (newnary, nary, sizeof_vn_nary_op (nary->length));
|
memcpy (newnary, nary, sizeof_vn_nary_op (nary->length));
|
|
|
for (i = 0; i < newnary->length; i++)
|
for (i = 0; i < newnary->length; i++)
|
{
|
{
|
if (TREE_CODE (newnary->op[i]) != SSA_NAME)
|
if (TREE_CODE (newnary->op[i]) != SSA_NAME)
|
continue;
|
continue;
|
else
|
else
|
{
|
{
|
pre_expr leader, result;
|
pre_expr leader, result;
|
unsigned int op_val_id = VN_INFO (newnary->op[i])->value_id;
|
unsigned int op_val_id = VN_INFO (newnary->op[i])->value_id;
|
leader = find_leader_in_sets (op_val_id, set1, set2);
|
leader = find_leader_in_sets (op_val_id, set1, set2);
|
result = phi_translate (leader, set1, set2, pred, phiblock);
|
result = phi_translate (leader, set1, set2, pred, phiblock);
|
if (result && result != leader)
|
if (result && result != leader)
|
{
|
{
|
tree name = get_representative_for (result);
|
tree name = get_representative_for (result);
|
if (!name)
|
if (!name)
|
return NULL;
|
return NULL;
|
newnary->op[i] = name;
|
newnary->op[i] = name;
|
}
|
}
|
else if (!result)
|
else if (!result)
|
return NULL;
|
return NULL;
|
|
|
changed |= newnary->op[i] != nary->op[i];
|
changed |= newnary->op[i] != nary->op[i];
|
}
|
}
|
}
|
}
|
if (changed)
|
if (changed)
|
{
|
{
|
pre_expr constant;
|
pre_expr constant;
|
unsigned int new_val_id;
|
unsigned int new_val_id;
|
|
|
tree result = vn_nary_op_lookup_pieces (newnary->length,
|
tree result = vn_nary_op_lookup_pieces (newnary->length,
|
newnary->opcode,
|
newnary->opcode,
|
newnary->type,
|
newnary->type,
|
&newnary->op[0],
|
&newnary->op[0],
|
&nary);
|
&nary);
|
if (result && is_gimple_min_invariant (result))
|
if (result && is_gimple_min_invariant (result))
|
return get_or_alloc_expr_for_constant (result);
|
return get_or_alloc_expr_for_constant (result);
|
|
|
expr = (pre_expr) pool_alloc (pre_expr_pool);
|
expr = (pre_expr) pool_alloc (pre_expr_pool);
|
expr->kind = NARY;
|
expr->kind = NARY;
|
expr->id = 0;
|
expr->id = 0;
|
if (nary)
|
if (nary)
|
{
|
{
|
PRE_EXPR_NARY (expr) = nary;
|
PRE_EXPR_NARY (expr) = nary;
|
constant = fully_constant_expression (expr);
|
constant = fully_constant_expression (expr);
|
if (constant != expr)
|
if (constant != expr)
|
return constant;
|
return constant;
|
|
|
new_val_id = nary->value_id;
|
new_val_id = nary->value_id;
|
get_or_alloc_expression_id (expr);
|
get_or_alloc_expression_id (expr);
|
}
|
}
|
else
|
else
|
{
|
{
|
new_val_id = get_next_value_id ();
|
new_val_id = get_next_value_id ();
|
VEC_safe_grow_cleared (bitmap_set_t, heap,
|
VEC_safe_grow_cleared (bitmap_set_t, heap,
|
value_expressions,
|
value_expressions,
|
get_max_value_id() + 1);
|
get_max_value_id() + 1);
|
nary = vn_nary_op_insert_pieces (newnary->length,
|
nary = vn_nary_op_insert_pieces (newnary->length,
|
newnary->opcode,
|
newnary->opcode,
|
newnary->type,
|
newnary->type,
|
&newnary->op[0],
|
&newnary->op[0],
|
result, new_val_id);
|
result, new_val_id);
|
PRE_EXPR_NARY (expr) = nary;
|
PRE_EXPR_NARY (expr) = nary;
|
constant = fully_constant_expression (expr);
|
constant = fully_constant_expression (expr);
|
if (constant != expr)
|
if (constant != expr)
|
return constant;
|
return constant;
|
get_or_alloc_expression_id (expr);
|
get_or_alloc_expression_id (expr);
|
}
|
}
|
add_to_value (new_val_id, expr);
|
add_to_value (new_val_id, expr);
|
}
|
}
|
return expr;
|
return expr;
|
}
|
}
|
break;
|
break;
|
|
|
case REFERENCE:
|
case REFERENCE:
|
{
|
{
|
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
|
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
|
VEC (vn_reference_op_s, heap) *operands = ref->operands;
|
VEC (vn_reference_op_s, heap) *operands = ref->operands;
|
tree vuse = ref->vuse;
|
tree vuse = ref->vuse;
|
tree newvuse = vuse;
|
tree newvuse = vuse;
|
VEC (vn_reference_op_s, heap) *newoperands = NULL;
|
VEC (vn_reference_op_s, heap) *newoperands = NULL;
|
bool changed = false, same_valid = true;
|
bool changed = false, same_valid = true;
|
unsigned int i, j, n;
|
unsigned int i, j, n;
|
vn_reference_op_t operand;
|
vn_reference_op_t operand;
|
vn_reference_t newref;
|
vn_reference_t newref;
|
|
|
for (i = 0, j = 0;
|
for (i = 0, j = 0;
|
VEC_iterate (vn_reference_op_s, operands, i, operand); i++, j++)
|
VEC_iterate (vn_reference_op_s, operands, i, operand); i++, j++)
|
{
|
{
|
pre_expr opresult;
|
pre_expr opresult;
|
pre_expr leader;
|
pre_expr leader;
|
tree op[3];
|
tree op[3];
|
tree type = operand->type;
|
tree type = operand->type;
|
vn_reference_op_s newop = *operand;
|
vn_reference_op_s newop = *operand;
|
op[0] = operand->op0;
|
op[0] = operand->op0;
|
op[1] = operand->op1;
|
op[1] = operand->op1;
|
op[2] = operand->op2;
|
op[2] = operand->op2;
|
for (n = 0; n < 3; ++n)
|
for (n = 0; n < 3; ++n)
|
{
|
{
|
unsigned int op_val_id;
|
unsigned int op_val_id;
|
if (!op[n])
|
if (!op[n])
|
continue;
|
continue;
|
if (TREE_CODE (op[n]) != SSA_NAME)
|
if (TREE_CODE (op[n]) != SSA_NAME)
|
{
|
{
|
/* We can't possibly insert these. */
|
/* We can't possibly insert these. */
|
if (n != 0
|
if (n != 0
|
&& !is_gimple_min_invariant (op[n]))
|
&& !is_gimple_min_invariant (op[n]))
|
break;
|
break;
|
continue;
|
continue;
|
}
|
}
|
op_val_id = VN_INFO (op[n])->value_id;
|
op_val_id = VN_INFO (op[n])->value_id;
|
leader = find_leader_in_sets (op_val_id, set1, set2);
|
leader = find_leader_in_sets (op_val_id, set1, set2);
|
if (!leader)
|
if (!leader)
|
break;
|
break;
|
/* Make sure we do not recursively translate ourselves
|
/* Make sure we do not recursively translate ourselves
|
like for translating a[n_1] with the leader for
|
like for translating a[n_1] with the leader for
|
n_1 being a[n_1]. */
|
n_1 being a[n_1]. */
|
if (get_expression_id (leader) != get_expression_id (expr))
|
if (get_expression_id (leader) != get_expression_id (expr))
|
{
|
{
|
opresult = phi_translate (leader, set1, set2,
|
opresult = phi_translate (leader, set1, set2,
|
pred, phiblock);
|
pred, phiblock);
|
if (!opresult)
|
if (!opresult)
|
break;
|
break;
|
if (opresult != leader)
|
if (opresult != leader)
|
{
|
{
|
tree name = get_representative_for (opresult);
|
tree name = get_representative_for (opresult);
|
if (!name)
|
if (!name)
|
break;
|
break;
|
changed |= name != op[n];
|
changed |= name != op[n];
|
op[n] = name;
|
op[n] = name;
|
}
|
}
|
}
|
}
|
}
|
}
|
if (n != 3)
|
if (n != 3)
|
{
|
{
|
if (newoperands)
|
if (newoperands)
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
return NULL;
|
return NULL;
|
}
|
}
|
if (!newoperands)
|
if (!newoperands)
|
newoperands = VEC_copy (vn_reference_op_s, heap, operands);
|
newoperands = VEC_copy (vn_reference_op_s, heap, operands);
|
/* We may have changed from an SSA_NAME to a constant */
|
/* We may have changed from an SSA_NAME to a constant */
|
if (newop.opcode == SSA_NAME && TREE_CODE (op[0]) != SSA_NAME)
|
if (newop.opcode == SSA_NAME && TREE_CODE (op[0]) != SSA_NAME)
|
newop.opcode = TREE_CODE (op[0]);
|
newop.opcode = TREE_CODE (op[0]);
|
newop.type = type;
|
newop.type = type;
|
newop.op0 = op[0];
|
newop.op0 = op[0];
|
newop.op1 = op[1];
|
newop.op1 = op[1];
|
newop.op2 = op[2];
|
newop.op2 = op[2];
|
/* If it transforms a non-constant ARRAY_REF into a constant
|
/* If it transforms a non-constant ARRAY_REF into a constant
|
one, adjust the constant offset. */
|
one, adjust the constant offset. */
|
if (newop.opcode == ARRAY_REF
|
if (newop.opcode == ARRAY_REF
|
&& newop.off == -1
|
&& newop.off == -1
|
&& TREE_CODE (op[0]) == INTEGER_CST
|
&& TREE_CODE (op[0]) == INTEGER_CST
|
&& TREE_CODE (op[1]) == INTEGER_CST
|
&& TREE_CODE (op[1]) == INTEGER_CST
|
&& TREE_CODE (op[2]) == INTEGER_CST)
|
&& TREE_CODE (op[2]) == INTEGER_CST)
|
{
|
{
|
double_int off = tree_to_double_int (op[0]);
|
double_int off = tree_to_double_int (op[0]);
|
off = double_int_add (off,
|
off = double_int_add (off,
|
double_int_neg
|
double_int_neg
|
(tree_to_double_int (op[1])));
|
(tree_to_double_int (op[1])));
|
off = double_int_mul (off, tree_to_double_int (op[2]));
|
off = double_int_mul (off, tree_to_double_int (op[2]));
|
if (double_int_fits_in_shwi_p (off))
|
if (double_int_fits_in_shwi_p (off))
|
newop.off = off.low;
|
newop.off = off.low;
|
}
|
}
|
VEC_replace (vn_reference_op_s, newoperands, j, &newop);
|
VEC_replace (vn_reference_op_s, newoperands, j, &newop);
|
/* If it transforms from an SSA_NAME to an address, fold with
|
/* If it transforms from an SSA_NAME to an address, fold with
|
a preceding indirect reference. */
|
a preceding indirect reference. */
|
if (j > 0 && op[0] && TREE_CODE (op[0]) == ADDR_EXPR
|
if (j > 0 && op[0] && TREE_CODE (op[0]) == ADDR_EXPR
|
&& VEC_index (vn_reference_op_s,
|
&& VEC_index (vn_reference_op_s,
|
newoperands, j - 1)->opcode == MEM_REF)
|
newoperands, j - 1)->opcode == MEM_REF)
|
vn_reference_fold_indirect (&newoperands, &j);
|
vn_reference_fold_indirect (&newoperands, &j);
|
}
|
}
|
if (i != VEC_length (vn_reference_op_s, operands))
|
if (i != VEC_length (vn_reference_op_s, operands))
|
{
|
{
|
if (newoperands)
|
if (newoperands)
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
if (vuse)
|
if (vuse)
|
{
|
{
|
newvuse = translate_vuse_through_block (newoperands,
|
newvuse = translate_vuse_through_block (newoperands,
|
ref->set, ref->type,
|
ref->set, ref->type,
|
vuse, phiblock, pred,
|
vuse, phiblock, pred,
|
&same_valid);
|
&same_valid);
|
if (newvuse == NULL_TREE)
|
if (newvuse == NULL_TREE)
|
{
|
{
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
return NULL;
|
return NULL;
|
}
|
}
|
}
|
}
|
|
|
if (changed || newvuse != vuse)
|
if (changed || newvuse != vuse)
|
{
|
{
|
unsigned int new_val_id;
|
unsigned int new_val_id;
|
pre_expr constant;
|
pre_expr constant;
|
bool converted = false;
|
bool converted = false;
|
|
|
tree result = vn_reference_lookup_pieces (newvuse, ref->set,
|
tree result = vn_reference_lookup_pieces (newvuse, ref->set,
|
ref->type,
|
ref->type,
|
newoperands,
|
newoperands,
|
&newref, VN_WALK);
|
&newref, VN_WALK);
|
if (result)
|
if (result)
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
|
|
if (result
|
if (result
|
&& !useless_type_conversion_p (ref->type, TREE_TYPE (result)))
|
&& !useless_type_conversion_p (ref->type, TREE_TYPE (result)))
|
{
|
{
|
result = fold_build1 (VIEW_CONVERT_EXPR, ref->type, result);
|
result = fold_build1 (VIEW_CONVERT_EXPR, ref->type, result);
|
converted = true;
|
converted = true;
|
}
|
}
|
else if (!result && newref
|
else if (!result && newref
|
&& !useless_type_conversion_p (ref->type, newref->type))
|
&& !useless_type_conversion_p (ref->type, newref->type))
|
{
|
{
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
if (result && is_gimple_min_invariant (result))
|
if (result && is_gimple_min_invariant (result))
|
{
|
{
|
gcc_assert (!newoperands);
|
gcc_assert (!newoperands);
|
return get_or_alloc_expr_for_constant (result);
|
return get_or_alloc_expr_for_constant (result);
|
}
|
}
|
|
|
expr = (pre_expr) pool_alloc (pre_expr_pool);
|
expr = (pre_expr) pool_alloc (pre_expr_pool);
|
expr->kind = REFERENCE;
|
expr->kind = REFERENCE;
|
expr->id = 0;
|
expr->id = 0;
|
|
|
if (converted)
|
if (converted)
|
{
|
{
|
vn_nary_op_t nary;
|
vn_nary_op_t nary;
|
tree nresult;
|
tree nresult;
|
|
|
gcc_assert (CONVERT_EXPR_P (result)
|
gcc_assert (CONVERT_EXPR_P (result)
|
|| TREE_CODE (result) == VIEW_CONVERT_EXPR);
|
|| TREE_CODE (result) == VIEW_CONVERT_EXPR);
|
|
|
nresult = vn_nary_op_lookup_pieces (1, TREE_CODE (result),
|
nresult = vn_nary_op_lookup_pieces (1, TREE_CODE (result),
|
TREE_TYPE (result),
|
TREE_TYPE (result),
|
&TREE_OPERAND (result, 0),
|
&TREE_OPERAND (result, 0),
|
&nary);
|
&nary);
|
if (nresult && is_gimple_min_invariant (nresult))
|
if (nresult && is_gimple_min_invariant (nresult))
|
return get_or_alloc_expr_for_constant (nresult);
|
return get_or_alloc_expr_for_constant (nresult);
|
|
|
expr->kind = NARY;
|
expr->kind = NARY;
|
if (nary)
|
if (nary)
|
{
|
{
|
PRE_EXPR_NARY (expr) = nary;
|
PRE_EXPR_NARY (expr) = nary;
|
constant = fully_constant_expression (expr);
|
constant = fully_constant_expression (expr);
|
if (constant != expr)
|
if (constant != expr)
|
return constant;
|
return constant;
|
|
|
new_val_id = nary->value_id;
|
new_val_id = nary->value_id;
|
get_or_alloc_expression_id (expr);
|
get_or_alloc_expression_id (expr);
|
}
|
}
|
else
|
else
|
{
|
{
|
new_val_id = get_next_value_id ();
|
new_val_id = get_next_value_id ();
|
VEC_safe_grow_cleared (bitmap_set_t, heap,
|
VEC_safe_grow_cleared (bitmap_set_t, heap,
|
value_expressions,
|
value_expressions,
|
get_max_value_id() + 1);
|
get_max_value_id() + 1);
|
nary = vn_nary_op_insert_pieces (1, TREE_CODE (result),
|
nary = vn_nary_op_insert_pieces (1, TREE_CODE (result),
|
TREE_TYPE (result),
|
TREE_TYPE (result),
|
&TREE_OPERAND (result, 0),
|
&TREE_OPERAND (result, 0),
|
NULL_TREE,
|
NULL_TREE,
|
new_val_id);
|
new_val_id);
|
PRE_EXPR_NARY (expr) = nary;
|
PRE_EXPR_NARY (expr) = nary;
|
constant = fully_constant_expression (expr);
|
constant = fully_constant_expression (expr);
|
if (constant != expr)
|
if (constant != expr)
|
return constant;
|
return constant;
|
get_or_alloc_expression_id (expr);
|
get_or_alloc_expression_id (expr);
|
}
|
}
|
}
|
}
|
else if (newref)
|
else if (newref)
|
{
|
{
|
PRE_EXPR_REFERENCE (expr) = newref;
|
PRE_EXPR_REFERENCE (expr) = newref;
|
constant = fully_constant_expression (expr);
|
constant = fully_constant_expression (expr);
|
if (constant != expr)
|
if (constant != expr)
|
return constant;
|
return constant;
|
|
|
new_val_id = newref->value_id;
|
new_val_id = newref->value_id;
|
get_or_alloc_expression_id (expr);
|
get_or_alloc_expression_id (expr);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (changed || !same_valid)
|
if (changed || !same_valid)
|
{
|
{
|
new_val_id = get_next_value_id ();
|
new_val_id = get_next_value_id ();
|
VEC_safe_grow_cleared (bitmap_set_t, heap,
|
VEC_safe_grow_cleared (bitmap_set_t, heap,
|
value_expressions,
|
value_expressions,
|
get_max_value_id() + 1);
|
get_max_value_id() + 1);
|
}
|
}
|
else
|
else
|
new_val_id = ref->value_id;
|
new_val_id = ref->value_id;
|
newref = vn_reference_insert_pieces (newvuse, ref->set,
|
newref = vn_reference_insert_pieces (newvuse, ref->set,
|
ref->type,
|
ref->type,
|
newoperands,
|
newoperands,
|
result, new_val_id);
|
result, new_val_id);
|
newoperands = NULL;
|
newoperands = NULL;
|
PRE_EXPR_REFERENCE (expr) = newref;
|
PRE_EXPR_REFERENCE (expr) = newref;
|
constant = fully_constant_expression (expr);
|
constant = fully_constant_expression (expr);
|
if (constant != expr)
|
if (constant != expr)
|
return constant;
|
return constant;
|
get_or_alloc_expression_id (expr);
|
get_or_alloc_expression_id (expr);
|
}
|
}
|
add_to_value (new_val_id, expr);
|
add_to_value (new_val_id, expr);
|
}
|
}
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
VEC_free (vn_reference_op_s, heap, newoperands);
|
return expr;
|
return expr;
|
}
|
}
|
break;
|
break;
|
|
|
case NAME:
|
case NAME:
|
{
|
{
|
gimple phi = NULL;
|
gimple phi = NULL;
|
edge e;
|
edge e;
|
gimple def_stmt;
|
gimple def_stmt;
|
tree name = PRE_EXPR_NAME (expr);
|
tree name = PRE_EXPR_NAME (expr);
|
|
|
def_stmt = SSA_NAME_DEF_STMT (name);
|
def_stmt = SSA_NAME_DEF_STMT (name);
|
if (gimple_code (def_stmt) == GIMPLE_PHI
|
if (gimple_code (def_stmt) == GIMPLE_PHI
|
&& gimple_bb (def_stmt) == phiblock)
|
&& gimple_bb (def_stmt) == phiblock)
|
phi = def_stmt;
|
phi = def_stmt;
|
else
|
else
|
return expr;
|
return expr;
|
|
|
e = find_edge (pred, gimple_bb (phi));
|
e = find_edge (pred, gimple_bb (phi));
|
if (e)
|
if (e)
|
{
|
{
|
tree def = PHI_ARG_DEF (phi, e->dest_idx);
|
tree def = PHI_ARG_DEF (phi, e->dest_idx);
|
pre_expr newexpr;
|
pre_expr newexpr;
|
|
|
if (TREE_CODE (def) == SSA_NAME)
|
if (TREE_CODE (def) == SSA_NAME)
|
def = VN_INFO (def)->valnum;
|
def = VN_INFO (def)->valnum;
|
|
|
/* Handle constant. */
|
/* Handle constant. */
|
if (is_gimple_min_invariant (def))
|
if (is_gimple_min_invariant (def))
|
return get_or_alloc_expr_for_constant (def);
|
return get_or_alloc_expr_for_constant (def);
|
|
|
if (TREE_CODE (def) == SSA_NAME && ssa_undefined_value_p (def))
|
if (TREE_CODE (def) == SSA_NAME && ssa_undefined_value_p (def))
|
return NULL;
|
return NULL;
|
|
|
newexpr = get_or_alloc_expr_for_name (def);
|
newexpr = get_or_alloc_expr_for_name (def);
|
return newexpr;
|
return newexpr;
|
}
|
}
|
}
|
}
|
return expr;
|
return expr;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Wrapper around phi_translate_1 providing caching functionality. */
|
/* Wrapper around phi_translate_1 providing caching functionality. */
|
|
|
static pre_expr
|
static pre_expr
|
phi_translate (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
|
phi_translate (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2,
|
basic_block pred, basic_block phiblock)
|
basic_block pred, basic_block phiblock)
|
{
|
{
|
pre_expr phitrans;
|
pre_expr phitrans;
|
|
|
if (!expr)
|
if (!expr)
|
return NULL;
|
return NULL;
|
|
|
/* Constants contain no values that need translation. */
|
/* Constants contain no values that need translation. */
|
if (expr->kind == CONSTANT)
|
if (expr->kind == CONSTANT)
|
return expr;
|
return expr;
|
|
|
if (value_id_constant_p (get_expr_value_id (expr)))
|
if (value_id_constant_p (get_expr_value_id (expr)))
|
return expr;
|
return expr;
|
|
|
if (expr->kind != NAME)
|
if (expr->kind != NAME)
|
{
|
{
|
phitrans = phi_trans_lookup (expr, pred);
|
phitrans = phi_trans_lookup (expr, pred);
|
if (phitrans)
|
if (phitrans)
|
return phitrans;
|
return phitrans;
|
}
|
}
|
|
|
/* Translate. */
|
/* Translate. */
|
phitrans = phi_translate_1 (expr, set1, set2, pred, phiblock);
|
phitrans = phi_translate_1 (expr, set1, set2, pred, phiblock);
|
|
|
/* Don't add empty translations to the cache. Neither add
|
/* Don't add empty translations to the cache. Neither add
|
translations of NAMEs as those are cheap to translate. */
|
translations of NAMEs as those are cheap to translate. */
|
if (phitrans
|
if (phitrans
|
&& expr->kind != NAME)
|
&& expr->kind != NAME)
|
phi_trans_add (expr, phitrans, pred);
|
phi_trans_add (expr, phitrans, pred);
|
|
|
return phitrans;
|
return phitrans;
|
}
|
}
|
|
|
|
|
/* For each expression in SET, translate the values through phi nodes
|
/* For each expression in SET, translate the values through phi nodes
|
in PHIBLOCK using edge PHIBLOCK->PRED, and store the resulting
|
in PHIBLOCK using edge PHIBLOCK->PRED, and store the resulting
|
expressions in DEST. */
|
expressions in DEST. */
|
|
|
static void
|
static void
|
phi_translate_set (bitmap_set_t dest, bitmap_set_t set, basic_block pred,
|
phi_translate_set (bitmap_set_t dest, bitmap_set_t set, basic_block pred,
|
basic_block phiblock)
|
basic_block phiblock)
|
{
|
{
|
VEC (pre_expr, heap) *exprs;
|
VEC (pre_expr, heap) *exprs;
|
pre_expr expr;
|
pre_expr expr;
|
int i;
|
int i;
|
|
|
if (gimple_seq_empty_p (phi_nodes (phiblock)))
|
if (gimple_seq_empty_p (phi_nodes (phiblock)))
|
{
|
{
|
bitmap_set_copy (dest, set);
|
bitmap_set_copy (dest, set);
|
return;
|
return;
|
}
|
}
|
|
|
exprs = sorted_array_from_bitmap_set (set);
|
exprs = sorted_array_from_bitmap_set (set);
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
{
|
{
|
pre_expr translated;
|
pre_expr translated;
|
translated = phi_translate (expr, set, NULL, pred, phiblock);
|
translated = phi_translate (expr, set, NULL, pred, phiblock);
|
if (!translated)
|
if (!translated)
|
continue;
|
continue;
|
|
|
/* We might end up with multiple expressions from SET being
|
/* We might end up with multiple expressions from SET being
|
translated to the same value. In this case we do not want
|
translated to the same value. In this case we do not want
|
to retain the NARY or REFERENCE expression but prefer a NAME
|
to retain the NARY or REFERENCE expression but prefer a NAME
|
which would be the leader. */
|
which would be the leader. */
|
if (translated->kind == NAME)
|
if (translated->kind == NAME)
|
bitmap_value_replace_in_set (dest, translated);
|
bitmap_value_replace_in_set (dest, translated);
|
else
|
else
|
bitmap_value_insert_into_set (dest, translated);
|
bitmap_value_insert_into_set (dest, translated);
|
}
|
}
|
VEC_free (pre_expr, heap, exprs);
|
VEC_free (pre_expr, heap, exprs);
|
}
|
}
|
|
|
/* Find the leader for a value (i.e., the name representing that
|
/* Find the leader for a value (i.e., the name representing that
|
value) in a given set, and return it. If STMT is non-NULL it
|
value) in a given set, and return it. If STMT is non-NULL it
|
makes sure the defining statement for the leader dominates it.
|
makes sure the defining statement for the leader dominates it.
|
Return NULL if no leader is found. */
|
Return NULL if no leader is found. */
|
|
|
static pre_expr
|
static pre_expr
|
bitmap_find_leader (bitmap_set_t set, unsigned int val, gimple stmt)
|
bitmap_find_leader (bitmap_set_t set, unsigned int val, gimple stmt)
|
{
|
{
|
if (value_id_constant_p (val))
|
if (value_id_constant_p (val))
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, val);
|
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, val);
|
|
|
FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
|
{
|
{
|
pre_expr expr = expression_for_id (i);
|
pre_expr expr = expression_for_id (i);
|
if (expr->kind == CONSTANT)
|
if (expr->kind == CONSTANT)
|
return expr;
|
return expr;
|
}
|
}
|
}
|
}
|
if (bitmap_set_contains_value (set, val))
|
if (bitmap_set_contains_value (set, val))
|
{
|
{
|
/* Rather than walk the entire bitmap of expressions, and see
|
/* Rather than walk the entire bitmap of expressions, and see
|
whether any of them has the value we are looking for, we look
|
whether any of them has the value we are looking for, we look
|
at the reverse mapping, which tells us the set of expressions
|
at the reverse mapping, which tells us the set of expressions
|
that have a given value (IE value->expressions with that
|
that have a given value (IE value->expressions with that
|
value) and see if any of those expressions are in our set.
|
value) and see if any of those expressions are in our set.
|
The number of expressions per value is usually significantly
|
The number of expressions per value is usually significantly
|
less than the number of expressions in the set. In fact, for
|
less than the number of expressions in the set. In fact, for
|
large testcases, doing it this way is roughly 5-10x faster
|
large testcases, doing it this way is roughly 5-10x faster
|
than walking the bitmap.
|
than walking the bitmap.
|
If this is somehow a significant lose for some cases, we can
|
If this is somehow a significant lose for some cases, we can
|
choose which set to walk based on which set is smaller. */
|
choose which set to walk based on which set is smaller. */
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, val);
|
bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, val);
|
|
|
EXECUTE_IF_AND_IN_BITMAP (&exprset->expressions,
|
EXECUTE_IF_AND_IN_BITMAP (&exprset->expressions,
|
&set->expressions, 0, i, bi)
|
&set->expressions, 0, i, bi)
|
{
|
{
|
pre_expr val = expression_for_id (i);
|
pre_expr val = expression_for_id (i);
|
/* At the point where stmt is not null, there should always
|
/* At the point where stmt is not null, there should always
|
be an SSA_NAME first in the list of expressions. */
|
be an SSA_NAME first in the list of expressions. */
|
if (stmt)
|
if (stmt)
|
{
|
{
|
gimple def_stmt = SSA_NAME_DEF_STMT (PRE_EXPR_NAME (val));
|
gimple def_stmt = SSA_NAME_DEF_STMT (PRE_EXPR_NAME (val));
|
if (gimple_code (def_stmt) != GIMPLE_PHI
|
if (gimple_code (def_stmt) != GIMPLE_PHI
|
&& gimple_bb (def_stmt) == gimple_bb (stmt)
|
&& gimple_bb (def_stmt) == gimple_bb (stmt)
|
/* PRE insertions are at the end of the basic-block
|
/* PRE insertions are at the end of the basic-block
|
and have UID 0. */
|
and have UID 0. */
|
&& (gimple_uid (def_stmt) == 0
|
&& (gimple_uid (def_stmt) == 0
|
|| gimple_uid (def_stmt) >= gimple_uid (stmt)))
|
|| gimple_uid (def_stmt) >= gimple_uid (stmt)))
|
continue;
|
continue;
|
}
|
}
|
return val;
|
return val;
|
}
|
}
|
}
|
}
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Determine if EXPR, a memory expression, is ANTIC_IN at the top of
|
/* Determine if EXPR, a memory expression, is ANTIC_IN at the top of
|
BLOCK by seeing if it is not killed in the block. Note that we are
|
BLOCK by seeing if it is not killed in the block. Note that we are
|
only determining whether there is a store that kills it. Because
|
only determining whether there is a store that kills it. Because
|
of the order in which clean iterates over values, we are guaranteed
|
of the order in which clean iterates over values, we are guaranteed
|
that altered operands will have caused us to be eliminated from the
|
that altered operands will have caused us to be eliminated from the
|
ANTIC_IN set already. */
|
ANTIC_IN set already. */
|
|
|
static bool
|
static bool
|
value_dies_in_block_x (pre_expr expr, basic_block block)
|
value_dies_in_block_x (pre_expr expr, basic_block block)
|
{
|
{
|
tree vuse = PRE_EXPR_REFERENCE (expr)->vuse;
|
tree vuse = PRE_EXPR_REFERENCE (expr)->vuse;
|
vn_reference_t refx = PRE_EXPR_REFERENCE (expr);
|
vn_reference_t refx = PRE_EXPR_REFERENCE (expr);
|
gimple def;
|
gimple def;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
unsigned id = get_expression_id (expr);
|
unsigned id = get_expression_id (expr);
|
bool res = false;
|
bool res = false;
|
ao_ref ref;
|
ao_ref ref;
|
|
|
if (!vuse)
|
if (!vuse)
|
return false;
|
return false;
|
|
|
/* Lookup a previously calculated result. */
|
/* Lookup a previously calculated result. */
|
if (EXPR_DIES (block)
|
if (EXPR_DIES (block)
|
&& bitmap_bit_p (EXPR_DIES (block), id * 2))
|
&& bitmap_bit_p (EXPR_DIES (block), id * 2))
|
return bitmap_bit_p (EXPR_DIES (block), id * 2 + 1);
|
return bitmap_bit_p (EXPR_DIES (block), id * 2 + 1);
|
|
|
/* A memory expression {e, VUSE} dies in the block if there is a
|
/* A memory expression {e, VUSE} dies in the block if there is a
|
statement that may clobber e. If, starting statement walk from the
|
statement that may clobber e. If, starting statement walk from the
|
top of the basic block, a statement uses VUSE there can be no kill
|
top of the basic block, a statement uses VUSE there can be no kill
|
inbetween that use and the original statement that loaded {e, VUSE},
|
inbetween that use and the original statement that loaded {e, VUSE},
|
so we can stop walking. */
|
so we can stop walking. */
|
ref.base = NULL_TREE;
|
ref.base = NULL_TREE;
|
for (gsi = gsi_start_bb (block); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_bb (block); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
tree def_vuse, def_vdef;
|
tree def_vuse, def_vdef;
|
def = gsi_stmt (gsi);
|
def = gsi_stmt (gsi);
|
def_vuse = gimple_vuse (def);
|
def_vuse = gimple_vuse (def);
|
def_vdef = gimple_vdef (def);
|
def_vdef = gimple_vdef (def);
|
|
|
/* Not a memory statement. */
|
/* Not a memory statement. */
|
if (!def_vuse)
|
if (!def_vuse)
|
continue;
|
continue;
|
|
|
/* Not a may-def. */
|
/* Not a may-def. */
|
if (!def_vdef)
|
if (!def_vdef)
|
{
|
{
|
/* A load with the same VUSE, we're done. */
|
/* A load with the same VUSE, we're done. */
|
if (def_vuse == vuse)
|
if (def_vuse == vuse)
|
break;
|
break;
|
|
|
continue;
|
continue;
|
}
|
}
|
|
|
/* Init ref only if we really need it. */
|
/* Init ref only if we really need it. */
|
if (ref.base == NULL_TREE
|
if (ref.base == NULL_TREE
|
&& !ao_ref_init_from_vn_reference (&ref, refx->set, refx->type,
|
&& !ao_ref_init_from_vn_reference (&ref, refx->set, refx->type,
|
refx->operands))
|
refx->operands))
|
{
|
{
|
res = true;
|
res = true;
|
break;
|
break;
|
}
|
}
|
/* If the statement may clobber expr, it dies. */
|
/* If the statement may clobber expr, it dies. */
|
if (stmt_may_clobber_ref_p_1 (def, &ref))
|
if (stmt_may_clobber_ref_p_1 (def, &ref))
|
{
|
{
|
res = true;
|
res = true;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Remember the result. */
|
/* Remember the result. */
|
if (!EXPR_DIES (block))
|
if (!EXPR_DIES (block))
|
EXPR_DIES (block) = BITMAP_ALLOC (&grand_bitmap_obstack);
|
EXPR_DIES (block) = BITMAP_ALLOC (&grand_bitmap_obstack);
|
bitmap_set_bit (EXPR_DIES (block), id * 2);
|
bitmap_set_bit (EXPR_DIES (block), id * 2);
|
if (res)
|
if (res)
|
bitmap_set_bit (EXPR_DIES (block), id * 2 + 1);
|
bitmap_set_bit (EXPR_DIES (block), id * 2 + 1);
|
|
|
return res;
|
return res;
|
}
|
}
|
|
|
|
|
#define union_contains_value(SET1, SET2, VAL) \
|
#define union_contains_value(SET1, SET2, VAL) \
|
(bitmap_set_contains_value ((SET1), (VAL)) \
|
(bitmap_set_contains_value ((SET1), (VAL)) \
|
|| ((SET2) && bitmap_set_contains_value ((SET2), (VAL))))
|
|| ((SET2) && bitmap_set_contains_value ((SET2), (VAL))))
|
|
|
/* Determine if vn_reference_op_t VRO is legal in SET1 U SET2.
|
/* Determine if vn_reference_op_t VRO is legal in SET1 U SET2.
|
*/
|
*/
|
static bool
|
static bool
|
vro_valid_in_sets (bitmap_set_t set1, bitmap_set_t set2,
|
vro_valid_in_sets (bitmap_set_t set1, bitmap_set_t set2,
|
vn_reference_op_t vro)
|
vn_reference_op_t vro)
|
{
|
{
|
if (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME)
|
if (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME)
|
{
|
{
|
struct pre_expr_d temp;
|
struct pre_expr_d temp;
|
temp.kind = NAME;
|
temp.kind = NAME;
|
temp.id = 0;
|
temp.id = 0;
|
PRE_EXPR_NAME (&temp) = vro->op0;
|
PRE_EXPR_NAME (&temp) = vro->op0;
|
temp.id = lookup_expression_id (&temp);
|
temp.id = lookup_expression_id (&temp);
|
if (temp.id == 0)
|
if (temp.id == 0)
|
return false;
|
return false;
|
if (!union_contains_value (set1, set2,
|
if (!union_contains_value (set1, set2,
|
get_expr_value_id (&temp)))
|
get_expr_value_id (&temp)))
|
return false;
|
return false;
|
}
|
}
|
if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
|
if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
|
{
|
{
|
struct pre_expr_d temp;
|
struct pre_expr_d temp;
|
temp.kind = NAME;
|
temp.kind = NAME;
|
temp.id = 0;
|
temp.id = 0;
|
PRE_EXPR_NAME (&temp) = vro->op1;
|
PRE_EXPR_NAME (&temp) = vro->op1;
|
temp.id = lookup_expression_id (&temp);
|
temp.id = lookup_expression_id (&temp);
|
if (temp.id == 0)
|
if (temp.id == 0)
|
return false;
|
return false;
|
if (!union_contains_value (set1, set2,
|
if (!union_contains_value (set1, set2,
|
get_expr_value_id (&temp)))
|
get_expr_value_id (&temp)))
|
return false;
|
return false;
|
}
|
}
|
|
|
if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
|
if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
|
{
|
{
|
struct pre_expr_d temp;
|
struct pre_expr_d temp;
|
temp.kind = NAME;
|
temp.kind = NAME;
|
temp.id = 0;
|
temp.id = 0;
|
PRE_EXPR_NAME (&temp) = vro->op2;
|
PRE_EXPR_NAME (&temp) = vro->op2;
|
temp.id = lookup_expression_id (&temp);
|
temp.id = lookup_expression_id (&temp);
|
if (temp.id == 0)
|
if (temp.id == 0)
|
return false;
|
return false;
|
if (!union_contains_value (set1, set2,
|
if (!union_contains_value (set1, set2,
|
get_expr_value_id (&temp)))
|
get_expr_value_id (&temp)))
|
return false;
|
return false;
|
}
|
}
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Determine if the expression EXPR is valid in SET1 U SET2.
|
/* Determine if the expression EXPR is valid in SET1 U SET2.
|
ONLY SET2 CAN BE NULL.
|
ONLY SET2 CAN BE NULL.
|
This means that we have a leader for each part of the expression
|
This means that we have a leader for each part of the expression
|
(if it consists of values), or the expression is an SSA_NAME.
|
(if it consists of values), or the expression is an SSA_NAME.
|
For loads/calls, we also see if the vuse is killed in this block. */
|
For loads/calls, we also see if the vuse is killed in this block. */
|
|
|
static bool
|
static bool
|
valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, pre_expr expr,
|
valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, pre_expr expr,
|
basic_block block)
|
basic_block block)
|
{
|
{
|
switch (expr->kind)
|
switch (expr->kind)
|
{
|
{
|
case NAME:
|
case NAME:
|
return bitmap_set_contains_expr (AVAIL_OUT (block), expr);
|
return bitmap_set_contains_expr (AVAIL_OUT (block), expr);
|
case NARY:
|
case NARY:
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
vn_nary_op_t nary = PRE_EXPR_NARY (expr);
|
vn_nary_op_t nary = PRE_EXPR_NARY (expr);
|
for (i = 0; i < nary->length; i++)
|
for (i = 0; i < nary->length; i++)
|
{
|
{
|
if (TREE_CODE (nary->op[i]) == SSA_NAME)
|
if (TREE_CODE (nary->op[i]) == SSA_NAME)
|
{
|
{
|
struct pre_expr_d temp;
|
struct pre_expr_d temp;
|
temp.kind = NAME;
|
temp.kind = NAME;
|
temp.id = 0;
|
temp.id = 0;
|
PRE_EXPR_NAME (&temp) = nary->op[i];
|
PRE_EXPR_NAME (&temp) = nary->op[i];
|
temp.id = lookup_expression_id (&temp);
|
temp.id = lookup_expression_id (&temp);
|
if (temp.id == 0)
|
if (temp.id == 0)
|
return false;
|
return false;
|
if (!union_contains_value (set1, set2,
|
if (!union_contains_value (set1, set2,
|
get_expr_value_id (&temp)))
|
get_expr_value_id (&temp)))
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
/* If the NARY may trap make sure the block does not contain
|
/* If the NARY may trap make sure the block does not contain
|
a possible exit point.
|
a possible exit point.
|
??? This is overly conservative if we translate AVAIL_OUT
|
??? This is overly conservative if we translate AVAIL_OUT
|
as the available expression might be after the exit point. */
|
as the available expression might be after the exit point. */
|
if (BB_MAY_NOTRETURN (block)
|
if (BB_MAY_NOTRETURN (block)
|
&& vn_nary_may_trap (nary))
|
&& vn_nary_may_trap (nary))
|
return false;
|
return false;
|
return true;
|
return true;
|
}
|
}
|
break;
|
break;
|
case REFERENCE:
|
case REFERENCE:
|
{
|
{
|
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
|
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
|
vn_reference_op_t vro;
|
vn_reference_op_t vro;
|
unsigned int i;
|
unsigned int i;
|
|
|
FOR_EACH_VEC_ELT (vn_reference_op_s, ref->operands, i, vro)
|
FOR_EACH_VEC_ELT (vn_reference_op_s, ref->operands, i, vro)
|
{
|
{
|
if (!vro_valid_in_sets (set1, set2, vro))
|
if (!vro_valid_in_sets (set1, set2, vro))
|
return false;
|
return false;
|
}
|
}
|
if (ref->vuse)
|
if (ref->vuse)
|
{
|
{
|
gimple def_stmt = SSA_NAME_DEF_STMT (ref->vuse);
|
gimple def_stmt = SSA_NAME_DEF_STMT (ref->vuse);
|
if (!gimple_nop_p (def_stmt)
|
if (!gimple_nop_p (def_stmt)
|
&& gimple_bb (def_stmt) != block
|
&& gimple_bb (def_stmt) != block
|
&& !dominated_by_p (CDI_DOMINATORS,
|
&& !dominated_by_p (CDI_DOMINATORS,
|
block, gimple_bb (def_stmt)))
|
block, gimple_bb (def_stmt)))
|
return false;
|
return false;
|
}
|
}
|
return !value_dies_in_block_x (expr, block);
|
return !value_dies_in_block_x (expr, block);
|
}
|
}
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Clean the set of expressions that are no longer valid in SET1 or
|
/* Clean the set of expressions that are no longer valid in SET1 or
|
SET2. This means expressions that are made up of values we have no
|
SET2. This means expressions that are made up of values we have no
|
leaders for in SET1 or SET2. This version is used for partial
|
leaders for in SET1 or SET2. This version is used for partial
|
anticipation, which means it is not valid in either ANTIC_IN or
|
anticipation, which means it is not valid in either ANTIC_IN or
|
PA_IN. */
|
PA_IN. */
|
|
|
static void
|
static void
|
dependent_clean (bitmap_set_t set1, bitmap_set_t set2, basic_block block)
|
dependent_clean (bitmap_set_t set1, bitmap_set_t set2, basic_block block)
|
{
|
{
|
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set1);
|
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set1);
|
pre_expr expr;
|
pre_expr expr;
|
int i;
|
int i;
|
|
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
{
|
{
|
if (!valid_in_sets (set1, set2, expr, block))
|
if (!valid_in_sets (set1, set2, expr, block))
|
bitmap_remove_from_set (set1, expr);
|
bitmap_remove_from_set (set1, expr);
|
}
|
}
|
VEC_free (pre_expr, heap, exprs);
|
VEC_free (pre_expr, heap, exprs);
|
}
|
}
|
|
|
/* Clean the set of expressions that are no longer valid in SET. This
|
/* Clean the set of expressions that are no longer valid in SET. This
|
means expressions that are made up of values we have no leaders for
|
means expressions that are made up of values we have no leaders for
|
in SET. */
|
in SET. */
|
|
|
static void
|
static void
|
clean (bitmap_set_t set, basic_block block)
|
clean (bitmap_set_t set, basic_block block)
|
{
|
{
|
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set);
|
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set);
|
pre_expr expr;
|
pre_expr expr;
|
int i;
|
int i;
|
|
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
{
|
{
|
if (!valid_in_sets (set, NULL, expr, block))
|
if (!valid_in_sets (set, NULL, expr, block))
|
bitmap_remove_from_set (set, expr);
|
bitmap_remove_from_set (set, expr);
|
}
|
}
|
VEC_free (pre_expr, heap, exprs);
|
VEC_free (pre_expr, heap, exprs);
|
}
|
}
|
|
|
static sbitmap has_abnormal_preds;
|
static sbitmap has_abnormal_preds;
|
|
|
/* List of blocks that may have changed during ANTIC computation and
|
/* List of blocks that may have changed during ANTIC computation and
|
thus need to be iterated over. */
|
thus need to be iterated over. */
|
|
|
static sbitmap changed_blocks;
|
static sbitmap changed_blocks;
|
|
|
/* Decide whether to defer a block for a later iteration, or PHI
|
/* Decide whether to defer a block for a later iteration, or PHI
|
translate SOURCE to DEST using phis in PHIBLOCK. Return false if we
|
translate SOURCE to DEST using phis in PHIBLOCK. Return false if we
|
should defer the block, and true if we processed it. */
|
should defer the block, and true if we processed it. */
|
|
|
static bool
|
static bool
|
defer_or_phi_translate_block (bitmap_set_t dest, bitmap_set_t source,
|
defer_or_phi_translate_block (bitmap_set_t dest, bitmap_set_t source,
|
basic_block block, basic_block phiblock)
|
basic_block block, basic_block phiblock)
|
{
|
{
|
if (!BB_VISITED (phiblock))
|
if (!BB_VISITED (phiblock))
|
{
|
{
|
SET_BIT (changed_blocks, block->index);
|
SET_BIT (changed_blocks, block->index);
|
BB_VISITED (block) = 0;
|
BB_VISITED (block) = 0;
|
BB_DEFERRED (block) = 1;
|
BB_DEFERRED (block) = 1;
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
phi_translate_set (dest, source, block, phiblock);
|
phi_translate_set (dest, source, block, phiblock);
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Compute the ANTIC set for BLOCK.
|
/* Compute the ANTIC set for BLOCK.
|
|
|
If succs(BLOCK) > 1 then
|
If succs(BLOCK) > 1 then
|
ANTIC_OUT[BLOCK] = intersection of ANTIC_IN[b] for all succ(BLOCK)
|
ANTIC_OUT[BLOCK] = intersection of ANTIC_IN[b] for all succ(BLOCK)
|
else if succs(BLOCK) == 1 then
|
else if succs(BLOCK) == 1 then
|
ANTIC_OUT[BLOCK] = phi_translate (ANTIC_IN[succ(BLOCK)])
|
ANTIC_OUT[BLOCK] = phi_translate (ANTIC_IN[succ(BLOCK)])
|
|
|
ANTIC_IN[BLOCK] = clean(ANTIC_OUT[BLOCK] U EXP_GEN[BLOCK] - TMP_GEN[BLOCK])
|
ANTIC_IN[BLOCK] = clean(ANTIC_OUT[BLOCK] U EXP_GEN[BLOCK] - TMP_GEN[BLOCK])
|
*/
|
*/
|
|
|
static bool
|
static bool
|
compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
|
compute_antic_aux (basic_block block, bool block_has_abnormal_pred_edge)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
bitmap_set_t S, old, ANTIC_OUT;
|
bitmap_set_t S, old, ANTIC_OUT;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned int bii;
|
unsigned int bii;
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
old = ANTIC_OUT = S = NULL;
|
old = ANTIC_OUT = S = NULL;
|
BB_VISITED (block) = 1;
|
BB_VISITED (block) = 1;
|
|
|
/* If any edges from predecessors are abnormal, antic_in is empty,
|
/* If any edges from predecessors are abnormal, antic_in is empty,
|
so do nothing. */
|
so do nothing. */
|
if (block_has_abnormal_pred_edge)
|
if (block_has_abnormal_pred_edge)
|
goto maybe_dump_sets;
|
goto maybe_dump_sets;
|
|
|
old = ANTIC_IN (block);
|
old = ANTIC_IN (block);
|
ANTIC_OUT = bitmap_set_new ();
|
ANTIC_OUT = bitmap_set_new ();
|
|
|
/* If the block has no successors, ANTIC_OUT is empty. */
|
/* If the block has no successors, ANTIC_OUT is empty. */
|
if (EDGE_COUNT (block->succs) == 0)
|
if (EDGE_COUNT (block->succs) == 0)
|
;
|
;
|
/* If we have one successor, we could have some phi nodes to
|
/* If we have one successor, we could have some phi nodes to
|
translate through. */
|
translate through. */
|
else if (single_succ_p (block))
|
else if (single_succ_p (block))
|
{
|
{
|
basic_block succ_bb = single_succ (block);
|
basic_block succ_bb = single_succ (block);
|
|
|
/* We trade iterations of the dataflow equations for having to
|
/* We trade iterations of the dataflow equations for having to
|
phi translate the maximal set, which is incredibly slow
|
phi translate the maximal set, which is incredibly slow
|
(since the maximal set often has 300+ members, even when you
|
(since the maximal set often has 300+ members, even when you
|
have a small number of blocks).
|
have a small number of blocks).
|
Basically, we defer the computation of ANTIC for this block
|
Basically, we defer the computation of ANTIC for this block
|
until we have processed it's successor, which will inevitably
|
until we have processed it's successor, which will inevitably
|
have a *much* smaller set of values to phi translate once
|
have a *much* smaller set of values to phi translate once
|
clean has been run on it.
|
clean has been run on it.
|
The cost of doing this is that we technically perform more
|
The cost of doing this is that we technically perform more
|
iterations, however, they are lower cost iterations.
|
iterations, however, they are lower cost iterations.
|
|
|
Timings for PRE on tramp3d-v4:
|
Timings for PRE on tramp3d-v4:
|
without maximal set fix: 11 seconds
|
without maximal set fix: 11 seconds
|
with maximal set fix/without deferring: 26 seconds
|
with maximal set fix/without deferring: 26 seconds
|
with maximal set fix/with deferring: 11 seconds
|
with maximal set fix/with deferring: 11 seconds
|
*/
|
*/
|
|
|
if (!defer_or_phi_translate_block (ANTIC_OUT, ANTIC_IN (succ_bb),
|
if (!defer_or_phi_translate_block (ANTIC_OUT, ANTIC_IN (succ_bb),
|
block, succ_bb))
|
block, succ_bb))
|
{
|
{
|
changed = true;
|
changed = true;
|
goto maybe_dump_sets;
|
goto maybe_dump_sets;
|
}
|
}
|
}
|
}
|
/* If we have multiple successors, we take the intersection of all of
|
/* If we have multiple successors, we take the intersection of all of
|
them. Note that in the case of loop exit phi nodes, we may have
|
them. Note that in the case of loop exit phi nodes, we may have
|
phis to translate through. */
|
phis to translate through. */
|
else
|
else
|
{
|
{
|
VEC(basic_block, heap) * worklist;
|
VEC(basic_block, heap) * worklist;
|
size_t i;
|
size_t i;
|
basic_block bprime, first = NULL;
|
basic_block bprime, first = NULL;
|
|
|
worklist = VEC_alloc (basic_block, heap, EDGE_COUNT (block->succs));
|
worklist = VEC_alloc (basic_block, heap, EDGE_COUNT (block->succs));
|
FOR_EACH_EDGE (e, ei, block->succs)
|
FOR_EACH_EDGE (e, ei, block->succs)
|
{
|
{
|
if (!first
|
if (!first
|
&& BB_VISITED (e->dest))
|
&& BB_VISITED (e->dest))
|
first = e->dest;
|
first = e->dest;
|
else if (BB_VISITED (e->dest))
|
else if (BB_VISITED (e->dest))
|
VEC_quick_push (basic_block, worklist, e->dest);
|
VEC_quick_push (basic_block, worklist, e->dest);
|
}
|
}
|
|
|
/* Of multiple successors we have to have visited one already. */
|
/* Of multiple successors we have to have visited one already. */
|
if (!first)
|
if (!first)
|
{
|
{
|
SET_BIT (changed_blocks, block->index);
|
SET_BIT (changed_blocks, block->index);
|
BB_VISITED (block) = 0;
|
BB_VISITED (block) = 0;
|
BB_DEFERRED (block) = 1;
|
BB_DEFERRED (block) = 1;
|
changed = true;
|
changed = true;
|
VEC_free (basic_block, heap, worklist);
|
VEC_free (basic_block, heap, worklist);
|
goto maybe_dump_sets;
|
goto maybe_dump_sets;
|
}
|
}
|
|
|
if (!gimple_seq_empty_p (phi_nodes (first)))
|
if (!gimple_seq_empty_p (phi_nodes (first)))
|
phi_translate_set (ANTIC_OUT, ANTIC_IN (first), block, first);
|
phi_translate_set (ANTIC_OUT, ANTIC_IN (first), block, first);
|
else
|
else
|
bitmap_set_copy (ANTIC_OUT, ANTIC_IN (first));
|
bitmap_set_copy (ANTIC_OUT, ANTIC_IN (first));
|
|
|
FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
|
FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
|
{
|
{
|
if (!gimple_seq_empty_p (phi_nodes (bprime)))
|
if (!gimple_seq_empty_p (phi_nodes (bprime)))
|
{
|
{
|
bitmap_set_t tmp = bitmap_set_new ();
|
bitmap_set_t tmp = bitmap_set_new ();
|
phi_translate_set (tmp, ANTIC_IN (bprime), block, bprime);
|
phi_translate_set (tmp, ANTIC_IN (bprime), block, bprime);
|
bitmap_set_and (ANTIC_OUT, tmp);
|
bitmap_set_and (ANTIC_OUT, tmp);
|
bitmap_set_free (tmp);
|
bitmap_set_free (tmp);
|
}
|
}
|
else
|
else
|
bitmap_set_and (ANTIC_OUT, ANTIC_IN (bprime));
|
bitmap_set_and (ANTIC_OUT, ANTIC_IN (bprime));
|
}
|
}
|
VEC_free (basic_block, heap, worklist);
|
VEC_free (basic_block, heap, worklist);
|
}
|
}
|
|
|
/* Generate ANTIC_OUT - TMP_GEN. */
|
/* Generate ANTIC_OUT - TMP_GEN. */
|
S = bitmap_set_subtract (ANTIC_OUT, TMP_GEN (block));
|
S = bitmap_set_subtract (ANTIC_OUT, TMP_GEN (block));
|
|
|
/* Start ANTIC_IN with EXP_GEN - TMP_GEN. */
|
/* Start ANTIC_IN with EXP_GEN - TMP_GEN. */
|
ANTIC_IN (block) = bitmap_set_subtract (EXP_GEN (block),
|
ANTIC_IN (block) = bitmap_set_subtract (EXP_GEN (block),
|
TMP_GEN (block));
|
TMP_GEN (block));
|
|
|
/* Then union in the ANTIC_OUT - TMP_GEN values,
|
/* Then union in the ANTIC_OUT - TMP_GEN values,
|
to get ANTIC_OUT U EXP_GEN - TMP_GEN */
|
to get ANTIC_OUT U EXP_GEN - TMP_GEN */
|
FOR_EACH_EXPR_ID_IN_SET (S, bii, bi)
|
FOR_EACH_EXPR_ID_IN_SET (S, bii, bi)
|
bitmap_value_insert_into_set (ANTIC_IN (block),
|
bitmap_value_insert_into_set (ANTIC_IN (block),
|
expression_for_id (bii));
|
expression_for_id (bii));
|
|
|
clean (ANTIC_IN (block), block);
|
clean (ANTIC_IN (block), block);
|
|
|
if (!bitmap_set_equal (old, ANTIC_IN (block)))
|
if (!bitmap_set_equal (old, ANTIC_IN (block)))
|
{
|
{
|
changed = true;
|
changed = true;
|
SET_BIT (changed_blocks, block->index);
|
SET_BIT (changed_blocks, block->index);
|
FOR_EACH_EDGE (e, ei, block->preds)
|
FOR_EACH_EDGE (e, ei, block->preds)
|
SET_BIT (changed_blocks, e->src->index);
|
SET_BIT (changed_blocks, e->src->index);
|
}
|
}
|
else
|
else
|
RESET_BIT (changed_blocks, block->index);
|
RESET_BIT (changed_blocks, block->index);
|
|
|
maybe_dump_sets:
|
maybe_dump_sets:
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
if (!BB_DEFERRED (block) || BB_VISITED (block))
|
if (!BB_DEFERRED (block) || BB_VISITED (block))
|
{
|
{
|
if (ANTIC_OUT)
|
if (ANTIC_OUT)
|
print_bitmap_set (dump_file, ANTIC_OUT, "ANTIC_OUT", block->index);
|
print_bitmap_set (dump_file, ANTIC_OUT, "ANTIC_OUT", block->index);
|
|
|
print_bitmap_set (dump_file, ANTIC_IN (block), "ANTIC_IN",
|
print_bitmap_set (dump_file, ANTIC_IN (block), "ANTIC_IN",
|
block->index);
|
block->index);
|
|
|
if (S)
|
if (S)
|
print_bitmap_set (dump_file, S, "S", block->index);
|
print_bitmap_set (dump_file, S, "S", block->index);
|
}
|
}
|
else
|
else
|
{
|
{
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"Block %d was deferred for a future iteration.\n",
|
"Block %d was deferred for a future iteration.\n",
|
block->index);
|
block->index);
|
}
|
}
|
}
|
}
|
if (old)
|
if (old)
|
bitmap_set_free (old);
|
bitmap_set_free (old);
|
if (S)
|
if (S)
|
bitmap_set_free (S);
|
bitmap_set_free (S);
|
if (ANTIC_OUT)
|
if (ANTIC_OUT)
|
bitmap_set_free (ANTIC_OUT);
|
bitmap_set_free (ANTIC_OUT);
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Compute PARTIAL_ANTIC for BLOCK.
|
/* Compute PARTIAL_ANTIC for BLOCK.
|
|
|
If succs(BLOCK) > 1 then
|
If succs(BLOCK) > 1 then
|
PA_OUT[BLOCK] = value wise union of PA_IN[b] + all ANTIC_IN not
|
PA_OUT[BLOCK] = value wise union of PA_IN[b] + all ANTIC_IN not
|
in ANTIC_OUT for all succ(BLOCK)
|
in ANTIC_OUT for all succ(BLOCK)
|
else if succs(BLOCK) == 1 then
|
else if succs(BLOCK) == 1 then
|
PA_OUT[BLOCK] = phi_translate (PA_IN[succ(BLOCK)])
|
PA_OUT[BLOCK] = phi_translate (PA_IN[succ(BLOCK)])
|
|
|
PA_IN[BLOCK] = dependent_clean(PA_OUT[BLOCK] - TMP_GEN[BLOCK]
|
PA_IN[BLOCK] = dependent_clean(PA_OUT[BLOCK] - TMP_GEN[BLOCK]
|
- ANTIC_IN[BLOCK])
|
- ANTIC_IN[BLOCK])
|
|
|
*/
|
*/
|
static bool
|
static bool
|
compute_partial_antic_aux (basic_block block,
|
compute_partial_antic_aux (basic_block block,
|
bool block_has_abnormal_pred_edge)
|
bool block_has_abnormal_pred_edge)
|
{
|
{
|
bool changed = false;
|
bool changed = false;
|
bitmap_set_t old_PA_IN;
|
bitmap_set_t old_PA_IN;
|
bitmap_set_t PA_OUT;
|
bitmap_set_t PA_OUT;
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
unsigned long max_pa = PARAM_VALUE (PARAM_MAX_PARTIAL_ANTIC_LENGTH);
|
unsigned long max_pa = PARAM_VALUE (PARAM_MAX_PARTIAL_ANTIC_LENGTH);
|
|
|
old_PA_IN = PA_OUT = NULL;
|
old_PA_IN = PA_OUT = NULL;
|
|
|
/* If any edges from predecessors are abnormal, antic_in is empty,
|
/* If any edges from predecessors are abnormal, antic_in is empty,
|
so do nothing. */
|
so do nothing. */
|
if (block_has_abnormal_pred_edge)
|
if (block_has_abnormal_pred_edge)
|
goto maybe_dump_sets;
|
goto maybe_dump_sets;
|
|
|
/* If there are too many partially anticipatable values in the
|
/* If there are too many partially anticipatable values in the
|
block, phi_translate_set can take an exponential time: stop
|
block, phi_translate_set can take an exponential time: stop
|
before the translation starts. */
|
before the translation starts. */
|
if (max_pa
|
if (max_pa
|
&& single_succ_p (block)
|
&& single_succ_p (block)
|
&& bitmap_count_bits (&PA_IN (single_succ (block))->values) > max_pa)
|
&& bitmap_count_bits (&PA_IN (single_succ (block))->values) > max_pa)
|
goto maybe_dump_sets;
|
goto maybe_dump_sets;
|
|
|
old_PA_IN = PA_IN (block);
|
old_PA_IN = PA_IN (block);
|
PA_OUT = bitmap_set_new ();
|
PA_OUT = bitmap_set_new ();
|
|
|
/* If the block has no successors, ANTIC_OUT is empty. */
|
/* If the block has no successors, ANTIC_OUT is empty. */
|
if (EDGE_COUNT (block->succs) == 0)
|
if (EDGE_COUNT (block->succs) == 0)
|
;
|
;
|
/* If we have one successor, we could have some phi nodes to
|
/* If we have one successor, we could have some phi nodes to
|
translate through. Note that we can't phi translate across DFS
|
translate through. Note that we can't phi translate across DFS
|
back edges in partial antic, because it uses a union operation on
|
back edges in partial antic, because it uses a union operation on
|
the successors. For recurrences like IV's, we will end up
|
the successors. For recurrences like IV's, we will end up
|
generating a new value in the set on each go around (i + 3 (VH.1)
|
generating a new value in the set on each go around (i + 3 (VH.1)
|
VH.1 + 1 (VH.2), VH.2 + 1 (VH.3), etc), forever. */
|
VH.1 + 1 (VH.2), VH.2 + 1 (VH.3), etc), forever. */
|
else if (single_succ_p (block))
|
else if (single_succ_p (block))
|
{
|
{
|
basic_block succ = single_succ (block);
|
basic_block succ = single_succ (block);
|
if (!(single_succ_edge (block)->flags & EDGE_DFS_BACK))
|
if (!(single_succ_edge (block)->flags & EDGE_DFS_BACK))
|
phi_translate_set (PA_OUT, PA_IN (succ), block, succ);
|
phi_translate_set (PA_OUT, PA_IN (succ), block, succ);
|
}
|
}
|
/* If we have multiple successors, we take the union of all of
|
/* If we have multiple successors, we take the union of all of
|
them. */
|
them. */
|
else
|
else
|
{
|
{
|
VEC(basic_block, heap) * worklist;
|
VEC(basic_block, heap) * worklist;
|
size_t i;
|
size_t i;
|
basic_block bprime;
|
basic_block bprime;
|
|
|
worklist = VEC_alloc (basic_block, heap, EDGE_COUNT (block->succs));
|
worklist = VEC_alloc (basic_block, heap, EDGE_COUNT (block->succs));
|
FOR_EACH_EDGE (e, ei, block->succs)
|
FOR_EACH_EDGE (e, ei, block->succs)
|
{
|
{
|
if (e->flags & EDGE_DFS_BACK)
|
if (e->flags & EDGE_DFS_BACK)
|
continue;
|
continue;
|
VEC_quick_push (basic_block, worklist, e->dest);
|
VEC_quick_push (basic_block, worklist, e->dest);
|
}
|
}
|
if (VEC_length (basic_block, worklist) > 0)
|
if (VEC_length (basic_block, worklist) > 0)
|
{
|
{
|
FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
|
FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
|
{
|
{
|
unsigned int i;
|
unsigned int i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
|
|
FOR_EACH_EXPR_ID_IN_SET (ANTIC_IN (bprime), i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (ANTIC_IN (bprime), i, bi)
|
bitmap_value_insert_into_set (PA_OUT,
|
bitmap_value_insert_into_set (PA_OUT,
|
expression_for_id (i));
|
expression_for_id (i));
|
if (!gimple_seq_empty_p (phi_nodes (bprime)))
|
if (!gimple_seq_empty_p (phi_nodes (bprime)))
|
{
|
{
|
bitmap_set_t pa_in = bitmap_set_new ();
|
bitmap_set_t pa_in = bitmap_set_new ();
|
phi_translate_set (pa_in, PA_IN (bprime), block, bprime);
|
phi_translate_set (pa_in, PA_IN (bprime), block, bprime);
|
FOR_EACH_EXPR_ID_IN_SET (pa_in, i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (pa_in, i, bi)
|
bitmap_value_insert_into_set (PA_OUT,
|
bitmap_value_insert_into_set (PA_OUT,
|
expression_for_id (i));
|
expression_for_id (i));
|
bitmap_set_free (pa_in);
|
bitmap_set_free (pa_in);
|
}
|
}
|
else
|
else
|
FOR_EACH_EXPR_ID_IN_SET (PA_IN (bprime), i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (PA_IN (bprime), i, bi)
|
bitmap_value_insert_into_set (PA_OUT,
|
bitmap_value_insert_into_set (PA_OUT,
|
expression_for_id (i));
|
expression_for_id (i));
|
}
|
}
|
}
|
}
|
VEC_free (basic_block, heap, worklist);
|
VEC_free (basic_block, heap, worklist);
|
}
|
}
|
|
|
/* PA_IN starts with PA_OUT - TMP_GEN.
|
/* PA_IN starts with PA_OUT - TMP_GEN.
|
Then we subtract things from ANTIC_IN. */
|
Then we subtract things from ANTIC_IN. */
|
PA_IN (block) = bitmap_set_subtract (PA_OUT, TMP_GEN (block));
|
PA_IN (block) = bitmap_set_subtract (PA_OUT, TMP_GEN (block));
|
|
|
/* For partial antic, we want to put back in the phi results, since
|
/* For partial antic, we want to put back in the phi results, since
|
we will properly avoid making them partially antic over backedges. */
|
we will properly avoid making them partially antic over backedges. */
|
bitmap_ior_into (&PA_IN (block)->values, &PHI_GEN (block)->values);
|
bitmap_ior_into (&PA_IN (block)->values, &PHI_GEN (block)->values);
|
bitmap_ior_into (&PA_IN (block)->expressions, &PHI_GEN (block)->expressions);
|
bitmap_ior_into (&PA_IN (block)->expressions, &PHI_GEN (block)->expressions);
|
|
|
/* PA_IN[block] = PA_IN[block] - ANTIC_IN[block] */
|
/* PA_IN[block] = PA_IN[block] - ANTIC_IN[block] */
|
bitmap_set_subtract_values (PA_IN (block), ANTIC_IN (block));
|
bitmap_set_subtract_values (PA_IN (block), ANTIC_IN (block));
|
|
|
dependent_clean (PA_IN (block), ANTIC_IN (block), block);
|
dependent_clean (PA_IN (block), ANTIC_IN (block), block);
|
|
|
if (!bitmap_set_equal (old_PA_IN, PA_IN (block)))
|
if (!bitmap_set_equal (old_PA_IN, PA_IN (block)))
|
{
|
{
|
changed = true;
|
changed = true;
|
SET_BIT (changed_blocks, block->index);
|
SET_BIT (changed_blocks, block->index);
|
FOR_EACH_EDGE (e, ei, block->preds)
|
FOR_EACH_EDGE (e, ei, block->preds)
|
SET_BIT (changed_blocks, e->src->index);
|
SET_BIT (changed_blocks, e->src->index);
|
}
|
}
|
else
|
else
|
RESET_BIT (changed_blocks, block->index);
|
RESET_BIT (changed_blocks, block->index);
|
|
|
maybe_dump_sets:
|
maybe_dump_sets:
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
if (PA_OUT)
|
if (PA_OUT)
|
print_bitmap_set (dump_file, PA_OUT, "PA_OUT", block->index);
|
print_bitmap_set (dump_file, PA_OUT, "PA_OUT", block->index);
|
|
|
print_bitmap_set (dump_file, PA_IN (block), "PA_IN", block->index);
|
print_bitmap_set (dump_file, PA_IN (block), "PA_IN", block->index);
|
}
|
}
|
if (old_PA_IN)
|
if (old_PA_IN)
|
bitmap_set_free (old_PA_IN);
|
bitmap_set_free (old_PA_IN);
|
if (PA_OUT)
|
if (PA_OUT)
|
bitmap_set_free (PA_OUT);
|
bitmap_set_free (PA_OUT);
|
return changed;
|
return changed;
|
}
|
}
|
|
|
/* Compute ANTIC and partial ANTIC sets. */
|
/* Compute ANTIC and partial ANTIC sets. */
|
|
|
static void
|
static void
|
compute_antic (void)
|
compute_antic (void)
|
{
|
{
|
bool changed = true;
|
bool changed = true;
|
int num_iterations = 0;
|
int num_iterations = 0;
|
basic_block block;
|
basic_block block;
|
int i;
|
int i;
|
|
|
/* If any predecessor edges are abnormal, we punt, so antic_in is empty.
|
/* If any predecessor edges are abnormal, we punt, so antic_in is empty.
|
We pre-build the map of blocks with incoming abnormal edges here. */
|
We pre-build the map of blocks with incoming abnormal edges here. */
|
has_abnormal_preds = sbitmap_alloc (last_basic_block);
|
has_abnormal_preds = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (has_abnormal_preds);
|
sbitmap_zero (has_abnormal_preds);
|
|
|
FOR_EACH_BB (block)
|
FOR_EACH_BB (block)
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
FOR_EACH_EDGE (e, ei, block->preds)
|
FOR_EACH_EDGE (e, ei, block->preds)
|
{
|
{
|
e->flags &= ~EDGE_DFS_BACK;
|
e->flags &= ~EDGE_DFS_BACK;
|
if (e->flags & EDGE_ABNORMAL)
|
if (e->flags & EDGE_ABNORMAL)
|
{
|
{
|
SET_BIT (has_abnormal_preds, block->index);
|
SET_BIT (has_abnormal_preds, block->index);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
BB_VISITED (block) = 0;
|
BB_VISITED (block) = 0;
|
BB_DEFERRED (block) = 0;
|
BB_DEFERRED (block) = 0;
|
|
|
/* While we are here, give empty ANTIC_IN sets to each block. */
|
/* While we are here, give empty ANTIC_IN sets to each block. */
|
ANTIC_IN (block) = bitmap_set_new ();
|
ANTIC_IN (block) = bitmap_set_new ();
|
PA_IN (block) = bitmap_set_new ();
|
PA_IN (block) = bitmap_set_new ();
|
}
|
}
|
|
|
/* At the exit block we anticipate nothing. */
|
/* At the exit block we anticipate nothing. */
|
ANTIC_IN (EXIT_BLOCK_PTR) = bitmap_set_new ();
|
ANTIC_IN (EXIT_BLOCK_PTR) = bitmap_set_new ();
|
BB_VISITED (EXIT_BLOCK_PTR) = 1;
|
BB_VISITED (EXIT_BLOCK_PTR) = 1;
|
PA_IN (EXIT_BLOCK_PTR) = bitmap_set_new ();
|
PA_IN (EXIT_BLOCK_PTR) = bitmap_set_new ();
|
|
|
changed_blocks = sbitmap_alloc (last_basic_block + 1);
|
changed_blocks = sbitmap_alloc (last_basic_block + 1);
|
sbitmap_ones (changed_blocks);
|
sbitmap_ones (changed_blocks);
|
while (changed)
|
while (changed)
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "Starting iteration %d\n", num_iterations);
|
fprintf (dump_file, "Starting iteration %d\n", num_iterations);
|
/* ??? We need to clear our PHI translation cache here as the
|
/* ??? We need to clear our PHI translation cache here as the
|
ANTIC sets shrink and we restrict valid translations to
|
ANTIC sets shrink and we restrict valid translations to
|
those having operands with leaders in ANTIC. Same below
|
those having operands with leaders in ANTIC. Same below
|
for PA ANTIC computation. */
|
for PA ANTIC computation. */
|
num_iterations++;
|
num_iterations++;
|
changed = false;
|
changed = false;
|
for (i = n_basic_blocks - NUM_FIXED_BLOCKS - 1; i >= 0; i--)
|
for (i = n_basic_blocks - NUM_FIXED_BLOCKS - 1; i >= 0; i--)
|
{
|
{
|
if (TEST_BIT (changed_blocks, postorder[i]))
|
if (TEST_BIT (changed_blocks, postorder[i]))
|
{
|
{
|
basic_block block = BASIC_BLOCK (postorder[i]);
|
basic_block block = BASIC_BLOCK (postorder[i]);
|
changed |= compute_antic_aux (block,
|
changed |= compute_antic_aux (block,
|
TEST_BIT (has_abnormal_preds,
|
TEST_BIT (has_abnormal_preds,
|
block->index));
|
block->index));
|
}
|
}
|
}
|
}
|
/* Theoretically possible, but *highly* unlikely. */
|
/* Theoretically possible, but *highly* unlikely. */
|
gcc_checking_assert (num_iterations < 500);
|
gcc_checking_assert (num_iterations < 500);
|
}
|
}
|
|
|
statistics_histogram_event (cfun, "compute_antic iterations",
|
statistics_histogram_event (cfun, "compute_antic iterations",
|
num_iterations);
|
num_iterations);
|
|
|
if (do_partial_partial)
|
if (do_partial_partial)
|
{
|
{
|
sbitmap_ones (changed_blocks);
|
sbitmap_ones (changed_blocks);
|
mark_dfs_back_edges ();
|
mark_dfs_back_edges ();
|
num_iterations = 0;
|
num_iterations = 0;
|
changed = true;
|
changed = true;
|
while (changed)
|
while (changed)
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "Starting iteration %d\n", num_iterations);
|
fprintf (dump_file, "Starting iteration %d\n", num_iterations);
|
num_iterations++;
|
num_iterations++;
|
changed = false;
|
changed = false;
|
for (i = n_basic_blocks - NUM_FIXED_BLOCKS - 1 ; i >= 0; i--)
|
for (i = n_basic_blocks - NUM_FIXED_BLOCKS - 1 ; i >= 0; i--)
|
{
|
{
|
if (TEST_BIT (changed_blocks, postorder[i]))
|
if (TEST_BIT (changed_blocks, postorder[i]))
|
{
|
{
|
basic_block block = BASIC_BLOCK (postorder[i]);
|
basic_block block = BASIC_BLOCK (postorder[i]);
|
changed
|
changed
|
|= compute_partial_antic_aux (block,
|
|= compute_partial_antic_aux (block,
|
TEST_BIT (has_abnormal_preds,
|
TEST_BIT (has_abnormal_preds,
|
block->index));
|
block->index));
|
}
|
}
|
}
|
}
|
/* Theoretically possible, but *highly* unlikely. */
|
/* Theoretically possible, but *highly* unlikely. */
|
gcc_checking_assert (num_iterations < 500);
|
gcc_checking_assert (num_iterations < 500);
|
}
|
}
|
statistics_histogram_event (cfun, "compute_partial_antic iterations",
|
statistics_histogram_event (cfun, "compute_partial_antic iterations",
|
num_iterations);
|
num_iterations);
|
}
|
}
|
sbitmap_free (has_abnormal_preds);
|
sbitmap_free (has_abnormal_preds);
|
sbitmap_free (changed_blocks);
|
sbitmap_free (changed_blocks);
|
}
|
}
|
|
|
/* Return true if we can value number the call in STMT. This is true
|
/* Return true if we can value number the call in STMT. This is true
|
if we have a pure or constant call to a real function. */
|
if we have a pure or constant call to a real function. */
|
|
|
static bool
|
static bool
|
can_value_number_call (gimple stmt)
|
can_value_number_call (gimple stmt)
|
{
|
{
|
if (gimple_call_internal_p (stmt))
|
if (gimple_call_internal_p (stmt))
|
return false;
|
return false;
|
if (gimple_call_flags (stmt) & (ECF_PURE | ECF_CONST))
|
if (gimple_call_flags (stmt) & (ECF_PURE | ECF_CONST))
|
return true;
|
return true;
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return true if OP is a tree which we can perform PRE on.
|
/* Return true if OP is a tree which we can perform PRE on.
|
This may not match the operations we can value number, but in
|
This may not match the operations we can value number, but in
|
a perfect world would. */
|
a perfect world would. */
|
|
|
static bool
|
static bool
|
can_PRE_operation (tree op)
|
can_PRE_operation (tree op)
|
{
|
{
|
return UNARY_CLASS_P (op)
|
return UNARY_CLASS_P (op)
|
|| BINARY_CLASS_P (op)
|
|| BINARY_CLASS_P (op)
|
|| COMPARISON_CLASS_P (op)
|
|| COMPARISON_CLASS_P (op)
|
|| TREE_CODE (op) == MEM_REF
|
|| TREE_CODE (op) == MEM_REF
|
|| TREE_CODE (op) == COMPONENT_REF
|
|| TREE_CODE (op) == COMPONENT_REF
|
|| TREE_CODE (op) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (op) == VIEW_CONVERT_EXPR
|
|| TREE_CODE (op) == CALL_EXPR
|
|| TREE_CODE (op) == CALL_EXPR
|
|| TREE_CODE (op) == ARRAY_REF;
|
|| TREE_CODE (op) == ARRAY_REF;
|
}
|
}
|
|
|
|
|
/* Inserted expressions are placed onto this worklist, which is used
|
/* Inserted expressions are placed onto this worklist, which is used
|
for performing quick dead code elimination of insertions we made
|
for performing quick dead code elimination of insertions we made
|
that didn't turn out to be necessary. */
|
that didn't turn out to be necessary. */
|
static bitmap inserted_exprs;
|
static bitmap inserted_exprs;
|
|
|
/* Pool allocated fake store expressions are placed onto this
|
/* Pool allocated fake store expressions are placed onto this
|
worklist, which, after performing dead code elimination, is walked
|
worklist, which, after performing dead code elimination, is walked
|
to see which expressions need to be put into GC'able memory */
|
to see which expressions need to be put into GC'able memory */
|
static VEC(gimple, heap) *need_creation;
|
static VEC(gimple, heap) *need_creation;
|
|
|
/* The actual worker for create_component_ref_by_pieces. */
|
/* The actual worker for create_component_ref_by_pieces. */
|
|
|
static tree
|
static tree
|
create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref,
|
create_component_ref_by_pieces_1 (basic_block block, vn_reference_t ref,
|
unsigned int *operand, gimple_seq *stmts,
|
unsigned int *operand, gimple_seq *stmts,
|
gimple domstmt)
|
gimple domstmt)
|
{
|
{
|
vn_reference_op_t currop = VEC_index (vn_reference_op_s, ref->operands,
|
vn_reference_op_t currop = VEC_index (vn_reference_op_s, ref->operands,
|
*operand);
|
*operand);
|
tree genop;
|
tree genop;
|
++*operand;
|
++*operand;
|
switch (currop->opcode)
|
switch (currop->opcode)
|
{
|
{
|
case CALL_EXPR:
|
case CALL_EXPR:
|
{
|
{
|
tree folded, sc = NULL_TREE;
|
tree folded, sc = NULL_TREE;
|
unsigned int nargs = 0;
|
unsigned int nargs = 0;
|
tree fn, *args;
|
tree fn, *args;
|
if (TREE_CODE (currop->op0) == FUNCTION_DECL)
|
if (TREE_CODE (currop->op0) == FUNCTION_DECL)
|
fn = currop->op0;
|
fn = currop->op0;
|
else
|
else
|
{
|
{
|
pre_expr op0 = get_or_alloc_expr_for (currop->op0);
|
pre_expr op0 = get_or_alloc_expr_for (currop->op0);
|
fn = find_or_generate_expression (block, op0, stmts, domstmt);
|
fn = find_or_generate_expression (block, op0, stmts, domstmt);
|
if (!fn)
|
if (!fn)
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
if (currop->op1)
|
if (currop->op1)
|
{
|
{
|
pre_expr scexpr = get_or_alloc_expr_for (currop->op1);
|
pre_expr scexpr = get_or_alloc_expr_for (currop->op1);
|
sc = find_or_generate_expression (block, scexpr, stmts, domstmt);
|
sc = find_or_generate_expression (block, scexpr, stmts, domstmt);
|
if (!sc)
|
if (!sc)
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
args = XNEWVEC (tree, VEC_length (vn_reference_op_s,
|
args = XNEWVEC (tree, VEC_length (vn_reference_op_s,
|
ref->operands) - 1);
|
ref->operands) - 1);
|
while (*operand < VEC_length (vn_reference_op_s, ref->operands))
|
while (*operand < VEC_length (vn_reference_op_s, ref->operands))
|
{
|
{
|
args[nargs] = create_component_ref_by_pieces_1 (block, ref,
|
args[nargs] = create_component_ref_by_pieces_1 (block, ref,
|
operand, stmts,
|
operand, stmts,
|
domstmt);
|
domstmt);
|
if (!args[nargs])
|
if (!args[nargs])
|
{
|
{
|
free (args);
|
free (args);
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
nargs++;
|
nargs++;
|
}
|
}
|
folded = build_call_array (currop->type,
|
folded = build_call_array (currop->type,
|
(TREE_CODE (fn) == FUNCTION_DECL
|
(TREE_CODE (fn) == FUNCTION_DECL
|
? build_fold_addr_expr (fn) : fn),
|
? build_fold_addr_expr (fn) : fn),
|
nargs, args);
|
nargs, args);
|
free (args);
|
free (args);
|
if (sc)
|
if (sc)
|
CALL_EXPR_STATIC_CHAIN (folded) = sc;
|
CALL_EXPR_STATIC_CHAIN (folded) = sc;
|
return folded;
|
return folded;
|
}
|
}
|
break;
|
break;
|
case MEM_REF:
|
case MEM_REF:
|
{
|
{
|
tree baseop = create_component_ref_by_pieces_1 (block, ref, operand,
|
tree baseop = create_component_ref_by_pieces_1 (block, ref, operand,
|
stmts, domstmt);
|
stmts, domstmt);
|
tree offset = currop->op0;
|
tree offset = currop->op0;
|
if (!baseop)
|
if (!baseop)
|
return NULL_TREE;
|
return NULL_TREE;
|
if (TREE_CODE (baseop) == ADDR_EXPR
|
if (TREE_CODE (baseop) == ADDR_EXPR
|
&& handled_component_p (TREE_OPERAND (baseop, 0)))
|
&& handled_component_p (TREE_OPERAND (baseop, 0)))
|
{
|
{
|
HOST_WIDE_INT off;
|
HOST_WIDE_INT off;
|
tree base;
|
tree base;
|
base = get_addr_base_and_unit_offset (TREE_OPERAND (baseop, 0),
|
base = get_addr_base_and_unit_offset (TREE_OPERAND (baseop, 0),
|
&off);
|
&off);
|
gcc_assert (base);
|
gcc_assert (base);
|
offset = int_const_binop (PLUS_EXPR, offset,
|
offset = int_const_binop (PLUS_EXPR, offset,
|
build_int_cst (TREE_TYPE (offset),
|
build_int_cst (TREE_TYPE (offset),
|
off));
|
off));
|
baseop = build_fold_addr_expr (base);
|
baseop = build_fold_addr_expr (base);
|
}
|
}
|
return fold_build2 (MEM_REF, currop->type, baseop, offset);
|
return fold_build2 (MEM_REF, currop->type, baseop, offset);
|
}
|
}
|
break;
|
break;
|
case TARGET_MEM_REF:
|
case TARGET_MEM_REF:
|
{
|
{
|
pre_expr op0expr, op1expr;
|
pre_expr op0expr, op1expr;
|
tree genop0 = NULL_TREE, genop1 = NULL_TREE;
|
tree genop0 = NULL_TREE, genop1 = NULL_TREE;
|
vn_reference_op_t nextop = VEC_index (vn_reference_op_s, ref->operands,
|
vn_reference_op_t nextop = VEC_index (vn_reference_op_s, ref->operands,
|
++*operand);
|
++*operand);
|
tree baseop = create_component_ref_by_pieces_1 (block, ref, operand,
|
tree baseop = create_component_ref_by_pieces_1 (block, ref, operand,
|
stmts, domstmt);
|
stmts, domstmt);
|
if (!baseop)
|
if (!baseop)
|
return NULL_TREE;
|
return NULL_TREE;
|
if (currop->op0)
|
if (currop->op0)
|
{
|
{
|
op0expr = get_or_alloc_expr_for (currop->op0);
|
op0expr = get_or_alloc_expr_for (currop->op0);
|
genop0 = find_or_generate_expression (block, op0expr,
|
genop0 = find_or_generate_expression (block, op0expr,
|
stmts, domstmt);
|
stmts, domstmt);
|
if (!genop0)
|
if (!genop0)
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
if (nextop->op0)
|
if (nextop->op0)
|
{
|
{
|
op1expr = get_or_alloc_expr_for (nextop->op0);
|
op1expr = get_or_alloc_expr_for (nextop->op0);
|
genop1 = find_or_generate_expression (block, op1expr,
|
genop1 = find_or_generate_expression (block, op1expr,
|
stmts, domstmt);
|
stmts, domstmt);
|
if (!genop1)
|
if (!genop1)
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
return build5 (TARGET_MEM_REF, currop->type,
|
return build5 (TARGET_MEM_REF, currop->type,
|
baseop, currop->op2, genop0, currop->op1, genop1);
|
baseop, currop->op2, genop0, currop->op1, genop1);
|
}
|
}
|
break;
|
break;
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
if (currop->op0)
|
if (currop->op0)
|
{
|
{
|
gcc_assert (is_gimple_min_invariant (currop->op0));
|
gcc_assert (is_gimple_min_invariant (currop->op0));
|
return currop->op0;
|
return currop->op0;
|
}
|
}
|
/* Fallthrough. */
|
/* Fallthrough. */
|
case REALPART_EXPR:
|
case REALPART_EXPR:
|
case IMAGPART_EXPR:
|
case IMAGPART_EXPR:
|
case VIEW_CONVERT_EXPR:
|
case VIEW_CONVERT_EXPR:
|
{
|
{
|
tree folded;
|
tree folded;
|
tree genop0 = create_component_ref_by_pieces_1 (block, ref,
|
tree genop0 = create_component_ref_by_pieces_1 (block, ref,
|
operand,
|
operand,
|
stmts, domstmt);
|
stmts, domstmt);
|
if (!genop0)
|
if (!genop0)
|
return NULL_TREE;
|
return NULL_TREE;
|
folded = fold_build1 (currop->opcode, currop->type,
|
folded = fold_build1 (currop->opcode, currop->type,
|
genop0);
|
genop0);
|
return folded;
|
return folded;
|
}
|
}
|
break;
|
break;
|
case WITH_SIZE_EXPR:
|
case WITH_SIZE_EXPR:
|
{
|
{
|
tree genop0 = create_component_ref_by_pieces_1 (block, ref, operand,
|
tree genop0 = create_component_ref_by_pieces_1 (block, ref, operand,
|
stmts, domstmt);
|
stmts, domstmt);
|
pre_expr op1expr = get_or_alloc_expr_for (currop->op0);
|
pre_expr op1expr = get_or_alloc_expr_for (currop->op0);
|
tree genop1;
|
tree genop1;
|
|
|
if (!genop0)
|
if (!genop0)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
genop1 = find_or_generate_expression (block, op1expr, stmts, domstmt);
|
genop1 = find_or_generate_expression (block, op1expr, stmts, domstmt);
|
if (!genop1)
|
if (!genop1)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
return fold_build2 (currop->opcode, currop->type, genop0, genop1);
|
return fold_build2 (currop->opcode, currop->type, genop0, genop1);
|
}
|
}
|
break;
|
break;
|
case BIT_FIELD_REF:
|
case BIT_FIELD_REF:
|
{
|
{
|
tree folded;
|
tree folded;
|
tree genop0 = create_component_ref_by_pieces_1 (block, ref, operand,
|
tree genop0 = create_component_ref_by_pieces_1 (block, ref, operand,
|
stmts, domstmt);
|
stmts, domstmt);
|
pre_expr op1expr = get_or_alloc_expr_for (currop->op0);
|
pre_expr op1expr = get_or_alloc_expr_for (currop->op0);
|
pre_expr op2expr = get_or_alloc_expr_for (currop->op1);
|
pre_expr op2expr = get_or_alloc_expr_for (currop->op1);
|
tree genop1;
|
tree genop1;
|
tree genop2;
|
tree genop2;
|
|
|
if (!genop0)
|
if (!genop0)
|
return NULL_TREE;
|
return NULL_TREE;
|
genop1 = find_or_generate_expression (block, op1expr, stmts, domstmt);
|
genop1 = find_or_generate_expression (block, op1expr, stmts, domstmt);
|
if (!genop1)
|
if (!genop1)
|
return NULL_TREE;
|
return NULL_TREE;
|
genop2 = find_or_generate_expression (block, op2expr, stmts, domstmt);
|
genop2 = find_or_generate_expression (block, op2expr, stmts, domstmt);
|
if (!genop2)
|
if (!genop2)
|
return NULL_TREE;
|
return NULL_TREE;
|
folded = fold_build3 (BIT_FIELD_REF, currop->type, genop0, genop1,
|
folded = fold_build3 (BIT_FIELD_REF, currop->type, genop0, genop1,
|
genop2);
|
genop2);
|
return folded;
|
return folded;
|
}
|
}
|
|
|
/* For array ref vn_reference_op's, operand 1 of the array ref
|
/* For array ref vn_reference_op's, operand 1 of the array ref
|
is op0 of the reference op and operand 3 of the array ref is
|
is op0 of the reference op and operand 3 of the array ref is
|
op1. */
|
op1. */
|
case ARRAY_RANGE_REF:
|
case ARRAY_RANGE_REF:
|
case ARRAY_REF:
|
case ARRAY_REF:
|
{
|
{
|
tree genop0;
|
tree genop0;
|
tree genop1 = currop->op0;
|
tree genop1 = currop->op0;
|
pre_expr op1expr;
|
pre_expr op1expr;
|
tree genop2 = currop->op1;
|
tree genop2 = currop->op1;
|
pre_expr op2expr;
|
pre_expr op2expr;
|
tree genop3 = currop->op2;
|
tree genop3 = currop->op2;
|
pre_expr op3expr;
|
pre_expr op3expr;
|
genop0 = create_component_ref_by_pieces_1 (block, ref, operand,
|
genop0 = create_component_ref_by_pieces_1 (block, ref, operand,
|
stmts, domstmt);
|
stmts, domstmt);
|
if (!genop0)
|
if (!genop0)
|
return NULL_TREE;
|
return NULL_TREE;
|
op1expr = get_or_alloc_expr_for (genop1);
|
op1expr = get_or_alloc_expr_for (genop1);
|
genop1 = find_or_generate_expression (block, op1expr, stmts, domstmt);
|
genop1 = find_or_generate_expression (block, op1expr, stmts, domstmt);
|
if (!genop1)
|
if (!genop1)
|
return NULL_TREE;
|
return NULL_TREE;
|
if (genop2)
|
if (genop2)
|
{
|
{
|
tree domain_type = TYPE_DOMAIN (TREE_TYPE (genop0));
|
tree domain_type = TYPE_DOMAIN (TREE_TYPE (genop0));
|
/* Drop zero minimum index if redundant. */
|
/* Drop zero minimum index if redundant. */
|
if (integer_zerop (genop2)
|
if (integer_zerop (genop2)
|
&& (!domain_type
|
&& (!domain_type
|
|| integer_zerop (TYPE_MIN_VALUE (domain_type))))
|
|| integer_zerop (TYPE_MIN_VALUE (domain_type))))
|
genop2 = NULL_TREE;
|
genop2 = NULL_TREE;
|
else
|
else
|
{
|
{
|
op2expr = get_or_alloc_expr_for (genop2);
|
op2expr = get_or_alloc_expr_for (genop2);
|
genop2 = find_or_generate_expression (block, op2expr, stmts,
|
genop2 = find_or_generate_expression (block, op2expr, stmts,
|
domstmt);
|
domstmt);
|
if (!genop2)
|
if (!genop2)
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
}
|
}
|
if (genop3)
|
if (genop3)
|
{
|
{
|
tree elmt_type = TREE_TYPE (TREE_TYPE (genop0));
|
tree elmt_type = TREE_TYPE (TREE_TYPE (genop0));
|
/* We can't always put a size in units of the element alignment
|
/* We can't always put a size in units of the element alignment
|
here as the element alignment may be not visible. See
|
here as the element alignment may be not visible. See
|
PR43783. Simply drop the element size for constant
|
PR43783. Simply drop the element size for constant
|
sizes. */
|
sizes. */
|
if (tree_int_cst_equal (genop3, TYPE_SIZE_UNIT (elmt_type)))
|
if (tree_int_cst_equal (genop3, TYPE_SIZE_UNIT (elmt_type)))
|
genop3 = NULL_TREE;
|
genop3 = NULL_TREE;
|
else
|
else
|
{
|
{
|
genop3 = size_binop (EXACT_DIV_EXPR, genop3,
|
genop3 = size_binop (EXACT_DIV_EXPR, genop3,
|
size_int (TYPE_ALIGN_UNIT (elmt_type)));
|
size_int (TYPE_ALIGN_UNIT (elmt_type)));
|
op3expr = get_or_alloc_expr_for (genop3);
|
op3expr = get_or_alloc_expr_for (genop3);
|
genop3 = find_or_generate_expression (block, op3expr, stmts,
|
genop3 = find_or_generate_expression (block, op3expr, stmts,
|
domstmt);
|
domstmt);
|
if (!genop3)
|
if (!genop3)
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
}
|
}
|
return build4 (currop->opcode, currop->type, genop0, genop1,
|
return build4 (currop->opcode, currop->type, genop0, genop1,
|
genop2, genop3);
|
genop2, genop3);
|
}
|
}
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
{
|
{
|
tree op0;
|
tree op0;
|
tree op1;
|
tree op1;
|
tree genop2 = currop->op1;
|
tree genop2 = currop->op1;
|
pre_expr op2expr;
|
pre_expr op2expr;
|
op0 = create_component_ref_by_pieces_1 (block, ref, operand,
|
op0 = create_component_ref_by_pieces_1 (block, ref, operand,
|
stmts, domstmt);
|
stmts, domstmt);
|
if (!op0)
|
if (!op0)
|
return NULL_TREE;
|
return NULL_TREE;
|
/* op1 should be a FIELD_DECL, which are represented by
|
/* op1 should be a FIELD_DECL, which are represented by
|
themselves. */
|
themselves. */
|
op1 = currop->op0;
|
op1 = currop->op0;
|
if (genop2)
|
if (genop2)
|
{
|
{
|
op2expr = get_or_alloc_expr_for (genop2);
|
op2expr = get_or_alloc_expr_for (genop2);
|
genop2 = find_or_generate_expression (block, op2expr, stmts,
|
genop2 = find_or_generate_expression (block, op2expr, stmts,
|
domstmt);
|
domstmt);
|
if (!genop2)
|
if (!genop2)
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
return fold_build3 (COMPONENT_REF, TREE_TYPE (op1), op0, op1,
|
return fold_build3 (COMPONENT_REF, TREE_TYPE (op1), op0, op1,
|
genop2);
|
genop2);
|
}
|
}
|
break;
|
break;
|
case SSA_NAME:
|
case SSA_NAME:
|
{
|
{
|
pre_expr op0expr = get_or_alloc_expr_for (currop->op0);
|
pre_expr op0expr = get_or_alloc_expr_for (currop->op0);
|
genop = find_or_generate_expression (block, op0expr, stmts, domstmt);
|
genop = find_or_generate_expression (block, op0expr, stmts, domstmt);
|
return genop;
|
return genop;
|
}
|
}
|
case STRING_CST:
|
case STRING_CST:
|
case INTEGER_CST:
|
case INTEGER_CST:
|
case COMPLEX_CST:
|
case COMPLEX_CST:
|
case VECTOR_CST:
|
case VECTOR_CST:
|
case REAL_CST:
|
case REAL_CST:
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
case VAR_DECL:
|
case VAR_DECL:
|
case PARM_DECL:
|
case PARM_DECL:
|
case CONST_DECL:
|
case CONST_DECL:
|
case RESULT_DECL:
|
case RESULT_DECL:
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
return currop->op0;
|
return currop->op0;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* For COMPONENT_REF's and ARRAY_REF's, we can't have any intermediates for the
|
/* For COMPONENT_REF's and ARRAY_REF's, we can't have any intermediates for the
|
COMPONENT_REF or MEM_REF or ARRAY_REF portion, because we'd end up with
|
COMPONENT_REF or MEM_REF or ARRAY_REF portion, because we'd end up with
|
trying to rename aggregates into ssa form directly, which is a no no.
|
trying to rename aggregates into ssa form directly, which is a no no.
|
|
|
Thus, this routine doesn't create temporaries, it just builds a
|
Thus, this routine doesn't create temporaries, it just builds a
|
single access expression for the array, calling
|
single access expression for the array, calling
|
find_or_generate_expression to build the innermost pieces.
|
find_or_generate_expression to build the innermost pieces.
|
|
|
This function is a subroutine of create_expression_by_pieces, and
|
This function is a subroutine of create_expression_by_pieces, and
|
should not be called on it's own unless you really know what you
|
should not be called on it's own unless you really know what you
|
are doing. */
|
are doing. */
|
|
|
static tree
|
static tree
|
create_component_ref_by_pieces (basic_block block, vn_reference_t ref,
|
create_component_ref_by_pieces (basic_block block, vn_reference_t ref,
|
gimple_seq *stmts, gimple domstmt)
|
gimple_seq *stmts, gimple domstmt)
|
{
|
{
|
unsigned int op = 0;
|
unsigned int op = 0;
|
return create_component_ref_by_pieces_1 (block, ref, &op, stmts, domstmt);
|
return create_component_ref_by_pieces_1 (block, ref, &op, stmts, domstmt);
|
}
|
}
|
|
|
/* Find a leader for an expression, or generate one using
|
/* Find a leader for an expression, or generate one using
|
create_expression_by_pieces if it's ANTIC but
|
create_expression_by_pieces if it's ANTIC but
|
complex.
|
complex.
|
BLOCK is the basic_block we are looking for leaders in.
|
BLOCK is the basic_block we are looking for leaders in.
|
EXPR is the expression to find a leader or generate for.
|
EXPR is the expression to find a leader or generate for.
|
STMTS is the statement list to put the inserted expressions on.
|
STMTS is the statement list to put the inserted expressions on.
|
Returns the SSA_NAME of the LHS of the generated expression or the
|
Returns the SSA_NAME of the LHS of the generated expression or the
|
leader.
|
leader.
|
DOMSTMT if non-NULL is a statement that should be dominated by
|
DOMSTMT if non-NULL is a statement that should be dominated by
|
all uses in the generated expression. If DOMSTMT is non-NULL this
|
all uses in the generated expression. If DOMSTMT is non-NULL this
|
routine can fail and return NULL_TREE. Otherwise it will assert
|
routine can fail and return NULL_TREE. Otherwise it will assert
|
on failure. */
|
on failure. */
|
|
|
static tree
|
static tree
|
find_or_generate_expression (basic_block block, pre_expr expr,
|
find_or_generate_expression (basic_block block, pre_expr expr,
|
gimple_seq *stmts, gimple domstmt)
|
gimple_seq *stmts, gimple domstmt)
|
{
|
{
|
pre_expr leader = bitmap_find_leader (AVAIL_OUT (block),
|
pre_expr leader = bitmap_find_leader (AVAIL_OUT (block),
|
get_expr_value_id (expr), domstmt);
|
get_expr_value_id (expr), domstmt);
|
tree genop = NULL;
|
tree genop = NULL;
|
if (leader)
|
if (leader)
|
{
|
{
|
if (leader->kind == NAME)
|
if (leader->kind == NAME)
|
genop = PRE_EXPR_NAME (leader);
|
genop = PRE_EXPR_NAME (leader);
|
else if (leader->kind == CONSTANT)
|
else if (leader->kind == CONSTANT)
|
genop = PRE_EXPR_CONSTANT (leader);
|
genop = PRE_EXPR_CONSTANT (leader);
|
}
|
}
|
|
|
/* If it's still NULL, it must be a complex expression, so generate
|
/* If it's still NULL, it must be a complex expression, so generate
|
it recursively. Not so if inserting expressions for values generated
|
it recursively. Not so if inserting expressions for values generated
|
by SCCVN. */
|
by SCCVN. */
|
if (genop == NULL
|
if (genop == NULL
|
&& !domstmt)
|
&& !domstmt)
|
{
|
{
|
bitmap_set_t exprset;
|
bitmap_set_t exprset;
|
unsigned int lookfor = get_expr_value_id (expr);
|
unsigned int lookfor = get_expr_value_id (expr);
|
bool handled = false;
|
bool handled = false;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
unsigned int i;
|
unsigned int i;
|
|
|
exprset = VEC_index (bitmap_set_t, value_expressions, lookfor);
|
exprset = VEC_index (bitmap_set_t, value_expressions, lookfor);
|
FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
|
{
|
{
|
pre_expr temp = expression_for_id (i);
|
pre_expr temp = expression_for_id (i);
|
if (temp->kind != NAME)
|
if (temp->kind != NAME)
|
{
|
{
|
handled = true;
|
handled = true;
|
genop = create_expression_by_pieces (block, temp, stmts,
|
genop = create_expression_by_pieces (block, temp, stmts,
|
domstmt,
|
domstmt,
|
get_expr_type (expr));
|
get_expr_type (expr));
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (!handled && domstmt)
|
if (!handled && domstmt)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
gcc_assert (handled);
|
gcc_assert (handled);
|
}
|
}
|
return genop;
|
return genop;
|
}
|
}
|
|
|
#define NECESSARY GF_PLF_1
|
#define NECESSARY GF_PLF_1
|
|
|
/* Create an expression in pieces, so that we can handle very complex
|
/* Create an expression in pieces, so that we can handle very complex
|
expressions that may be ANTIC, but not necessary GIMPLE.
|
expressions that may be ANTIC, but not necessary GIMPLE.
|
BLOCK is the basic block the expression will be inserted into,
|
BLOCK is the basic block the expression will be inserted into,
|
EXPR is the expression to insert (in value form)
|
EXPR is the expression to insert (in value form)
|
STMTS is a statement list to append the necessary insertions into.
|
STMTS is a statement list to append the necessary insertions into.
|
|
|
This function will die if we hit some value that shouldn't be
|
This function will die if we hit some value that shouldn't be
|
ANTIC but is (IE there is no leader for it, or its components).
|
ANTIC but is (IE there is no leader for it, or its components).
|
This function may also generate expressions that are themselves
|
This function may also generate expressions that are themselves
|
partially or fully redundant. Those that are will be either made
|
partially or fully redundant. Those that are will be either made
|
fully redundant during the next iteration of insert (for partially
|
fully redundant during the next iteration of insert (for partially
|
redundant ones), or eliminated by eliminate (for fully redundant
|
redundant ones), or eliminated by eliminate (for fully redundant
|
ones).
|
ones).
|
|
|
If DOMSTMT is non-NULL then we make sure that all uses in the
|
If DOMSTMT is non-NULL then we make sure that all uses in the
|
expressions dominate that statement. In this case the function
|
expressions dominate that statement. In this case the function
|
can return NULL_TREE to signal failure. */
|
can return NULL_TREE to signal failure. */
|
|
|
static tree
|
static tree
|
create_expression_by_pieces (basic_block block, pre_expr expr,
|
create_expression_by_pieces (basic_block block, pre_expr expr,
|
gimple_seq *stmts, gimple domstmt, tree type)
|
gimple_seq *stmts, gimple domstmt, tree type)
|
{
|
{
|
tree temp, name;
|
tree temp, name;
|
tree folded;
|
tree folded;
|
gimple_seq forced_stmts = NULL;
|
gimple_seq forced_stmts = NULL;
|
unsigned int value_id;
|
unsigned int value_id;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
tree exprtype = type ? type : get_expr_type (expr);
|
tree exprtype = type ? type : get_expr_type (expr);
|
pre_expr nameexpr;
|
pre_expr nameexpr;
|
gimple newstmt;
|
gimple newstmt;
|
|
|
switch (expr->kind)
|
switch (expr->kind)
|
{
|
{
|
/* We may hit the NAME/CONSTANT case if we have to convert types
|
/* We may hit the NAME/CONSTANT case if we have to convert types
|
that value numbering saw through. */
|
that value numbering saw through. */
|
case NAME:
|
case NAME:
|
folded = PRE_EXPR_NAME (expr);
|
folded = PRE_EXPR_NAME (expr);
|
break;
|
break;
|
case CONSTANT:
|
case CONSTANT:
|
folded = PRE_EXPR_CONSTANT (expr);
|
folded = PRE_EXPR_CONSTANT (expr);
|
break;
|
break;
|
case REFERENCE:
|
case REFERENCE:
|
{
|
{
|
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
|
vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
|
folded = create_component_ref_by_pieces (block, ref, stmts, domstmt);
|
folded = create_component_ref_by_pieces (block, ref, stmts, domstmt);
|
}
|
}
|
break;
|
break;
|
case NARY:
|
case NARY:
|
{
|
{
|
vn_nary_op_t nary = PRE_EXPR_NARY (expr);
|
vn_nary_op_t nary = PRE_EXPR_NARY (expr);
|
tree genop[4];
|
tree genop[4];
|
unsigned i;
|
unsigned i;
|
for (i = 0; i < nary->length; ++i)
|
for (i = 0; i < nary->length; ++i)
|
{
|
{
|
pre_expr op = get_or_alloc_expr_for (nary->op[i]);
|
pre_expr op = get_or_alloc_expr_for (nary->op[i]);
|
genop[i] = find_or_generate_expression (block, op,
|
genop[i] = find_or_generate_expression (block, op,
|
stmts, domstmt);
|
stmts, domstmt);
|
if (!genop[i])
|
if (!genop[i])
|
return NULL_TREE;
|
return NULL_TREE;
|
/* Ensure genop[] is properly typed for POINTER_PLUS_EXPR. It
|
/* Ensure genop[] is properly typed for POINTER_PLUS_EXPR. It
|
may have conversions stripped. */
|
may have conversions stripped. */
|
if (nary->opcode == POINTER_PLUS_EXPR)
|
if (nary->opcode == POINTER_PLUS_EXPR)
|
{
|
{
|
if (i == 0)
|
if (i == 0)
|
genop[i] = fold_convert (nary->type, genop[i]);
|
genop[i] = fold_convert (nary->type, genop[i]);
|
else if (i == 1)
|
else if (i == 1)
|
genop[i] = convert_to_ptrofftype (genop[i]);
|
genop[i] = convert_to_ptrofftype (genop[i]);
|
}
|
}
|
else
|
else
|
genop[i] = fold_convert (TREE_TYPE (nary->op[i]), genop[i]);
|
genop[i] = fold_convert (TREE_TYPE (nary->op[i]), genop[i]);
|
}
|
}
|
if (nary->opcode == CONSTRUCTOR)
|
if (nary->opcode == CONSTRUCTOR)
|
{
|
{
|
VEC(constructor_elt,gc) *elts = NULL;
|
VEC(constructor_elt,gc) *elts = NULL;
|
for (i = 0; i < nary->length; ++i)
|
for (i = 0; i < nary->length; ++i)
|
CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE, genop[i]);
|
CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE, genop[i]);
|
folded = build_constructor (nary->type, elts);
|
folded = build_constructor (nary->type, elts);
|
}
|
}
|
else
|
else
|
{
|
{
|
switch (nary->length)
|
switch (nary->length)
|
{
|
{
|
case 1:
|
case 1:
|
folded = fold_build1 (nary->opcode, nary->type,
|
folded = fold_build1 (nary->opcode, nary->type,
|
genop[0]);
|
genop[0]);
|
break;
|
break;
|
case 2:
|
case 2:
|
folded = fold_build2 (nary->opcode, nary->type,
|
folded = fold_build2 (nary->opcode, nary->type,
|
genop[0], genop[1]);
|
genop[0], genop[1]);
|
break;
|
break;
|
case 3:
|
case 3:
|
folded = fold_build3 (nary->opcode, nary->type,
|
folded = fold_build3 (nary->opcode, nary->type,
|
genop[0], genop[1], genop[3]);
|
genop[0], genop[1], genop[3]);
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
if (!useless_type_conversion_p (exprtype, TREE_TYPE (folded)))
|
if (!useless_type_conversion_p (exprtype, TREE_TYPE (folded)))
|
folded = fold_convert (exprtype, folded);
|
folded = fold_convert (exprtype, folded);
|
|
|
/* Force the generated expression to be a sequence of GIMPLE
|
/* Force the generated expression to be a sequence of GIMPLE
|
statements.
|
statements.
|
We have to call unshare_expr because force_gimple_operand may
|
We have to call unshare_expr because force_gimple_operand may
|
modify the tree we pass to it. */
|
modify the tree we pass to it. */
|
folded = force_gimple_operand (unshare_expr (folded), &forced_stmts,
|
folded = force_gimple_operand (unshare_expr (folded), &forced_stmts,
|
false, NULL);
|
false, NULL);
|
|
|
/* If we have any intermediate expressions to the value sets, add them
|
/* If we have any intermediate expressions to the value sets, add them
|
to the value sets and chain them in the instruction stream. */
|
to the value sets and chain them in the instruction stream. */
|
if (forced_stmts)
|
if (forced_stmts)
|
{
|
{
|
gsi = gsi_start (forced_stmts);
|
gsi = gsi_start (forced_stmts);
|
for (; !gsi_end_p (gsi); gsi_next (&gsi))
|
for (; !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
gimple stmt = gsi_stmt (gsi);
|
gimple stmt = gsi_stmt (gsi);
|
tree forcedname = gimple_get_lhs (stmt);
|
tree forcedname = gimple_get_lhs (stmt);
|
pre_expr nameexpr;
|
pre_expr nameexpr;
|
|
|
if (TREE_CODE (forcedname) == SSA_NAME)
|
if (TREE_CODE (forcedname) == SSA_NAME)
|
{
|
{
|
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (forcedname));
|
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (forcedname));
|
VN_INFO_GET (forcedname)->valnum = forcedname;
|
VN_INFO_GET (forcedname)->valnum = forcedname;
|
VN_INFO (forcedname)->value_id = get_next_value_id ();
|
VN_INFO (forcedname)->value_id = get_next_value_id ();
|
nameexpr = get_or_alloc_expr_for_name (forcedname);
|
nameexpr = get_or_alloc_expr_for_name (forcedname);
|
add_to_value (VN_INFO (forcedname)->value_id, nameexpr);
|
add_to_value (VN_INFO (forcedname)->value_id, nameexpr);
|
if (!in_fre)
|
if (!in_fre)
|
bitmap_value_replace_in_set (NEW_SETS (block), nameexpr);
|
bitmap_value_replace_in_set (NEW_SETS (block), nameexpr);
|
bitmap_value_replace_in_set (AVAIL_OUT (block), nameexpr);
|
bitmap_value_replace_in_set (AVAIL_OUT (block), nameexpr);
|
}
|
}
|
mark_symbols_for_renaming (stmt);
|
mark_symbols_for_renaming (stmt);
|
}
|
}
|
gimple_seq_add_seq (stmts, forced_stmts);
|
gimple_seq_add_seq (stmts, forced_stmts);
|
}
|
}
|
|
|
/* Build and insert the assignment of the end result to the temporary
|
/* Build and insert the assignment of the end result to the temporary
|
that we will return. */
|
that we will return. */
|
if (!pretemp || exprtype != TREE_TYPE (pretemp))
|
if (!pretemp || exprtype != TREE_TYPE (pretemp))
|
pretemp = create_tmp_reg (exprtype, "pretmp");
|
pretemp = create_tmp_reg (exprtype, "pretmp");
|
|
|
temp = pretemp;
|
temp = pretemp;
|
add_referenced_var (temp);
|
add_referenced_var (temp);
|
|
|
newstmt = gimple_build_assign (temp, folded);
|
newstmt = gimple_build_assign (temp, folded);
|
name = make_ssa_name (temp, newstmt);
|
name = make_ssa_name (temp, newstmt);
|
gimple_assign_set_lhs (newstmt, name);
|
gimple_assign_set_lhs (newstmt, name);
|
gimple_set_plf (newstmt, NECESSARY, false);
|
gimple_set_plf (newstmt, NECESSARY, false);
|
|
|
gimple_seq_add_stmt (stmts, newstmt);
|
gimple_seq_add_stmt (stmts, newstmt);
|
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (name));
|
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (name));
|
|
|
/* All the symbols in NEWEXPR should be put into SSA form. */
|
/* All the symbols in NEWEXPR should be put into SSA form. */
|
mark_symbols_for_renaming (newstmt);
|
mark_symbols_for_renaming (newstmt);
|
|
|
/* Fold the last statement. */
|
/* Fold the last statement. */
|
gsi = gsi_last (*stmts);
|
gsi = gsi_last (*stmts);
|
if (fold_stmt_inplace (&gsi))
|
if (fold_stmt_inplace (&gsi))
|
update_stmt (gsi_stmt (gsi));
|
update_stmt (gsi_stmt (gsi));
|
|
|
/* Add a value number to the temporary.
|
/* Add a value number to the temporary.
|
The value may already exist in either NEW_SETS, or AVAIL_OUT, because
|
The value may already exist in either NEW_SETS, or AVAIL_OUT, because
|
we are creating the expression by pieces, and this particular piece of
|
we are creating the expression by pieces, and this particular piece of
|
the expression may have been represented. There is no harm in replacing
|
the expression may have been represented. There is no harm in replacing
|
here. */
|
here. */
|
VN_INFO_GET (name)->valnum = name;
|
VN_INFO_GET (name)->valnum = name;
|
value_id = get_expr_value_id (expr);
|
value_id = get_expr_value_id (expr);
|
VN_INFO (name)->value_id = value_id;
|
VN_INFO (name)->value_id = value_id;
|
nameexpr = get_or_alloc_expr_for_name (name);
|
nameexpr = get_or_alloc_expr_for_name (name);
|
add_to_value (value_id, nameexpr);
|
add_to_value (value_id, nameexpr);
|
if (NEW_SETS (block))
|
if (NEW_SETS (block))
|
bitmap_value_replace_in_set (NEW_SETS (block), nameexpr);
|
bitmap_value_replace_in_set (NEW_SETS (block), nameexpr);
|
bitmap_value_replace_in_set (AVAIL_OUT (block), nameexpr);
|
bitmap_value_replace_in_set (AVAIL_OUT (block), nameexpr);
|
|
|
pre_stats.insertions++;
|
pre_stats.insertions++;
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Inserted ");
|
fprintf (dump_file, "Inserted ");
|
print_gimple_stmt (dump_file, newstmt, 0, 0);
|
print_gimple_stmt (dump_file, newstmt, 0, 0);
|
fprintf (dump_file, " in predecessor %d\n", block->index);
|
fprintf (dump_file, " in predecessor %d\n", block->index);
|
}
|
}
|
|
|
return name;
|
return name;
|
}
|
}
|
|
|
|
|
/* Returns true if we want to inhibit the insertions of PHI nodes
|
/* Returns true if we want to inhibit the insertions of PHI nodes
|
for the given EXPR for basic block BB (a member of a loop).
|
for the given EXPR for basic block BB (a member of a loop).
|
We want to do this, when we fear that the induction variable we
|
We want to do this, when we fear that the induction variable we
|
create might inhibit vectorization. */
|
create might inhibit vectorization. */
|
|
|
static bool
|
static bool
|
inhibit_phi_insertion (basic_block bb, pre_expr expr)
|
inhibit_phi_insertion (basic_block bb, pre_expr expr)
|
{
|
{
|
vn_reference_t vr = PRE_EXPR_REFERENCE (expr);
|
vn_reference_t vr = PRE_EXPR_REFERENCE (expr);
|
VEC (vn_reference_op_s, heap) *ops = vr->operands;
|
VEC (vn_reference_op_s, heap) *ops = vr->operands;
|
vn_reference_op_t op;
|
vn_reference_op_t op;
|
unsigned i;
|
unsigned i;
|
|
|
/* If we aren't going to vectorize we don't inhibit anything. */
|
/* If we aren't going to vectorize we don't inhibit anything. */
|
if (!flag_tree_vectorize)
|
if (!flag_tree_vectorize)
|
return false;
|
return false;
|
|
|
/* Otherwise we inhibit the insertion when the address of the
|
/* Otherwise we inhibit the insertion when the address of the
|
memory reference is a simple induction variable. In other
|
memory reference is a simple induction variable. In other
|
cases the vectorizer won't do anything anyway (either it's
|
cases the vectorizer won't do anything anyway (either it's
|
loop invariant or a complicated expression). */
|
loop invariant or a complicated expression). */
|
FOR_EACH_VEC_ELT (vn_reference_op_s, ops, i, op)
|
FOR_EACH_VEC_ELT (vn_reference_op_s, ops, i, op)
|
{
|
{
|
switch (op->opcode)
|
switch (op->opcode)
|
{
|
{
|
case ARRAY_REF:
|
case ARRAY_REF:
|
case ARRAY_RANGE_REF:
|
case ARRAY_RANGE_REF:
|
if (TREE_CODE (op->op0) != SSA_NAME)
|
if (TREE_CODE (op->op0) != SSA_NAME)
|
break;
|
break;
|
/* Fallthru. */
|
/* Fallthru. */
|
case SSA_NAME:
|
case SSA_NAME:
|
{
|
{
|
basic_block defbb = gimple_bb (SSA_NAME_DEF_STMT (op->op0));
|
basic_block defbb = gimple_bb (SSA_NAME_DEF_STMT (op->op0));
|
affine_iv iv;
|
affine_iv iv;
|
/* Default defs are loop invariant. */
|
/* Default defs are loop invariant. */
|
if (!defbb)
|
if (!defbb)
|
break;
|
break;
|
/* Defined outside this loop, also loop invariant. */
|
/* Defined outside this loop, also loop invariant. */
|
if (!flow_bb_inside_loop_p (bb->loop_father, defbb))
|
if (!flow_bb_inside_loop_p (bb->loop_father, defbb))
|
break;
|
break;
|
/* If it's a simple induction variable inhibit insertion,
|
/* If it's a simple induction variable inhibit insertion,
|
the vectorizer might be interested in this one. */
|
the vectorizer might be interested in this one. */
|
if (simple_iv (bb->loop_father, bb->loop_father,
|
if (simple_iv (bb->loop_father, bb->loop_father,
|
op->op0, &iv, true))
|
op->op0, &iv, true))
|
return true;
|
return true;
|
/* No simple IV, vectorizer can't do anything, hence no
|
/* No simple IV, vectorizer can't do anything, hence no
|
reason to inhibit the transformation for this operand. */
|
reason to inhibit the transformation for this operand. */
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Insert the to-be-made-available values of expression EXPRNUM for each
|
/* Insert the to-be-made-available values of expression EXPRNUM for each
|
predecessor, stored in AVAIL, into the predecessors of BLOCK, and
|
predecessor, stored in AVAIL, into the predecessors of BLOCK, and
|
merge the result with a phi node, given the same value number as
|
merge the result with a phi node, given the same value number as
|
NODE. Return true if we have inserted new stuff. */
|
NODE. Return true if we have inserted new stuff. */
|
|
|
static bool
|
static bool
|
insert_into_preds_of_block (basic_block block, unsigned int exprnum,
|
insert_into_preds_of_block (basic_block block, unsigned int exprnum,
|
pre_expr *avail)
|
pre_expr *avail)
|
{
|
{
|
pre_expr expr = expression_for_id (exprnum);
|
pre_expr expr = expression_for_id (exprnum);
|
pre_expr newphi;
|
pre_expr newphi;
|
unsigned int val = get_expr_value_id (expr);
|
unsigned int val = get_expr_value_id (expr);
|
edge pred;
|
edge pred;
|
bool insertions = false;
|
bool insertions = false;
|
bool nophi = false;
|
bool nophi = false;
|
basic_block bprime;
|
basic_block bprime;
|
pre_expr eprime;
|
pre_expr eprime;
|
edge_iterator ei;
|
edge_iterator ei;
|
tree type = get_expr_type (expr);
|
tree type = get_expr_type (expr);
|
tree temp;
|
tree temp;
|
gimple phi;
|
gimple phi;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Found partial redundancy for expression ");
|
fprintf (dump_file, "Found partial redundancy for expression ");
|
print_pre_expr (dump_file, expr);
|
print_pre_expr (dump_file, expr);
|
fprintf (dump_file, " (%04d)\n", val);
|
fprintf (dump_file, " (%04d)\n", val);
|
}
|
}
|
|
|
/* Make sure we aren't creating an induction variable. */
|
/* Make sure we aren't creating an induction variable. */
|
if (block->loop_depth > 0 && EDGE_COUNT (block->preds) == 2)
|
if (block->loop_depth > 0 && EDGE_COUNT (block->preds) == 2)
|
{
|
{
|
bool firstinsideloop = false;
|
bool firstinsideloop = false;
|
bool secondinsideloop = false;
|
bool secondinsideloop = false;
|
firstinsideloop = flow_bb_inside_loop_p (block->loop_father,
|
firstinsideloop = flow_bb_inside_loop_p (block->loop_father,
|
EDGE_PRED (block, 0)->src);
|
EDGE_PRED (block, 0)->src);
|
secondinsideloop = flow_bb_inside_loop_p (block->loop_father,
|
secondinsideloop = flow_bb_inside_loop_p (block->loop_father,
|
EDGE_PRED (block, 1)->src);
|
EDGE_PRED (block, 1)->src);
|
/* Induction variables only have one edge inside the loop. */
|
/* Induction variables only have one edge inside the loop. */
|
if ((firstinsideloop ^ secondinsideloop)
|
if ((firstinsideloop ^ secondinsideloop)
|
&& (expr->kind != REFERENCE
|
&& (expr->kind != REFERENCE
|
|| inhibit_phi_insertion (block, expr)))
|
|| inhibit_phi_insertion (block, expr)))
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "Skipping insertion of phi for partial redundancy: Looks like an induction variable\n");
|
fprintf (dump_file, "Skipping insertion of phi for partial redundancy: Looks like an induction variable\n");
|
nophi = true;
|
nophi = true;
|
}
|
}
|
}
|
}
|
|
|
/* Make the necessary insertions. */
|
/* Make the necessary insertions. */
|
FOR_EACH_EDGE (pred, ei, block->preds)
|
FOR_EACH_EDGE (pred, ei, block->preds)
|
{
|
{
|
gimple_seq stmts = NULL;
|
gimple_seq stmts = NULL;
|
tree builtexpr;
|
tree builtexpr;
|
bprime = pred->src;
|
bprime = pred->src;
|
eprime = avail[bprime->index];
|
eprime = avail[bprime->index];
|
|
|
if (eprime->kind != NAME && eprime->kind != CONSTANT)
|
if (eprime->kind != NAME && eprime->kind != CONSTANT)
|
{
|
{
|
builtexpr = create_expression_by_pieces (bprime,
|
builtexpr = create_expression_by_pieces (bprime,
|
eprime,
|
eprime,
|
&stmts, NULL,
|
&stmts, NULL,
|
type);
|
type);
|
gcc_assert (!(pred->flags & EDGE_ABNORMAL));
|
gcc_assert (!(pred->flags & EDGE_ABNORMAL));
|
gsi_insert_seq_on_edge (pred, stmts);
|
gsi_insert_seq_on_edge (pred, stmts);
|
avail[bprime->index] = get_or_alloc_expr_for_name (builtexpr);
|
avail[bprime->index] = get_or_alloc_expr_for_name (builtexpr);
|
insertions = true;
|
insertions = true;
|
}
|
}
|
else if (eprime->kind == CONSTANT)
|
else if (eprime->kind == CONSTANT)
|
{
|
{
|
/* Constants may not have the right type, fold_convert
|
/* Constants may not have the right type, fold_convert
|
should give us back a constant with the right type.
|
should give us back a constant with the right type.
|
*/
|
*/
|
tree constant = PRE_EXPR_CONSTANT (eprime);
|
tree constant = PRE_EXPR_CONSTANT (eprime);
|
if (!useless_type_conversion_p (type, TREE_TYPE (constant)))
|
if (!useless_type_conversion_p (type, TREE_TYPE (constant)))
|
{
|
{
|
tree builtexpr = fold_convert (type, constant);
|
tree builtexpr = fold_convert (type, constant);
|
if (!is_gimple_min_invariant (builtexpr))
|
if (!is_gimple_min_invariant (builtexpr))
|
{
|
{
|
tree forcedexpr = force_gimple_operand (builtexpr,
|
tree forcedexpr = force_gimple_operand (builtexpr,
|
&stmts, true,
|
&stmts, true,
|
NULL);
|
NULL);
|
if (!is_gimple_min_invariant (forcedexpr))
|
if (!is_gimple_min_invariant (forcedexpr))
|
{
|
{
|
if (forcedexpr != builtexpr)
|
if (forcedexpr != builtexpr)
|
{
|
{
|
VN_INFO_GET (forcedexpr)->valnum = PRE_EXPR_CONSTANT (eprime);
|
VN_INFO_GET (forcedexpr)->valnum = PRE_EXPR_CONSTANT (eprime);
|
VN_INFO (forcedexpr)->value_id = get_expr_value_id (eprime);
|
VN_INFO (forcedexpr)->value_id = get_expr_value_id (eprime);
|
}
|
}
|
if (stmts)
|
if (stmts)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
gsi = gsi_start (stmts);
|
gsi = gsi_start (stmts);
|
for (; !gsi_end_p (gsi); gsi_next (&gsi))
|
for (; !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
gimple stmt = gsi_stmt (gsi);
|
gimple stmt = gsi_stmt (gsi);
|
tree lhs = gimple_get_lhs (stmt);
|
tree lhs = gimple_get_lhs (stmt);
|
if (TREE_CODE (lhs) == SSA_NAME)
|
if (TREE_CODE (lhs) == SSA_NAME)
|
bitmap_set_bit (inserted_exprs,
|
bitmap_set_bit (inserted_exprs,
|
SSA_NAME_VERSION (lhs));
|
SSA_NAME_VERSION (lhs));
|
gimple_set_plf (stmt, NECESSARY, false);
|
gimple_set_plf (stmt, NECESSARY, false);
|
}
|
}
|
gsi_insert_seq_on_edge (pred, stmts);
|
gsi_insert_seq_on_edge (pred, stmts);
|
}
|
}
|
avail[bprime->index] = get_or_alloc_expr_for_name (forcedexpr);
|
avail[bprime->index] = get_or_alloc_expr_for_name (forcedexpr);
|
}
|
}
|
}
|
}
|
else
|
else
|
avail[bprime->index] = get_or_alloc_expr_for_constant (builtexpr);
|
avail[bprime->index] = get_or_alloc_expr_for_constant (builtexpr);
|
}
|
}
|
}
|
}
|
else if (eprime->kind == NAME)
|
else if (eprime->kind == NAME)
|
{
|
{
|
/* We may have to do a conversion because our value
|
/* We may have to do a conversion because our value
|
numbering can look through types in certain cases, but
|
numbering can look through types in certain cases, but
|
our IL requires all operands of a phi node have the same
|
our IL requires all operands of a phi node have the same
|
type. */
|
type. */
|
tree name = PRE_EXPR_NAME (eprime);
|
tree name = PRE_EXPR_NAME (eprime);
|
if (!useless_type_conversion_p (type, TREE_TYPE (name)))
|
if (!useless_type_conversion_p (type, TREE_TYPE (name)))
|
{
|
{
|
tree builtexpr;
|
tree builtexpr;
|
tree forcedexpr;
|
tree forcedexpr;
|
builtexpr = fold_convert (type, name);
|
builtexpr = fold_convert (type, name);
|
forcedexpr = force_gimple_operand (builtexpr,
|
forcedexpr = force_gimple_operand (builtexpr,
|
&stmts, true,
|
&stmts, true,
|
NULL);
|
NULL);
|
|
|
if (forcedexpr != name)
|
if (forcedexpr != name)
|
{
|
{
|
VN_INFO_GET (forcedexpr)->valnum = VN_INFO (name)->valnum;
|
VN_INFO_GET (forcedexpr)->valnum = VN_INFO (name)->valnum;
|
VN_INFO (forcedexpr)->value_id = VN_INFO (name)->value_id;
|
VN_INFO (forcedexpr)->value_id = VN_INFO (name)->value_id;
|
}
|
}
|
|
|
if (stmts)
|
if (stmts)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
gsi = gsi_start (stmts);
|
gsi = gsi_start (stmts);
|
for (; !gsi_end_p (gsi); gsi_next (&gsi))
|
for (; !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
gimple stmt = gsi_stmt (gsi);
|
gimple stmt = gsi_stmt (gsi);
|
tree lhs = gimple_get_lhs (stmt);
|
tree lhs = gimple_get_lhs (stmt);
|
if (TREE_CODE (lhs) == SSA_NAME)
|
if (TREE_CODE (lhs) == SSA_NAME)
|
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (lhs));
|
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (lhs));
|
gimple_set_plf (stmt, NECESSARY, false);
|
gimple_set_plf (stmt, NECESSARY, false);
|
}
|
}
|
gsi_insert_seq_on_edge (pred, stmts);
|
gsi_insert_seq_on_edge (pred, stmts);
|
}
|
}
|
avail[bprime->index] = get_or_alloc_expr_for_name (forcedexpr);
|
avail[bprime->index] = get_or_alloc_expr_for_name (forcedexpr);
|
}
|
}
|
}
|
}
|
}
|
}
|
/* If we didn't want a phi node, and we made insertions, we still have
|
/* If we didn't want a phi node, and we made insertions, we still have
|
inserted new stuff, and thus return true. If we didn't want a phi node,
|
inserted new stuff, and thus return true. If we didn't want a phi node,
|
and didn't make insertions, we haven't added anything new, so return
|
and didn't make insertions, we haven't added anything new, so return
|
false. */
|
false. */
|
if (nophi && insertions)
|
if (nophi && insertions)
|
return true;
|
return true;
|
else if (nophi && !insertions)
|
else if (nophi && !insertions)
|
return false;
|
return false;
|
|
|
/* Now build a phi for the new variable. */
|
/* Now build a phi for the new variable. */
|
if (!prephitemp || TREE_TYPE (prephitemp) != type)
|
if (!prephitemp || TREE_TYPE (prephitemp) != type)
|
prephitemp = create_tmp_var (type, "prephitmp");
|
prephitemp = create_tmp_var (type, "prephitmp");
|
|
|
temp = prephitemp;
|
temp = prephitemp;
|
add_referenced_var (temp);
|
add_referenced_var (temp);
|
|
|
if (TREE_CODE (type) == COMPLEX_TYPE
|
if (TREE_CODE (type) == COMPLEX_TYPE
|
|| TREE_CODE (type) == VECTOR_TYPE)
|
|| TREE_CODE (type) == VECTOR_TYPE)
|
DECL_GIMPLE_REG_P (temp) = 1;
|
DECL_GIMPLE_REG_P (temp) = 1;
|
phi = create_phi_node (temp, block);
|
phi = create_phi_node (temp, block);
|
|
|
gimple_set_plf (phi, NECESSARY, false);
|
gimple_set_plf (phi, NECESSARY, false);
|
VN_INFO_GET (gimple_phi_result (phi))->valnum = gimple_phi_result (phi);
|
VN_INFO_GET (gimple_phi_result (phi))->valnum = gimple_phi_result (phi);
|
VN_INFO (gimple_phi_result (phi))->value_id = val;
|
VN_INFO (gimple_phi_result (phi))->value_id = val;
|
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (gimple_phi_result (phi)));
|
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (gimple_phi_result (phi)));
|
FOR_EACH_EDGE (pred, ei, block->preds)
|
FOR_EACH_EDGE (pred, ei, block->preds)
|
{
|
{
|
pre_expr ae = avail[pred->src->index];
|
pre_expr ae = avail[pred->src->index];
|
gcc_assert (get_expr_type (ae) == type
|
gcc_assert (get_expr_type (ae) == type
|
|| useless_type_conversion_p (type, get_expr_type (ae)));
|
|| useless_type_conversion_p (type, get_expr_type (ae)));
|
if (ae->kind == CONSTANT)
|
if (ae->kind == CONSTANT)
|
add_phi_arg (phi, PRE_EXPR_CONSTANT (ae), pred, UNKNOWN_LOCATION);
|
add_phi_arg (phi, PRE_EXPR_CONSTANT (ae), pred, UNKNOWN_LOCATION);
|
else
|
else
|
add_phi_arg (phi, PRE_EXPR_NAME (avail[pred->src->index]), pred,
|
add_phi_arg (phi, PRE_EXPR_NAME (avail[pred->src->index]), pred,
|
UNKNOWN_LOCATION);
|
UNKNOWN_LOCATION);
|
}
|
}
|
|
|
newphi = get_or_alloc_expr_for_name (gimple_phi_result (phi));
|
newphi = get_or_alloc_expr_for_name (gimple_phi_result (phi));
|
add_to_value (val, newphi);
|
add_to_value (val, newphi);
|
|
|
/* The value should *not* exist in PHI_GEN, or else we wouldn't be doing
|
/* The value should *not* exist in PHI_GEN, or else we wouldn't be doing
|
this insertion, since we test for the existence of this value in PHI_GEN
|
this insertion, since we test for the existence of this value in PHI_GEN
|
before proceeding with the partial redundancy checks in insert_aux.
|
before proceeding with the partial redundancy checks in insert_aux.
|
|
|
The value may exist in AVAIL_OUT, in particular, it could be represented
|
The value may exist in AVAIL_OUT, in particular, it could be represented
|
by the expression we are trying to eliminate, in which case we want the
|
by the expression we are trying to eliminate, in which case we want the
|
replacement to occur. If it's not existing in AVAIL_OUT, we want it
|
replacement to occur. If it's not existing in AVAIL_OUT, we want it
|
inserted there.
|
inserted there.
|
|
|
Similarly, to the PHI_GEN case, the value should not exist in NEW_SETS of
|
Similarly, to the PHI_GEN case, the value should not exist in NEW_SETS of
|
this block, because if it did, it would have existed in our dominator's
|
this block, because if it did, it would have existed in our dominator's
|
AVAIL_OUT, and would have been skipped due to the full redundancy check.
|
AVAIL_OUT, and would have been skipped due to the full redundancy check.
|
*/
|
*/
|
|
|
bitmap_insert_into_set (PHI_GEN (block), newphi);
|
bitmap_insert_into_set (PHI_GEN (block), newphi);
|
bitmap_value_replace_in_set (AVAIL_OUT (block),
|
bitmap_value_replace_in_set (AVAIL_OUT (block),
|
newphi);
|
newphi);
|
bitmap_insert_into_set (NEW_SETS (block),
|
bitmap_insert_into_set (NEW_SETS (block),
|
newphi);
|
newphi);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Created phi ");
|
fprintf (dump_file, "Created phi ");
|
print_gimple_stmt (dump_file, phi, 0, 0);
|
print_gimple_stmt (dump_file, phi, 0, 0);
|
fprintf (dump_file, " in block %d\n", block->index);
|
fprintf (dump_file, " in block %d\n", block->index);
|
}
|
}
|
pre_stats.phis++;
|
pre_stats.phis++;
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
|
|
/* Perform insertion of partially redundant values.
|
/* Perform insertion of partially redundant values.
|
For BLOCK, do the following:
|
For BLOCK, do the following:
|
1. Propagate the NEW_SETS of the dominator into the current block.
|
1. Propagate the NEW_SETS of the dominator into the current block.
|
If the block has multiple predecessors,
|
If the block has multiple predecessors,
|
2a. Iterate over the ANTIC expressions for the block to see if
|
2a. Iterate over the ANTIC expressions for the block to see if
|
any of them are partially redundant.
|
any of them are partially redundant.
|
2b. If so, insert them into the necessary predecessors to make
|
2b. If so, insert them into the necessary predecessors to make
|
the expression fully redundant.
|
the expression fully redundant.
|
2c. Insert a new PHI merging the values of the predecessors.
|
2c. Insert a new PHI merging the values of the predecessors.
|
2d. Insert the new PHI, and the new expressions, into the
|
2d. Insert the new PHI, and the new expressions, into the
|
NEW_SETS set.
|
NEW_SETS set.
|
3. Recursively call ourselves on the dominator children of BLOCK.
|
3. Recursively call ourselves on the dominator children of BLOCK.
|
|
|
Steps 1, 2a, and 3 are done by insert_aux. 2b, 2c and 2d are done by
|
Steps 1, 2a, and 3 are done by insert_aux. 2b, 2c and 2d are done by
|
do_regular_insertion and do_partial_insertion.
|
do_regular_insertion and do_partial_insertion.
|
|
|
*/
|
*/
|
|
|
static bool
|
static bool
|
do_regular_insertion (basic_block block, basic_block dom)
|
do_regular_insertion (basic_block block, basic_block dom)
|
{
|
{
|
bool new_stuff = false;
|
bool new_stuff = false;
|
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (ANTIC_IN (block));
|
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (ANTIC_IN (block));
|
pre_expr expr;
|
pre_expr expr;
|
int i;
|
int i;
|
|
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
{
|
{
|
if (expr->kind != NAME)
|
if (expr->kind != NAME)
|
{
|
{
|
pre_expr *avail;
|
pre_expr *avail;
|
unsigned int val;
|
unsigned int val;
|
bool by_some = false;
|
bool by_some = false;
|
bool cant_insert = false;
|
bool cant_insert = false;
|
bool all_same = true;
|
bool all_same = true;
|
pre_expr first_s = NULL;
|
pre_expr first_s = NULL;
|
edge pred;
|
edge pred;
|
basic_block bprime;
|
basic_block bprime;
|
pre_expr eprime = NULL;
|
pre_expr eprime = NULL;
|
edge_iterator ei;
|
edge_iterator ei;
|
pre_expr edoubleprime = NULL;
|
pre_expr edoubleprime = NULL;
|
bool do_insertion = false;
|
bool do_insertion = false;
|
|
|
val = get_expr_value_id (expr);
|
val = get_expr_value_id (expr);
|
if (bitmap_set_contains_value (PHI_GEN (block), val))
|
if (bitmap_set_contains_value (PHI_GEN (block), val))
|
continue;
|
continue;
|
if (bitmap_set_contains_value (AVAIL_OUT (dom), val))
|
if (bitmap_set_contains_value (AVAIL_OUT (dom), val))
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, "Found fully redundant value\n");
|
fprintf (dump_file, "Found fully redundant value\n");
|
continue;
|
continue;
|
}
|
}
|
|
|
avail = XCNEWVEC (pre_expr, last_basic_block);
|
avail = XCNEWVEC (pre_expr, last_basic_block);
|
FOR_EACH_EDGE (pred, ei, block->preds)
|
FOR_EACH_EDGE (pred, ei, block->preds)
|
{
|
{
|
unsigned int vprime;
|
unsigned int vprime;
|
|
|
/* We should never run insertion for the exit block
|
/* We should never run insertion for the exit block
|
and so not come across fake pred edges. */
|
and so not come across fake pred edges. */
|
gcc_assert (!(pred->flags & EDGE_FAKE));
|
gcc_assert (!(pred->flags & EDGE_FAKE));
|
bprime = pred->src;
|
bprime = pred->src;
|
eprime = phi_translate (expr, ANTIC_IN (block), NULL,
|
eprime = phi_translate (expr, ANTIC_IN (block), NULL,
|
bprime, block);
|
bprime, block);
|
|
|
/* eprime will generally only be NULL if the
|
/* eprime will generally only be NULL if the
|
value of the expression, translated
|
value of the expression, translated
|
through the PHI for this predecessor, is
|
through the PHI for this predecessor, is
|
undefined. If that is the case, we can't
|
undefined. If that is the case, we can't
|
make the expression fully redundant,
|
make the expression fully redundant,
|
because its value is undefined along a
|
because its value is undefined along a
|
predecessor path. We can thus break out
|
predecessor path. We can thus break out
|
early because it doesn't matter what the
|
early because it doesn't matter what the
|
rest of the results are. */
|
rest of the results are. */
|
if (eprime == NULL)
|
if (eprime == NULL)
|
{
|
{
|
cant_insert = true;
|
cant_insert = true;
|
break;
|
break;
|
}
|
}
|
|
|
eprime = fully_constant_expression (eprime);
|
eprime = fully_constant_expression (eprime);
|
vprime = get_expr_value_id (eprime);
|
vprime = get_expr_value_id (eprime);
|
edoubleprime = bitmap_find_leader (AVAIL_OUT (bprime),
|
edoubleprime = bitmap_find_leader (AVAIL_OUT (bprime),
|
vprime, NULL);
|
vprime, NULL);
|
if (edoubleprime == NULL)
|
if (edoubleprime == NULL)
|
{
|
{
|
avail[bprime->index] = eprime;
|
avail[bprime->index] = eprime;
|
all_same = false;
|
all_same = false;
|
}
|
}
|
else
|
else
|
{
|
{
|
avail[bprime->index] = edoubleprime;
|
avail[bprime->index] = edoubleprime;
|
by_some = true;
|
by_some = true;
|
/* We want to perform insertions to remove a redundancy on
|
/* We want to perform insertions to remove a redundancy on
|
a path in the CFG we want to optimize for speed. */
|
a path in the CFG we want to optimize for speed. */
|
if (optimize_edge_for_speed_p (pred))
|
if (optimize_edge_for_speed_p (pred))
|
do_insertion = true;
|
do_insertion = true;
|
if (first_s == NULL)
|
if (first_s == NULL)
|
first_s = edoubleprime;
|
first_s = edoubleprime;
|
else if (!pre_expr_eq (first_s, edoubleprime))
|
else if (!pre_expr_eq (first_s, edoubleprime))
|
all_same = false;
|
all_same = false;
|
}
|
}
|
}
|
}
|
/* If we can insert it, it's not the same value
|
/* If we can insert it, it's not the same value
|
already existing along every predecessor, and
|
already existing along every predecessor, and
|
it's defined by some predecessor, it is
|
it's defined by some predecessor, it is
|
partially redundant. */
|
partially redundant. */
|
if (!cant_insert && !all_same && by_some)
|
if (!cant_insert && !all_same && by_some)
|
{
|
{
|
if (!do_insertion)
|
if (!do_insertion)
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Skipping partial redundancy for "
|
fprintf (dump_file, "Skipping partial redundancy for "
|
"expression ");
|
"expression ");
|
print_pre_expr (dump_file, expr);
|
print_pre_expr (dump_file, expr);
|
fprintf (dump_file, " (%04d), no redundancy on to be "
|
fprintf (dump_file, " (%04d), no redundancy on to be "
|
"optimized for speed edge\n", val);
|
"optimized for speed edge\n", val);
|
}
|
}
|
}
|
}
|
else if (dbg_cnt (treepre_insert)
|
else if (dbg_cnt (treepre_insert)
|
&& insert_into_preds_of_block (block,
|
&& insert_into_preds_of_block (block,
|
get_expression_id (expr),
|
get_expression_id (expr),
|
avail))
|
avail))
|
new_stuff = true;
|
new_stuff = true;
|
}
|
}
|
/* If all edges produce the same value and that value is
|
/* If all edges produce the same value and that value is
|
an invariant, then the PHI has the same value on all
|
an invariant, then the PHI has the same value on all
|
edges. Note this. */
|
edges. Note this. */
|
else if (!cant_insert && all_same && eprime
|
else if (!cant_insert && all_same && eprime
|
&& (edoubleprime->kind == CONSTANT
|
&& (edoubleprime->kind == CONSTANT
|
|| edoubleprime->kind == NAME)
|
|| edoubleprime->kind == NAME)
|
&& !value_id_constant_p (val))
|
&& !value_id_constant_p (val))
|
{
|
{
|
unsigned int j;
|
unsigned int j;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
bitmap_set_t exprset = VEC_index (bitmap_set_t,
|
bitmap_set_t exprset = VEC_index (bitmap_set_t,
|
value_expressions, val);
|
value_expressions, val);
|
|
|
unsigned int new_val = get_expr_value_id (edoubleprime);
|
unsigned int new_val = get_expr_value_id (edoubleprime);
|
FOR_EACH_EXPR_ID_IN_SET (exprset, j, bi)
|
FOR_EACH_EXPR_ID_IN_SET (exprset, j, bi)
|
{
|
{
|
pre_expr expr = expression_for_id (j);
|
pre_expr expr = expression_for_id (j);
|
|
|
if (expr->kind == NAME)
|
if (expr->kind == NAME)
|
{
|
{
|
vn_ssa_aux_t info = VN_INFO (PRE_EXPR_NAME (expr));
|
vn_ssa_aux_t info = VN_INFO (PRE_EXPR_NAME (expr));
|
/* Just reset the value id and valnum so it is
|
/* Just reset the value id and valnum so it is
|
the same as the constant we have discovered. */
|
the same as the constant we have discovered. */
|
if (edoubleprime->kind == CONSTANT)
|
if (edoubleprime->kind == CONSTANT)
|
{
|
{
|
info->valnum = PRE_EXPR_CONSTANT (edoubleprime);
|
info->valnum = PRE_EXPR_CONSTANT (edoubleprime);
|
pre_stats.constified++;
|
pre_stats.constified++;
|
}
|
}
|
else
|
else
|
info->valnum = VN_INFO (PRE_EXPR_NAME (edoubleprime))->valnum;
|
info->valnum = VN_INFO (PRE_EXPR_NAME (edoubleprime))->valnum;
|
info->value_id = new_val;
|
info->value_id = new_val;
|
}
|
}
|
}
|
}
|
}
|
}
|
free (avail);
|
free (avail);
|
}
|
}
|
}
|
}
|
|
|
VEC_free (pre_expr, heap, exprs);
|
VEC_free (pre_expr, heap, exprs);
|
return new_stuff;
|
return new_stuff;
|
}
|
}
|
|
|
|
|
/* Perform insertion for partially anticipatable expressions. There
|
/* Perform insertion for partially anticipatable expressions. There
|
is only one case we will perform insertion for these. This case is
|
is only one case we will perform insertion for these. This case is
|
if the expression is partially anticipatable, and fully available.
|
if the expression is partially anticipatable, and fully available.
|
In this case, we know that putting it earlier will enable us to
|
In this case, we know that putting it earlier will enable us to
|
remove the later computation. */
|
remove the later computation. */
|
|
|
|
|
static bool
|
static bool
|
do_partial_partial_insertion (basic_block block, basic_block dom)
|
do_partial_partial_insertion (basic_block block, basic_block dom)
|
{
|
{
|
bool new_stuff = false;
|
bool new_stuff = false;
|
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (PA_IN (block));
|
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (PA_IN (block));
|
pre_expr expr;
|
pre_expr expr;
|
int i;
|
int i;
|
|
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
|
{
|
{
|
if (expr->kind != NAME)
|
if (expr->kind != NAME)
|
{
|
{
|
pre_expr *avail;
|
pre_expr *avail;
|
unsigned int val;
|
unsigned int val;
|
bool by_all = true;
|
bool by_all = true;
|
bool cant_insert = false;
|
bool cant_insert = false;
|
edge pred;
|
edge pred;
|
basic_block bprime;
|
basic_block bprime;
|
pre_expr eprime = NULL;
|
pre_expr eprime = NULL;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
val = get_expr_value_id (expr);
|
val = get_expr_value_id (expr);
|
if (bitmap_set_contains_value (PHI_GEN (block), val))
|
if (bitmap_set_contains_value (PHI_GEN (block), val))
|
continue;
|
continue;
|
if (bitmap_set_contains_value (AVAIL_OUT (dom), val))
|
if (bitmap_set_contains_value (AVAIL_OUT (dom), val))
|
continue;
|
continue;
|
|
|
avail = XCNEWVEC (pre_expr, last_basic_block);
|
avail = XCNEWVEC (pre_expr, last_basic_block);
|
FOR_EACH_EDGE (pred, ei, block->preds)
|
FOR_EACH_EDGE (pred, ei, block->preds)
|
{
|
{
|
unsigned int vprime;
|
unsigned int vprime;
|
pre_expr edoubleprime;
|
pre_expr edoubleprime;
|
|
|
/* We should never run insertion for the exit block
|
/* We should never run insertion for the exit block
|
and so not come across fake pred edges. */
|
and so not come across fake pred edges. */
|
gcc_assert (!(pred->flags & EDGE_FAKE));
|
gcc_assert (!(pred->flags & EDGE_FAKE));
|
bprime = pred->src;
|
bprime = pred->src;
|
eprime = phi_translate (expr, ANTIC_IN (block),
|
eprime = phi_translate (expr, ANTIC_IN (block),
|
PA_IN (block),
|
PA_IN (block),
|
bprime, block);
|
bprime, block);
|
|
|
/* eprime will generally only be NULL if the
|
/* eprime will generally only be NULL if the
|
value of the expression, translated
|
value of the expression, translated
|
through the PHI for this predecessor, is
|
through the PHI for this predecessor, is
|
undefined. If that is the case, we can't
|
undefined. If that is the case, we can't
|
make the expression fully redundant,
|
make the expression fully redundant,
|
because its value is undefined along a
|
because its value is undefined along a
|
predecessor path. We can thus break out
|
predecessor path. We can thus break out
|
early because it doesn't matter what the
|
early because it doesn't matter what the
|
rest of the results are. */
|
rest of the results are. */
|
if (eprime == NULL)
|
if (eprime == NULL)
|
{
|
{
|
cant_insert = true;
|
cant_insert = true;
|
break;
|
break;
|
}
|
}
|
|
|
eprime = fully_constant_expression (eprime);
|
eprime = fully_constant_expression (eprime);
|
vprime = get_expr_value_id (eprime);
|
vprime = get_expr_value_id (eprime);
|
edoubleprime = bitmap_find_leader (AVAIL_OUT (bprime),
|
edoubleprime = bitmap_find_leader (AVAIL_OUT (bprime),
|
vprime, NULL);
|
vprime, NULL);
|
if (edoubleprime == NULL)
|
if (edoubleprime == NULL)
|
{
|
{
|
by_all = false;
|
by_all = false;
|
break;
|
break;
|
}
|
}
|
else
|
else
|
avail[bprime->index] = edoubleprime;
|
avail[bprime->index] = edoubleprime;
|
|
|
}
|
}
|
|
|
/* If we can insert it, it's not the same value
|
/* If we can insert it, it's not the same value
|
already existing along every predecessor, and
|
already existing along every predecessor, and
|
it's defined by some predecessor, it is
|
it's defined by some predecessor, it is
|
partially redundant. */
|
partially redundant. */
|
if (!cant_insert && by_all && dbg_cnt (treepre_insert))
|
if (!cant_insert && by_all && dbg_cnt (treepre_insert))
|
{
|
{
|
pre_stats.pa_insert++;
|
pre_stats.pa_insert++;
|
if (insert_into_preds_of_block (block, get_expression_id (expr),
|
if (insert_into_preds_of_block (block, get_expression_id (expr),
|
avail))
|
avail))
|
new_stuff = true;
|
new_stuff = true;
|
}
|
}
|
free (avail);
|
free (avail);
|
}
|
}
|
}
|
}
|
|
|
VEC_free (pre_expr, heap, exprs);
|
VEC_free (pre_expr, heap, exprs);
|
return new_stuff;
|
return new_stuff;
|
}
|
}
|
|
|
static bool
|
static bool
|
insert_aux (basic_block block)
|
insert_aux (basic_block block)
|
{
|
{
|
basic_block son;
|
basic_block son;
|
bool new_stuff = false;
|
bool new_stuff = false;
|
|
|
if (block)
|
if (block)
|
{
|
{
|
basic_block dom;
|
basic_block dom;
|
dom = get_immediate_dominator (CDI_DOMINATORS, block);
|
dom = get_immediate_dominator (CDI_DOMINATORS, block);
|
if (dom)
|
if (dom)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
bitmap_set_t newset = NEW_SETS (dom);
|
bitmap_set_t newset = NEW_SETS (dom);
|
if (newset)
|
if (newset)
|
{
|
{
|
/* Note that we need to value_replace both NEW_SETS, and
|
/* Note that we need to value_replace both NEW_SETS, and
|
AVAIL_OUT. For both the case of NEW_SETS, the value may be
|
AVAIL_OUT. For both the case of NEW_SETS, the value may be
|
represented by some non-simple expression here that we want
|
represented by some non-simple expression here that we want
|
to replace it with. */
|
to replace it with. */
|
FOR_EACH_EXPR_ID_IN_SET (newset, i, bi)
|
FOR_EACH_EXPR_ID_IN_SET (newset, i, bi)
|
{
|
{
|
pre_expr expr = expression_for_id (i);
|
pre_expr expr = expression_for_id (i);
|
bitmap_value_replace_in_set (NEW_SETS (block), expr);
|
bitmap_value_replace_in_set (NEW_SETS (block), expr);
|
bitmap_value_replace_in_set (AVAIL_OUT (block), expr);
|
bitmap_value_replace_in_set (AVAIL_OUT (block), expr);
|
}
|
}
|
}
|
}
|
if (!single_pred_p (block))
|
if (!single_pred_p (block))
|
{
|
{
|
new_stuff |= do_regular_insertion (block, dom);
|
new_stuff |= do_regular_insertion (block, dom);
|
if (do_partial_partial)
|
if (do_partial_partial)
|
new_stuff |= do_partial_partial_insertion (block, dom);
|
new_stuff |= do_partial_partial_insertion (block, dom);
|
}
|
}
|
}
|
}
|
}
|
}
|
for (son = first_dom_son (CDI_DOMINATORS, block);
|
for (son = first_dom_son (CDI_DOMINATORS, block);
|
son;
|
son;
|
son = next_dom_son (CDI_DOMINATORS, son))
|
son = next_dom_son (CDI_DOMINATORS, son))
|
{
|
{
|
new_stuff |= insert_aux (son);
|
new_stuff |= insert_aux (son);
|
}
|
}
|
|
|
return new_stuff;
|
return new_stuff;
|
}
|
}
|
|
|
/* Perform insertion of partially redundant values. */
|
/* Perform insertion of partially redundant values. */
|
|
|
static void
|
static void
|
insert (void)
|
insert (void)
|
{
|
{
|
bool new_stuff = true;
|
bool new_stuff = true;
|
basic_block bb;
|
basic_block bb;
|
int num_iterations = 0;
|
int num_iterations = 0;
|
|
|
FOR_ALL_BB (bb)
|
FOR_ALL_BB (bb)
|
NEW_SETS (bb) = bitmap_set_new ();
|
NEW_SETS (bb) = bitmap_set_new ();
|
|
|
while (new_stuff)
|
while (new_stuff)
|
{
|
{
|
num_iterations++;
|
num_iterations++;
|
new_stuff = insert_aux (ENTRY_BLOCK_PTR);
|
new_stuff = insert_aux (ENTRY_BLOCK_PTR);
|
}
|
}
|
statistics_histogram_event (cfun, "insert iterations", num_iterations);
|
statistics_histogram_event (cfun, "insert iterations", num_iterations);
|
}
|
}
|
|
|
|
|
/* Add OP to EXP_GEN (block), and possibly to the maximal set. */
|
/* Add OP to EXP_GEN (block), and possibly to the maximal set. */
|
|
|
static void
|
static void
|
add_to_exp_gen (basic_block block, tree op)
|
add_to_exp_gen (basic_block block, tree op)
|
{
|
{
|
if (!in_fre)
|
if (!in_fre)
|
{
|
{
|
pre_expr result;
|
pre_expr result;
|
if (TREE_CODE (op) == SSA_NAME && ssa_undefined_value_p (op))
|
if (TREE_CODE (op) == SSA_NAME && ssa_undefined_value_p (op))
|
return;
|
return;
|
result = get_or_alloc_expr_for_name (op);
|
result = get_or_alloc_expr_for_name (op);
|
bitmap_value_insert_into_set (EXP_GEN (block), result);
|
bitmap_value_insert_into_set (EXP_GEN (block), result);
|
}
|
}
|
}
|
}
|
|
|
/* Create value ids for PHI in BLOCK. */
|
/* Create value ids for PHI in BLOCK. */
|
|
|
static void
|
static void
|
make_values_for_phi (gimple phi, basic_block block)
|
make_values_for_phi (gimple phi, basic_block block)
|
{
|
{
|
tree result = gimple_phi_result (phi);
|
tree result = gimple_phi_result (phi);
|
|
|
/* We have no need for virtual phis, as they don't represent
|
/* We have no need for virtual phis, as they don't represent
|
actual computations. */
|
actual computations. */
|
if (is_gimple_reg (result))
|
if (is_gimple_reg (result))
|
{
|
{
|
pre_expr e = get_or_alloc_expr_for_name (result);
|
pre_expr e = get_or_alloc_expr_for_name (result);
|
add_to_value (get_expr_value_id (e), e);
|
add_to_value (get_expr_value_id (e), e);
|
bitmap_insert_into_set (PHI_GEN (block), e);
|
bitmap_insert_into_set (PHI_GEN (block), e);
|
bitmap_value_insert_into_set (AVAIL_OUT (block), e);
|
bitmap_value_insert_into_set (AVAIL_OUT (block), e);
|
if (!in_fre)
|
if (!in_fre)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
for (i = 0; i < gimple_phi_num_args (phi); ++i)
|
for (i = 0; i < gimple_phi_num_args (phi); ++i)
|
{
|
{
|
tree arg = gimple_phi_arg_def (phi, i);
|
tree arg = gimple_phi_arg_def (phi, i);
|
if (TREE_CODE (arg) == SSA_NAME)
|
if (TREE_CODE (arg) == SSA_NAME)
|
{
|
{
|
e = get_or_alloc_expr_for_name (arg);
|
e = get_or_alloc_expr_for_name (arg);
|
add_to_value (get_expr_value_id (e), e);
|
add_to_value (get_expr_value_id (e), e);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Compute the AVAIL set for all basic blocks.
|
/* Compute the AVAIL set for all basic blocks.
|
|
|
This function performs value numbering of the statements in each basic
|
This function performs value numbering of the statements in each basic
|
block. The AVAIL sets are built from information we glean while doing
|
block. The AVAIL sets are built from information we glean while doing
|
this value numbering, since the AVAIL sets contain only one entry per
|
this value numbering, since the AVAIL sets contain only one entry per
|
value.
|
value.
|
|
|
AVAIL_IN[BLOCK] = AVAIL_OUT[dom(BLOCK)].
|
AVAIL_IN[BLOCK] = AVAIL_OUT[dom(BLOCK)].
|
AVAIL_OUT[BLOCK] = AVAIL_IN[BLOCK] U PHI_GEN[BLOCK] U TMP_GEN[BLOCK]. */
|
AVAIL_OUT[BLOCK] = AVAIL_IN[BLOCK] U PHI_GEN[BLOCK] U TMP_GEN[BLOCK]. */
|
|
|
static void
|
static void
|
compute_avail (void)
|
compute_avail (void)
|
{
|
{
|
|
|
basic_block block, son;
|
basic_block block, son;
|
basic_block *worklist;
|
basic_block *worklist;
|
size_t sp = 0;
|
size_t sp = 0;
|
unsigned i;
|
unsigned i;
|
|
|
/* We pretend that default definitions are defined in the entry block.
|
/* We pretend that default definitions are defined in the entry block.
|
This includes function arguments and the static chain decl. */
|
This includes function arguments and the static chain decl. */
|
for (i = 1; i < num_ssa_names; ++i)
|
for (i = 1; i < num_ssa_names; ++i)
|
{
|
{
|
tree name = ssa_name (i);
|
tree name = ssa_name (i);
|
pre_expr e;
|
pre_expr e;
|
if (!name
|
if (!name
|
|| !SSA_NAME_IS_DEFAULT_DEF (name)
|
|| !SSA_NAME_IS_DEFAULT_DEF (name)
|
|| has_zero_uses (name)
|
|| has_zero_uses (name)
|
|| !is_gimple_reg (name))
|
|| !is_gimple_reg (name))
|
continue;
|
continue;
|
|
|
e = get_or_alloc_expr_for_name (name);
|
e = get_or_alloc_expr_for_name (name);
|
add_to_value (get_expr_value_id (e), e);
|
add_to_value (get_expr_value_id (e), e);
|
if (!in_fre)
|
if (!in_fre)
|
bitmap_insert_into_set (TMP_GEN (ENTRY_BLOCK_PTR), e);
|
bitmap_insert_into_set (TMP_GEN (ENTRY_BLOCK_PTR), e);
|
bitmap_value_insert_into_set (AVAIL_OUT (ENTRY_BLOCK_PTR), e);
|
bitmap_value_insert_into_set (AVAIL_OUT (ENTRY_BLOCK_PTR), e);
|
}
|
}
|
|
|
/* Allocate the worklist. */
|
/* Allocate the worklist. */
|
worklist = XNEWVEC (basic_block, n_basic_blocks);
|
worklist = XNEWVEC (basic_block, n_basic_blocks);
|
|
|
/* Seed the algorithm by putting the dominator children of the entry
|
/* Seed the algorithm by putting the dominator children of the entry
|
block on the worklist. */
|
block on the worklist. */
|
for (son = first_dom_son (CDI_DOMINATORS, ENTRY_BLOCK_PTR);
|
for (son = first_dom_son (CDI_DOMINATORS, ENTRY_BLOCK_PTR);
|
son;
|
son;
|
son = next_dom_son (CDI_DOMINATORS, son))
|
son = next_dom_son (CDI_DOMINATORS, son))
|
worklist[sp++] = son;
|
worklist[sp++] = son;
|
|
|
/* Loop until the worklist is empty. */
|
/* Loop until the worklist is empty. */
|
while (sp)
|
while (sp)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
gimple stmt;
|
gimple stmt;
|
basic_block dom;
|
basic_block dom;
|
unsigned int stmt_uid = 1;
|
unsigned int stmt_uid = 1;
|
|
|
/* Pick a block from the worklist. */
|
/* Pick a block from the worklist. */
|
block = worklist[--sp];
|
block = worklist[--sp];
|
|
|
/* Initially, the set of available values in BLOCK is that of
|
/* Initially, the set of available values in BLOCK is that of
|
its immediate dominator. */
|
its immediate dominator. */
|
dom = get_immediate_dominator (CDI_DOMINATORS, block);
|
dom = get_immediate_dominator (CDI_DOMINATORS, block);
|
if (dom)
|
if (dom)
|
bitmap_set_copy (AVAIL_OUT (block), AVAIL_OUT (dom));
|
bitmap_set_copy (AVAIL_OUT (block), AVAIL_OUT (dom));
|
|
|
/* Generate values for PHI nodes. */
|
/* Generate values for PHI nodes. */
|
for (gsi = gsi_start_phis (block); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_phis (block); !gsi_end_p (gsi); gsi_next (&gsi))
|
make_values_for_phi (gsi_stmt (gsi), block);
|
make_values_for_phi (gsi_stmt (gsi), block);
|
|
|
BB_MAY_NOTRETURN (block) = 0;
|
BB_MAY_NOTRETURN (block) = 0;
|
|
|
/* Now compute value numbers and populate value sets with all
|
/* Now compute value numbers and populate value sets with all
|
the expressions computed in BLOCK. */
|
the expressions computed in BLOCK. */
|
for (gsi = gsi_start_bb (block); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_bb (block); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
tree op;
|
tree op;
|
|
|
stmt = gsi_stmt (gsi);
|
stmt = gsi_stmt (gsi);
|
gimple_set_uid (stmt, stmt_uid++);
|
gimple_set_uid (stmt, stmt_uid++);
|
|
|
/* Cache whether the basic-block has any non-visible side-effect
|
/* Cache whether the basic-block has any non-visible side-effect
|
or control flow.
|
or control flow.
|
If this isn't a call or it is the last stmt in the
|
If this isn't a call or it is the last stmt in the
|
basic-block then the CFG represents things correctly. */
|
basic-block then the CFG represents things correctly. */
|
if (is_gimple_call (stmt)
|
if (is_gimple_call (stmt)
|
&& !stmt_ends_bb_p (stmt))
|
&& !stmt_ends_bb_p (stmt))
|
{
|
{
|
/* Non-looping const functions always return normally.
|
/* Non-looping const functions always return normally.
|
Otherwise the call might not return or have side-effects
|
Otherwise the call might not return or have side-effects
|
that forbids hoisting possibly trapping expressions
|
that forbids hoisting possibly trapping expressions
|
before it. */
|
before it. */
|
int flags = gimple_call_flags (stmt);
|
int flags = gimple_call_flags (stmt);
|
if (!(flags & ECF_CONST)
|
if (!(flags & ECF_CONST)
|
|| (flags & ECF_LOOPING_CONST_OR_PURE))
|
|| (flags & ECF_LOOPING_CONST_OR_PURE))
|
BB_MAY_NOTRETURN (block) = 1;
|
BB_MAY_NOTRETURN (block) = 1;
|
}
|
}
|
|
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_DEF)
|
{
|
{
|
pre_expr e = get_or_alloc_expr_for_name (op);
|
pre_expr e = get_or_alloc_expr_for_name (op);
|
|
|
add_to_value (get_expr_value_id (e), e);
|
add_to_value (get_expr_value_id (e), e);
|
if (!in_fre)
|
if (!in_fre)
|
bitmap_insert_into_set (TMP_GEN (block), e);
|
bitmap_insert_into_set (TMP_GEN (block), e);
|
bitmap_value_insert_into_set (AVAIL_OUT (block), e);
|
bitmap_value_insert_into_set (AVAIL_OUT (block), e);
|
}
|
}
|
|
|
if (gimple_has_volatile_ops (stmt)
|
if (gimple_has_volatile_ops (stmt)
|
|| stmt_could_throw_p (stmt))
|
|| stmt_could_throw_p (stmt))
|
continue;
|
continue;
|
|
|
switch (gimple_code (stmt))
|
switch (gimple_code (stmt))
|
{
|
{
|
case GIMPLE_RETURN:
|
case GIMPLE_RETURN:
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
|
add_to_exp_gen (block, op);
|
add_to_exp_gen (block, op);
|
continue;
|
continue;
|
|
|
case GIMPLE_CALL:
|
case GIMPLE_CALL:
|
{
|
{
|
vn_reference_t ref;
|
vn_reference_t ref;
|
unsigned int i;
|
unsigned int i;
|
vn_reference_op_t vro;
|
vn_reference_op_t vro;
|
pre_expr result = NULL;
|
pre_expr result = NULL;
|
VEC(vn_reference_op_s, heap) *ops = NULL;
|
VEC(vn_reference_op_s, heap) *ops = NULL;
|
|
|
if (!can_value_number_call (stmt))
|
if (!can_value_number_call (stmt))
|
continue;
|
continue;
|
|
|
copy_reference_ops_from_call (stmt, &ops);
|
copy_reference_ops_from_call (stmt, &ops);
|
vn_reference_lookup_pieces (gimple_vuse (stmt), 0,
|
vn_reference_lookup_pieces (gimple_vuse (stmt), 0,
|
gimple_expr_type (stmt),
|
gimple_expr_type (stmt),
|
ops, &ref, VN_NOWALK);
|
ops, &ref, VN_NOWALK);
|
VEC_free (vn_reference_op_s, heap, ops);
|
VEC_free (vn_reference_op_s, heap, ops);
|
if (!ref)
|
if (!ref)
|
continue;
|
continue;
|
|
|
for (i = 0; VEC_iterate (vn_reference_op_s,
|
for (i = 0; VEC_iterate (vn_reference_op_s,
|
ref->operands, i,
|
ref->operands, i,
|
vro); i++)
|
vro); i++)
|
{
|
{
|
if (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME)
|
if (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME)
|
add_to_exp_gen (block, vro->op0);
|
add_to_exp_gen (block, vro->op0);
|
if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
|
if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
|
add_to_exp_gen (block, vro->op1);
|
add_to_exp_gen (block, vro->op1);
|
if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
|
if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
|
add_to_exp_gen (block, vro->op2);
|
add_to_exp_gen (block, vro->op2);
|
}
|
}
|
result = (pre_expr) pool_alloc (pre_expr_pool);
|
result = (pre_expr) pool_alloc (pre_expr_pool);
|
result->kind = REFERENCE;
|
result->kind = REFERENCE;
|
result->id = 0;
|
result->id = 0;
|
PRE_EXPR_REFERENCE (result) = ref;
|
PRE_EXPR_REFERENCE (result) = ref;
|
|
|
get_or_alloc_expression_id (result);
|
get_or_alloc_expression_id (result);
|
add_to_value (get_expr_value_id (result), result);
|
add_to_value (get_expr_value_id (result), result);
|
if (!in_fre)
|
if (!in_fre)
|
bitmap_value_insert_into_set (EXP_GEN (block), result);
|
bitmap_value_insert_into_set (EXP_GEN (block), result);
|
continue;
|
continue;
|
}
|
}
|
|
|
case GIMPLE_ASSIGN:
|
case GIMPLE_ASSIGN:
|
{
|
{
|
pre_expr result = NULL;
|
pre_expr result = NULL;
|
switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
|
switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
|
{
|
{
|
case tcc_unary:
|
case tcc_unary:
|
case tcc_binary:
|
case tcc_binary:
|
case tcc_comparison:
|
case tcc_comparison:
|
{
|
{
|
vn_nary_op_t nary;
|
vn_nary_op_t nary;
|
unsigned int i;
|
unsigned int i;
|
|
|
vn_nary_op_lookup_pieces (gimple_num_ops (stmt) - 1,
|
vn_nary_op_lookup_pieces (gimple_num_ops (stmt) - 1,
|
gimple_assign_rhs_code (stmt),
|
gimple_assign_rhs_code (stmt),
|
gimple_expr_type (stmt),
|
gimple_expr_type (stmt),
|
gimple_assign_rhs1_ptr (stmt),
|
gimple_assign_rhs1_ptr (stmt),
|
&nary);
|
&nary);
|
|
|
if (!nary)
|
if (!nary)
|
continue;
|
continue;
|
|
|
for (i = 0; i < nary->length; i++)
|
for (i = 0; i < nary->length; i++)
|
if (TREE_CODE (nary->op[i]) == SSA_NAME)
|
if (TREE_CODE (nary->op[i]) == SSA_NAME)
|
add_to_exp_gen (block, nary->op[i]);
|
add_to_exp_gen (block, nary->op[i]);
|
|
|
result = (pre_expr) pool_alloc (pre_expr_pool);
|
result = (pre_expr) pool_alloc (pre_expr_pool);
|
result->kind = NARY;
|
result->kind = NARY;
|
result->id = 0;
|
result->id = 0;
|
PRE_EXPR_NARY (result) = nary;
|
PRE_EXPR_NARY (result) = nary;
|
break;
|
break;
|
}
|
}
|
|
|
case tcc_declaration:
|
case tcc_declaration:
|
case tcc_reference:
|
case tcc_reference:
|
{
|
{
|
vn_reference_t ref;
|
vn_reference_t ref;
|
unsigned int i;
|
unsigned int i;
|
vn_reference_op_t vro;
|
vn_reference_op_t vro;
|
|
|
vn_reference_lookup (gimple_assign_rhs1 (stmt),
|
vn_reference_lookup (gimple_assign_rhs1 (stmt),
|
gimple_vuse (stmt),
|
gimple_vuse (stmt),
|
VN_WALK, &ref);
|
VN_WALK, &ref);
|
if (!ref)
|
if (!ref)
|
continue;
|
continue;
|
|
|
for (i = 0; VEC_iterate (vn_reference_op_s,
|
for (i = 0; VEC_iterate (vn_reference_op_s,
|
ref->operands, i,
|
ref->operands, i,
|
vro); i++)
|
vro); i++)
|
{
|
{
|
if (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME)
|
if (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME)
|
add_to_exp_gen (block, vro->op0);
|
add_to_exp_gen (block, vro->op0);
|
if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
|
if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
|
add_to_exp_gen (block, vro->op1);
|
add_to_exp_gen (block, vro->op1);
|
if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
|
if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
|
add_to_exp_gen (block, vro->op2);
|
add_to_exp_gen (block, vro->op2);
|
}
|
}
|
result = (pre_expr) pool_alloc (pre_expr_pool);
|
result = (pre_expr) pool_alloc (pre_expr_pool);
|
result->kind = REFERENCE;
|
result->kind = REFERENCE;
|
result->id = 0;
|
result->id = 0;
|
PRE_EXPR_REFERENCE (result) = ref;
|
PRE_EXPR_REFERENCE (result) = ref;
|
break;
|
break;
|
}
|
}
|
|
|
default:
|
default:
|
/* For any other statement that we don't
|
/* For any other statement that we don't
|
recognize, simply add all referenced
|
recognize, simply add all referenced
|
SSA_NAMEs to EXP_GEN. */
|
SSA_NAMEs to EXP_GEN. */
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
|
FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE)
|
add_to_exp_gen (block, op);
|
add_to_exp_gen (block, op);
|
continue;
|
continue;
|
}
|
}
|
|
|
get_or_alloc_expression_id (result);
|
get_or_alloc_expression_id (result);
|
add_to_value (get_expr_value_id (result), result);
|
add_to_value (get_expr_value_id (result), result);
|
if (!in_fre)
|
if (!in_fre)
|
bitmap_value_insert_into_set (EXP_GEN (block), result);
|
bitmap_value_insert_into_set (EXP_GEN (block), result);
|
|
|
continue;
|
continue;
|
}
|
}
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Put the dominator children of BLOCK on the worklist of blocks
|
/* Put the dominator children of BLOCK on the worklist of blocks
|
to compute available sets for. */
|
to compute available sets for. */
|
for (son = first_dom_son (CDI_DOMINATORS, block);
|
for (son = first_dom_son (CDI_DOMINATORS, block);
|
son;
|
son;
|
son = next_dom_son (CDI_DOMINATORS, son))
|
son = next_dom_son (CDI_DOMINATORS, son))
|
worklist[sp++] = son;
|
worklist[sp++] = son;
|
}
|
}
|
|
|
free (worklist);
|
free (worklist);
|
}
|
}
|
|
|
/* Insert the expression for SSA_VN that SCCVN thought would be simpler
|
/* Insert the expression for SSA_VN that SCCVN thought would be simpler
|
than the available expressions for it. The insertion point is
|
than the available expressions for it. The insertion point is
|
right before the first use in STMT. Returns the SSA_NAME that should
|
right before the first use in STMT. Returns the SSA_NAME that should
|
be used for replacement. */
|
be used for replacement. */
|
|
|
static tree
|
static tree
|
do_SCCVN_insertion (gimple stmt, tree ssa_vn)
|
do_SCCVN_insertion (gimple stmt, tree ssa_vn)
|
{
|
{
|
basic_block bb = gimple_bb (stmt);
|
basic_block bb = gimple_bb (stmt);
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
gimple_seq stmts = NULL;
|
gimple_seq stmts = NULL;
|
tree expr;
|
tree expr;
|
pre_expr e;
|
pre_expr e;
|
|
|
/* First create a value expression from the expression we want
|
/* First create a value expression from the expression we want
|
to insert and associate it with the value handle for SSA_VN. */
|
to insert and associate it with the value handle for SSA_VN. */
|
e = get_or_alloc_expr_for (vn_get_expr_for (ssa_vn));
|
e = get_or_alloc_expr_for (vn_get_expr_for (ssa_vn));
|
if (e == NULL)
|
if (e == NULL)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* Then use create_expression_by_pieces to generate a valid
|
/* Then use create_expression_by_pieces to generate a valid
|
expression to insert at this point of the IL stream. */
|
expression to insert at this point of the IL stream. */
|
expr = create_expression_by_pieces (bb, e, &stmts, stmt, NULL);
|
expr = create_expression_by_pieces (bb, e, &stmts, stmt, NULL);
|
if (expr == NULL_TREE)
|
if (expr == NULL_TREE)
|
return NULL_TREE;
|
return NULL_TREE;
|
gsi = gsi_for_stmt (stmt);
|
gsi = gsi_for_stmt (stmt);
|
gsi_insert_seq_before (&gsi, stmts, GSI_SAME_STMT);
|
gsi_insert_seq_before (&gsi, stmts, GSI_SAME_STMT);
|
|
|
return expr;
|
return expr;
|
}
|
}
|
|
|
/* Eliminate fully redundant computations. */
|
/* Eliminate fully redundant computations. */
|
|
|
static unsigned int
|
static unsigned int
|
eliminate (void)
|
eliminate (void)
|
{
|
{
|
VEC (gimple, heap) *to_remove = NULL;
|
VEC (gimple, heap) *to_remove = NULL;
|
VEC (gimple, heap) *to_update = NULL;
|
VEC (gimple, heap) *to_update = NULL;
|
basic_block b;
|
basic_block b;
|
unsigned int todo = 0;
|
unsigned int todo = 0;
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
gimple stmt;
|
gimple stmt;
|
unsigned i;
|
unsigned i;
|
|
|
FOR_EACH_BB (b)
|
FOR_EACH_BB (b)
|
{
|
{
|
for (gsi = gsi_start_bb (b); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start_bb (b); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
tree lhs = NULL_TREE;
|
tree lhs = NULL_TREE;
|
tree rhs = NULL_TREE;
|
tree rhs = NULL_TREE;
|
|
|
stmt = gsi_stmt (gsi);
|
stmt = gsi_stmt (gsi);
|
|
|
if (gimple_has_lhs (stmt))
|
if (gimple_has_lhs (stmt))
|
lhs = gimple_get_lhs (stmt);
|
lhs = gimple_get_lhs (stmt);
|
|
|
if (gimple_assign_single_p (stmt))
|
if (gimple_assign_single_p (stmt))
|
rhs = gimple_assign_rhs1 (stmt);
|
rhs = gimple_assign_rhs1 (stmt);
|
|
|
/* Lookup the RHS of the expression, see if we have an
|
/* Lookup the RHS of the expression, see if we have an
|
available computation for it. If so, replace the RHS with
|
available computation for it. If so, replace the RHS with
|
the available computation.
|
the available computation.
|
|
|
See PR43491.
|
See PR43491.
|
We don't replace global register variable when it is a the RHS of
|
We don't replace global register variable when it is a the RHS of
|
a single assign. We do replace local register variable since gcc
|
a single assign. We do replace local register variable since gcc
|
does not guarantee local variable will be allocated in register. */
|
does not guarantee local variable will be allocated in register. */
|
if (gimple_has_lhs (stmt)
|
if (gimple_has_lhs (stmt)
|
&& TREE_CODE (lhs) == SSA_NAME
|
&& TREE_CODE (lhs) == SSA_NAME
|
&& !gimple_assign_ssa_name_copy_p (stmt)
|
&& !gimple_assign_ssa_name_copy_p (stmt)
|
&& (!gimple_assign_single_p (stmt)
|
&& (!gimple_assign_single_p (stmt)
|
|| (!is_gimple_min_invariant (rhs)
|
|| (!is_gimple_min_invariant (rhs)
|
&& (gimple_assign_rhs_code (stmt) != VAR_DECL
|
&& (gimple_assign_rhs_code (stmt) != VAR_DECL
|
|| !is_global_var (rhs)
|
|| !is_global_var (rhs)
|
|| !DECL_HARD_REGISTER (rhs))))
|
|| !DECL_HARD_REGISTER (rhs))))
|
&& !gimple_has_volatile_ops (stmt)
|
&& !gimple_has_volatile_ops (stmt)
|
&& !has_zero_uses (lhs))
|
&& !has_zero_uses (lhs))
|
{
|
{
|
tree sprime = NULL;
|
tree sprime = NULL;
|
pre_expr lhsexpr = get_or_alloc_expr_for_name (lhs);
|
pre_expr lhsexpr = get_or_alloc_expr_for_name (lhs);
|
pre_expr sprimeexpr;
|
pre_expr sprimeexpr;
|
gimple orig_stmt = stmt;
|
gimple orig_stmt = stmt;
|
|
|
sprimeexpr = bitmap_find_leader (AVAIL_OUT (b),
|
sprimeexpr = bitmap_find_leader (AVAIL_OUT (b),
|
get_expr_value_id (lhsexpr),
|
get_expr_value_id (lhsexpr),
|
NULL);
|
NULL);
|
|
|
if (sprimeexpr)
|
if (sprimeexpr)
|
{
|
{
|
if (sprimeexpr->kind == CONSTANT)
|
if (sprimeexpr->kind == CONSTANT)
|
sprime = PRE_EXPR_CONSTANT (sprimeexpr);
|
sprime = PRE_EXPR_CONSTANT (sprimeexpr);
|
else if (sprimeexpr->kind == NAME)
|
else if (sprimeexpr->kind == NAME)
|
sprime = PRE_EXPR_NAME (sprimeexpr);
|
sprime = PRE_EXPR_NAME (sprimeexpr);
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* If there is no existing leader but SCCVN knows this
|
/* If there is no existing leader but SCCVN knows this
|
value is constant, use that constant. */
|
value is constant, use that constant. */
|
if (!sprime && is_gimple_min_invariant (VN_INFO (lhs)->valnum))
|
if (!sprime && is_gimple_min_invariant (VN_INFO (lhs)->valnum))
|
{
|
{
|
sprime = VN_INFO (lhs)->valnum;
|
sprime = VN_INFO (lhs)->valnum;
|
if (!useless_type_conversion_p (TREE_TYPE (lhs),
|
if (!useless_type_conversion_p (TREE_TYPE (lhs),
|
TREE_TYPE (sprime)))
|
TREE_TYPE (sprime)))
|
sprime = fold_convert (TREE_TYPE (lhs), sprime);
|
sprime = fold_convert (TREE_TYPE (lhs), sprime);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Replaced ");
|
fprintf (dump_file, "Replaced ");
|
print_gimple_expr (dump_file, stmt, 0, 0);
|
print_gimple_expr (dump_file, stmt, 0, 0);
|
fprintf (dump_file, " with ");
|
fprintf (dump_file, " with ");
|
print_generic_expr (dump_file, sprime, 0);
|
print_generic_expr (dump_file, sprime, 0);
|
fprintf (dump_file, " in ");
|
fprintf (dump_file, " in ");
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
}
|
}
|
pre_stats.eliminations++;
|
pre_stats.eliminations++;
|
propagate_tree_value_into_stmt (&gsi, sprime);
|
propagate_tree_value_into_stmt (&gsi, sprime);
|
stmt = gsi_stmt (gsi);
|
stmt = gsi_stmt (gsi);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
|
|
/* If we removed EH side-effects from the statement, clean
|
/* If we removed EH side-effects from the statement, clean
|
its EH information. */
|
its EH information. */
|
if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
|
if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
|
{
|
{
|
bitmap_set_bit (need_eh_cleanup,
|
bitmap_set_bit (need_eh_cleanup,
|
gimple_bb (stmt)->index);
|
gimple_bb (stmt)->index);
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, " Removed EH side-effects.\n");
|
fprintf (dump_file, " Removed EH side-effects.\n");
|
}
|
}
|
continue;
|
continue;
|
}
|
}
|
|
|
/* If there is no existing usable leader but SCCVN thinks
|
/* If there is no existing usable leader but SCCVN thinks
|
it has an expression it wants to use as replacement,
|
it has an expression it wants to use as replacement,
|
insert that. */
|
insert that. */
|
if (!sprime || sprime == lhs)
|
if (!sprime || sprime == lhs)
|
{
|
{
|
tree val = VN_INFO (lhs)->valnum;
|
tree val = VN_INFO (lhs)->valnum;
|
if (val != VN_TOP
|
if (val != VN_TOP
|
&& TREE_CODE (val) == SSA_NAME
|
&& TREE_CODE (val) == SSA_NAME
|
&& VN_INFO (val)->needs_insertion
|
&& VN_INFO (val)->needs_insertion
|
&& can_PRE_operation (vn_get_expr_for (val)))
|
&& can_PRE_operation (vn_get_expr_for (val)))
|
sprime = do_SCCVN_insertion (stmt, val);
|
sprime = do_SCCVN_insertion (stmt, val);
|
}
|
}
|
if (sprime
|
if (sprime
|
&& sprime != lhs
|
&& sprime != lhs
|
&& (rhs == NULL_TREE
|
&& (rhs == NULL_TREE
|
|| TREE_CODE (rhs) != SSA_NAME
|
|| TREE_CODE (rhs) != SSA_NAME
|
|| may_propagate_copy (rhs, sprime)))
|
|| may_propagate_copy (rhs, sprime)))
|
{
|
{
|
bool can_make_abnormal_goto
|
bool can_make_abnormal_goto
|
= is_gimple_call (stmt)
|
= is_gimple_call (stmt)
|
&& stmt_can_make_abnormal_goto (stmt);
|
&& stmt_can_make_abnormal_goto (stmt);
|
|
|
gcc_assert (sprime != rhs);
|
gcc_assert (sprime != rhs);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Replaced ");
|
fprintf (dump_file, "Replaced ");
|
print_gimple_expr (dump_file, stmt, 0, 0);
|
print_gimple_expr (dump_file, stmt, 0, 0);
|
fprintf (dump_file, " with ");
|
fprintf (dump_file, " with ");
|
print_generic_expr (dump_file, sprime, 0);
|
print_generic_expr (dump_file, sprime, 0);
|
fprintf (dump_file, " in ");
|
fprintf (dump_file, " in ");
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
}
|
}
|
|
|
if (TREE_CODE (sprime) == SSA_NAME)
|
if (TREE_CODE (sprime) == SSA_NAME)
|
gimple_set_plf (SSA_NAME_DEF_STMT (sprime),
|
gimple_set_plf (SSA_NAME_DEF_STMT (sprime),
|
NECESSARY, true);
|
NECESSARY, true);
|
/* We need to make sure the new and old types actually match,
|
/* We need to make sure the new and old types actually match,
|
which may require adding a simple cast, which fold_convert
|
which may require adding a simple cast, which fold_convert
|
will do for us. */
|
will do for us. */
|
if ((!rhs || TREE_CODE (rhs) != SSA_NAME)
|
if ((!rhs || TREE_CODE (rhs) != SSA_NAME)
|
&& !useless_type_conversion_p (gimple_expr_type (stmt),
|
&& !useless_type_conversion_p (gimple_expr_type (stmt),
|
TREE_TYPE (sprime)))
|
TREE_TYPE (sprime)))
|
sprime = fold_convert (gimple_expr_type (stmt), sprime);
|
sprime = fold_convert (gimple_expr_type (stmt), sprime);
|
|
|
pre_stats.eliminations++;
|
pre_stats.eliminations++;
|
propagate_tree_value_into_stmt (&gsi, sprime);
|
propagate_tree_value_into_stmt (&gsi, sprime);
|
stmt = gsi_stmt (gsi);
|
stmt = gsi_stmt (gsi);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
|
|
/* If we removed EH side-effects from the statement, clean
|
/* If we removed EH side-effects from the statement, clean
|
its EH information. */
|
its EH information. */
|
if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
|
if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
|
{
|
{
|
bitmap_set_bit (need_eh_cleanup,
|
bitmap_set_bit (need_eh_cleanup,
|
gimple_bb (stmt)->index);
|
gimple_bb (stmt)->index);
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, " Removed EH side-effects.\n");
|
fprintf (dump_file, " Removed EH side-effects.\n");
|
}
|
}
|
|
|
/* Likewise for AB side-effects. */
|
/* Likewise for AB side-effects. */
|
if (can_make_abnormal_goto
|
if (can_make_abnormal_goto
|
&& !stmt_can_make_abnormal_goto (stmt))
|
&& !stmt_can_make_abnormal_goto (stmt))
|
{
|
{
|
bitmap_set_bit (need_ab_cleanup,
|
bitmap_set_bit (need_ab_cleanup,
|
gimple_bb (stmt)->index);
|
gimple_bb (stmt)->index);
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, " Removed AB side-effects.\n");
|
fprintf (dump_file, " Removed AB side-effects.\n");
|
}
|
}
|
}
|
}
|
}
|
}
|
/* If the statement is a scalar store, see if the expression
|
/* If the statement is a scalar store, see if the expression
|
has the same value number as its rhs. If so, the store is
|
has the same value number as its rhs. If so, the store is
|
dead. */
|
dead. */
|
else if (gimple_assign_single_p (stmt)
|
else if (gimple_assign_single_p (stmt)
|
&& !is_gimple_reg (gimple_assign_lhs (stmt))
|
&& !is_gimple_reg (gimple_assign_lhs (stmt))
|
&& (TREE_CODE (rhs) == SSA_NAME
|
&& (TREE_CODE (rhs) == SSA_NAME
|
|| is_gimple_min_invariant (rhs)))
|
|| is_gimple_min_invariant (rhs)))
|
{
|
{
|
tree val;
|
tree val;
|
val = vn_reference_lookup (gimple_assign_lhs (stmt),
|
val = vn_reference_lookup (gimple_assign_lhs (stmt),
|
gimple_vuse (stmt), VN_WALK, NULL);
|
gimple_vuse (stmt), VN_WALK, NULL);
|
if (TREE_CODE (rhs) == SSA_NAME)
|
if (TREE_CODE (rhs) == SSA_NAME)
|
rhs = VN_INFO (rhs)->valnum;
|
rhs = VN_INFO (rhs)->valnum;
|
if (val
|
if (val
|
&& operand_equal_p (val, rhs, 0))
|
&& operand_equal_p (val, rhs, 0))
|
{
|
{
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Deleted redundant store ");
|
fprintf (dump_file, "Deleted redundant store ");
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
}
|
}
|
|
|
/* Queue stmt for removal. */
|
/* Queue stmt for removal. */
|
VEC_safe_push (gimple, heap, to_remove, stmt);
|
VEC_safe_push (gimple, heap, to_remove, stmt);
|
}
|
}
|
}
|
}
|
/* Visit COND_EXPRs and fold the comparison with the
|
/* Visit COND_EXPRs and fold the comparison with the
|
available value-numbers. */
|
available value-numbers. */
|
else if (gimple_code (stmt) == GIMPLE_COND)
|
else if (gimple_code (stmt) == GIMPLE_COND)
|
{
|
{
|
tree op0 = gimple_cond_lhs (stmt);
|
tree op0 = gimple_cond_lhs (stmt);
|
tree op1 = gimple_cond_rhs (stmt);
|
tree op1 = gimple_cond_rhs (stmt);
|
tree result;
|
tree result;
|
|
|
if (TREE_CODE (op0) == SSA_NAME)
|
if (TREE_CODE (op0) == SSA_NAME)
|
op0 = VN_INFO (op0)->valnum;
|
op0 = VN_INFO (op0)->valnum;
|
if (TREE_CODE (op1) == SSA_NAME)
|
if (TREE_CODE (op1) == SSA_NAME)
|
op1 = VN_INFO (op1)->valnum;
|
op1 = VN_INFO (op1)->valnum;
|
result = fold_binary (gimple_cond_code (stmt), boolean_type_node,
|
result = fold_binary (gimple_cond_code (stmt), boolean_type_node,
|
op0, op1);
|
op0, op1);
|
if (result && TREE_CODE (result) == INTEGER_CST)
|
if (result && TREE_CODE (result) == INTEGER_CST)
|
{
|
{
|
if (integer_zerop (result))
|
if (integer_zerop (result))
|
gimple_cond_make_false (stmt);
|
gimple_cond_make_false (stmt);
|
else
|
else
|
gimple_cond_make_true (stmt);
|
gimple_cond_make_true (stmt);
|
update_stmt (stmt);
|
update_stmt (stmt);
|
todo = TODO_cleanup_cfg;
|
todo = TODO_cleanup_cfg;
|
}
|
}
|
}
|
}
|
/* Visit indirect calls and turn them into direct calls if
|
/* Visit indirect calls and turn them into direct calls if
|
possible. */
|
possible. */
|
if (is_gimple_call (stmt))
|
if (is_gimple_call (stmt))
|
{
|
{
|
tree orig_fn = gimple_call_fn (stmt);
|
tree orig_fn = gimple_call_fn (stmt);
|
tree fn;
|
tree fn;
|
if (!orig_fn)
|
if (!orig_fn)
|
continue;
|
continue;
|
if (TREE_CODE (orig_fn) == SSA_NAME)
|
if (TREE_CODE (orig_fn) == SSA_NAME)
|
fn = VN_INFO (orig_fn)->valnum;
|
fn = VN_INFO (orig_fn)->valnum;
|
else if (TREE_CODE (orig_fn) == OBJ_TYPE_REF
|
else if (TREE_CODE (orig_fn) == OBJ_TYPE_REF
|
&& TREE_CODE (OBJ_TYPE_REF_EXPR (orig_fn)) == SSA_NAME)
|
&& TREE_CODE (OBJ_TYPE_REF_EXPR (orig_fn)) == SSA_NAME)
|
fn = VN_INFO (OBJ_TYPE_REF_EXPR (orig_fn))->valnum;
|
fn = VN_INFO (OBJ_TYPE_REF_EXPR (orig_fn))->valnum;
|
else
|
else
|
continue;
|
continue;
|
if (gimple_call_addr_fndecl (fn) != NULL_TREE
|
if (gimple_call_addr_fndecl (fn) != NULL_TREE
|
&& useless_type_conversion_p (TREE_TYPE (orig_fn),
|
&& useless_type_conversion_p (TREE_TYPE (orig_fn),
|
TREE_TYPE (fn)))
|
TREE_TYPE (fn)))
|
{
|
{
|
bool can_make_abnormal_goto
|
bool can_make_abnormal_goto
|
= stmt_can_make_abnormal_goto (stmt);
|
= stmt_can_make_abnormal_goto (stmt);
|
bool was_noreturn = gimple_call_noreturn_p (stmt);
|
bool was_noreturn = gimple_call_noreturn_p (stmt);
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Replacing call target with ");
|
fprintf (dump_file, "Replacing call target with ");
|
print_generic_expr (dump_file, fn, 0);
|
print_generic_expr (dump_file, fn, 0);
|
fprintf (dump_file, " in ");
|
fprintf (dump_file, " in ");
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
print_gimple_stmt (dump_file, stmt, 0, 0);
|
}
|
}
|
|
|
gimple_call_set_fn (stmt, fn);
|
gimple_call_set_fn (stmt, fn);
|
VEC_safe_push (gimple, heap, to_update, stmt);
|
VEC_safe_push (gimple, heap, to_update, stmt);
|
|
|
/* When changing a call into a noreturn call, cfg cleanup
|
/* When changing a call into a noreturn call, cfg cleanup
|
is needed to fix up the noreturn call. */
|
is needed to fix up the noreturn call. */
|
if (!was_noreturn && gimple_call_noreturn_p (stmt))
|
if (!was_noreturn && gimple_call_noreturn_p (stmt))
|
todo |= TODO_cleanup_cfg;
|
todo |= TODO_cleanup_cfg;
|
|
|
/* If we removed EH side-effects from the statement, clean
|
/* If we removed EH side-effects from the statement, clean
|
its EH information. */
|
its EH information. */
|
if (maybe_clean_or_replace_eh_stmt (stmt, stmt))
|
if (maybe_clean_or_replace_eh_stmt (stmt, stmt))
|
{
|
{
|
bitmap_set_bit (need_eh_cleanup,
|
bitmap_set_bit (need_eh_cleanup,
|
gimple_bb (stmt)->index);
|
gimple_bb (stmt)->index);
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, " Removed EH side-effects.\n");
|
fprintf (dump_file, " Removed EH side-effects.\n");
|
}
|
}
|
|
|
/* Likewise for AB side-effects. */
|
/* Likewise for AB side-effects. */
|
if (can_make_abnormal_goto
|
if (can_make_abnormal_goto
|
&& !stmt_can_make_abnormal_goto (stmt))
|
&& !stmt_can_make_abnormal_goto (stmt))
|
{
|
{
|
bitmap_set_bit (need_ab_cleanup,
|
bitmap_set_bit (need_ab_cleanup,
|
gimple_bb (stmt)->index);
|
gimple_bb (stmt)->index);
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
fprintf (dump_file, " Removed AB side-effects.\n");
|
fprintf (dump_file, " Removed AB side-effects.\n");
|
}
|
}
|
|
|
/* Changing an indirect call to a direct call may
|
/* Changing an indirect call to a direct call may
|
have exposed different semantics. This may
|
have exposed different semantics. This may
|
require an SSA update. */
|
require an SSA update. */
|
todo |= TODO_update_ssa_only_virtuals;
|
todo |= TODO_update_ssa_only_virtuals;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
for (gsi = gsi_start_phis (b); !gsi_end_p (gsi);)
|
for (gsi = gsi_start_phis (b); !gsi_end_p (gsi);)
|
{
|
{
|
gimple stmt, phi = gsi_stmt (gsi);
|
gimple stmt, phi = gsi_stmt (gsi);
|
tree sprime = NULL_TREE, res = PHI_RESULT (phi);
|
tree sprime = NULL_TREE, res = PHI_RESULT (phi);
|
pre_expr sprimeexpr, resexpr;
|
pre_expr sprimeexpr, resexpr;
|
gimple_stmt_iterator gsi2;
|
gimple_stmt_iterator gsi2;
|
|
|
/* We want to perform redundant PHI elimination. Do so by
|
/* We want to perform redundant PHI elimination. Do so by
|
replacing the PHI with a single copy if possible.
|
replacing the PHI with a single copy if possible.
|
Do not touch inserted, single-argument or virtual PHIs. */
|
Do not touch inserted, single-argument or virtual PHIs. */
|
if (gimple_phi_num_args (phi) == 1
|
if (gimple_phi_num_args (phi) == 1
|
|| !is_gimple_reg (res))
|
|| !is_gimple_reg (res))
|
{
|
{
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
continue;
|
continue;
|
}
|
}
|
|
|
resexpr = get_or_alloc_expr_for_name (res);
|
resexpr = get_or_alloc_expr_for_name (res);
|
sprimeexpr = bitmap_find_leader (AVAIL_OUT (b),
|
sprimeexpr = bitmap_find_leader (AVAIL_OUT (b),
|
get_expr_value_id (resexpr), NULL);
|
get_expr_value_id (resexpr), NULL);
|
if (sprimeexpr)
|
if (sprimeexpr)
|
{
|
{
|
if (sprimeexpr->kind == CONSTANT)
|
if (sprimeexpr->kind == CONSTANT)
|
sprime = PRE_EXPR_CONSTANT (sprimeexpr);
|
sprime = PRE_EXPR_CONSTANT (sprimeexpr);
|
else if (sprimeexpr->kind == NAME)
|
else if (sprimeexpr->kind == NAME)
|
sprime = PRE_EXPR_NAME (sprimeexpr);
|
sprime = PRE_EXPR_NAME (sprimeexpr);
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
if (!sprime && is_gimple_min_invariant (VN_INFO (res)->valnum))
|
if (!sprime && is_gimple_min_invariant (VN_INFO (res)->valnum))
|
{
|
{
|
sprime = VN_INFO (res)->valnum;
|
sprime = VN_INFO (res)->valnum;
|
if (!useless_type_conversion_p (TREE_TYPE (res),
|
if (!useless_type_conversion_p (TREE_TYPE (res),
|
TREE_TYPE (sprime)))
|
TREE_TYPE (sprime)))
|
sprime = fold_convert (TREE_TYPE (res), sprime);
|
sprime = fold_convert (TREE_TYPE (res), sprime);
|
}
|
}
|
if (!sprime
|
if (!sprime
|
|| sprime == res)
|
|| sprime == res)
|
{
|
{
|
gsi_next (&gsi);
|
gsi_next (&gsi);
|
continue;
|
continue;
|
}
|
}
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Replaced redundant PHI node defining ");
|
fprintf (dump_file, "Replaced redundant PHI node defining ");
|
print_generic_expr (dump_file, res, 0);
|
print_generic_expr (dump_file, res, 0);
|
fprintf (dump_file, " with ");
|
fprintf (dump_file, " with ");
|
print_generic_expr (dump_file, sprime, 0);
|
print_generic_expr (dump_file, sprime, 0);
|
fprintf (dump_file, "\n");
|
fprintf (dump_file, "\n");
|
}
|
}
|
|
|
remove_phi_node (&gsi, false);
|
remove_phi_node (&gsi, false);
|
|
|
if (!bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res))
|
if (!bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res))
|
&& TREE_CODE (sprime) == SSA_NAME)
|
&& TREE_CODE (sprime) == SSA_NAME)
|
gimple_set_plf (SSA_NAME_DEF_STMT (sprime), NECESSARY, true);
|
gimple_set_plf (SSA_NAME_DEF_STMT (sprime), NECESSARY, true);
|
|
|
if (!useless_type_conversion_p (TREE_TYPE (res), TREE_TYPE (sprime)))
|
if (!useless_type_conversion_p (TREE_TYPE (res), TREE_TYPE (sprime)))
|
sprime = fold_convert (TREE_TYPE (res), sprime);
|
sprime = fold_convert (TREE_TYPE (res), sprime);
|
stmt = gimple_build_assign (res, sprime);
|
stmt = gimple_build_assign (res, sprime);
|
SSA_NAME_DEF_STMT (res) = stmt;
|
SSA_NAME_DEF_STMT (res) = stmt;
|
gimple_set_plf (stmt, NECESSARY, gimple_plf (phi, NECESSARY));
|
gimple_set_plf (stmt, NECESSARY, gimple_plf (phi, NECESSARY));
|
|
|
gsi2 = gsi_after_labels (b);
|
gsi2 = gsi_after_labels (b);
|
gsi_insert_before (&gsi2, stmt, GSI_NEW_STMT);
|
gsi_insert_before (&gsi2, stmt, GSI_NEW_STMT);
|
/* Queue the copy for eventual removal. */
|
/* Queue the copy for eventual removal. */
|
VEC_safe_push (gimple, heap, to_remove, stmt);
|
VEC_safe_push (gimple, heap, to_remove, stmt);
|
/* If we inserted this PHI node ourself, it's not an elimination. */
|
/* If we inserted this PHI node ourself, it's not an elimination. */
|
if (bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res)))
|
if (bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (res)))
|
pre_stats.phis--;
|
pre_stats.phis--;
|
else
|
else
|
pre_stats.eliminations++;
|
pre_stats.eliminations++;
|
}
|
}
|
}
|
}
|
|
|
/* We cannot remove stmts during BB walk, especially not release SSA
|
/* We cannot remove stmts during BB walk, especially not release SSA
|
names there as this confuses the VN machinery. The stmts ending
|
names there as this confuses the VN machinery. The stmts ending
|
up in to_remove are either stores or simple copies. */
|
up in to_remove are either stores or simple copies. */
|
FOR_EACH_VEC_ELT (gimple, to_remove, i, stmt)
|
FOR_EACH_VEC_ELT (gimple, to_remove, i, stmt)
|
{
|
{
|
tree lhs = gimple_assign_lhs (stmt);
|
tree lhs = gimple_assign_lhs (stmt);
|
tree rhs = gimple_assign_rhs1 (stmt);
|
tree rhs = gimple_assign_rhs1 (stmt);
|
use_operand_p use_p;
|
use_operand_p use_p;
|
gimple use_stmt;
|
gimple use_stmt;
|
|
|
/* If there is a single use only, propagate the equivalency
|
/* If there is a single use only, propagate the equivalency
|
instead of keeping the copy. */
|
instead of keeping the copy. */
|
if (TREE_CODE (lhs) == SSA_NAME
|
if (TREE_CODE (lhs) == SSA_NAME
|
&& TREE_CODE (rhs) == SSA_NAME
|
&& TREE_CODE (rhs) == SSA_NAME
|
&& single_imm_use (lhs, &use_p, &use_stmt)
|
&& single_imm_use (lhs, &use_p, &use_stmt)
|
&& may_propagate_copy (USE_FROM_PTR (use_p), rhs))
|
&& may_propagate_copy (USE_FROM_PTR (use_p), rhs))
|
{
|
{
|
SET_USE (use_p, rhs);
|
SET_USE (use_p, rhs);
|
update_stmt (use_stmt);
|
update_stmt (use_stmt);
|
if (bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (lhs))
|
if (bitmap_bit_p (inserted_exprs, SSA_NAME_VERSION (lhs))
|
&& TREE_CODE (rhs) == SSA_NAME)
|
&& TREE_CODE (rhs) == SSA_NAME)
|
gimple_set_plf (SSA_NAME_DEF_STMT (rhs), NECESSARY, true);
|
gimple_set_plf (SSA_NAME_DEF_STMT (rhs), NECESSARY, true);
|
}
|
}
|
|
|
/* If this is a store or a now unused copy, remove it. */
|
/* If this is a store or a now unused copy, remove it. */
|
if (TREE_CODE (lhs) != SSA_NAME
|
if (TREE_CODE (lhs) != SSA_NAME
|
|| has_zero_uses (lhs))
|
|| has_zero_uses (lhs))
|
{
|
{
|
basic_block bb = gimple_bb (stmt);
|
basic_block bb = gimple_bb (stmt);
|
gsi = gsi_for_stmt (stmt);
|
gsi = gsi_for_stmt (stmt);
|
unlink_stmt_vdef (stmt);
|
unlink_stmt_vdef (stmt);
|
gsi_remove (&gsi, true);
|
gsi_remove (&gsi, true);
|
/* ??? gsi_remove doesn't tell us whether the stmt was
|
/* ??? gsi_remove doesn't tell us whether the stmt was
|
in EH tables and thus whether we need to purge EH edges.
|
in EH tables and thus whether we need to purge EH edges.
|
Simply schedule the block for a cleanup. */
|
Simply schedule the block for a cleanup. */
|
bitmap_set_bit (need_eh_cleanup, bb->index);
|
bitmap_set_bit (need_eh_cleanup, bb->index);
|
if (TREE_CODE (lhs) == SSA_NAME)
|
if (TREE_CODE (lhs) == SSA_NAME)
|
bitmap_clear_bit (inserted_exprs, SSA_NAME_VERSION (lhs));
|
bitmap_clear_bit (inserted_exprs, SSA_NAME_VERSION (lhs));
|
release_defs (stmt);
|
release_defs (stmt);
|
}
|
}
|
}
|
}
|
VEC_free (gimple, heap, to_remove);
|
VEC_free (gimple, heap, to_remove);
|
|
|
/* We cannot update call statements with virtual operands during
|
/* We cannot update call statements with virtual operands during
|
SSA walk. This might remove them which in turn makes our
|
SSA walk. This might remove them which in turn makes our
|
VN lattice invalid. */
|
VN lattice invalid. */
|
FOR_EACH_VEC_ELT (gimple, to_update, i, stmt)
|
FOR_EACH_VEC_ELT (gimple, to_update, i, stmt)
|
update_stmt (stmt);
|
update_stmt (stmt);
|
VEC_free (gimple, heap, to_update);
|
VEC_free (gimple, heap, to_update);
|
|
|
return todo;
|
return todo;
|
}
|
}
|
|
|
/* Borrow a bit of tree-ssa-dce.c for the moment.
|
/* Borrow a bit of tree-ssa-dce.c for the moment.
|
XXX: In 4.1, we should be able to just run a DCE pass after PRE, though
|
XXX: In 4.1, we should be able to just run a DCE pass after PRE, though
|
this may be a bit faster, and we may want critical edges kept split. */
|
this may be a bit faster, and we may want critical edges kept split. */
|
|
|
/* If OP's defining statement has not already been determined to be necessary,
|
/* If OP's defining statement has not already been determined to be necessary,
|
mark that statement necessary. Return the stmt, if it is newly
|
mark that statement necessary. Return the stmt, if it is newly
|
necessary. */
|
necessary. */
|
|
|
static inline gimple
|
static inline gimple
|
mark_operand_necessary (tree op)
|
mark_operand_necessary (tree op)
|
{
|
{
|
gimple stmt;
|
gimple stmt;
|
|
|
gcc_assert (op);
|
gcc_assert (op);
|
|
|
if (TREE_CODE (op) != SSA_NAME)
|
if (TREE_CODE (op) != SSA_NAME)
|
return NULL;
|
return NULL;
|
|
|
stmt = SSA_NAME_DEF_STMT (op);
|
stmt = SSA_NAME_DEF_STMT (op);
|
gcc_assert (stmt);
|
gcc_assert (stmt);
|
|
|
if (gimple_plf (stmt, NECESSARY)
|
if (gimple_plf (stmt, NECESSARY)
|
|| gimple_nop_p (stmt))
|
|| gimple_nop_p (stmt))
|
return NULL;
|
return NULL;
|
|
|
gimple_set_plf (stmt, NECESSARY, true);
|
gimple_set_plf (stmt, NECESSARY, true);
|
return stmt;
|
return stmt;
|
}
|
}
|
|
|
/* Because we don't follow exactly the standard PRE algorithm, and decide not
|
/* Because we don't follow exactly the standard PRE algorithm, and decide not
|
to insert PHI nodes sometimes, and because value numbering of casts isn't
|
to insert PHI nodes sometimes, and because value numbering of casts isn't
|
perfect, we sometimes end up inserting dead code. This simple DCE-like
|
perfect, we sometimes end up inserting dead code. This simple DCE-like
|
pass removes any insertions we made that weren't actually used. */
|
pass removes any insertions we made that weren't actually used. */
|
|
|
static void
|
static void
|
remove_dead_inserted_code (void)
|
remove_dead_inserted_code (void)
|
{
|
{
|
bitmap worklist;
|
bitmap worklist;
|
unsigned i;
|
unsigned i;
|
bitmap_iterator bi;
|
bitmap_iterator bi;
|
gimple t;
|
gimple t;
|
|
|
worklist = BITMAP_ALLOC (NULL);
|
worklist = BITMAP_ALLOC (NULL);
|
EXECUTE_IF_SET_IN_BITMAP (inserted_exprs, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (inserted_exprs, 0, i, bi)
|
{
|
{
|
t = SSA_NAME_DEF_STMT (ssa_name (i));
|
t = SSA_NAME_DEF_STMT (ssa_name (i));
|
if (gimple_plf (t, NECESSARY))
|
if (gimple_plf (t, NECESSARY))
|
bitmap_set_bit (worklist, i);
|
bitmap_set_bit (worklist, i);
|
}
|
}
|
while (!bitmap_empty_p (worklist))
|
while (!bitmap_empty_p (worklist))
|
{
|
{
|
i = bitmap_first_set_bit (worklist);
|
i = bitmap_first_set_bit (worklist);
|
bitmap_clear_bit (worklist, i);
|
bitmap_clear_bit (worklist, i);
|
t = SSA_NAME_DEF_STMT (ssa_name (i));
|
t = SSA_NAME_DEF_STMT (ssa_name (i));
|
|
|
/* PHI nodes are somewhat special in that each PHI alternative has
|
/* PHI nodes are somewhat special in that each PHI alternative has
|
data and control dependencies. All the statements feeding the
|
data and control dependencies. All the statements feeding the
|
PHI node's arguments are always necessary. */
|
PHI node's arguments are always necessary. */
|
if (gimple_code (t) == GIMPLE_PHI)
|
if (gimple_code (t) == GIMPLE_PHI)
|
{
|
{
|
unsigned k;
|
unsigned k;
|
|
|
for (k = 0; k < gimple_phi_num_args (t); k++)
|
for (k = 0; k < gimple_phi_num_args (t); k++)
|
{
|
{
|
tree arg = PHI_ARG_DEF (t, k);
|
tree arg = PHI_ARG_DEF (t, k);
|
if (TREE_CODE (arg) == SSA_NAME)
|
if (TREE_CODE (arg) == SSA_NAME)
|
{
|
{
|
gimple n = mark_operand_necessary (arg);
|
gimple n = mark_operand_necessary (arg);
|
if (n)
|
if (n)
|
bitmap_set_bit (worklist, SSA_NAME_VERSION (arg));
|
bitmap_set_bit (worklist, SSA_NAME_VERSION (arg));
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Propagate through the operands. Examine all the USE, VUSE and
|
/* Propagate through the operands. Examine all the USE, VUSE and
|
VDEF operands in this statement. Mark all the statements
|
VDEF operands in this statement. Mark all the statements
|
which feed this statement's uses as necessary. */
|
which feed this statement's uses as necessary. */
|
ssa_op_iter iter;
|
ssa_op_iter iter;
|
tree use;
|
tree use;
|
|
|
/* The operands of VDEF expressions are also needed as they
|
/* The operands of VDEF expressions are also needed as they
|
represent potential definitions that may reach this
|
represent potential definitions that may reach this
|
statement (VDEF operands allow us to follow def-def
|
statement (VDEF operands allow us to follow def-def
|
links). */
|
links). */
|
|
|
FOR_EACH_SSA_TREE_OPERAND (use, t, iter, SSA_OP_ALL_USES)
|
FOR_EACH_SSA_TREE_OPERAND (use, t, iter, SSA_OP_ALL_USES)
|
{
|
{
|
gimple n = mark_operand_necessary (use);
|
gimple n = mark_operand_necessary (use);
|
if (n)
|
if (n)
|
bitmap_set_bit (worklist, SSA_NAME_VERSION (use));
|
bitmap_set_bit (worklist, SSA_NAME_VERSION (use));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
EXECUTE_IF_SET_IN_BITMAP (inserted_exprs, 0, i, bi)
|
EXECUTE_IF_SET_IN_BITMAP (inserted_exprs, 0, i, bi)
|
{
|
{
|
t = SSA_NAME_DEF_STMT (ssa_name (i));
|
t = SSA_NAME_DEF_STMT (ssa_name (i));
|
if (!gimple_plf (t, NECESSARY))
|
if (!gimple_plf (t, NECESSARY))
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
fprintf (dump_file, "Removing unnecessary insertion:");
|
fprintf (dump_file, "Removing unnecessary insertion:");
|
print_gimple_stmt (dump_file, t, 0, 0);
|
print_gimple_stmt (dump_file, t, 0, 0);
|
}
|
}
|
|
|
gsi = gsi_for_stmt (t);
|
gsi = gsi_for_stmt (t);
|
if (gimple_code (t) == GIMPLE_PHI)
|
if (gimple_code (t) == GIMPLE_PHI)
|
remove_phi_node (&gsi, true);
|
remove_phi_node (&gsi, true);
|
else
|
else
|
{
|
{
|
gsi_remove (&gsi, true);
|
gsi_remove (&gsi, true);
|
release_defs (t);
|
release_defs (t);
|
}
|
}
|
}
|
}
|
}
|
}
|
BITMAP_FREE (worklist);
|
BITMAP_FREE (worklist);
|
}
|
}
|
|
|
/* Compute a reverse post-order in *POST_ORDER. If INCLUDE_ENTRY_EXIT is
|
/* Compute a reverse post-order in *POST_ORDER. If INCLUDE_ENTRY_EXIT is
|
true, then then ENTRY_BLOCK and EXIT_BLOCK are included. Returns
|
true, then then ENTRY_BLOCK and EXIT_BLOCK are included. Returns
|
the number of visited blocks. */
|
the number of visited blocks. */
|
|
|
static int
|
static int
|
my_rev_post_order_compute (int *post_order, bool include_entry_exit)
|
my_rev_post_order_compute (int *post_order, bool include_entry_exit)
|
{
|
{
|
edge_iterator *stack;
|
edge_iterator *stack;
|
int sp;
|
int sp;
|
int post_order_num = 0;
|
int post_order_num = 0;
|
sbitmap visited;
|
sbitmap visited;
|
|
|
if (include_entry_exit)
|
if (include_entry_exit)
|
post_order[post_order_num++] = EXIT_BLOCK;
|
post_order[post_order_num++] = EXIT_BLOCK;
|
|
|
/* Allocate stack for back-tracking up CFG. */
|
/* Allocate stack for back-tracking up CFG. */
|
stack = XNEWVEC (edge_iterator, n_basic_blocks + 1);
|
stack = XNEWVEC (edge_iterator, n_basic_blocks + 1);
|
sp = 0;
|
sp = 0;
|
|
|
/* Allocate bitmap to track nodes that have been visited. */
|
/* Allocate bitmap to track nodes that have been visited. */
|
visited = sbitmap_alloc (last_basic_block);
|
visited = sbitmap_alloc (last_basic_block);
|
|
|
/* None of the nodes in the CFG have been visited yet. */
|
/* None of the nodes in the CFG have been visited yet. */
|
sbitmap_zero (visited);
|
sbitmap_zero (visited);
|
|
|
/* Push the last edge on to the stack. */
|
/* Push the last edge on to the stack. */
|
stack[sp++] = ei_start (EXIT_BLOCK_PTR->preds);
|
stack[sp++] = ei_start (EXIT_BLOCK_PTR->preds);
|
|
|
while (sp)
|
while (sp)
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
basic_block src;
|
basic_block src;
|
basic_block dest;
|
basic_block dest;
|
|
|
/* Look at the edge on the top of the stack. */
|
/* Look at the edge on the top of the stack. */
|
ei = stack[sp - 1];
|
ei = stack[sp - 1];
|
src = ei_edge (ei)->src;
|
src = ei_edge (ei)->src;
|
dest = ei_edge (ei)->dest;
|
dest = ei_edge (ei)->dest;
|
|
|
/* Check if the edge destination has been visited yet. */
|
/* Check if the edge destination has been visited yet. */
|
if (src != ENTRY_BLOCK_PTR && ! TEST_BIT (visited, src->index))
|
if (src != ENTRY_BLOCK_PTR && ! TEST_BIT (visited, src->index))
|
{
|
{
|
/* Mark that we have visited the destination. */
|
/* Mark that we have visited the destination. */
|
SET_BIT (visited, src->index);
|
SET_BIT (visited, src->index);
|
|
|
if (EDGE_COUNT (src->preds) > 0)
|
if (EDGE_COUNT (src->preds) > 0)
|
/* Since the DEST node has been visited for the first
|
/* Since the DEST node has been visited for the first
|
time, check its successors. */
|
time, check its successors. */
|
stack[sp++] = ei_start (src->preds);
|
stack[sp++] = ei_start (src->preds);
|
else
|
else
|
post_order[post_order_num++] = src->index;
|
post_order[post_order_num++] = src->index;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (ei_one_before_end_p (ei) && dest != EXIT_BLOCK_PTR)
|
if (ei_one_before_end_p (ei) && dest != EXIT_BLOCK_PTR)
|
post_order[post_order_num++] = dest->index;
|
post_order[post_order_num++] = dest->index;
|
|
|
if (!ei_one_before_end_p (ei))
|
if (!ei_one_before_end_p (ei))
|
ei_next (&stack[sp - 1]);
|
ei_next (&stack[sp - 1]);
|
else
|
else
|
sp--;
|
sp--;
|
}
|
}
|
}
|
}
|
|
|
if (include_entry_exit)
|
if (include_entry_exit)
|
post_order[post_order_num++] = ENTRY_BLOCK;
|
post_order[post_order_num++] = ENTRY_BLOCK;
|
|
|
free (stack);
|
free (stack);
|
sbitmap_free (visited);
|
sbitmap_free (visited);
|
return post_order_num;
|
return post_order_num;
|
}
|
}
|
|
|
|
|
/* Initialize data structures used by PRE. */
|
/* Initialize data structures used by PRE. */
|
|
|
static void
|
static void
|
init_pre (bool do_fre)
|
init_pre (bool do_fre)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
next_expression_id = 1;
|
next_expression_id = 1;
|
expressions = NULL;
|
expressions = NULL;
|
VEC_safe_push (pre_expr, heap, expressions, NULL);
|
VEC_safe_push (pre_expr, heap, expressions, NULL);
|
value_expressions = VEC_alloc (bitmap_set_t, heap, get_max_value_id () + 1);
|
value_expressions = VEC_alloc (bitmap_set_t, heap, get_max_value_id () + 1);
|
VEC_safe_grow_cleared (bitmap_set_t, heap, value_expressions,
|
VEC_safe_grow_cleared (bitmap_set_t, heap, value_expressions,
|
get_max_value_id() + 1);
|
get_max_value_id() + 1);
|
name_to_id = NULL;
|
name_to_id = NULL;
|
|
|
in_fre = do_fre;
|
in_fre = do_fre;
|
|
|
inserted_exprs = BITMAP_ALLOC (NULL);
|
inserted_exprs = BITMAP_ALLOC (NULL);
|
need_creation = NULL;
|
need_creation = NULL;
|
pretemp = NULL_TREE;
|
pretemp = NULL_TREE;
|
storetemp = NULL_TREE;
|
storetemp = NULL_TREE;
|
prephitemp = NULL_TREE;
|
prephitemp = NULL_TREE;
|
|
|
connect_infinite_loops_to_exit ();
|
connect_infinite_loops_to_exit ();
|
memset (&pre_stats, 0, sizeof (pre_stats));
|
memset (&pre_stats, 0, sizeof (pre_stats));
|
|
|
|
|
postorder = XNEWVEC (int, n_basic_blocks - NUM_FIXED_BLOCKS);
|
postorder = XNEWVEC (int, n_basic_blocks - NUM_FIXED_BLOCKS);
|
my_rev_post_order_compute (postorder, false);
|
my_rev_post_order_compute (postorder, false);
|
|
|
alloc_aux_for_blocks (sizeof (struct bb_bitmap_sets));
|
alloc_aux_for_blocks (sizeof (struct bb_bitmap_sets));
|
|
|
calculate_dominance_info (CDI_POST_DOMINATORS);
|
calculate_dominance_info (CDI_POST_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
|
|
bitmap_obstack_initialize (&grand_bitmap_obstack);
|
bitmap_obstack_initialize (&grand_bitmap_obstack);
|
phi_translate_table = htab_create (5110, expr_pred_trans_hash,
|
phi_translate_table = htab_create (5110, expr_pred_trans_hash,
|
expr_pred_trans_eq, free);
|
expr_pred_trans_eq, free);
|
expression_to_id = htab_create (num_ssa_names * 3,
|
expression_to_id = htab_create (num_ssa_names * 3,
|
pre_expr_hash,
|
pre_expr_hash,
|
pre_expr_eq, NULL);
|
pre_expr_eq, NULL);
|
bitmap_set_pool = create_alloc_pool ("Bitmap sets",
|
bitmap_set_pool = create_alloc_pool ("Bitmap sets",
|
sizeof (struct bitmap_set), 30);
|
sizeof (struct bitmap_set), 30);
|
pre_expr_pool = create_alloc_pool ("pre_expr nodes",
|
pre_expr_pool = create_alloc_pool ("pre_expr nodes",
|
sizeof (struct pre_expr_d), 30);
|
sizeof (struct pre_expr_d), 30);
|
FOR_ALL_BB (bb)
|
FOR_ALL_BB (bb)
|
{
|
{
|
EXP_GEN (bb) = bitmap_set_new ();
|
EXP_GEN (bb) = bitmap_set_new ();
|
PHI_GEN (bb) = bitmap_set_new ();
|
PHI_GEN (bb) = bitmap_set_new ();
|
TMP_GEN (bb) = bitmap_set_new ();
|
TMP_GEN (bb) = bitmap_set_new ();
|
AVAIL_OUT (bb) = bitmap_set_new ();
|
AVAIL_OUT (bb) = bitmap_set_new ();
|
}
|
}
|
|
|
need_eh_cleanup = BITMAP_ALLOC (NULL);
|
need_eh_cleanup = BITMAP_ALLOC (NULL);
|
need_ab_cleanup = BITMAP_ALLOC (NULL);
|
need_ab_cleanup = BITMAP_ALLOC (NULL);
|
}
|
}
|
|
|
|
|
/* Deallocate data structures used by PRE. */
|
/* Deallocate data structures used by PRE. */
|
|
|
static void
|
static void
|
fini_pre (bool do_fre)
|
fini_pre (bool do_fre)
|
{
|
{
|
bool do_eh_cleanup = !bitmap_empty_p (need_eh_cleanup);
|
bool do_eh_cleanup = !bitmap_empty_p (need_eh_cleanup);
|
bool do_ab_cleanup = !bitmap_empty_p (need_ab_cleanup);
|
bool do_ab_cleanup = !bitmap_empty_p (need_ab_cleanup);
|
|
|
free (postorder);
|
free (postorder);
|
VEC_free (bitmap_set_t, heap, value_expressions);
|
VEC_free (bitmap_set_t, heap, value_expressions);
|
BITMAP_FREE (inserted_exprs);
|
BITMAP_FREE (inserted_exprs);
|
VEC_free (gimple, heap, need_creation);
|
VEC_free (gimple, heap, need_creation);
|
bitmap_obstack_release (&grand_bitmap_obstack);
|
bitmap_obstack_release (&grand_bitmap_obstack);
|
free_alloc_pool (bitmap_set_pool);
|
free_alloc_pool (bitmap_set_pool);
|
free_alloc_pool (pre_expr_pool);
|
free_alloc_pool (pre_expr_pool);
|
htab_delete (phi_translate_table);
|
htab_delete (phi_translate_table);
|
htab_delete (expression_to_id);
|
htab_delete (expression_to_id);
|
VEC_free (unsigned, heap, name_to_id);
|
VEC_free (unsigned, heap, name_to_id);
|
|
|
free_aux_for_blocks ();
|
free_aux_for_blocks ();
|
|
|
free_dominance_info (CDI_POST_DOMINATORS);
|
free_dominance_info (CDI_POST_DOMINATORS);
|
|
|
if (do_eh_cleanup)
|
if (do_eh_cleanup)
|
gimple_purge_all_dead_eh_edges (need_eh_cleanup);
|
gimple_purge_all_dead_eh_edges (need_eh_cleanup);
|
|
|
if (do_ab_cleanup)
|
if (do_ab_cleanup)
|
gimple_purge_all_dead_abnormal_call_edges (need_ab_cleanup);
|
gimple_purge_all_dead_abnormal_call_edges (need_ab_cleanup);
|
|
|
BITMAP_FREE (need_eh_cleanup);
|
BITMAP_FREE (need_eh_cleanup);
|
BITMAP_FREE (need_ab_cleanup);
|
BITMAP_FREE (need_ab_cleanup);
|
|
|
if (do_eh_cleanup || do_ab_cleanup)
|
if (do_eh_cleanup || do_ab_cleanup)
|
cleanup_tree_cfg ();
|
cleanup_tree_cfg ();
|
|
|
if (!do_fre)
|
if (!do_fre)
|
loop_optimizer_finalize ();
|
loop_optimizer_finalize ();
|
}
|
}
|
|
|
/* Main entry point to the SSA-PRE pass. DO_FRE is true if the caller
|
/* Main entry point to the SSA-PRE pass. DO_FRE is true if the caller
|
only wants to do full redundancy elimination. */
|
only wants to do full redundancy elimination. */
|
|
|
static unsigned int
|
static unsigned int
|
execute_pre (bool do_fre)
|
execute_pre (bool do_fre)
|
{
|
{
|
unsigned int todo = 0;
|
unsigned int todo = 0;
|
|
|
do_partial_partial = optimize > 2 && optimize_function_for_speed_p (cfun);
|
do_partial_partial = optimize > 2 && optimize_function_for_speed_p (cfun);
|
|
|
/* This has to happen before SCCVN runs because
|
/* This has to happen before SCCVN runs because
|
loop_optimizer_init may create new phis, etc. */
|
loop_optimizer_init may create new phis, etc. */
|
if (!do_fre)
|
if (!do_fre)
|
loop_optimizer_init (LOOPS_NORMAL);
|
loop_optimizer_init (LOOPS_NORMAL);
|
|
|
if (!run_scc_vn (do_fre ? VN_WALKREWRITE : VN_WALK))
|
if (!run_scc_vn (do_fre ? VN_WALKREWRITE : VN_WALK))
|
{
|
{
|
if (!do_fre)
|
if (!do_fre)
|
loop_optimizer_finalize ();
|
loop_optimizer_finalize ();
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
init_pre (do_fre);
|
init_pre (do_fre);
|
scev_initialize ();
|
scev_initialize ();
|
|
|
/* Collect and value number expressions computed in each basic block. */
|
/* Collect and value number expressions computed in each basic block. */
|
compute_avail ();
|
compute_avail ();
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
FOR_ALL_BB (bb)
|
FOR_ALL_BB (bb)
|
{
|
{
|
print_bitmap_set (dump_file, EXP_GEN (bb), "exp_gen", bb->index);
|
print_bitmap_set (dump_file, EXP_GEN (bb), "exp_gen", bb->index);
|
print_bitmap_set (dump_file, PHI_GEN (bb), "phi_gen", bb->index);
|
print_bitmap_set (dump_file, PHI_GEN (bb), "phi_gen", bb->index);
|
print_bitmap_set (dump_file, TMP_GEN (bb), "tmp_gen", bb->index);
|
print_bitmap_set (dump_file, TMP_GEN (bb), "tmp_gen", bb->index);
|
print_bitmap_set (dump_file, AVAIL_OUT (bb), "avail_out", bb->index);
|
print_bitmap_set (dump_file, AVAIL_OUT (bb), "avail_out", bb->index);
|
}
|
}
|
}
|
}
|
|
|
/* Insert can get quite slow on an incredibly large number of basic
|
/* Insert can get quite slow on an incredibly large number of basic
|
blocks due to some quadratic behavior. Until this behavior is
|
blocks due to some quadratic behavior. Until this behavior is
|
fixed, don't run it when he have an incredibly large number of
|
fixed, don't run it when he have an incredibly large number of
|
bb's. If we aren't going to run insert, there is no point in
|
bb's. If we aren't going to run insert, there is no point in
|
computing ANTIC, either, even though it's plenty fast. */
|
computing ANTIC, either, even though it's plenty fast. */
|
if (!do_fre && n_basic_blocks < 4000)
|
if (!do_fre && n_basic_blocks < 4000)
|
{
|
{
|
compute_antic ();
|
compute_antic ();
|
insert ();
|
insert ();
|
}
|
}
|
|
|
/* Make sure to remove fake edges before committing our inserts.
|
/* Make sure to remove fake edges before committing our inserts.
|
This makes sure we don't end up with extra critical edges that
|
This makes sure we don't end up with extra critical edges that
|
we would need to split. */
|
we would need to split. */
|
remove_fake_exit_edges ();
|
remove_fake_exit_edges ();
|
gsi_commit_edge_inserts ();
|
gsi_commit_edge_inserts ();
|
|
|
/* Remove all the redundant expressions. */
|
/* Remove all the redundant expressions. */
|
todo |= eliminate ();
|
todo |= eliminate ();
|
|
|
statistics_counter_event (cfun, "Insertions", pre_stats.insertions);
|
statistics_counter_event (cfun, "Insertions", pre_stats.insertions);
|
statistics_counter_event (cfun, "PA inserted", pre_stats.pa_insert);
|
statistics_counter_event (cfun, "PA inserted", pre_stats.pa_insert);
|
statistics_counter_event (cfun, "New PHIs", pre_stats.phis);
|
statistics_counter_event (cfun, "New PHIs", pre_stats.phis);
|
statistics_counter_event (cfun, "Eliminated", pre_stats.eliminations);
|
statistics_counter_event (cfun, "Eliminated", pre_stats.eliminations);
|
statistics_counter_event (cfun, "Constified", pre_stats.constified);
|
statistics_counter_event (cfun, "Constified", pre_stats.constified);
|
|
|
clear_expression_ids ();
|
clear_expression_ids ();
|
if (!do_fre)
|
if (!do_fre)
|
{
|
{
|
remove_dead_inserted_code ();
|
remove_dead_inserted_code ();
|
todo |= TODO_verify_flow;
|
todo |= TODO_verify_flow;
|
}
|
}
|
|
|
scev_finalize ();
|
scev_finalize ();
|
fini_pre (do_fre);
|
fini_pre (do_fre);
|
|
|
if (!do_fre)
|
if (!do_fre)
|
/* TODO: tail_merge_optimize may merge all predecessors of a block, in which
|
/* TODO: tail_merge_optimize may merge all predecessors of a block, in which
|
case we can merge the block with the remaining predecessor of the block.
|
case we can merge the block with the remaining predecessor of the block.
|
It should either:
|
It should either:
|
- call merge_blocks after each tail merge iteration
|
- call merge_blocks after each tail merge iteration
|
- call merge_blocks after all tail merge iterations
|
- call merge_blocks after all tail merge iterations
|
- mark TODO_cleanup_cfg when necessary
|
- mark TODO_cleanup_cfg when necessary
|
- share the cfg cleanup with fini_pre. */
|
- share the cfg cleanup with fini_pre. */
|
todo |= tail_merge_optimize (todo);
|
todo |= tail_merge_optimize (todo);
|
free_scc_vn ();
|
free_scc_vn ();
|
|
|
return todo;
|
return todo;
|
}
|
}
|
|
|
/* Gate and execute functions for PRE. */
|
/* Gate and execute functions for PRE. */
|
|
|
static unsigned int
|
static unsigned int
|
do_pre (void)
|
do_pre (void)
|
{
|
{
|
return execute_pre (false);
|
return execute_pre (false);
|
}
|
}
|
|
|
static bool
|
static bool
|
gate_pre (void)
|
gate_pre (void)
|
{
|
{
|
return flag_tree_pre != 0;
|
return flag_tree_pre != 0;
|
}
|
}
|
|
|
struct gimple_opt_pass pass_pre =
|
struct gimple_opt_pass pass_pre =
|
{
|
{
|
{
|
{
|
GIMPLE_PASS,
|
GIMPLE_PASS,
|
"pre", /* name */
|
"pre", /* name */
|
gate_pre, /* gate */
|
gate_pre, /* gate */
|
do_pre, /* execute */
|
do_pre, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_TREE_PRE, /* tv_id */
|
TV_TREE_PRE, /* tv_id */
|
PROP_no_crit_edges | PROP_cfg
|
PROP_no_crit_edges | PROP_cfg
|
| PROP_ssa, /* properties_required */
|
| PROP_ssa, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
TODO_rebuild_alias, /* todo_flags_start */
|
TODO_rebuild_alias, /* todo_flags_start */
|
TODO_update_ssa_only_virtuals | TODO_ggc_collect
|
TODO_update_ssa_only_virtuals | TODO_ggc_collect
|
| TODO_verify_ssa /* todo_flags_finish */
|
| TODO_verify_ssa /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
|
|
/* Gate and execute functions for FRE. */
|
/* Gate and execute functions for FRE. */
|
|
|
static unsigned int
|
static unsigned int
|
execute_fre (void)
|
execute_fre (void)
|
{
|
{
|
return execute_pre (true);
|
return execute_pre (true);
|
}
|
}
|
|
|
static bool
|
static bool
|
gate_fre (void)
|
gate_fre (void)
|
{
|
{
|
return flag_tree_fre != 0;
|
return flag_tree_fre != 0;
|
}
|
}
|
|
|
struct gimple_opt_pass pass_fre =
|
struct gimple_opt_pass pass_fre =
|
{
|
{
|
{
|
{
|
GIMPLE_PASS,
|
GIMPLE_PASS,
|
"fre", /* name */
|
"fre", /* name */
|
gate_fre, /* gate */
|
gate_fre, /* gate */
|
execute_fre, /* execute */
|
execute_fre, /* execute */
|
NULL, /* sub */
|
NULL, /* sub */
|
NULL, /* next */
|
NULL, /* next */
|
0, /* static_pass_number */
|
0, /* static_pass_number */
|
TV_TREE_FRE, /* tv_id */
|
TV_TREE_FRE, /* tv_id */
|
PROP_cfg | PROP_ssa, /* properties_required */
|
PROP_cfg | PROP_ssa, /* properties_required */
|
0, /* properties_provided */
|
0, /* properties_provided */
|
0, /* properties_destroyed */
|
0, /* properties_destroyed */
|
0, /* todo_flags_start */
|
0, /* todo_flags_start */
|
TODO_ggc_collect | TODO_verify_ssa /* todo_flags_finish */
|
TODO_ggc_collect | TODO_verify_ssa /* todo_flags_finish */
|
}
|
}
|
};
|
};
|
|
|
