/* Conditional constant propagation pass for the GNU compiler.
- Copyright (C) 2000-2016 Free Software Foundation, Inc.
+ Copyright (C) 2000-2020 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>
#include "tree-cfg.h"
#include "tree-ssa-propagate.h"
#include "dbgcnt.h"
-#include "params.h"
#include "builtins.h"
-#include "tree-chkp.h"
#include "cfgloop.h"
#include "stor-layout.h"
#include "optabs-query.h"
-
+#include "tree-ssa-ccp.h"
+#include "tree-dfa.h"
+#include "diagnostic-core.h"
+#include "stringpool.h"
+#include "attribs.h"
+#include "tree-vector-builder.h"
+#include "cgraph.h"
+#include "alloc-pool.h"
+#include "symbol-summary.h"
+#include "ipa-utils.h"
+#include "ipa-prop.h"
/* Possible lattice values. */
typedef enum
VARYING
} ccp_lattice_t;
-struct ccp_prop_value_t {
+class ccp_prop_value_t {
+public:
/* Lattice value. */
ccp_lattice_t lattice_val;
widest_int mask;
};
+class ccp_propagate : public ssa_propagation_engine
+{
+ public:
+ enum ssa_prop_result visit_stmt (gimple *, edge *, tree *) FINAL OVERRIDE;
+ enum ssa_prop_result visit_phi (gphi *) FINAL OVERRIDE;
+};
+
/* 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
static unsigned n_const_val;
static void canonicalize_value (ccp_prop_value_t *);
-static bool ccp_fold_stmt (gimple_stmt_iterator *);
static void ccp_lattice_meet (ccp_prop_value_t *, ccp_prop_value_t *);
/* Dump constant propagation value VAL to file OUTF prefixed by PREFIX. */
if (flag_tree_bit_ccp)
{
wide_int nonzero_bits = get_nonzero_bits (var);
- if (nonzero_bits != -1)
+ tree value;
+ widest_int mask;
+
+ if (SSA_NAME_VAR (var)
+ && TREE_CODE (SSA_NAME_VAR (var)) == PARM_DECL
+ && ipcp_get_parm_bits (SSA_NAME_VAR (var), &value, &mask))
+ {
+ val.lattice_val = CONSTANT;
+ val.value = value;
+ val.mask = mask;
+ if (nonzero_bits != -1)
+ val.mask &= extend_mask (nonzero_bits,
+ TYPE_SIGN (TREE_TYPE (var)));
+ }
+ else if (nonzero_bits != -1)
{
val.lattice_val = CONSTANT;
val.value = build_zero_cst (TREE_TYPE (var));
- val.mask = extend_mask (nonzero_bits, TYPE_SIGN (TREE_TYPE (var)));
+ val.mask = extend_mask (nonzero_bits,
+ TYPE_SIGN (TREE_TYPE (var)));
}
}
}
else if (VECTOR_FLOAT_TYPE_P (type)
&& !HONOR_NANS (type))
{
- for (unsigned i = 0; i < VECTOR_CST_NELTS (old_val.value); ++i)
+ unsigned int count
+ = tree_vector_builder::binary_encoded_nelts (old_val.value,
+ new_val.value);
+ for (unsigned int i = 0; i < count; ++i)
if (!REAL_VALUE_ISNAN
- (TREE_REAL_CST (VECTOR_CST_ELT (old_val.value, i)))
- && !operand_equal_p (VECTOR_CST_ELT (old_val.value, i),
- VECTOR_CST_ELT (new_val.value, i), 0))
+ (TREE_REAL_CST (VECTOR_CST_ENCODED_ELT (old_val.value, i)))
+ && !operand_equal_p (VECTOR_CST_ENCODED_ELT (old_val.value, i),
+ VECTOR_CST_ENCODED_ELT (new_val.value, i), 0))
return false;
return true;
}
use the meet operator to retain a conservative value.
Missed optimizations like PR65851 makes this necessary.
It also ensures we converge to a stable lattice solution. */
- if (new_val->lattice_val == CONSTANT
- && old_val->lattice_val == CONSTANT
- && TREE_CODE (new_val->value) != SSA_NAME)
+ if (old_val->lattice_val != UNINITIALIZED)
ccp_lattice_meet (new_val, old_val);
gcc_checking_assert (valid_lattice_transition (*old_val, *new_val));
static ccp_prop_value_t get_value_for_expr (tree, bool);
static ccp_prop_value_t bit_value_binop (enum tree_code, tree, tree, tree);
-static void bit_value_binop_1 (enum tree_code, tree, widest_int *, widest_int *,
- tree, const widest_int &, const widest_int &,
- tree, const widest_int &, const widest_int &);
+void bit_value_binop (enum tree_code, signop, int, widest_int *, widest_int *,
+ signop, int, const widest_int &, const widest_int &,
+ signop, int, const widest_int &, const widest_int &);
/* Return a widest_int that can be used for bitwise simplifications
from VAL. */
gcc_assert (TREE_CODE (expr) == ADDR_EXPR);
get_pointer_alignment_1 (expr, &align, &bitpos);
- val.mask = (POINTER_TYPE_P (type) || TYPE_UNSIGNED (type)
- ? wi::mask <widest_int> (TYPE_PRECISION (type), false)
- : -1).and_not (align / BITS_PER_UNIT - 1);
+ val.mask = wi::bit_and_not
+ (POINTER_TYPE_P (type) || TYPE_UNSIGNED (type)
+ ? wi::mask <widest_int> (TYPE_PRECISION (type), false)
+ : -1,
+ align / BITS_PER_UNIT - 1);
val.lattice_val
= wi::sext (val.mask, TYPE_PRECISION (type)) == -1 ? VARYING : CONSTANT;
if (val.lattice_val == CONSTANT)
if (TREE_CODE (expr) == SSA_NAME)
{
- val = *get_value (expr);
+ ccp_prop_value_t *val_ = get_value (expr);
+ if (val_)
+ val = *val_;
+ else
+ {
+ val.lattice_val = VARYING;
+ val.value = NULL_TREE;
+ val.mask = -1;
+ }
if (for_bits_p
- && val.lattice_val == CONSTANT
- && TREE_CODE (val.value) == ADDR_EXPR)
- val = get_value_from_alignment (val.value);
+ && val.lattice_val == CONSTANT)
+ {
+ if (TREE_CODE (val.value) == ADDR_EXPR)
+ val = get_value_from_alignment (val.value);
+ else if (TREE_CODE (val.value) != INTEGER_CST)
+ {
+ val.lattice_val = VARYING;
+ val.value = NULL_TREE;
+ val.mask = -1;
+ }
+ }
/* Fall back to a copy value. */
if (!for_bits_p
&& val.lattice_val == VARYING
}
}
else if (is_gimple_min_invariant (expr)
- && (!for_bits_p || TREE_CODE (expr) != ADDR_EXPR))
+ && (!for_bits_p || TREE_CODE (expr) == INTEGER_CST))
{
val.lattice_val = CONSTANT;
val.value = expr;
{
ccp_prop_value_t *val = get_value (use);
- if (val->lattice_val == UNDEFINED)
+ if (val && val->lattice_val == UNDEFINED)
has_undefined_operand = true;
else
all_undefined_operands = false;
- if (val->lattice_val == CONSTANT)
+ if (val && val->lattice_val == CONSTANT)
has_constant_operand = true;
if (SSA_NAME_IS_DEFAULT_DEF (use)
case PLUS_EXPR:
case MINUS_EXPR:
case POINTER_PLUS_EXPR:
+ case BIT_XOR_EXPR:
/* Not MIN_EXPR, MAX_EXPR. One VARYING operand may be selected.
Not bitwise operators, one VARYING operand may specify the
- result completely. Not logical operators for the same reason.
+ result completely.
+ Not logical operators for the same reason, apart from XOR.
Not COMPLEX_EXPR as one VARYING operand makes the result partly
not UNDEFINED. Not *DIV_EXPR, comparisons and shifts because
the undefined operand may be promoted. */
tree fndecl, fntype = gimple_call_fntype (stmt);
if (!gimple_call_lhs (stmt)
|| ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
- && !DECL_BUILT_IN (fndecl)
+ && !fndecl_built_in_p (fndecl)
&& !lookup_attribute ("assume_aligned",
TYPE_ATTRIBUTES (fntype))
&& !lookup_attribute ("alloc_align",
}
+/* We want to provide our own GET_VALUE and FOLD_STMT virtual methods. */
+class ccp_folder : public substitute_and_fold_engine
+{
+ public:
+ tree get_value (tree) FINAL OVERRIDE;
+ bool fold_stmt (gimple_stmt_iterator *) FINAL OVERRIDE;
+};
+
+/* This method just wraps GET_CONSTANT_VALUE for now. Over time
+ naked calls to GET_CONSTANT_VALUE should be eliminated in favor
+ of calling member functions. */
+
+tree
+ccp_folder::get_value (tree op)
+{
+ return get_constant_value (op);
+}
+
/* Do final substitution of propagated values, cleanup the flowgraph and
free allocated storage. If NONZERO_P, record nonzero bits.
Return TRUE when something was optimized. */
static bool
-ccp_finalize (bool nonzero_p)
+ccp_finalize (bool nonzero_p)
{
bool something_changed;
unsigned i;
+ tree name;
do_dbg_cnt ();
/* Derive alignment and misalignment information from partially
constant pointers in the lattice or nonzero bits from partially
constant integers. */
- for (i = 1; i < num_ssa_names; ++i)
+ FOR_EACH_SSA_NAME (i, name, cfun)
{
- tree name = ssa_name (i);
ccp_prop_value_t *val;
unsigned int tem, align;
- if (!name
- || (!POINTER_TYPE_P (TREE_TYPE (name))
- && (!INTEGRAL_TYPE_P (TREE_TYPE (name))
- /* Don't record nonzero bits before IPA to avoid
- using too much memory. */
- || !nonzero_p)))
+ if (!POINTER_TYPE_P (TREE_TYPE (name))
+ && (!INTEGRAL_TYPE_P (TREE_TYPE (name))
+ /* Don't record nonzero bits before IPA to avoid
+ using too much memory. */
+ || !nonzero_p))
continue;
val = get_value (name);
if (val->lattice_val != CONSTANT
- || TREE_CODE (val->value) != INTEGER_CST)
+ || TREE_CODE (val->value) != INTEGER_CST
+ || val->mask == 0)
continue;
if (POINTER_TYPE_P (TREE_TYPE (name)))
/* Trailing mask bits specify the alignment, trailing value
bits the misalignment. */
tem = val->mask.to_uhwi ();
- align = (tem & -tem);
+ align = least_bit_hwi (tem);
if (align > 1)
set_ptr_info_alignment (get_ptr_info (name), align,
(TREE_INT_CST_LOW (val->value)
else
{
unsigned int precision = TYPE_PRECISION (TREE_TYPE (val->value));
- wide_int nonzero_bits = wide_int::from (val->mask, precision,
- UNSIGNED) | val->value;
+ wide_int nonzero_bits
+ = (wide_int::from (val->mask, precision, UNSIGNED)
+ | wi::to_wide (val->value));
nonzero_bits &= get_nonzero_bits (name);
set_nonzero_bits (name, nonzero_bits);
}
}
/* Perform substitutions based on the known constant values. */
- something_changed = substitute_and_fold (get_constant_value,
- ccp_fold_stmt, true);
+ class ccp_folder ccp_folder;
+ something_changed = ccp_folder.substitute_and_fold ();
free (const_val);
const_val = NULL;
- return something_changed;;
+ return something_changed;
}
PHI node is determined calling ccp_lattice_meet with all the arguments
of the PHI node that are incoming via executable edges. */
-static enum ssa_prop_result
-ccp_visit_phi_node (gphi *phi)
+enum ssa_prop_result
+ccp_propagate::visit_phi (gphi *phi)
{
unsigned i;
ccp_prop_value_t new_val;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file,
- "\n Argument #%d (%d -> %d %sexecutable)\n",
+ "\tArgument #%d (%d -> %d %sexecutable)\n",
i, e->src->index, e->dest->index,
(e->flags & EDGE_EXECUTABLE) ? "" : "not ");
}
RVAL and RMASK representing a value of type RTYPE and set
the value, mask pair *VAL and *MASK to the result. */
-static void
-bit_value_unop_1 (enum tree_code code, tree type,
- widest_int *val, widest_int *mask,
- tree rtype, const widest_int &rval, const widest_int &rmask)
+void
+bit_value_unop (enum tree_code code, signop type_sgn, int type_precision,
+ widest_int *val, widest_int *mask,
+ signop rtype_sgn, int rtype_precision,
+ const widest_int &rval, const widest_int &rmask)
{
switch (code)
{
{
widest_int temv, temm;
/* Return ~rval + 1. */
- bit_value_unop_1 (BIT_NOT_EXPR, type, &temv, &temm, type, rval, rmask);
- bit_value_binop_1 (PLUS_EXPR, type, val, mask,
- type, temv, temm, type, 1, 0);
+ bit_value_unop (BIT_NOT_EXPR, type_sgn, type_precision, &temv, &temm,
+ type_sgn, type_precision, rval, rmask);
+ bit_value_binop (PLUS_EXPR, type_sgn, type_precision, val, mask,
+ type_sgn, type_precision, temv, temm,
+ type_sgn, type_precision, 1, 0);
break;
}
CASE_CONVERT:
{
- signop sgn;
-
/* First extend mask and value according to the original type. */
- sgn = TYPE_SIGN (rtype);
- *mask = wi::ext (rmask, TYPE_PRECISION (rtype), sgn);
- *val = wi::ext (rval, TYPE_PRECISION (rtype), sgn);
+ *mask = wi::ext (rmask, rtype_precision, rtype_sgn);
+ *val = wi::ext (rval, rtype_precision, rtype_sgn);
/* Then extend mask and value according to the target type. */
- sgn = TYPE_SIGN (type);
- *mask = wi::ext (*mask, TYPE_PRECISION (type), sgn);
- *val = wi::ext (*val, TYPE_PRECISION (type), sgn);
+ *mask = wi::ext (*mask, type_precision, type_sgn);
+ *val = wi::ext (*val, type_precision, type_sgn);
break;
}
R1VAL, R1MASK and R2VAL, R2MASK representing a values of type R1TYPE
and R2TYPE and set the value, mask pair *VAL and *MASK to the result. */
-static void
-bit_value_binop_1 (enum tree_code code, tree type,
- widest_int *val, widest_int *mask,
- tree r1type, const widest_int &r1val,
- const widest_int &r1mask, tree r2type,
- const widest_int &r2val, const widest_int &r2mask)
+void
+bit_value_binop (enum tree_code code, signop sgn, int width,
+ widest_int *val, widest_int *mask,
+ signop r1type_sgn, int r1type_precision,
+ const widest_int &r1val, const widest_int &r1mask,
+ signop r2type_sgn, int r2type_precision,
+ const widest_int &r2val, const widest_int &r2mask)
{
- signop sgn = TYPE_SIGN (type);
- int width = TYPE_PRECISION (type);
bool swap_p = false;
/* Assume we'll get a constant result. Use an initial non varying
case BIT_IOR_EXPR:
/* The mask is constant where there is a known
set bit, (m1 | m2) & ~((v1 & ~m1) | (v2 & ~m2)). */
- *mask = (r1mask | r2mask)
- .and_not (r1val.and_not (r1mask) | r2val.and_not (r2mask));
+ *mask = wi::bit_and_not (r1mask | r2mask,
+ wi::bit_and_not (r1val, r1mask)
+ | wi::bit_and_not (r2val, r2mask));
*val = r1val | r2val;
break;
{
/* Do the addition with unknown bits set to zero, to give carry-ins of
zero wherever possible. */
- widest_int lo = r1val.and_not (r1mask) + r2val.and_not (r2mask);
+ widest_int lo = (wi::bit_and_not (r1val, r1mask)
+ + wi::bit_and_not (r2val, r2mask));
lo = wi::ext (lo, width, sgn);
/* Do the addition with unknown bits set to one, to give carry-ins of
one wherever possible. */
case MINUS_EXPR:
{
widest_int temv, temm;
- bit_value_unop_1 (NEGATE_EXPR, r2type, &temv, &temm,
- r2type, r2val, r2mask);
- bit_value_binop_1 (PLUS_EXPR, type, val, mask,
- r1type, r1val, r1mask,
- r2type, temv, temm);
+ bit_value_unop (NEGATE_EXPR, r2type_sgn, r2type_precision, &temv, &temm,
+ r2type_sgn, r2type_precision, r2val, r2mask);
+ bit_value_binop (PLUS_EXPR, sgn, width, val, mask,
+ r1type_sgn, r1type_precision, r1val, r1mask,
+ r2type_sgn, r2type_precision, temv, temm);
break;
}
case NE_EXPR:
{
widest_int m = r1mask | r2mask;
- if (r1val.and_not (m) != r2val.and_not (m))
+ if (wi::bit_and_not (r1val, m) != wi::bit_and_not (r2val, m))
{
*mask = 0;
*val = ((code == EQ_EXPR) ? 0 : 1);
break;
/* For comparisons the signedness is in the comparison operands. */
- sgn = TYPE_SIGN (r1type);
+ sgn = r1type_sgn;
/* If we know the most significant bits we know the values
value ranges by means of treating varying bits as zero
or one. Do a cross comparison of the max/min pairs. */
- maxmin = wi::cmp (o1val | o1mask, o2val.and_not (o2mask), sgn);
- minmax = wi::cmp (o1val.and_not (o1mask), o2val | o2mask, sgn);
+ maxmin = wi::cmp (o1val | o1mask,
+ wi::bit_and_not (o2val, o2mask), sgn);
+ minmax = wi::cmp (wi::bit_and_not (o1val, o1mask),
+ o2val | o2mask, sgn);
if (maxmin < 0) /* o1 is less than o2. */
{
*mask = 0;
gcc_assert ((rval.lattice_val == CONSTANT
&& TREE_CODE (rval.value) == INTEGER_CST)
|| wi::sext (rval.mask, TYPE_PRECISION (TREE_TYPE (rhs))) == -1);
- bit_value_unop_1 (code, type, &value, &mask,
- TREE_TYPE (rhs), value_to_wide_int (rval), rval.mask);
+ bit_value_unop (code, TYPE_SIGN (type), TYPE_PRECISION (type), &value, &mask,
+ TYPE_SIGN (TREE_TYPE (rhs)), TYPE_PRECISION (TREE_TYPE (rhs)),
+ value_to_wide_int (rval), rval.mask);
if (wi::sext (mask, TYPE_PRECISION (type)) != -1)
{
val.lattice_val = CONSTANT;
&& TREE_CODE (r2val.value) == INTEGER_CST)
|| wi::sext (r2val.mask,
TYPE_PRECISION (TREE_TYPE (rhs2))) == -1);
- bit_value_binop_1 (code, type, &value, &mask,
- TREE_TYPE (rhs1), value_to_wide_int (r1val), r1val.mask,
- TREE_TYPE (rhs2), value_to_wide_int (r2val), r2val.mask);
+ bit_value_binop (code, TYPE_SIGN (type), TYPE_PRECISION (type), &value, &mask,
+ TYPE_SIGN (TREE_TYPE (rhs1)), TYPE_PRECISION (TREE_TYPE (rhs1)),
+ value_to_wide_int (r1val), r1val.mask,
+ TYPE_SIGN (TREE_TYPE (rhs2)), TYPE_PRECISION (TREE_TYPE (rhs2)),
+ value_to_wide_int (r2val), r2val.mask);
+
+ /* (x * x) & 2 == 0. */
+ if (code == MULT_EXPR && rhs1 == rhs2 && TYPE_PRECISION (type) > 1)
+ {
+ widest_int m = 2;
+ if (wi::sext (mask, TYPE_PRECISION (type)) != -1)
+ value = wi::bit_and_not (value, m);
+ else
+ value = 0;
+ mask = wi::bit_and_not (mask, m);
+ }
+
if (wi::sext (mask, TYPE_PRECISION (type)) != -1)
{
val.lattice_val = CONSTANT;
align = build_int_cst_type (type, -aligni);
alignval = get_value_for_expr (align, true);
- bit_value_binop_1 (BIT_AND_EXPR, type, &value, &mask,
- type, value_to_wide_int (ptrval), ptrval.mask,
- type, value_to_wide_int (alignval), alignval.mask);
+ bit_value_binop (BIT_AND_EXPR, TYPE_SIGN (type), TYPE_PRECISION (type), &value, &mask,
+ TYPE_SIGN (type), TYPE_PRECISION (type), value_to_wide_int (ptrval), ptrval.mask,
+ TYPE_SIGN (type), TYPE_PRECISION (type), value_to_wide_int (alignval), alignval.mask);
+
if (wi::sext (mask, TYPE_PRECISION (type)) != -1)
{
val.lattice_val = CONSTANT;
{
fold_defer_overflow_warnings ();
simplified = ccp_fold (stmt);
- if (simplified && TREE_CODE (simplified) == SSA_NAME)
+ if (simplified
+ && TREE_CODE (simplified) == SSA_NAME)
{
- val = *get_value (simplified);
- if (val.lattice_val != VARYING)
+ /* We may not use values of something that may be simulated again,
+ see valueize_op_1. */
+ if (SSA_NAME_IS_DEFAULT_DEF (simplified)
+ || ! prop_simulate_again_p (SSA_NAME_DEF_STMT (simplified)))
{
- fold_undefer_overflow_warnings (true, stmt, 0);
- return val;
+ ccp_prop_value_t *val = get_value (simplified);
+ if (val && val->lattice_val != VARYING)
+ {
+ fold_undefer_overflow_warnings (true, stmt, 0);
+ return *val;
+ }
}
+ else
+ /* We may also not place a non-valueized copy in the lattice
+ as that might become stale if we never re-visit this stmt. */
+ simplified = NULL_TREE;
}
is_constant = simplified && is_gimple_min_invariant (simplified);
fold_undefer_overflow_warnings (is_constant, stmt, 0);
/ BITS_PER_UNIT - 1);
break;
- case BUILT_IN_ALLOCA:
- case BUILT_IN_ALLOCA_WITH_ALIGN:
- align = (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA_WITH_ALIGN
- ? TREE_INT_CST_LOW (gimple_call_arg (stmt, 1))
- : BIGGEST_ALIGNMENT);
+ CASE_BUILT_IN_ALLOCA:
+ align = (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA
+ ? BIGGEST_ALIGNMENT
+ : TREE_INT_CST_LOW (gimple_call_arg (stmt, 1)));
val.lattice_val = CONSTANT;
val.value = build_int_cst (TREE_TYPE (gimple_get_lhs (stmt)), 0);
val.mask = ~((HOST_WIDE_INT) align / BITS_PER_UNIT - 1);
break;
}
+ case BUILT_IN_BSWAP16:
+ case BUILT_IN_BSWAP32:
+ case BUILT_IN_BSWAP64:
+ val = get_value_for_expr (gimple_call_arg (stmt, 0), true);
+ if (val.lattice_val == UNDEFINED)
+ break;
+ else if (val.lattice_val == CONSTANT
+ && val.value
+ && TREE_CODE (val.value) == INTEGER_CST)
+ {
+ tree type = TREE_TYPE (gimple_call_lhs (stmt));
+ int prec = TYPE_PRECISION (type);
+ wide_int wval = wi::to_wide (val.value);
+ val.value
+ = wide_int_to_tree (type,
+ wide_int::from (wval, prec,
+ UNSIGNED).bswap ());
+ val.mask
+ = widest_int::from (wide_int::from (val.mask, prec,
+ UNSIGNED).bswap (),
+ UNSIGNED);
+ if (wi::sext (val.mask, prec) != -1)
+ break;
+ }
+ val.lattice_val = VARYING;
+ val.value = NULL_TREE;
+ val.mask = -1;
+ break;
+
default:;
}
}
}
else
{
- if (wi::bit_and_not (val.value, nonzero_bits) != 0)
+ if (wi::bit_and_not (wi::to_wide (val.value), nonzero_bits) != 0)
val.value = wide_int_to_tree (TREE_TYPE (lhs),
- nonzero_bits & val.value);
+ nonzero_bits
+ & wi::to_wide (val.value));
if (nonzero_bits == 0)
val.mask = 0;
else
FOR_EACH_IMM_USE_STMT (stmt, iter, saved_val)
if (gimple_call_builtin_p (stmt, BUILT_IN_STACK_RESTORE))
{
- clobber = build_constructor (TREE_TYPE (var),
- NULL);
- TREE_THIS_VOLATILE (clobber) = 1;
+ clobber = build_clobber (TREE_TYPE (var));
clobber_stmt = gimple_build_assign (var, clobber);
i = gsi_for_stmt (stmt);
else if (gimple_assign_ssa_name_copy_p (stmt))
insert_clobber_before_stack_restore (gimple_assign_lhs (stmt), var,
visited);
- else if (chkp_gimple_call_builtin_p (stmt, BUILT_IN_CHKP_BNDRET))
- continue;
- else
- gcc_assert (is_gimple_debug (stmt));
}
/* Advance the iterator to the previous non-debug gimple statement in the same
/* Find a BUILT_IN_STACK_SAVE dominating gsi_stmt (I), and insert
a clobber of VAR before each matching BUILT_IN_STACK_RESTORE.
- It is possible that BUILT_IN_STACK_SAVE cannot be find in a dominator when a
- previous pass (such as DOM) duplicated it along multiple paths to a BB. In
- that case the function gives up without inserting the clobbers. */
+ It is possible that BUILT_IN_STACK_SAVE cannot be found in a dominator when
+ a previous pass (such as DOM) duplicated it along multiple paths to a BB.
+ In that case the function gives up without inserting the clobbers. */
static void
insert_clobbers_for_var (gimple_stmt_iterator i, tree var)
size = tree_to_uhwi (arg);
/* Heuristic: don't fold large allocas. */
- threshold = (unsigned HOST_WIDE_INT)PARAM_VALUE (PARAM_LARGE_STACK_FRAME);
+ threshold = (unsigned HOST_WIDE_INT)param_large_stack_frame;
/* In case the alloca is located at function entry, it has the same lifetime
as a declared array, so we allow a larger size. */
block = gimple_block (stmt);
if (size > threshold)
return NULL_TREE;
+ /* We have to be able to move points-to info. We used to assert
+ that we can but IPA PTA might end up with two UIDs here
+ as it might need to handle more than one instance being
+ live at the same time. Instead of trying to detect this case
+ (using the first UID would be OK) just give up for now. */
+ struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs);
+ unsigned uid = 0;
+ if (pi != NULL
+ && !pi->pt.anything
+ && !pt_solution_singleton_or_null_p (&pi->pt, &uid))
+ return NULL_TREE;
+
/* Declare array. */
elem_type = build_nonstandard_integer_type (BITS_PER_UNIT, 1);
n_elem = size * 8 / BITS_PER_UNIT;
array_type = build_array_type_nelts (elem_type, n_elem);
- var = create_tmp_var (array_type);
+
+ if (tree ssa_name = SSA_NAME_IDENTIFIER (lhs))
+ {
+ /* Give the temporary a name derived from the name of the VLA
+ declaration so it can be referenced in diagnostics. */
+ const char *name = IDENTIFIER_POINTER (ssa_name);
+ var = create_tmp_var (array_type, name);
+ }
+ else
+ var = create_tmp_var (array_type);
+
+ if (gimple *lhsdef = SSA_NAME_DEF_STMT (lhs))
+ {
+ /* Set the temporary's location to that of the VLA declaration
+ so it can be pointed to in diagnostics. */
+ location_t loc = gimple_location (lhsdef);
+ DECL_SOURCE_LOCATION (var) = loc;
+ }
+
SET_DECL_ALIGN (var, TREE_INT_CST_LOW (gimple_call_arg (stmt, 1)));
- {
- struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs);
- if (pi != NULL && !pi->pt.anything)
- {
- bool singleton_p;
- unsigned uid;
- singleton_p = pt_solution_singleton_p (&pi->pt, &uid);
- gcc_assert (singleton_p);
- SET_DECL_PT_UID (var, uid);
- }
- }
+ if (uid != 0)
+ SET_DECL_PT_UID (var, uid);
/* Fold alloca to the address of the array. */
return fold_convert (TREE_TYPE (lhs), build_fold_addr_expr (var));
/* Fold the stmt at *GSI with CCP specific information that propagating
and regular folding does not catch. */
-static bool
-ccp_fold_stmt (gimple_stmt_iterator *gsi)
+bool
+ccp_folder::fold_stmt (gimple_stmt_iterator *gsi)
{
gimple *stmt = gsi_stmt (*gsi);
if (dump_file)
{
fprintf (dump_file, "Folding predicate ");
- print_gimple_expr (dump_file, stmt, 0, 0);
+ print_gimple_expr (dump_file, stmt, 0);
fprintf (dump_file, " to ");
- print_generic_expr (dump_file, val.value, 0);
+ print_generic_expr (dump_file, val.value);
fprintf (dump_file, "\n");
}
/* The heuristic of fold_builtin_alloca_with_align differs before and
after inlining, so we don't require the arg to be changed into a
constant for folding, but just to be constant. */
- if (gimple_call_builtin_p (stmt, BUILT_IN_ALLOCA_WITH_ALIGN))
+ if (gimple_call_builtin_p (stmt, BUILT_IN_ALLOCA_WITH_ALIGN)
+ || gimple_call_builtin_p (stmt, BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX))
{
tree new_rhs = fold_builtin_alloca_with_align (stmt);
if (new_rhs)
}
}
+ /* If there's no extra info from an assume_aligned call,
+ drop it so it doesn't act as otherwise useless dataflow
+ barrier. */
+ if (gimple_call_builtin_p (stmt, BUILT_IN_ASSUME_ALIGNED))
+ {
+ tree ptr = gimple_call_arg (stmt, 0);
+ ccp_prop_value_t ptrval = get_value_for_expr (ptr, true);
+ if (ptrval.lattice_val == CONSTANT
+ && TREE_CODE (ptrval.value) == INTEGER_CST
+ && ptrval.mask != 0)
+ {
+ ccp_prop_value_t val
+ = bit_value_assume_aligned (stmt, NULL_TREE, ptrval, false);
+ unsigned int ptralign = least_bit_hwi (ptrval.mask.to_uhwi ());
+ unsigned int align = least_bit_hwi (val.mask.to_uhwi ());
+ if (ptralign == align
+ && ((TREE_INT_CST_LOW (ptrval.value) & (align - 1))
+ == (TREE_INT_CST_LOW (val.value) & (align - 1))))
+ {
+ bool res = update_call_from_tree (gsi, ptr);
+ gcc_assert (res);
+ return true;
+ }
+ }
+ }
+
/* Propagate into the call arguments. Compared to replace_uses_in
this can use the argument slot types for type verification
instead of the current argument type. We also can safely
value, set *TAKEN_EDGE_P accordingly. If STMT produces a varying
value, return SSA_PROP_VARYING. */
-static enum ssa_prop_result
-ccp_visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p)
+enum ssa_prop_result
+ccp_propagate::visit_stmt (gimple *stmt, edge *taken_edge_p, tree *output_p)
{
tree def;
ssa_op_iter iter;
calculate_dominance_info (CDI_DOMINATORS);
ccp_initialize ();
- ssa_propagate (ccp_visit_stmt, ccp_visit_phi_node);
- if (ccp_finalize (nonzero_p))
+ class ccp_propagate ccp_propagate;
+ ccp_propagate.ssa_propagate ();
+ if (ccp_finalize (nonzero_p || flag_ipa_bit_cp))
{
todo = (TODO_cleanup_cfg | TODO_update_ssa);
callee = gimple_call_fndecl (stmt);
if (!callee
- || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
+ || !fndecl_built_in_p (callee, BUILT_IN_NORMAL)
/* All regular builtins are ok, just obviously not alloca. */
- || DECL_FUNCTION_CODE (callee) == BUILT_IN_ALLOCA
- || DECL_FUNCTION_CODE (callee) == BUILT_IN_ALLOCA_WITH_ALIGN)
+ || ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (callee)))
return NULL_TREE;
- if (DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_RESTORE)
+ if (fndecl_built_in_p (callee, BUILT_IN_STACK_RESTORE))
goto second_stack_restore;
}
if (is_gimple_call (stack_save))
{
callee = gimple_call_fndecl (stack_save);
- if (callee
- && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
- && DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_SAVE)
+ if (callee && fndecl_built_in_p (callee, BUILT_IN_STACK_SAVE))
{
gimple_stmt_iterator stack_save_gsi;
tree rhs;
bool va_list_simple_ptr;
location_t loc = gimple_location (call);
- if (gimple_code (call) != GIMPLE_CALL)
- return NULL_TREE;
-
callee = gimple_call_fndecl (call);
cfun_va_list = targetm.fn_abi_va_list (callee);
}
else
{
- /* Todo: handle other cases, f.i. switch statement. */
+ /* Todo: handle other cases. Note that unreachable switch case
+ statements have already been removed. */
continue;
}
FOR_EACH_IMM_USE_STMT (g, iter, use_lhs)
{
enum tree_code code = ERROR_MARK;
- tree op0, op1;
+ tree op0 = NULL_TREE, op1 = NULL_TREE;
if (is_gimple_debug (g))
{
has_debug_uses = true;
bit, flag);
gimple_call_set_lhs (g, new_lhs);
gimple_set_location (g, gimple_location (call));
- gimple_set_vuse (g, gimple_vuse (call));
- gimple_set_vdef (g, gimple_vdef (call));
- SSA_NAME_DEF_STMT (gimple_vdef (call)) = g;
+ gimple_move_vops (g, call);
+ bool throws = stmt_can_throw_internal (cfun, call);
+ gimple_call_set_nothrow (as_a <gcall *> (g),
+ gimple_call_nothrow_p (as_a <gcall *> (call)));
gimple_stmt_iterator gsi = *gsip;
gsi_insert_after (&gsi, g, GSI_NEW_STMT);
+ edge e = NULL;
+ if (throws)
+ {
+ maybe_clean_or_replace_eh_stmt (call, g);
+ if (after || (use_bool && has_debug_uses))
+ e = find_fallthru_edge (gsi_bb (gsi)->succs);
+ }
if (after)
{
/* The internal function returns the value of the specified bit
use_bool ? build_int_cst (TREE_TYPE (lhs), 1)
: mask);
new_lhs = gimple_assign_lhs (g);
- gsi_insert_after (&gsi, g, GSI_NEW_STMT);
+ if (throws)
+ {
+ gsi_insert_on_edge_immediate (e, g);
+ gsi = gsi_for_stmt (g);
+ }
+ else
+ gsi_insert_after (&gsi, g, GSI_NEW_STMT);
}
if (use_bool && has_debug_uses)
{
- tree temp = make_node (DEBUG_EXPR_DECL);
- DECL_ARTIFICIAL (temp) = 1;
- TREE_TYPE (temp) = TREE_TYPE (lhs);
- DECL_MODE (temp) = TYPE_MODE (TREE_TYPE (lhs));
- tree t = build2 (LSHIFT_EXPR, TREE_TYPE (lhs), new_lhs, bit);
- g = gimple_build_debug_bind (temp, t, g);
- gsi_insert_after (&gsi, g, GSI_NEW_STMT);
+ tree temp = NULL_TREE;
+ if (!throws || after || single_pred_p (e->dest))
+ {
+ temp = make_node (DEBUG_EXPR_DECL);
+ DECL_ARTIFICIAL (temp) = 1;
+ TREE_TYPE (temp) = TREE_TYPE (lhs);
+ SET_DECL_MODE (temp, TYPE_MODE (TREE_TYPE (lhs)));
+ tree t = build2 (LSHIFT_EXPR, TREE_TYPE (lhs), new_lhs, bit);
+ g = gimple_build_debug_bind (temp, t, g);
+ if (throws && !after)
+ {
+ gsi = gsi_after_labels (e->dest);
+ gsi_insert_before (&gsi, g, GSI_SAME_STMT);
+ }
+ else
+ gsi_insert_after (&gsi, g, GSI_NEW_STMT);
+ }
FOR_EACH_IMM_USE_STMT (g, iter, use_lhs)
if (is_gimple_debug (g))
{
use_operand_p use_p;
- FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
- SET_USE (use_p, temp);
+ if (temp == NULL_TREE)
+ gimple_debug_bind_reset_value (g);
+ else
+ FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
+ SET_USE (use_p, temp);
update_stmt (g);
}
}
release_ssa_name (lhs);
}
+/* Optimize
+ a = {};
+ b = a;
+ into
+ a = {};
+ b = {};
+ Similarly for memset (&a, ..., sizeof (a)); instead of a = {};
+ and/or memcpy (&b, &a, sizeof (a)); instead of b = a; */
+
+static void
+optimize_memcpy (gimple_stmt_iterator *gsip, tree dest, tree src, tree len)
+{
+ gimple *stmt = gsi_stmt (*gsip);
+ if (gimple_has_volatile_ops (stmt))
+ return;
+
+ tree vuse = gimple_vuse (stmt);
+ if (vuse == NULL)
+ return;
+
+ gimple *defstmt = SSA_NAME_DEF_STMT (vuse);
+ tree src2 = NULL_TREE, len2 = NULL_TREE;
+ poly_int64 offset, offset2;
+ tree val = integer_zero_node;
+ if (gimple_store_p (defstmt)
+ && gimple_assign_single_p (defstmt)
+ && TREE_CODE (gimple_assign_rhs1 (defstmt)) == CONSTRUCTOR
+ && !gimple_clobber_p (defstmt))
+ src2 = gimple_assign_lhs (defstmt);
+ else if (gimple_call_builtin_p (defstmt, BUILT_IN_MEMSET)
+ && TREE_CODE (gimple_call_arg (defstmt, 0)) == ADDR_EXPR
+ && TREE_CODE (gimple_call_arg (defstmt, 1)) == INTEGER_CST)
+ {
+ src2 = TREE_OPERAND (gimple_call_arg (defstmt, 0), 0);
+ len2 = gimple_call_arg (defstmt, 2);
+ val = gimple_call_arg (defstmt, 1);
+ /* For non-0 val, we'd have to transform stmt from assignment
+ into memset (only if dest is addressable). */
+ if (!integer_zerop (val) && is_gimple_assign (stmt))
+ src2 = NULL_TREE;
+ }
+
+ if (src2 == NULL_TREE)
+ return;
+
+ if (len == NULL_TREE)
+ len = (TREE_CODE (src) == COMPONENT_REF
+ ? DECL_SIZE_UNIT (TREE_OPERAND (src, 1))
+ : TYPE_SIZE_UNIT (TREE_TYPE (src)));
+ if (len2 == NULL_TREE)
+ len2 = (TREE_CODE (src2) == COMPONENT_REF
+ ? DECL_SIZE_UNIT (TREE_OPERAND (src2, 1))
+ : TYPE_SIZE_UNIT (TREE_TYPE (src2)));
+ if (len == NULL_TREE
+ || !poly_int_tree_p (len)
+ || len2 == NULL_TREE
+ || !poly_int_tree_p (len2))
+ return;
+
+ src = get_addr_base_and_unit_offset (src, &offset);
+ src2 = get_addr_base_and_unit_offset (src2, &offset2);
+ if (src == NULL_TREE
+ || src2 == NULL_TREE
+ || maybe_lt (offset, offset2))
+ return;
+
+ if (!operand_equal_p (src, src2, 0))
+ return;
+
+ /* [ src + offset2, src + offset2 + len2 - 1 ] is set to val.
+ Make sure that
+ [ src + offset, src + offset + len - 1 ] is a subset of that. */
+ if (maybe_gt (wi::to_poly_offset (len) + (offset - offset2),
+ wi::to_poly_offset (len2)))
+ return;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "Simplified\n ");
+ print_gimple_stmt (dump_file, stmt, 0, dump_flags);
+ fprintf (dump_file, "after previous\n ");
+ print_gimple_stmt (dump_file, defstmt, 0, dump_flags);
+ }
+
+ /* For simplicity, don't change the kind of the stmt,
+ turn dest = src; into dest = {}; and memcpy (&dest, &src, len);
+ into memset (&dest, val, len);
+ In theory we could change dest = src into memset if dest
+ is addressable (maybe beneficial if val is not 0), or
+ memcpy (&dest, &src, len) into dest = {} if len is the size
+ of dest, dest isn't volatile. */
+ if (is_gimple_assign (stmt))
+ {
+ tree ctor = build_constructor (TREE_TYPE (dest), NULL);
+ gimple_assign_set_rhs_from_tree (gsip, ctor);
+ update_stmt (stmt);
+ }
+ else /* If stmt is memcpy, transform it into memset. */
+ {
+ gcall *call = as_a <gcall *> (stmt);
+ tree fndecl = builtin_decl_implicit (BUILT_IN_MEMSET);
+ gimple_call_set_fndecl (call, fndecl);
+ gimple_call_set_fntype (call, TREE_TYPE (fndecl));
+ gimple_call_set_arg (call, 1, val);
+ update_stmt (stmt);
+ }
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "into\n ");
+ print_gimple_stmt (dump_file, stmt, 0, dump_flags);
+ }
+}
+
/* A simple pass that attempts to fold all builtin functions. This pass
is run after we've propagated as many constants as we can. */
continue;
}
}
+ else if (gimple_assign_load_p (stmt) && gimple_store_p (stmt))
+ optimize_memcpy (&i, gimple_assign_lhs (stmt),
+ gimple_assign_rhs1 (stmt), NULL_TREE);
gsi_next (&i);
continue;
}
callee = gimple_call_fndecl (stmt);
- if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
+ if (!callee || !fndecl_built_in_p (callee, BUILT_IN_NORMAL))
{
gsi_next (&i);
continue;
false, false);
break;
+ case BUILT_IN_MEMCPY:
+ if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL)
+ && TREE_CODE (gimple_call_arg (stmt, 0)) == ADDR_EXPR
+ && TREE_CODE (gimple_call_arg (stmt, 1)) == ADDR_EXPR
+ && TREE_CODE (gimple_call_arg (stmt, 2)) == INTEGER_CST)
+ {
+ tree dest = TREE_OPERAND (gimple_call_arg (stmt, 0), 0);
+ tree src = TREE_OPERAND (gimple_call_arg (stmt, 1), 0);
+ tree len = gimple_call_arg (stmt, 2);
+ optimize_memcpy (&i, dest, src, len);
+ }
+ break;
+
case BUILT_IN_VA_START:
case BUILT_IN_VA_END:
case BUILT_IN_VA_COPY:
/* These shouldn't be folded before pass_stdarg. */
result = optimize_stdarg_builtin (stmt);
- if (result)
- break;
- /* FALLTHRU */
+ break;
default:;
}
}
callee = gimple_call_fndecl (stmt);
if (!callee
- || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
- || DECL_FUNCTION_CODE (callee) == fcode)
+ || !fndecl_built_in_p (callee, fcode))
gsi_next (&i);
}
}
{
return new pass_fold_builtins (ctxt);
}
+
+/* A simple pass that emits some warnings post IPA. */
+
+namespace {
+
+const pass_data pass_data_post_ipa_warn =
+{
+ GIMPLE_PASS, /* type */
+ "post_ipa_warn", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ TV_NONE, /* tv_id */
+ ( PROP_cfg | PROP_ssa ), /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
+
+class pass_post_ipa_warn : public gimple_opt_pass
+{
+public:
+ pass_post_ipa_warn (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_post_ipa_warn, ctxt)
+ {}
+
+ /* opt_pass methods: */
+ opt_pass * clone () { return new pass_post_ipa_warn (m_ctxt); }
+ virtual bool gate (function *) { return warn_nonnull != 0; }
+ virtual unsigned int execute (function *);
+
+}; // class pass_fold_builtins
+
+unsigned int
+pass_post_ipa_warn::execute (function *fun)
+{
+ basic_block bb;
+
+ FOR_EACH_BB_FN (bb, fun)
+ {
+ gimple_stmt_iterator gsi;
+ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ {
+ gimple *stmt = gsi_stmt (gsi);
+ if (!is_gimple_call (stmt) || gimple_no_warning_p (stmt))
+ continue;
+
+ if (warn_nonnull)
+ {
+ bitmap nonnullargs
+ = get_nonnull_args (gimple_call_fntype (stmt));
+ if (nonnullargs)
+ {
+ for (unsigned i = 0; i < gimple_call_num_args (stmt); i++)
+ {
+ tree arg = gimple_call_arg (stmt, i);
+ if (TREE_CODE (TREE_TYPE (arg)) != POINTER_TYPE)
+ continue;
+ if (!integer_zerop (arg))
+ continue;
+ if (!bitmap_empty_p (nonnullargs)
+ && !bitmap_bit_p (nonnullargs, i))
+ continue;
+
+ location_t loc = gimple_location (stmt);
+ auto_diagnostic_group d;
+ if (warning_at (loc, OPT_Wnonnull,
+ "%Gargument %u null where non-null "
+ "expected", stmt, i + 1))
+ {
+ tree fndecl = gimple_call_fndecl (stmt);
+ if (fndecl && DECL_IS_BUILTIN (fndecl))
+ inform (loc, "in a call to built-in function %qD",
+ fndecl);
+ else if (fndecl)
+ inform (DECL_SOURCE_LOCATION (fndecl),
+ "in a call to function %qD declared here",
+ fndecl);
+
+ }
+ }
+ BITMAP_FREE (nonnullargs);
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_post_ipa_warn (gcc::context *ctxt)
+{
+ return new pass_post_ipa_warn (ctxt);
+}