/* Conditional constant propagation pass for the GNU compiler.
- Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
Adapted from original RTL SSA-CCP by Daniel Berlin <dberlin@dberlin.org>
Adapted to GIMPLE trees by Diego Novillo <dnovillo@redhat.com>
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
/* Conditional constant propagation (CCP) is based on the SSA
propagation engine (tree-ssa-propagate.c). Constant assignments of
with SSA names. Given an SSA name V_i, it may take one of the
following values:
- UNINITIALIZED -> This is the default starting value. V_i
- has not been processed yet.
+ UNINITIALIZED -> the initial state of the value. This value
+ is replaced with a correct initial value
+ the first time the value is used, so the
+ rest of the pass does not need to care about
+ it. Using this value simplifies initialization
+ of the pass, and prevents us from needlessly
+ scanning statements that are never reached.
UNDEFINED -> V_i is a local variable whose definition
has not been processed yet. Therefore we
We should be able to deduce that the predicate 'a.a != B' is always
false. To achieve this, we associate constant values to the SSA
- names in the V_MAY_DEF and V_MUST_DEF operands for each store.
- Additionally, since we also glob partial loads/stores with the base
- symbol, we also keep track of the memory reference where the
- constant value was stored (in the MEM_REF field of PROP_VALUE_T).
- For instance,
+ names in the VDEF operands for each store. Additionally,
+ since we also glob partial loads/stores with the base symbol, we
+ also keep track of the memory reference where the constant value
+ was stored (in the MEM_REF field of PROP_VALUE_T). For instance,
- # a_5 = V_MAY_DEF <a_4>
+ # a_5 = VDEF <a_4>
a.a = 2;
# VUSE <a_5>
it would be wrong to replace the load from 'a.b' with '2', because
'2' had been stored into a.a.
- To support STORE-CCP, it is necessary to add a new value to the
- constant propagation lattice. When evaluating a load for a memory
- reference we can no longer assume a value of UNDEFINED if we
- haven't seen a preceding store to the same memory location.
- Consider, for instance global variables:
+ Note that the initial value of virtual operands is VARYING, not
+ UNDEFINED. Consider, for instance global variables:
int A;
The value of A_2 cannot be assumed to be UNDEFINED, as it may have
been defined outside of foo. If we were to assume it UNDEFINED, we
- would erroneously optimize the above into 'return 3;'. Therefore,
- when doing STORE-CCP, we introduce a fifth lattice value
- (UNKNOWN_VAL), which overrides any other value when computing the
- meet operation in PHI nodes.
+ would erroneously optimize the above into 'return 3;'.
Though STORE-CCP is not too expensive, it does have to do more work
than regular CCP, so it is only enabled at -O2. Both regular CCP
#include "ggc.h"
#include "basic-block.h"
#include "output.h"
-#include "errors.h"
#include "expr.h"
#include "function.h"
#include "diagnostic.h"
#include "tree-pass.h"
#include "tree-ssa-propagate.h"
#include "langhooks.h"
+#include "target.h"
+#include "toplev.h"
/* Possible lattice values. */
typedef enum
{
- UNINITIALIZED = 0,
+ UNINITIALIZED,
UNDEFINED,
- UNKNOWN_VAL,
CONSTANT,
VARYING
} ccp_lattice_t;
/* Array of propagated constant values. After propagation,
CONST_VAL[I].VALUE holds the constant value for SSA_NAME(I). If
the constant is held in an SSA name representing a memory store
- (i.e., a V_MAY_DEF or V_MUST_DEF), CONST_VAL[I].MEM_REF will
- contain the actual memory reference used to store (i.e., the LHS of
- the assignment doing the store). */
-prop_value_t *const_val;
+ (i.e., a VDEF), CONST_VAL[I].MEM_REF will contain the actual
+ memory reference used to store (i.e., the LHS of the assignment
+ doing the store). */
+static prop_value_t *const_val;
/* True if we are also propagating constants in stores and loads. */
static bool do_store_ccp;
case VARYING:
fprintf (outf, "%sVARYING", prefix);
break;
- case UNKNOWN_VAL:
- fprintf (outf, "%sUNKNOWN_VAL", prefix);
- break;
case CONSTANT:
fprintf (outf, "%sCONSTANT ", prefix);
print_generic_expr (outf, val.value, dump_flags);
}
+/* The regular is_gimple_min_invariant does a shallow test of the object.
+ It assumes that full gimplification has happened, or will happen on the
+ object. For a value coming from DECL_INITIAL, this is not true, so we
+ have to be more strict ourselves. */
+
+static bool
+ccp_decl_initial_min_invariant (tree t)
+{
+ if (!is_gimple_min_invariant (t))
+ return false;
+ if (TREE_CODE (t) == ADDR_EXPR)
+ {
+ /* Inline and unroll is_gimple_addressable. */
+ while (1)
+ {
+ t = TREE_OPERAND (t, 0);
+ if (is_gimple_id (t))
+ return true;
+ if (!handled_component_p (t))
+ return false;
+ }
+ }
+ return true;
+}
+
+/* If SYM is a constant variable with known value, return the value.
+ NULL_TREE is returned otherwise. */
+
+static tree
+get_symbol_constant_value (tree sym)
+{
+ if (TREE_STATIC (sym)
+ && TREE_READONLY (sym)
+ && !MTAG_P (sym))
+ {
+ tree val = DECL_INITIAL (sym);
+ if (val
+ && ccp_decl_initial_min_invariant (val))
+ return val;
+ }
+
+ return NULL_TREE;
+}
+
/* Compute a default value for variable VAR and store it in the
CONST_VAL array. The following rules are used to get default
values:
4- Variables defined by statements other than assignments and PHI
nodes are considered VARYING.
- 5- Variables that are not GIMPLE registers are considered
- UNKNOWN_VAL, which is really a stronger version of UNDEFINED.
- It's used to avoid the short circuit evaluation implied by
- UNDEFINED in ccp_lattice_meet. */
+ 5- Initial values of variables that are not GIMPLE registers are
+ considered VARYING. */
static prop_value_t
get_default_value (tree var)
{
tree sym = SSA_NAME_VAR (var);
prop_value_t val = { UNINITIALIZED, NULL_TREE, NULL_TREE };
-
+ tree cst_val;
+
if (!do_store_ccp && !is_gimple_reg (var))
{
/* Short circuit for regular CCP. We are not interested in any
val.lattice_val = CONSTANT;
val.value = SSA_NAME_VALUE (var);
}
- else if (TREE_STATIC (sym)
- && TREE_READONLY (sym)
- && DECL_INITIAL (sym)
- && is_gimple_min_invariant (DECL_INITIAL (sym)))
+ else if ((cst_val = get_symbol_constant_value (sym)) != NULL_TREE)
{
/* Globals and static variables declared 'const' take their
initial value. */
val.lattice_val = CONSTANT;
- val.value = DECL_INITIAL (sym);
+ val.value = cst_val;
val.mem_ref = sym;
}
else
{
/* Variables defined by an empty statement are those used
before being initialized. If VAR is a local variable, we
- can assume initially that it is UNDEFINED. If we are
- doing STORE-CCP, function arguments and non-register
- variables are initially UNKNOWN_VAL, because we cannot
- discard the value incoming from outside of this function
- (see ccp_lattice_meet for details). */
+ can assume initially that it is UNDEFINED, otherwise we must
+ consider it VARYING. */
if (is_gimple_reg (sym) && TREE_CODE (sym) != PARM_DECL)
val.lattice_val = UNDEFINED;
- else if (do_store_ccp)
- val.lattice_val = UNKNOWN_VAL;
else
val.lattice_val = VARYING;
}
- else if (TREE_CODE (stmt) == MODIFY_EXPR
+ else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
|| TREE_CODE (stmt) == PHI_NODE)
{
/* Any other variable defined by an assignment or a PHI node
- is considered UNDEFINED (or UNKNOWN_VAL if VAR is not a
- GIMPLE register). */
- val.lattice_val = is_gimple_reg (sym) ? UNDEFINED : UNKNOWN_VAL;
+ is considered UNDEFINED. */
+ val.lattice_val = UNDEFINED;
}
else
{
}
-/* Get the constant value associated with variable VAR. If
- MAY_USE_DEFAULT_P is true, call get_default_value on variables that
- have the lattice value UNINITIALIZED. */
+/* Get the constant value associated with variable VAR. */
-static prop_value_t *
-get_value (tree var, bool may_use_default_p)
+static inline prop_value_t *
+get_value (tree var)
{
prop_value_t *val = &const_val[SSA_NAME_VERSION (var)];
- if (may_use_default_p && val->lattice_val == UNINITIALIZED)
+
+ if (val->lattice_val == UNINITIALIZED)
*val = get_default_value (var);
return val;
}
+/* Sets the value associated with VAR to VARYING. */
+
+static inline void
+set_value_varying (tree var)
+{
+ prop_value_t *val = &const_val[SSA_NAME_VERSION (var)];
+
+ val->lattice_val = VARYING;
+ val->value = NULL_TREE;
+ val->mem_ref = NULL_TREE;
+}
+
+/* For float types, modify the value of VAL to make ccp work correctly
+ for non-standard values (-0, NaN):
+
+ If HONOR_SIGNED_ZEROS is false, and VAL = -0, we canonicalize it to 0.
+ If HONOR_NANS is false, and VAL is NaN, we canonicalize it to UNDEFINED.
+ This is to fix the following problem (see PR 29921): Suppose we have
+
+ x = 0.0 * y
+
+ and we set value of y to NaN. This causes value of x to be set to NaN.
+ When we later determine that y is in fact VARYING, fold uses the fact
+ that HONOR_NANS is false, and we try to change the value of x to 0,
+ causing an ICE. With HONOR_NANS being false, the real appearance of
+ NaN would cause undefined behavior, though, so claiming that y (and x)
+ are UNDEFINED initially is correct. */
+
+static void
+canonicalize_float_value (prop_value_t *val)
+{
+ enum machine_mode mode;
+ tree type;
+ REAL_VALUE_TYPE d;
+
+ if (val->lattice_val != CONSTANT
+ || TREE_CODE (val->value) != REAL_CST)
+ return;
+
+ d = TREE_REAL_CST (val->value);
+ type = TREE_TYPE (val->value);
+ mode = TYPE_MODE (type);
+
+ if (!HONOR_SIGNED_ZEROS (mode)
+ && REAL_VALUE_MINUS_ZERO (d))
+ {
+ val->value = build_real (type, dconst0);
+ return;
+ }
+
+ if (!HONOR_NANS (mode)
+ && REAL_VALUE_ISNAN (d))
+ {
+ val->lattice_val = UNDEFINED;
+ val->value = NULL;
+ val->mem_ref = NULL;
+ return;
+ }
+}
/* Set the value for variable VAR to NEW_VAL. Return true if the new
value is different from VAR's previous value. */
static bool
set_lattice_value (tree var, prop_value_t new_val)
{
- prop_value_t *old_val = get_value (var, false);
+ prop_value_t *old_val = get_value (var);
+
+ canonicalize_float_value (&new_val);
/* Lattice transitions must always be monotonically increasing in
- value. We allow two exceptions:
-
- 1- If *OLD_VAL and NEW_VAL are the same, return false to
- inform the caller that this was a non-transition.
-
- 2- If we are doing store-ccp (i.e., DOING_STORE_CCP is true),
- allow CONSTANT->UNKNOWN_VAL. The UNKNOWN_VAL state is a
- special type of UNDEFINED state which prevents the short
- circuit evaluation of PHI arguments (see ccp_visit_phi_node
- and ccp_lattice_meet). */
- gcc_assert (old_val->lattice_val <= new_val.lattice_val
+ value. If *OLD_VAL and NEW_VAL are the same, return false to
+ inform the caller that this was a non-transition. */
+
+ gcc_assert (old_val->lattice_val < new_val.lattice_val
|| (old_val->lattice_val == new_val.lattice_val
- && old_val->value == new_val.value
- && old_val->mem_ref == new_val.mem_ref)
- || (do_store_ccp
- && old_val->lattice_val == CONSTANT
- && new_val.lattice_val == UNKNOWN_VAL));
+ && ((!old_val->value && !new_val.value)
+ || operand_equal_p (old_val->value, new_val.value, 0))
+ && old_val->mem_ref == new_val.mem_ref));
if (old_val->lattice_val != new_val.lattice_val)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
dump_lattice_value (dump_file, "Lattice value changed to ", new_val);
- fprintf (dump_file, ". %sdding SSA edges to worklist.\n",
- new_val.lattice_val != UNDEFINED ? "A" : "Not a");
+ fprintf (dump_file, ". Adding SSA edges to worklist.\n");
}
*old_val = new_val;
- /* Transitions UNINITIALIZED -> UNDEFINED are never interesting
- for propagation purposes. In these cases return false to
- avoid doing useless work. */
- return (new_val.lattice_val != UNDEFINED);
+ gcc_assert (new_val.lattice_val != UNDEFINED);
+ return true;
}
return false;
static ccp_lattice_t
likely_value (tree stmt)
{
- bool found_constant;
+ bool has_constant_operand;
stmt_ann_t ann;
tree use;
ssa_op_iter iter;
/* If we are not doing store-ccp, statements with loads
and/or stores will never fold into a constant. */
if (!do_store_ccp
- && (ann->makes_aliased_stores
- || ann->makes_aliased_loads
- || !ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)))
+ && !ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
return VARYING;
/* Anything other than assignments and conditional jumps are not
interesting for CCP. */
- if (TREE_CODE (stmt) != MODIFY_EXPR
+ if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT
+ && !(TREE_CODE (stmt) == RETURN_EXPR && get_rhs (stmt) != NULL_TREE)
&& TREE_CODE (stmt) != COND_EXPR
&& TREE_CODE (stmt) != SWITCH_EXPR)
return VARYING;
- found_constant = false;
- FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
+ if (is_gimple_min_invariant (get_rhs (stmt)))
+ return CONSTANT;
+
+ has_constant_operand = false;
+ FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE | SSA_OP_VUSE)
{
- prop_value_t *val = get_value (use, true);
+ prop_value_t *val = get_value (use);
- if (val->lattice_val == VARYING)
- return VARYING;
-
- if (val->lattice_val == UNKNOWN_VAL)
- {
- /* UNKNOWN_VAL is invalid when not doing STORE-CCP. */
- gcc_assert (do_store_ccp);
- return UNKNOWN_VAL;
- }
+ if (val->lattice_val == UNDEFINED)
+ return UNDEFINED;
if (val->lattice_val == CONSTANT)
- found_constant = true;
+ has_constant_operand = true;
}
- if (found_constant
- || ZERO_SSA_OPERANDS (stmt, SSA_OP_USE)
- || ZERO_SSA_OPERANDS (stmt, SSA_OP_VUSE))
+ if (has_constant_operand
+ /* We do not consider virtual operands here -- load from read-only
+ memory may have only VARYING virtual operands, but still be
+ constant. */
+ || ZERO_SSA_OPERANDS (stmt, SSA_OP_USE))
return CONSTANT;
- return UNDEFINED;
+ return VARYING;
}
+/* Returns true if STMT cannot be constant. */
+
+static bool
+surely_varying_stmt_p (tree stmt)
+{
+ /* If the statement has operands that we cannot handle, it cannot be
+ constant. */
+ if (stmt_ann (stmt)->has_volatile_ops)
+ return true;
+
+ if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
+ {
+ if (!do_store_ccp)
+ return true;
+
+ /* We can only handle simple loads and stores. */
+ if (!stmt_makes_single_load (stmt)
+ && !stmt_makes_single_store (stmt))
+ return true;
+ }
+
+ /* If it contains a call, it is varying. */
+ if (get_call_expr_in (stmt) != NULL_TREE)
+ return true;
+
+ /* Anything other than assignments and conditional jumps are not
+ interesting for CCP. */
+ if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT
+ && !(TREE_CODE (stmt) == RETURN_EXPR && get_rhs (stmt) != NULL_TREE)
+ && TREE_CODE (stmt) != COND_EXPR
+ && TREE_CODE (stmt) != SWITCH_EXPR)
+ return true;
+
+ return false;
+}
/* Initialize local data structures for CCP. */
{
basic_block bb;
- const_val = xmalloc (num_ssa_names * sizeof (*const_val));
- memset (const_val, 0, num_ssa_names * sizeof (*const_val));
+ const_val = XCNEWVEC (prop_value_t, num_ssa_names);
/* Initialize simulation flags for PHI nodes and statements. */
FOR_EACH_BB (bb)
for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
{
- bool is_varying = false;
tree stmt = bsi_stmt (i);
+ bool is_varying = surely_varying_stmt_p (stmt);
- if (likely_value (stmt) == VARYING)
-
+ if (is_varying)
{
tree def;
ssa_op_iter iter;
/* If the statement will not produce a constant, mark
all its outputs VARYING. */
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
- get_value (def, false)->lattice_val = VARYING;
-
- /* Never mark conditional jumps with DONT_SIMULATE_AGAIN,
- otherwise the propagator will never add the outgoing
- control edges. */
- if (TREE_CODE (stmt) != COND_EXPR
- && TREE_CODE (stmt) != SWITCH_EXPR)
- is_varying = true;
+ {
+ if (is_varying)
+ set_value_varying (def);
+ }
}
DONT_SIMULATE_AGAIN (stmt) = is_varying;
}
}
- /* Now process PHI nodes. */
+ /* Now process PHI nodes. We never set DONT_SIMULATE_AGAIN on phi node,
+ since we do not know which edges are executable yet, except for
+ phi nodes for virtual operands when we do not do store ccp. */
FOR_EACH_BB (bb)
{
tree phi;
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
{
- int i;
- tree arg;
- prop_value_t *val = get_value (PHI_RESULT (phi), false);
-
- for (i = 0; i < PHI_NUM_ARGS (phi); i++)
- {
- arg = PHI_ARG_DEF (phi, i);
-
- if (TREE_CODE (arg) == SSA_NAME
- && get_value (arg, false)->lattice_val == VARYING)
- {
- val->lattice_val = VARYING;
- break;
- }
- }
-
- DONT_SIMULATE_AGAIN (phi) = (val->lattice_val == VARYING);
+ if (!do_store_ccp && !is_gimple_reg (PHI_RESULT (phi)))
+ DONT_SIMULATE_AGAIN (phi) = true;
+ else
+ DONT_SIMULATE_AGAIN (phi) = false;
}
}
}
/* Do final substitution of propagated values, cleanup the flowgraph and
- free allocated storage. */
+ free allocated storage.
-static void
+ Return TRUE when something was optimized. */
+
+static bool
ccp_finalize (void)
{
/* Perform substitutions based on the known constant values. */
- substitute_and_fold (const_val);
+ bool something_changed = substitute_and_fold (const_val, false);
free (const_val);
+ return something_changed;;
}
in VAL1.
any M UNDEFINED = any
- any M UNKNOWN_VAL = UNKNOWN_VAL
any M VARYING = VARYING
Ci M Cj = Ci if (i == j)
Ci M Cj = VARYING if (i != j)
-
- Lattice values UNKNOWN_VAL and UNDEFINED are similar but have
- different semantics at PHI nodes. Both values imply that we don't
- know whether the variable is constant or not. However, UNKNOWN_VAL
- values override all others. For instance, suppose that A is a
- global variable:
-
- +------+
- | |
- | / \
- | / \
- | | A_1 = 4
- | \ /
- | \ /
- | A_3 = PHI (A_2, A_1)
- | ... = A_3
- | |
- +----+
-
- If the edge into A_2 is not executable, the first visit to A_3 will
- yield the constant 4. But the second visit to A_3 will be with A_2
- in state UNKNOWN_VAL. We can no longer conclude that A_3 is 4
- because A_2 may have been set in another function. If we had used
- the lattice value UNDEFINED, we would have had wrongly concluded
- that A_3 is 4. */
-
+ */
static void
ccp_lattice_meet (prop_value_t *val1, prop_value_t *val2)
Nothing to do. VAL1 already contains the value we want. */
;
}
- else if (val1->lattice_val == UNKNOWN_VAL
- || val2->lattice_val == UNKNOWN_VAL)
- {
- /* UNKNOWN_VAL values are invalid if we are not doing STORE-CCP. */
- gcc_assert (do_store_ccp);
-
- /* any M UNKNOWN_VAL = UNKNOWN_VAL. */
- val1->lattice_val = UNKNOWN_VAL;
- val1->value = NULL_TREE;
- val1->mem_ref = NULL_TREE;
- }
else if (val1->lattice_val == VARYING
|| val2->lattice_val == VARYING)
{
&& val2->lattice_val == CONSTANT
&& simple_cst_equal (val1->value, val2->value) == 1
&& (!do_store_ccp
- || simple_cst_equal (val1->mem_ref, val2->mem_ref) == 1))
+ || (val1->mem_ref && val2->mem_ref
+ && operand_equal_p (val1->mem_ref, val2->mem_ref, 0))))
{
/* Ci M Cj = Ci if (i == j)
Ci M Cj = VARYING if (i != j)
print_generic_expr (dump_file, phi, dump_flags);
}
- old_val = get_value (PHI_RESULT (phi), false);
+ old_val = get_value (PHI_RESULT (phi));
switch (old_val->lattice_val)
{
case VARYING:
new_val = *old_val;
break;
- case UNKNOWN_VAL:
- /* To avoid the default value of UNKNOWN_VAL overriding
- that of its possible constant arguments, temporarily
- set the PHI node's default lattice value to be
- UNDEFINED. If the PHI node's old value was UNKNOWN_VAL and
- the new value is UNDEFINED, then we prevent the invalid
- transition by not calling set_lattice_value. */
- gcc_assert (do_store_ccp);
-
- /* FALLTHRU */
-
case UNDEFINED:
- case UNINITIALIZED:
new_val.lattice_val = UNDEFINED;
new_val.value = NULL_TREE;
new_val.mem_ref = NULL_TREE;
arg_val.mem_ref = NULL_TREE;
}
else
- arg_val = *(get_value (arg, true));
+ arg_val = *(get_value (arg));
ccp_lattice_meet (&new_val, &arg_val);
fprintf (dump_file, "\n\n");
}
- /* Check for an invalid change from UNKNOWN_VAL to UNDEFINED. */
- if (do_store_ccp
- && old_val->lattice_val == UNKNOWN_VAL
- && new_val.lattice_val == UNDEFINED)
- return SSA_PROP_NOT_INTERESTING;
-
- /* Otherwise, make the transition to the new value. */
+ /* Make the transition to the new value. */
if (set_lattice_value (PHI_RESULT (phi), new_val))
{
if (new_val.lattice_val == VARYING)
{
/* If the RHS is an SSA_NAME, return its known constant value,
if any. */
- return get_value (rhs, true)->value;
+ return get_value (rhs)->value;
}
else if (do_store_ccp && stmt_makes_single_load (stmt))
{
/* If the RHS is a memory load, see if the VUSEs associated with
it are a valid constant for that memory load. */
prop_value_t *val = get_value_loaded_by (stmt, const_val);
- if (val && simple_cst_equal (val->mem_ref, rhs) == 1)
- return val->value;
- else
- return NULL_TREE;
+ if (val && val->mem_ref)
+ {
+ if (operand_equal_p (val->mem_ref, rhs, 0))
+ return val->value;
+
+ /* If RHS is extracting REALPART_EXPR or IMAGPART_EXPR of a
+ complex type with a known constant value, return it. */
+ if ((TREE_CODE (rhs) == REALPART_EXPR
+ || TREE_CODE (rhs) == IMAGPART_EXPR)
+ && operand_equal_p (val->mem_ref, TREE_OPERAND (rhs, 0), 0))
+ return fold_build1 (TREE_CODE (rhs), TREE_TYPE (rhs), val->value);
+ }
+ return NULL_TREE;
}
/* Unary operators. Note that we know the single operand must
/* Simplify the operand down to a constant. */
if (TREE_CODE (op0) == SSA_NAME)
{
- prop_value_t *val = get_value (op0, true);
+ prop_value_t *val = get_value (op0);
if (val->lattice_val == CONSTANT)
- op0 = get_value (op0, true)->value;
+ op0 = get_value (op0)->value;
}
- retval = fold_unary_to_constant (code, TREE_TYPE (rhs), op0);
-
- /* If we folded, but did not create an invariant, then we can not
- use this expression. */
- if (retval && ! is_gimple_min_invariant (retval))
- return NULL;
-
- /* If we could not fold the expression, but the arguments are all
- constants and gimple values, then build and return the new
- expression.
-
- In some cases the new expression is still something we can
- use as a replacement for an argument. This happens with
- NOP conversions of types for example.
-
- In other cases the new expression can not be used as a
- replacement for an argument (as it would create non-gimple
- code). But the new expression can still be used to derive
- other constants. */
- if (! retval && is_gimple_min_invariant (op0))
- return build1 (code, TREE_TYPE (rhs), op0);
+ if ((code == NOP_EXPR || code == CONVERT_EXPR)
+ && tree_ssa_useless_type_conversion_1 (TREE_TYPE (rhs),
+ TREE_TYPE (op0)))
+ return op0;
+ return fold_unary (code, TREE_TYPE (rhs), op0);
}
/* Binary and comparison operators. We know one or both of the
/* Simplify the operands down to constants when appropriate. */
if (TREE_CODE (op0) == SSA_NAME)
{
- prop_value_t *val = get_value (op0, true);
+ prop_value_t *val = get_value (op0);
if (val->lattice_val == CONSTANT)
op0 = val->value;
}
if (TREE_CODE (op1) == SSA_NAME)
{
- prop_value_t *val = get_value (op1, true);
+ prop_value_t *val = get_value (op1);
if (val->lattice_val == CONSTANT)
op1 = val->value;
}
- retval = fold_binary_to_constant (code, TREE_TYPE (rhs), op0, op1);
-
- /* If we folded, but did not create an invariant, then we can not
- use this expression. */
- if (retval && ! is_gimple_min_invariant (retval))
- return NULL;
-
- /* If we could not fold the expression, but the arguments are all
- constants and gimple values, then build and return the new
- expression.
-
- In some cases the new expression is still something we can
- use as a replacement for an argument. This happens with
- NOP conversions of types for example.
-
- In other cases the new expression can not be used as a
- replacement for an argument (as it would create non-gimple
- code). But the new expression can still be used to derive
- other constants. */
- if (! retval
- && is_gimple_min_invariant (op0)
- && is_gimple_min_invariant (op1))
- return build (code, TREE_TYPE (rhs), op0, op1);
+ return fold_binary (code, TREE_TYPE (rhs), op0, op1);
}
/* We may be able to fold away calls to builtin functions if their
arguments are constants. */
else if (code == CALL_EXPR
- && TREE_CODE (TREE_OPERAND (rhs, 0)) == ADDR_EXPR
- && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0))
- == FUNCTION_DECL)
- && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0)))
+ && TREE_CODE (CALL_EXPR_FN (rhs)) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (CALL_EXPR_FN (rhs), 0)) == FUNCTION_DECL
+ && DECL_BUILT_IN (TREE_OPERAND (CALL_EXPR_FN (rhs), 0)))
{
if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_USE))
{
tree *orig, var;
- tree fndecl, arglist;
size_t i = 0;
ssa_op_iter iter;
use_operand_p var_p;
/* Preserve the original values of every operand. */
- orig = xmalloc (sizeof (tree) * NUM_SSA_OPERANDS (stmt, SSA_OP_USE));
+ orig = XNEWVEC (tree, NUM_SSA_OPERANDS (stmt, SSA_OP_USE));
FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_USE)
orig[i++] = var;
/* Substitute operands with their values and try to fold. */
replace_uses_in (stmt, NULL, const_val);
- fndecl = get_callee_fndecl (rhs);
- arglist = TREE_OPERAND (rhs, 1);
- retval = fold_builtin (fndecl, arglist, false);
+ retval = fold_call_expr (rhs, false);
/* Restore operands to their original form. */
i = 0;
}
+/* Return the tree representing the element referenced by T if T is an
+ ARRAY_REF or COMPONENT_REF into constant aggregates. Return
+ NULL_TREE otherwise. */
+
+static tree
+fold_const_aggregate_ref (tree t)
+{
+ prop_value_t *value;
+ tree base, ctor, idx, field;
+ unsigned HOST_WIDE_INT cnt;
+ tree cfield, cval;
+
+ switch (TREE_CODE (t))
+ {
+ case ARRAY_REF:
+ /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
+ DECL_INITIAL. If BASE is a nested reference into another
+ ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
+ the inner reference. */
+ base = TREE_OPERAND (t, 0);
+ switch (TREE_CODE (base))
+ {
+ case VAR_DECL:
+ if (!TREE_READONLY (base)
+ || TREE_CODE (TREE_TYPE (base)) != ARRAY_TYPE
+ || !targetm.binds_local_p (base))
+ return NULL_TREE;
+
+ ctor = DECL_INITIAL (base);
+ break;
+
+ case ARRAY_REF:
+ case COMPONENT_REF:
+ ctor = fold_const_aggregate_ref (base);
+ break;
+
+ default:
+ return NULL_TREE;
+ }
+
+ if (ctor == NULL_TREE
+ || (TREE_CODE (ctor) != CONSTRUCTOR
+ && TREE_CODE (ctor) != STRING_CST)
+ || !TREE_STATIC (ctor))
+ return NULL_TREE;
+
+ /* Get the index. If we have an SSA_NAME, try to resolve it
+ with the current lattice value for the SSA_NAME. */
+ idx = TREE_OPERAND (t, 1);
+ switch (TREE_CODE (idx))
+ {
+ case SSA_NAME:
+ if ((value = get_value (idx))
+ && value->lattice_val == CONSTANT
+ && TREE_CODE (value->value) == INTEGER_CST)
+ idx = value->value;
+ else
+ return NULL_TREE;
+ break;
+
+ case INTEGER_CST:
+ break;
+
+ default:
+ return NULL_TREE;
+ }
+
+ /* Fold read from constant string. */
+ if (TREE_CODE (ctor) == STRING_CST)
+ {
+ if ((TYPE_MODE (TREE_TYPE (t))
+ == TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
+ && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor))))
+ == MODE_INT)
+ && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor)))) == 1
+ && compare_tree_int (idx, TREE_STRING_LENGTH (ctor)) < 0)
+ return build_int_cst (TREE_TYPE (t), (TREE_STRING_POINTER (ctor)
+ [TREE_INT_CST_LOW (idx)]));
+ return NULL_TREE;
+ }
+
+ /* Whoo-hoo! I'll fold ya baby. Yeah! */
+ FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
+ if (tree_int_cst_equal (cfield, idx))
+ return cval;
+ break;
+
+ case COMPONENT_REF:
+ /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
+ DECL_INITIAL. If BASE is a nested reference into another
+ ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
+ the inner reference. */
+ base = TREE_OPERAND (t, 0);
+ switch (TREE_CODE (base))
+ {
+ case VAR_DECL:
+ if (!TREE_READONLY (base)
+ || TREE_CODE (TREE_TYPE (base)) != RECORD_TYPE
+ || !targetm.binds_local_p (base))
+ return NULL_TREE;
+
+ ctor = DECL_INITIAL (base);
+ break;
+
+ case ARRAY_REF:
+ case COMPONENT_REF:
+ ctor = fold_const_aggregate_ref (base);
+ break;
+
+ default:
+ return NULL_TREE;
+ }
+
+ if (ctor == NULL_TREE
+ || TREE_CODE (ctor) != CONSTRUCTOR
+ || !TREE_STATIC (ctor))
+ return NULL_TREE;
+
+ field = TREE_OPERAND (t, 1);
+
+ FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
+ if (cfield == field
+ /* FIXME: Handle bit-fields. */
+ && ! DECL_BIT_FIELD (cfield))
+ return cval;
+ break;
+
+ case REALPART_EXPR:
+ case IMAGPART_EXPR:
+ {
+ tree c = fold_const_aggregate_ref (TREE_OPERAND (t, 0));
+ if (c && TREE_CODE (c) == COMPLEX_CST)
+ return fold_build1 (TREE_CODE (t), TREE_TYPE (t), c);
+ break;
+ }
+
+ default:
+ break;
+ }
+
+ return NULL_TREE;
+}
+
/* Evaluate statement STMT. */
static prop_value_t
evaluate_stmt (tree stmt)
{
prop_value_t val;
- tree simplified;
+ tree simplified = NULL_TREE;
ccp_lattice_t likelyvalue = likely_value (stmt);
+ bool is_constant;
val.mem_ref = NULL_TREE;
+ fold_defer_overflow_warnings ();
+
/* If the statement is likely to have a CONSTANT result, then try
to fold the statement to determine the constant value. */
if (likelyvalue == CONSTANT)
simplified = ccp_fold (stmt);
/* If the statement is likely to have a VARYING result, then do not
bother folding the statement. */
- else if (likelyvalue == VARYING)
+ if (likelyvalue == VARYING)
simplified = get_rhs (stmt);
- /* Otherwise the statement is likely to have an UNDEFINED value and
- there will be nothing to do. */
- else
- simplified = NULL_TREE;
+ /* If the statement is an ARRAY_REF or COMPONENT_REF into constant
+ aggregates, extract the referenced constant. Otherwise the
+ statement is likely to have an UNDEFINED value, and there will be
+ nothing to do. Note that fold_const_aggregate_ref returns
+ NULL_TREE if the first case does not match. */
+ else if (!simplified)
+ simplified = fold_const_aggregate_ref (get_rhs (stmt));
+
+ is_constant = simplified && is_gimple_min_invariant (simplified);
- if (simplified && is_gimple_min_invariant (simplified))
+ fold_undefer_overflow_warnings (is_constant, stmt, 0);
+
+ if (is_constant)
{
/* The statement produced a constant value. */
val.lattice_val = CONSTANT;
/* The statement produced a nonconstant value. If the statement
had UNDEFINED operands, then the result of the statement
should be UNDEFINED. Otherwise, the statement is VARYING. */
- val.lattice_val = (likelyvalue == UNDEFINED) ? UNDEFINED : VARYING;
+ if (likelyvalue == UNDEFINED)
+ val.lattice_val = likelyvalue;
+ else
+ val.lattice_val = VARYING;
+
val.value = NULL_TREE;
}
tree lhs, rhs;
enum ssa_prop_result retval;
- lhs = TREE_OPERAND (stmt, 0);
- rhs = TREE_OPERAND (stmt, 1);
+ lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+ rhs = GIMPLE_STMT_OPERAND (stmt, 1);
if (TREE_CODE (rhs) == SSA_NAME)
{
/* For a simple copy operation, we copy the lattice values. */
- prop_value_t *nval = get_value (rhs, true);
+ prop_value_t *nval = get_value (rhs);
val = *nval;
}
else if (do_store_ccp && stmt_makes_single_load (stmt))
{
/* Same as above, but the RHS is not a gimple register and yet
- has a known VUSE. If STMT is loading from the same memory
+ has a known VUSE. If STMT is loading from the same memory
location that created the SSA_NAMEs for the virtual operands,
we can propagate the value on the RHS. */
prop_value_t *nval = get_value_loaded_by (stmt, const_val);
- if (nval && simple_cst_equal (nval->mem_ref, rhs) == 1)
+ if (nval
+ && nval->mem_ref
+ && operand_equal_p (nval->mem_ref, rhs, 0))
val = *nval;
else
val = evaluate_stmt (stmt);
the constant value into the type of the destination variable. This
should not be necessary if GCC represented bitfields properly. */
{
- tree orig_lhs = TREE_OPERAND (stmt, 0);
+ tree orig_lhs = GIMPLE_STMT_OPERAND (stmt, 0);
if (TREE_CODE (orig_lhs) == VIEW_CONVERT_EXPR
&& val.lattice_val == CONSTANT)
{
- tree w = fold (build1 (VIEW_CONVERT_EXPR,
- TREE_TYPE (TREE_OPERAND (orig_lhs, 0)),
- val.value));
+ tree w = fold_unary (VIEW_CONVERT_EXPR,
+ TREE_TYPE (TREE_OPERAND (orig_lhs, 0)),
+ val.value);
orig_lhs = TREE_OPERAND (orig_lhs, 0);
if (w && is_gimple_min_invariant (w))
}
else if (do_store_ccp && stmt_makes_single_store (stmt))
{
- /* Otherwise, set the names in V_MAY_DEF/V_MUST_DEF operands
- to the new constant value and mark the LHS as the memory
- reference associated with VAL. */
+ /* Otherwise, set the names in VDEF operands to the new
+ constant value and mark the LHS as the memory reference
+ associated with VAL. */
ssa_op_iter i;
tree vdef;
bool changed;
- /* Stores cannot take on an UNDEFINED value. */
- if (val.lattice_val == UNDEFINED)
- val.lattice_val = UNKNOWN_VAL;
-
/* Mark VAL as stored in the LHS of this assignment. */
- val.mem_ref = lhs;
+ if (val.lattice_val == CONSTANT)
+ val.mem_ref = lhs;
/* Set the value of every VDEF to VAL. */
changed = false;
FOR_EACH_SSA_TREE_OPERAND (vdef, stmt, i, SSA_OP_VIRTUAL_DEFS)
- changed |= set_lattice_value (vdef, val);
+ {
+ /* See PR 29801. We may have VDEFs for read-only variables
+ (see the handling of unmodifiable variables in
+ add_virtual_operand); do not attempt to change their value. */
+ if (get_symbol_constant_value (SSA_NAME_VAR (vdef)) != NULL_TREE)
+ continue;
+
+ changed |= set_lattice_value (vdef, val);
+ }
/* Note that for propagation purposes, we are only interested in
visiting statements that load the exact same memory reference
fprintf (dump_file, "\n");
}
- if (TREE_CODE (stmt) == MODIFY_EXPR)
+ if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
{
/* If the statement is an assignment that produces a single
output value, evaluate its RHS to see if the lattice value of
/* Main entry point for SSA Conditional Constant Propagation. */
-static void
+static unsigned int
execute_ssa_ccp (bool store_ccp)
{
do_store_ccp = store_ccp;
ccp_initialize ();
ssa_propagate (ccp_visit_stmt, ccp_visit_phi_node);
- ccp_finalize ();
+ if (ccp_finalize ())
+ return (TODO_cleanup_cfg | TODO_update_ssa | TODO_remove_unused_locals);
+ else
+ return 0;
}
-static void
+static unsigned int
do_ssa_ccp (void)
{
- execute_ssa_ccp (false);
+ return execute_ssa_ccp (false);
}
NULL, /* next */
0, /* static_pass_number */
TV_TREE_CCP, /* tv_id */
- PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
+ PROP_cfg | PROP_ssa, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_cleanup_cfg | TODO_dump_func | TODO_update_ssa
- | TODO_ggc_collect | TODO_verify_ssa
- | TODO_verify_stmts, /* todo_flags_finish */
+ TODO_dump_func | TODO_verify_ssa
+ | TODO_verify_stmts | TODO_ggc_collect,/* todo_flags_finish */
0 /* letter */
};
-static void
+static unsigned int
do_ssa_store_ccp (void)
{
/* If STORE-CCP is not enabled, we just run regular CCP. */
- execute_ssa_ccp (flag_tree_store_ccp != 0);
+ return execute_ssa_ccp (flag_tree_store_ccp != 0);
}
static bool
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_dump_func | TODO_update_ssa
- | TODO_ggc_collect | TODO_verify_ssa
- | TODO_cleanup_cfg
- | TODO_verify_stmts, /* todo_flags_finish */
+ TODO_dump_func | TODO_verify_ssa
+ | TODO_verify_stmts | TODO_ggc_collect,/* todo_flags_finish */
0 /* letter */
};
for (i = 0, mask = 0; i < field_size; i++)
mask |= ((HOST_WIDE_INT) 1) << i;
- wide_val = build2 (BIT_AND_EXPR, TREE_TYPE (var), val,
- build_int_cst (TREE_TYPE (var), mask));
+ wide_val = fold_build2 (BIT_AND_EXPR, TREE_TYPE (var), val,
+ build_int_cst (TREE_TYPE (var), mask));
}
else
{
for (i = 0, mask = 0; i < (var_size - field_size); i++)
mask |= ((HOST_WIDE_INT) 1) << (var_size - i - 1);
- wide_val = build2 (BIT_IOR_EXPR, TREE_TYPE (var), val,
- build_int_cst (TREE_TYPE (var), mask));
+ wide_val = fold_build2 (BIT_IOR_EXPR, TREE_TYPE (var), val,
+ build_int_cst (TREE_TYPE (var), mask));
}
- return fold (wide_val);
+ return wide_val;
}
|| lrem || hrem)
return NULL_TREE;
- idx = build_int_cst_wide (NULL_TREE, lquo, hquo);
+ idx = build_int_cst_wide (TREE_TYPE (offset), lquo, hquo);
}
/* Assume the low bound is zero. If there is a domain type, get the
if (!integer_zerop (elt_offset))
idx = int_const_binop (PLUS_EXPR, idx, elt_offset, 0);
- return build (ARRAY_REF, orig_type, base, idx, min_idx,
- size_int (tree_low_cst (elt_size, 1)
- / (TYPE_ALIGN_UNIT (elt_type))));
+ return build4 (ARRAY_REF, orig_type, base, idx, NULL_TREE, NULL_TREE);
}
is the desired result type. */
/* ??? This doesn't handle class inheritance. */
-static tree
+tree
maybe_fold_offset_to_component_ref (tree record_type, tree base, tree offset,
tree orig_type, bool base_is_ptr)
{
tree f, t, field_type, tail_array_field, field_offset;
+ tree ret;
+ tree new_base;
if (TREE_CODE (record_type) != RECORD_TYPE
&& TREE_CODE (record_type) != UNION_TYPE
{
if (base_is_ptr)
base = build1 (INDIRECT_REF, record_type, base);
- t = build (COMPONENT_REF, field_type, base, f, NULL_TREE);
+ t = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
return t;
}
/* If we matched, then set offset to the displacement into
this field. */
- offset = t;
- goto found;
+ if (base_is_ptr)
+ new_base = build1 (INDIRECT_REF, record_type, base);
+ else
+ new_base = base;
+ new_base = build3 (COMPONENT_REF, field_type, new_base, f, NULL_TREE);
+
+ /* Recurse to possibly find the match. */
+ ret = maybe_fold_offset_to_array_ref (new_base, t, orig_type);
+ if (ret)
+ return ret;
+ ret = maybe_fold_offset_to_component_ref (field_type, new_base, t,
+ orig_type, false);
+ if (ret)
+ return ret;
}
if (!tail_array_field)
field_type = TREE_TYPE (f);
offset = int_const_binop (MINUS_EXPR, offset, byte_position (f), 1);
- found:
/* If we get here, we've got an aggregate field, and a possibly
nonzero offset into them. Recurse and hope for a valid match. */
if (base_is_ptr)
base = build1 (INDIRECT_REF, record_type, base);
- base = build (COMPONENT_REF, field_type, base, f, NULL_TREE);
+ base = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
t = maybe_fold_offset_to_array_ref (base, offset, orig_type);
if (t)
substitutions. Fold that down to one. Remove NON_LVALUE_EXPRs that
are sometimes added. */
base = fold (base);
- STRIP_NOPS (base);
+ STRIP_TYPE_NOPS (base);
TREE_OPERAND (expr, 0) = base;
/* One possibility is that the address reduces to a string constant. */
/* Fold away CONST_DECL to its value, if the type is scalar. */
if (TREE_CODE (base) == CONST_DECL
- && is_gimple_min_invariant (DECL_INITIAL (base)))
+ && ccp_decl_initial_min_invariant (DECL_INITIAL (base)))
return DECL_INITIAL (base);
/* Try folding *(&B+O) to B[X]. */
if (TREE_CODE (min_idx) != INTEGER_CST)
break;
- array_idx = convert (TREE_TYPE (min_idx), array_idx);
+ array_idx = fold_convert (TREE_TYPE (min_idx), array_idx);
if (!integer_zerop (min_idx))
array_idx = int_const_binop (MINUS_EXPR, array_idx,
min_idx, 0);
}
/* Convert the index to a byte offset. */
- array_idx = convert (sizetype, array_idx);
+ array_idx = fold_convert (sizetype, array_idx);
array_idx = int_const_binop (MULT_EXPR, array_idx, elt_size, 0);
/* Update the operands for the next round, or for folding. */
{
if (TYPE_UNSIGNED (TREE_TYPE (op1)))
return NULL;
- op1 = fold (build1 (NEGATE_EXPR, TREE_TYPE (op1), op1));
+ op1 = fold_unary (NEGATE_EXPR, TREE_TYPE (op1), op1);
/* ??? In theory fold should always produce another integer. */
- if (TREE_CODE (op1) != INTEGER_CST)
+ if (op1 == NULL || TREE_CODE (op1) != INTEGER_CST)
return NULL;
}
return t;
}
+/* For passing state through walk_tree into fold_stmt_r and its
+ children. */
+
+struct fold_stmt_r_data
+{
+ tree stmt;
+ bool *changed_p;
+ bool *inside_addr_expr_p;
+};
/* Subroutine of fold_stmt called via walk_tree. We perform several
simplifications of EXPR_P, mostly having to do with pointer arithmetic. */
static tree
fold_stmt_r (tree *expr_p, int *walk_subtrees, void *data)
{
- bool *changed_p = data;
+ struct fold_stmt_r_data *fold_stmt_r_data = (struct fold_stmt_r_data *) data;
+ bool *inside_addr_expr_p = fold_stmt_r_data->inside_addr_expr_p;
+ bool *changed_p = fold_stmt_r_data->changed_p;
tree expr = *expr_p, t;
/* ??? It'd be nice if walk_tree had a pre-order option. */
integer_zero_node);
break;
- /* ??? Could handle ARRAY_REF here, as a variant of INDIRECT_REF.
+ /* ??? Could handle more ARRAY_REFs here, as a variant of INDIRECT_REF.
We'd only want to bother decomposing an existing ARRAY_REF if
the base array is found to have another offset contained within.
Otherwise we'd be wasting time. */
+ case ARRAY_REF:
+ /* If we are not processing expressions found within an
+ ADDR_EXPR, then we can fold constant array references. */
+ if (!*inside_addr_expr_p)
+ t = fold_read_from_constant_string (expr);
+ else
+ t = NULL;
+ break;
case ADDR_EXPR:
+ *inside_addr_expr_p = true;
t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
+ *inside_addr_expr_p = false;
if (t)
return t;
*walk_subtrees = 0;
/* Set TREE_INVARIANT properly so that the value is properly
considered constant, and so gets propagated as expected. */
if (*changed_p)
- recompute_tree_invarant_for_addr_expr (expr);
+ recompute_tree_invariant_for_addr_expr (expr);
return NULL_TREE;
case PLUS_EXPR:
}
break;
+ case TARGET_MEM_REF:
+ t = maybe_fold_tmr (expr);
+ break;
+
+ case COND_EXPR:
+ if (COMPARISON_CLASS_P (TREE_OPERAND (expr, 0)))
+ {
+ tree op0 = TREE_OPERAND (expr, 0);
+ tree tem;
+ bool set;
+
+ fold_defer_overflow_warnings ();
+ tem = fold_binary (TREE_CODE (op0), TREE_TYPE (op0),
+ TREE_OPERAND (op0, 0),
+ TREE_OPERAND (op0, 1));
+ set = tem && set_rhs (expr_p, tem);
+ fold_undefer_overflow_warnings (set, fold_stmt_r_data->stmt, 0);
+ if (set)
+ {
+ t = *expr_p;
+ break;
+ }
+ }
+ return NULL_TREE;
+
default:
return NULL_TREE;
}
}
-/* Return the string length of ARG in LENGTH. If ARG is an SSA name variable,
- follow its use-def chains. If LENGTH is not NULL and its value is not
- equal to the length we determine, or if we are unable to determine the
- length, return false. VISITED is a bitmap of visited variables. */
+/* Return the string length, maximum string length or maximum value of
+ ARG in LENGTH.
+ If ARG is an SSA name variable, follow its use-def chains. If LENGTH
+ is not NULL and, for TYPE == 0, its value is not equal to the length
+ we determine or if we are unable to determine the length or value,
+ return false. VISITED is a bitmap of visited variables.
+ TYPE is 0 if string length should be returned, 1 for maximum string
+ length and 2 for maximum value ARG can have. */
static bool
-get_strlen (tree arg, tree *length, bitmap visited)
+get_maxval_strlen (tree arg, tree *length, bitmap visited, int type)
{
tree var, def_stmt, val;
if (TREE_CODE (arg) != SSA_NAME)
{
- val = c_strlen (arg, 1);
+ if (TREE_CODE (arg) == COND_EXPR)
+ return get_maxval_strlen (COND_EXPR_THEN (arg), length, visited, type)
+ && get_maxval_strlen (COND_EXPR_ELSE (arg), length, visited, type);
+
+ if (type == 2)
+ {
+ val = arg;
+ if (TREE_CODE (val) != INTEGER_CST
+ || tree_int_cst_sgn (val) < 0)
+ return false;
+ }
+ else
+ val = c_strlen (arg, 1);
if (!val)
return false;
- if (*length && simple_cst_equal (val, *length) != 1)
- return false;
+ if (*length)
+ {
+ if (type > 0)
+ {
+ if (TREE_CODE (*length) != INTEGER_CST
+ || TREE_CODE (val) != INTEGER_CST)
+ return false;
+
+ if (tree_int_cst_lt (*length, val))
+ *length = val;
+ return true;
+ }
+ else if (simple_cst_equal (val, *length) != 1)
+ return false;
+ }
*length = val;
return true;
switch (TREE_CODE (def_stmt))
{
- case MODIFY_EXPR:
+ case GIMPLE_MODIFY_STMT:
{
- tree len, rhs;
-
+ tree rhs;
+
/* The RHS of the statement defining VAR must either have a
constant length or come from another SSA_NAME with a constant
length. */
- rhs = TREE_OPERAND (def_stmt, 1);
+ rhs = GIMPLE_STMT_OPERAND (def_stmt, 1);
STRIP_NOPS (rhs);
- if (TREE_CODE (rhs) == SSA_NAME)
- return get_strlen (rhs, length, visited);
-
- /* See if the RHS is a constant length. */
- len = c_strlen (rhs, 1);
- if (len)
- {
- if (*length && simple_cst_equal (len, *length) != 1)
- return false;
-
- *length = len;
- return true;
- }
-
- break;
+ return get_maxval_strlen (rhs, length, visited, type);
}
case PHI_NODE:
if (arg == PHI_RESULT (def_stmt))
continue;
- if (!get_strlen (arg, length, visited))
+ if (!get_maxval_strlen (arg, length, visited, type))
return false;
}
static tree
ccp_fold_builtin (tree stmt, tree fn)
{
- tree result, strlen_val[2];
- tree callee, arglist, a;
- int strlen_arg, i;
+ tree result, val[3];
+ tree callee, a;
+ int arg_mask, i, type;
bitmap visited;
bool ignore;
+ call_expr_arg_iterator iter;
+ int nargs;
- ignore = TREE_CODE (stmt) != MODIFY_EXPR;
+ ignore = TREE_CODE (stmt) != GIMPLE_MODIFY_STMT;
/* First try the generic builtin folder. If that succeeds, return the
result directly. */
- callee = get_callee_fndecl (fn);
- arglist = TREE_OPERAND (fn, 1);
- result = fold_builtin (callee, arglist, ignore);
+ result = fold_call_expr (fn, ignore);
if (result)
- {
- if (ignore)
- STRIP_NOPS (result);
- return result;
- }
+ {
+ if (ignore)
+ STRIP_NOPS (result);
+ return result;
+ }
/* Ignore MD builtins. */
+ callee = get_callee_fndecl (fn);
if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_MD)
return NULL_TREE;
/* If the builtin could not be folded, and it has no argument list,
we're done. */
- if (!arglist)
+ nargs = call_expr_nargs (fn);
+ if (nargs == 0)
return NULL_TREE;
/* Limit the work only for builtins we know how to simplify. */
case BUILT_IN_STRLEN:
case BUILT_IN_FPUTS:
case BUILT_IN_FPUTS_UNLOCKED:
- strlen_arg = 1;
+ arg_mask = 1;
+ type = 0;
break;
case BUILT_IN_STRCPY:
case BUILT_IN_STRNCPY:
- strlen_arg = 2;
+ arg_mask = 2;
+ type = 0;
+ break;
+ case BUILT_IN_MEMCPY_CHK:
+ case BUILT_IN_MEMPCPY_CHK:
+ case BUILT_IN_MEMMOVE_CHK:
+ case BUILT_IN_MEMSET_CHK:
+ case BUILT_IN_STRNCPY_CHK:
+ arg_mask = 4;
+ type = 2;
+ break;
+ case BUILT_IN_STRCPY_CHK:
+ case BUILT_IN_STPCPY_CHK:
+ arg_mask = 2;
+ type = 1;
+ break;
+ case BUILT_IN_SNPRINTF_CHK:
+ case BUILT_IN_VSNPRINTF_CHK:
+ arg_mask = 2;
+ type = 2;
break;
default:
return NULL_TREE;
/* Try to use the dataflow information gathered by the CCP process. */
visited = BITMAP_ALLOC (NULL);
- memset (strlen_val, 0, sizeof (strlen_val));
- for (i = 0, a = arglist;
- strlen_arg;
- i++, strlen_arg >>= 1, a = TREE_CHAIN (a))
- if (strlen_arg & 1)
- {
- bitmap_clear (visited);
- if (!get_strlen (TREE_VALUE (a), &strlen_val[i], visited))
- strlen_val[i] = NULL_TREE;
- }
+ memset (val, 0, sizeof (val));
+ init_call_expr_arg_iterator (fn, &iter);
+ for (i = 0; arg_mask; i++, arg_mask >>= 1)
+ {
+ a = next_call_expr_arg (&iter);
+ if (arg_mask & 1)
+ {
+ bitmap_clear (visited);
+ if (!get_maxval_strlen (a, &val[i], visited, type))
+ val[i] = NULL_TREE;
+ }
+ }
BITMAP_FREE (visited);
switch (DECL_FUNCTION_CODE (callee))
{
case BUILT_IN_STRLEN:
- if (strlen_val[0])
+ if (val[0])
{
- tree new = fold_convert (TREE_TYPE (fn), strlen_val[0]);
+ tree new = fold_convert (TREE_TYPE (fn), val[0]);
/* If the result is not a valid gimple value, or not a cast
of a valid gimple value, then we can not use the result. */
break;
case BUILT_IN_STRCPY:
- if (strlen_val[1] && is_gimple_val (strlen_val[1]))
- {
- tree fndecl = get_callee_fndecl (fn);
- tree arglist = TREE_OPERAND (fn, 1);
- result = fold_builtin_strcpy (fndecl, arglist, strlen_val[1]);
- }
+ if (val[1] && is_gimple_val (val[1]) && nargs == 2)
+ result = fold_builtin_strcpy (callee,
+ CALL_EXPR_ARG (fn, 0),
+ CALL_EXPR_ARG (fn, 1),
+ val[1]);
break;
case BUILT_IN_STRNCPY:
- if (strlen_val[1] && is_gimple_val (strlen_val[1]))
- {
- tree fndecl = get_callee_fndecl (fn);
- tree arglist = TREE_OPERAND (fn, 1);
- result = fold_builtin_strncpy (fndecl, arglist, strlen_val[1]);
- }
+ if (val[1] && is_gimple_val (val[1]) && nargs == 3)
+ result = fold_builtin_strncpy (callee,
+ CALL_EXPR_ARG (fn, 0),
+ CALL_EXPR_ARG (fn, 1),
+ CALL_EXPR_ARG (fn, 2),
+ val[1]);
break;
case BUILT_IN_FPUTS:
- result = fold_builtin_fputs (arglist,
- TREE_CODE (stmt) != MODIFY_EXPR, 0,
- strlen_val[0]);
+ result = fold_builtin_fputs (CALL_EXPR_ARG (fn, 0),
+ CALL_EXPR_ARG (fn, 1),
+ TREE_CODE (stmt) != GIMPLE_MODIFY_STMT, 0,
+ val[0]);
break;
case BUILT_IN_FPUTS_UNLOCKED:
- result = fold_builtin_fputs (arglist,
- TREE_CODE (stmt) != MODIFY_EXPR, 1,
- strlen_val[0]);
+ result = fold_builtin_fputs (CALL_EXPR_ARG (fn, 0),
+ CALL_EXPR_ARG (fn, 1),
+ TREE_CODE (stmt) != GIMPLE_MODIFY_STMT, 1,
+ val[0]);
+ break;
+
+ case BUILT_IN_MEMCPY_CHK:
+ case BUILT_IN_MEMPCPY_CHK:
+ case BUILT_IN_MEMMOVE_CHK:
+ case BUILT_IN_MEMSET_CHK:
+ if (val[2] && is_gimple_val (val[2]))
+ result = fold_builtin_memory_chk (callee,
+ CALL_EXPR_ARG (fn, 0),
+ CALL_EXPR_ARG (fn, 1),
+ CALL_EXPR_ARG (fn, 2),
+ CALL_EXPR_ARG (fn, 3),
+ val[2], ignore,
+ DECL_FUNCTION_CODE (callee));
+ break;
+
+ case BUILT_IN_STRCPY_CHK:
+ case BUILT_IN_STPCPY_CHK:
+ if (val[1] && is_gimple_val (val[1]))
+ result = fold_builtin_stxcpy_chk (callee,
+ CALL_EXPR_ARG (fn, 0),
+ CALL_EXPR_ARG (fn, 1),
+ CALL_EXPR_ARG (fn, 2),
+ val[1], ignore,
+ DECL_FUNCTION_CODE (callee));
+ break;
+
+ case BUILT_IN_STRNCPY_CHK:
+ if (val[2] && is_gimple_val (val[2]))
+ result = fold_builtin_strncpy_chk (CALL_EXPR_ARG (fn, 0),
+ CALL_EXPR_ARG (fn, 1),
+ CALL_EXPR_ARG (fn, 2),
+ CALL_EXPR_ARG (fn, 3),
+ val[2]);
+ break;
+
+ case BUILT_IN_SNPRINTF_CHK:
+ case BUILT_IN_VSNPRINTF_CHK:
+ if (val[1] && is_gimple_val (val[1]))
+ result = fold_builtin_snprintf_chk (fn, val[1],
+ DECL_FUNCTION_CODE (callee));
break;
default:
}
-/* Fold the statement pointed by STMT_P. In some cases, this function may
+/* Fold the statement pointed to by STMT_P. In some cases, this function may
replace the whole statement with a new one. Returns true iff folding
makes any changes. */
fold_stmt (tree *stmt_p)
{
tree rhs, result, stmt;
+ struct fold_stmt_r_data fold_stmt_r_data;
bool changed = false;
+ bool inside_addr_expr = false;
stmt = *stmt_p;
+ fold_stmt_r_data.stmt = stmt;
+ fold_stmt_r_data.changed_p = &changed;
+ fold_stmt_r_data.inside_addr_expr_p = &inside_addr_expr;
+
/* If we replaced constants and the statement makes pointer dereferences,
then we may need to fold instances of *&VAR into VAR, etc. */
- if (walk_tree (stmt_p, fold_stmt_r, &changed, NULL))
+ if (walk_tree (stmt_p, fold_stmt_r, &fold_stmt_r_data, NULL))
{
- *stmt_p
- = build_function_call_expr (implicit_built_in_decls[BUILT_IN_TRAP],
- NULL);
+ *stmt_p = build_call_expr (implicit_built_in_decls[BUILT_IN_TRAP], 0);
return true;
}
/* ??? Should perhaps do this in fold proper. However, doing it
there requires that we create a new CALL_EXPR, and that requires
copying EH region info to the new node. Easier to just do it
- here where we can just smash the call operand. */
- callee = TREE_OPERAND (rhs, 0);
+ here where we can just smash the call operand. Also
+ CALL_EXPR_RETURN_SLOT_OPT needs to be handled correctly and
+ copied, fold_call_expr does not have not information. */
+ callee = CALL_EXPR_FN (rhs);
if (TREE_CODE (callee) == OBJ_TYPE_REF
&& lang_hooks.fold_obj_type_ref
&& TREE_CODE (OBJ_TYPE_REF_OBJECT (callee)) == ADDR_EXPR
t = lang_hooks.fold_obj_type_ref (callee, t);
if (t)
{
- TREE_OPERAND (rhs, 0) = t;
+ CALL_EXPR_FN (rhs) = t;
changed = true;
}
}
}
}
+ else if (TREE_CODE (rhs) == COND_EXPR)
+ {
+ tree temp = fold (COND_EXPR_COND (rhs));
+ if (temp != COND_EXPR_COND (rhs))
+ result = fold_build3 (COND_EXPR, TREE_TYPE (rhs), temp,
+ COND_EXPR_THEN (rhs), COND_EXPR_ELSE (rhs));
+ }
/* If we couldn't fold the RHS, hand over to the generic fold routines. */
if (result == NULL_TREE)
return changed;
}
+/* Perform the minimal folding on statement STMT. Only operations like
+ *&x created by constant propagation are handled. The statement cannot
+ be replaced with a new one. */
+
+bool
+fold_stmt_inplace (tree stmt)
+{
+ tree old_stmt = stmt, rhs, new_rhs;
+ struct fold_stmt_r_data fold_stmt_r_data;
+ bool changed = false;
+ bool inside_addr_expr = false;
+
+ fold_stmt_r_data.stmt = stmt;
+ fold_stmt_r_data.changed_p = &changed;
+ fold_stmt_r_data.inside_addr_expr_p = &inside_addr_expr;
+
+ walk_tree (&stmt, fold_stmt_r, &fold_stmt_r_data, NULL);
+ gcc_assert (stmt == old_stmt);
+
+ rhs = get_rhs (stmt);
+ if (!rhs || rhs == stmt)
+ return changed;
+
+ new_rhs = fold (rhs);
+ STRIP_USELESS_TYPE_CONVERSION (new_rhs);
+ if (new_rhs == rhs)
+ return changed;
+
+ changed |= set_rhs (&stmt, new_rhs);
+ gcc_assert (stmt == old_stmt);
+
+ return changed;
+}
\f
/* Convert EXPR into a GIMPLE value suitable for substitution on the
RHS of an assignment. Insert the necessary statements before
- iterator *SI_P. */
+ iterator *SI_P.
+ When IGNORE is set, don't worry about the return value. */
static tree
-convert_to_gimple_builtin (block_stmt_iterator *si_p, tree expr)
+convert_to_gimple_builtin (block_stmt_iterator *si_p, tree expr, bool ignore)
{
tree_stmt_iterator ti;
tree stmt = bsi_stmt (*si_p);
tree tmp, stmts = NULL;
push_gimplify_context ();
- tmp = get_initialized_tmp_var (expr, &stmts, NULL);
+ if (ignore)
+ {
+ tmp = build_empty_stmt ();
+ gimplify_and_add (expr, &stmts);
+ }
+ else
+ tmp = get_initialized_tmp_var (expr, &stmts, NULL);
pop_gimplify_context (NULL);
if (EXPR_HAS_LOCATION (stmt))
tree new_stmt = tsi_stmt (ti);
find_new_referenced_vars (tsi_stmt_ptr (ti));
bsi_insert_before (si_p, new_stmt, BSI_NEW_STMT);
- mark_new_vars_to_rename (bsi_stmt (*si_p));
+ mark_symbols_for_renaming (new_stmt);
bsi_next (si_p);
}
/* A simple pass that attempts to fold all builtin functions. This pass
is run after we've propagated as many constants as we can. */
-static void
+static unsigned int
execute_fold_all_builtins (void)
{
bool cfg_changed = false;
FOR_EACH_BB (bb)
{
block_stmt_iterator i;
- for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
+ for (i = bsi_start (bb); !bsi_end_p (i); )
{
tree *stmtp = bsi_stmt_ptr (i);
+ tree old_stmt = *stmtp;
tree call = get_rhs (*stmtp);
tree callee, result;
+ enum built_in_function fcode;
if (!call || TREE_CODE (call) != CALL_EXPR)
- continue;
+ {
+ bsi_next (&i);
+ continue;
+ }
callee = get_callee_fndecl (call);
if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
- continue;
+ {
+ bsi_next (&i);
+ continue;
+ }
+ fcode = DECL_FUNCTION_CODE (callee);
result = ccp_fold_builtin (*stmtp, call);
if (!result)
break;
default:
+ bsi_next (&i);
continue;
}
print_generic_stmt (dump_file, *stmtp, dump_flags);
}
+ push_stmt_changes (stmtp);
+
if (!set_rhs (stmtp, result))
{
- result = convert_to_gimple_builtin (&i, result);
+ result = convert_to_gimple_builtin (&i, result,
+ TREE_CODE (old_stmt)
+ != GIMPLE_MODIFY_STMT);
if (result)
{
bool ok = set_rhs (stmtp, result);
-
gcc_assert (ok);
}
}
- update_stmt (*stmtp);
- if (maybe_clean_eh_stmt (*stmtp)
+
+ pop_stmt_changes (stmtp);
+
+ if (maybe_clean_or_replace_eh_stmt (old_stmt, *stmtp)
&& tree_purge_dead_eh_edges (bb))
cfg_changed = true;
print_generic_stmt (dump_file, *stmtp, dump_flags);
fprintf (dump_file, "\n");
}
+
+ /* Retry the same statement if it changed into another
+ builtin, there might be new opportunities now. */
+ call = get_rhs (*stmtp);
+ if (!call || TREE_CODE (call) != CALL_EXPR)
+ {
+ bsi_next (&i);
+ continue;
+ }
+ callee = get_callee_fndecl (call);
+ if (!callee
+ || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
+ || DECL_FUNCTION_CODE (callee) == fcode)
+ bsi_next (&i);
}
}
/* Delete unreachable blocks. */
- if (cfg_changed)
- cleanup_tree_cfg ();
+ return cfg_changed ? TODO_cleanup_cfg : 0;
}
NULL, /* next */
0, /* static_pass_number */
0, /* tv_id */
- PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
+ PROP_cfg | PROP_ssa, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */