#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "flags.h"
#include "rtl.h"
#include "tm_p.h"
#include "ggc.h"
#include "basic-block.h"
#include "output.h"
#include "expr.h"
#include "function.h"
#include "diagnostic.h"
#include "timevar.h"
#include "tree-dump.h"
#include "tree-flow.h"
#include "tree-pass.h"
#include "tree-ssa-propagate.h"
#include "langhooks.h"
#include "target.h"
#include "toplev.h"
typedef enum
{
UNINITIALIZED = 0,
UNDEFINED,
UNKNOWN_VAL,
CONSTANT,
VARYING
} ccp_lattice_t;
static prop_value_t *const_val;
static bool do_store_ccp;
static void
dump_lattice_value (FILE *outf, const char *prefix, prop_value_t val)
{
switch (val.lattice_val)
{
case UNINITIALIZED:
fprintf (outf, "%sUNINITIALIZED", prefix);
break;
case UNDEFINED:
fprintf (outf, "%sUNDEFINED", prefix);
break;
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);
break;
default:
gcc_unreachable ();
}
}
void debug_lattice_value (prop_value_t val);
void
debug_lattice_value (prop_value_t val)
{
dump_lattice_value (stderr, "", val);
fprintf (stderr, "\n");
}
static bool
ccp_decl_initial_min_invariant (tree t)
{
if (!is_gimple_min_invariant (t))
return false;
if (TREE_CODE (t) == ADDR_EXPR)
{
while (1)
{
t = TREE_OPERAND (t, 0);
if (is_gimple_id (t))
return true;
if (!handled_component_p (t))
return false;
}
}
return true;
}
static prop_value_t
get_default_value (tree var)
{
tree sym = SSA_NAME_VAR (var);
prop_value_t val = { UNINITIALIZED, NULL_TREE, NULL_TREE };
if (!do_store_ccp && !is_gimple_reg (var))
{
val.lattice_val = VARYING;
}
else if (SSA_NAME_VALUE (var)
&& is_gimple_min_invariant (SSA_NAME_VALUE (var)))
{
val.lattice_val = CONSTANT;
val.value = SSA_NAME_VALUE (var);
}
else if (TREE_STATIC (sym)
&& TREE_READONLY (sym)
&& !MTAG_P (sym)
&& DECL_INITIAL (sym)
&& ccp_decl_initial_min_invariant (DECL_INITIAL (sym)))
{
val.lattice_val = CONSTANT;
val.value = DECL_INITIAL (sym);
val.mem_ref = sym;
}
else
{
tree stmt = SSA_NAME_DEF_STMT (var);
if (IS_EMPTY_STMT (stmt))
{
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
|| TREE_CODE (stmt) == PHI_NODE)
{
val.lattice_val = is_gimple_reg (sym) ? UNDEFINED : UNKNOWN_VAL;
}
else
{
val.lattice_val = VARYING;
}
}
return val;
}
static prop_value_t *
get_value (tree var, bool may_use_default_p)
{
prop_value_t *val = &const_val[SSA_NAME_VERSION (var)];
if (may_use_default_p && val->lattice_val == UNINITIALIZED)
*val = get_default_value (var);
return val;
}
static bool
set_lattice_value (tree var, prop_value_t new_val)
{
prop_value_t *old_val = get_value (var, false);
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));
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");
}
*old_val = new_val;
return (new_val.lattice_val != UNDEFINED);
}
return false;
}
static ccp_lattice_t
likely_value (tree stmt)
{
bool found_constant;
stmt_ann_t ann;
tree use;
ssa_op_iter iter;
ann = stmt_ann (stmt);
if (ann->has_volatile_ops)
return VARYING;
if (!do_store_ccp
&& !ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
return VARYING;
if (get_call_expr_in (stmt) != NULL_TREE)
return VARYING;
if (TREE_CODE (stmt) != MODIFY_EXPR
&& TREE_CODE (stmt) != COND_EXPR
&& TREE_CODE (stmt) != SWITCH_EXPR)
return VARYING;
if (is_gimple_min_invariant (get_rhs (stmt)))
return CONSTANT;
found_constant = false;
FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
{
prop_value_t *val = get_value (use, true);
if (val->lattice_val == VARYING)
return VARYING;
if (val->lattice_val == UNKNOWN_VAL)
{
gcc_assert (do_store_ccp);
return UNKNOWN_VAL;
}
if (val->lattice_val == CONSTANT)
found_constant = true;
}
if (found_constant
|| ZERO_SSA_OPERANDS (stmt, SSA_OP_USE)
|| ZERO_SSA_OPERANDS (stmt, SSA_OP_VUSE))
return CONSTANT;
return UNDEFINED;
}
static void
ccp_initialize (void)
{
basic_block bb;
const_val = XNEWVEC (prop_value_t, num_ssa_names);
memset (const_val, 0, num_ssa_names * sizeof (*const_val));
FOR_EACH_BB (bb)
{
block_stmt_iterator i;
for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
{
bool is_varying = false;
tree stmt = bsi_stmt (i);
if (likely_value (stmt) == VARYING)
{
tree def;
ssa_op_iter iter;
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
get_value (def, false)->lattice_val = VARYING;
if (TREE_CODE (stmt) != COND_EXPR
&& TREE_CODE (stmt) != SWITCH_EXPR)
is_varying = true;
}
DONT_SIMULATE_AGAIN (stmt) = is_varying;
}
}
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);
}
}
}
static void
ccp_finalize (void)
{
substitute_and_fold (const_val, false);
free (const_val);
}
static void
ccp_lattice_meet (prop_value_t *val1, prop_value_t *val2)
{
if (val1->lattice_val == UNDEFINED)
{
*val1 = *val2;
}
else if (val2->lattice_val == UNDEFINED)
{
;
}
else if (val1->lattice_val == UNKNOWN_VAL
|| val2->lattice_val == UNKNOWN_VAL)
{
gcc_assert (do_store_ccp);
val1->lattice_val = UNKNOWN_VAL;
val1->value = NULL_TREE;
val1->mem_ref = NULL_TREE;
}
else if (val1->lattice_val == VARYING
|| val2->lattice_val == VARYING)
{
val1->lattice_val = VARYING;
val1->value = NULL_TREE;
val1->mem_ref = NULL_TREE;
}
else if (val1->lattice_val == CONSTANT
&& val2->lattice_val == CONSTANT
&& simple_cst_equal (val1->value, val2->value) == 1
&& (!do_store_ccp
|| (val1->mem_ref && val2->mem_ref
&& operand_equal_p (val1->mem_ref, val2->mem_ref, 0))))
{
val1->lattice_val = CONSTANT;
val1->value = val1->value;
val1->mem_ref = val1->mem_ref;
}
else
{
val1->lattice_val = VARYING;
val1->value = NULL_TREE;
val1->mem_ref = NULL_TREE;
}
}
static enum ssa_prop_result
ccp_visit_phi_node (tree phi)
{
int i;
prop_value_t *old_val, new_val;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\nVisiting PHI node: ");
print_generic_expr (dump_file, phi, dump_flags);
}
old_val = get_value (PHI_RESULT (phi), false);
switch (old_val->lattice_val)
{
case VARYING:
return SSA_PROP_VARYING;
case CONSTANT:
new_val = *old_val;
break;
case UNKNOWN_VAL:
gcc_assert (do_store_ccp);
case UNDEFINED:
case UNINITIALIZED:
new_val.lattice_val = UNDEFINED;
new_val.value = NULL_TREE;
new_val.mem_ref = NULL_TREE;
break;
default:
gcc_unreachable ();
}
for (i = 0; i < PHI_NUM_ARGS (phi); i++)
{
edge e = PHI_ARG_EDGE (phi, i);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file,
"\n Argument #%d (%d -> %d %sexecutable)\n",
i, e->src->index, e->dest->index,
(e->flags & EDGE_EXECUTABLE) ? "" : "not ");
}
if (e->flags & EDGE_EXECUTABLE)
{
tree arg = PHI_ARG_DEF (phi, i);
prop_value_t arg_val;
if (is_gimple_min_invariant (arg))
{
arg_val.lattice_val = CONSTANT;
arg_val.value = arg;
arg_val.mem_ref = NULL_TREE;
}
else
arg_val = *(get_value (arg, true));
ccp_lattice_meet (&new_val, &arg_val);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\t");
print_generic_expr (dump_file, arg, dump_flags);
dump_lattice_value (dump_file, "\tValue: ", arg_val);
fprintf (dump_file, "\n");
}
if (new_val.lattice_val == VARYING)
break;
}
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
dump_lattice_value (dump_file, "\n PHI node value: ", new_val);
fprintf (dump_file, "\n\n");
}
if (do_store_ccp
&& old_val->lattice_val == UNKNOWN_VAL
&& new_val.lattice_val == UNDEFINED)
return SSA_PROP_NOT_INTERESTING;
if (set_lattice_value (PHI_RESULT (phi), new_val))
{
if (new_val.lattice_val == VARYING)
return SSA_PROP_VARYING;
else
return SSA_PROP_INTERESTING;
}
else
return SSA_PROP_NOT_INTERESTING;
}
static tree
ccp_fold (tree stmt)
{
tree rhs = get_rhs (stmt);
enum tree_code code = TREE_CODE (rhs);
enum tree_code_class kind = TREE_CODE_CLASS (code);
tree retval = NULL_TREE;
if (TREE_CODE (rhs) == SSA_NAME)
{
return get_value (rhs, true)->value;
}
else if (do_store_ccp && stmt_makes_single_load (stmt))
{
prop_value_t *val = get_value_loaded_by (stmt, const_val);
if (val && val->mem_ref)
{
if (operand_equal_p (val->mem_ref, rhs, 0))
return val->value;
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;
}
if (kind == tcc_unary)
{
tree op0 = TREE_OPERAND (rhs, 0);
if (TREE_CODE (op0) == SSA_NAME)
{
prop_value_t *val = get_value (op0, true);
if (val->lattice_val == CONSTANT)
op0 = get_value (op0, true)->value;
}
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);
}
else if (kind == tcc_binary
|| kind == tcc_comparison
|| code == TRUTH_AND_EXPR
|| code == TRUTH_OR_EXPR
|| code == TRUTH_XOR_EXPR)
{
tree op0 = TREE_OPERAND (rhs, 0);
tree op1 = TREE_OPERAND (rhs, 1);
if (TREE_CODE (op0) == SSA_NAME)
{
prop_value_t *val = get_value (op0, true);
if (val->lattice_val == CONSTANT)
op0 = val->value;
}
if (TREE_CODE (op1) == SSA_NAME)
{
prop_value_t *val = get_value (op1, true);
if (val->lattice_val == CONSTANT)
op1 = val->value;
}
return fold_binary (code, TREE_TYPE (rhs), op0, op1);
}
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)))
{
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;
orig = XNEWVEC (tree, NUM_SSA_OPERANDS (stmt, SSA_OP_USE));
FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_USE)
orig[i++] = var;
replace_uses_in (stmt, NULL, const_val);
fndecl = get_callee_fndecl (rhs);
arglist = TREE_OPERAND (rhs, 1);
retval = fold_builtin (fndecl, arglist, false);
i = 0;
FOR_EACH_SSA_USE_OPERAND (var_p, stmt, iter, SSA_OP_USE)
SET_USE (var_p, orig[i++]);
free (orig);
}
}
else
return rhs;
if (retval)
return fold_convert (TREE_TYPE (rhs), retval);
return rhs;
}
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:
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;
idx = TREE_OPERAND (t, 1);
switch (TREE_CODE (idx))
{
case SSA_NAME:
if ((value = get_value (idx, true))
&& 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;
}
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;
}
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
if (tree_int_cst_equal (cfield, idx))
return cval;
break;
case COMPONENT_REF:
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
&& ! 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;
}
static prop_value_t
evaluate_stmt (tree stmt)
{
prop_value_t val;
tree simplified = NULL_TREE;
ccp_lattice_t likelyvalue = likely_value (stmt);
bool is_constant;
val.mem_ref = NULL_TREE;
fold_defer_overflow_warnings ();
if (likelyvalue == CONSTANT)
simplified = ccp_fold (stmt);
if (likelyvalue == VARYING)
simplified = get_rhs (stmt);
else if (!simplified)
simplified = fold_const_aggregate_ref (get_rhs (stmt));
is_constant = simplified && is_gimple_min_invariant (simplified);
fold_undefer_overflow_warnings (is_constant, stmt, 0);
if (is_constant)
{
val.lattice_val = CONSTANT;
val.value = simplified;
}
else
{
if (likelyvalue == UNDEFINED || likelyvalue == UNKNOWN_VAL)
val.lattice_val = likelyvalue;
else
val.lattice_val = VARYING;
val.value = NULL_TREE;
}
return val;
}
static enum ssa_prop_result
visit_assignment (tree stmt, tree *output_p)
{
prop_value_t val;
tree lhs, rhs;
enum ssa_prop_result retval;
lhs = TREE_OPERAND (stmt, 0);
rhs = TREE_OPERAND (stmt, 1);
if (TREE_CODE (rhs) == SSA_NAME)
{
prop_value_t *nval = get_value (rhs, true);
val = *nval;
}
else if (do_store_ccp && stmt_makes_single_load (stmt))
{
prop_value_t *nval = get_value_loaded_by (stmt, const_val);
if (nval && nval->mem_ref
&& operand_equal_p (nval->mem_ref, rhs, 0))
val = *nval;
else
val = evaluate_stmt (stmt);
}
else
val = evaluate_stmt (stmt);
{
tree orig_lhs = TREE_OPERAND (stmt, 0);
if (TREE_CODE (orig_lhs) == VIEW_CONVERT_EXPR
&& val.lattice_val == CONSTANT)
{
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))
val.value = w;
else
{
val.lattice_val = VARYING;
val.value = NULL;
}
}
if (val.lattice_val == CONSTANT
&& TREE_CODE (orig_lhs) == COMPONENT_REF
&& DECL_BIT_FIELD (TREE_OPERAND (orig_lhs, 1)))
{
tree w = widen_bitfield (val.value, TREE_OPERAND (orig_lhs, 1),
orig_lhs);
if (w && is_gimple_min_invariant (w))
val.value = w;
else
{
val.lattice_val = VARYING;
val.value = NULL_TREE;
val.mem_ref = NULL_TREE;
}
}
}
retval = SSA_PROP_NOT_INTERESTING;
if (TREE_CODE (lhs) == SSA_NAME)
{
if (set_lattice_value (lhs, val))
{
*output_p = lhs;
if (val.lattice_val == VARYING)
retval = SSA_PROP_VARYING;
else
retval = SSA_PROP_INTERESTING;
}
}
else if (do_store_ccp && stmt_makes_single_store (stmt))
{
ssa_op_iter i;
tree vdef;
bool changed;
if (val.lattice_val == UNDEFINED)
val.lattice_val = UNKNOWN_VAL;
val.mem_ref = lhs;
changed = false;
FOR_EACH_SSA_TREE_OPERAND (vdef, stmt, i, SSA_OP_VIRTUAL_DEFS)
changed |= set_lattice_value (vdef, val);
*output_p = first_vdef (stmt);
if (changed)
{
if (val.lattice_val == VARYING)
retval = SSA_PROP_VARYING;
else
retval = SSA_PROP_INTERESTING;
}
}
return retval;
}
static enum ssa_prop_result
visit_cond_stmt (tree stmt, edge *taken_edge_p)
{
prop_value_t val;
basic_block block;
block = bb_for_stmt (stmt);
val = evaluate_stmt (stmt);
*taken_edge_p = val.value ? find_taken_edge (block, val.value) : 0;
if (*taken_edge_p)
return SSA_PROP_INTERESTING;
else
return SSA_PROP_VARYING;
}
static enum ssa_prop_result
ccp_visit_stmt (tree stmt, edge *taken_edge_p, tree *output_p)
{
tree def;
ssa_op_iter iter;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\nVisiting statement:\n");
print_generic_stmt (dump_file, stmt, dump_flags);
fprintf (dump_file, "\n");
}
if (TREE_CODE (stmt) == MODIFY_EXPR)
{
return visit_assignment (stmt, output_p);
}
else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR)
{
return visit_cond_stmt (stmt, taken_edge_p);
}
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "No interesting values produced. Marked VARYING.\n");
FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
{
prop_value_t v = { VARYING, NULL_TREE, NULL_TREE };
set_lattice_value (def, v);
}
return SSA_PROP_VARYING;
}
static void
execute_ssa_ccp (bool store_ccp)
{
do_store_ccp = store_ccp;
ccp_initialize ();
ssa_propagate (ccp_visit_stmt, ccp_visit_phi_node);
ccp_finalize ();
}
static unsigned int
do_ssa_ccp (void)
{
execute_ssa_ccp (false);
return 0;
}
static bool
gate_ccp (void)
{
return flag_tree_ccp != 0;
}
struct tree_opt_pass pass_ccp =
{
"ccp",
gate_ccp,
do_ssa_ccp,
NULL,
NULL,
0,
TV_TREE_CCP,
PROP_cfg | PROP_ssa | PROP_alias,
0,
PROP_smt_usage,
0,
TODO_cleanup_cfg | TODO_dump_func | TODO_update_ssa
| TODO_ggc_collect | TODO_verify_ssa
| TODO_verify_stmts | TODO_update_smt_usage,
0
};
static unsigned int
do_ssa_store_ccp (void)
{
execute_ssa_ccp (flag_tree_store_ccp != 0);
return 0;
}
static bool
gate_store_ccp (void)
{
return flag_tree_store_ccp != 0 || flag_tree_ccp != 0;
}
struct tree_opt_pass pass_store_ccp =
{
"store_ccp",
gate_store_ccp,
do_ssa_store_ccp,
NULL,
NULL,
0,
TV_TREE_STORE_CCP,
PROP_cfg | PROP_ssa | PROP_alias,
0,
PROP_smt_usage,
0,
TODO_dump_func | TODO_update_ssa
| TODO_ggc_collect | TODO_verify_ssa
| TODO_cleanup_cfg
| TODO_verify_stmts | TODO_update_smt_usage,
0
};
tree
widen_bitfield (tree val, tree field, tree var)
{
unsigned HOST_WIDE_INT var_size, field_size;
tree wide_val;
unsigned HOST_WIDE_INT mask;
unsigned int i;
if (!host_integerp (TYPE_SIZE (TREE_TYPE (var)), 1)
|| !host_integerp (DECL_SIZE (field), 1)
|| !host_integerp (val, 0))
return NULL_TREE;
var_size = tree_low_cst (TYPE_SIZE (TREE_TYPE (var)), 1);
field_size = tree_low_cst (DECL_SIZE (field), 1);
if (field_size > HOST_BITS_PER_WIDE_INT || var_size > HOST_BITS_PER_WIDE_INT)
return NULL_TREE;
gcc_assert (var_size >= field_size);
if (DECL_UNSIGNED (field)
|| !(tree_low_cst (val, 0) & (((HOST_WIDE_INT)1) << (field_size - 1))))
{
for (i = 0, mask = 0; i < field_size; i++)
mask |= ((HOST_WIDE_INT) 1) << i;
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 = fold_build2 (BIT_IOR_EXPR, TREE_TYPE (var), val,
build_int_cst (TREE_TYPE (var), mask));
}
return wide_val;
}
static tree
maybe_fold_offset_to_array_ref (tree base, tree offset, tree orig_type)
{
tree min_idx, idx, elt_offset = integer_zero_node;
tree array_type, elt_type, elt_size;
if (TREE_CODE (base) == ARRAY_REF)
{
tree low_bound = array_ref_low_bound (base);
elt_offset = TREE_OPERAND (base, 1);
if (TREE_CODE (low_bound) != INTEGER_CST
|| TREE_CODE (elt_offset) != INTEGER_CST)
return NULL_TREE;
elt_offset = int_const_binop (MINUS_EXPR, elt_offset, low_bound, 0);
base = TREE_OPERAND (base, 0);
}
array_type = TREE_TYPE (base);
if (TREE_CODE (array_type) != ARRAY_TYPE)
return NULL_TREE;
elt_type = TREE_TYPE (array_type);
if (!lang_hooks.types_compatible_p (orig_type, elt_type))
return NULL_TREE;
elt_size = TYPE_SIZE_UNIT (elt_type);
if (integer_zerop (offset))
{
if (TREE_CODE (elt_size) != INTEGER_CST)
elt_size = size_int (TYPE_ALIGN (elt_type));
idx = integer_zero_node;
}
else
{
unsigned HOST_WIDE_INT lquo, lrem;
HOST_WIDE_INT hquo, hrem;
if (TREE_CODE (elt_size) != INTEGER_CST
|| div_and_round_double (TRUNC_DIV_EXPR, 1,
TREE_INT_CST_LOW (offset),
TREE_INT_CST_HIGH (offset),
TREE_INT_CST_LOW (elt_size),
TREE_INT_CST_HIGH (elt_size),
&lquo, &hquo, &lrem, &hrem)
|| lrem || hrem)
return NULL_TREE;
idx = build_int_cst_wide (NULL_TREE, lquo, hquo);
}
min_idx = integer_zero_node;
if (TYPE_DOMAIN (array_type))
{
if (TYPE_MIN_VALUE (TYPE_DOMAIN (array_type)))
min_idx = TYPE_MIN_VALUE (TYPE_DOMAIN (array_type));
else
min_idx = fold_convert (TYPE_DOMAIN (array_type), min_idx);
if (TREE_CODE (min_idx) != INTEGER_CST)
return NULL_TREE;
idx = fold_convert (TYPE_DOMAIN (array_type), idx);
elt_offset = fold_convert (TYPE_DOMAIN (array_type), elt_offset);
}
if (!integer_zerop (min_idx))
idx = int_const_binop (PLUS_EXPR, idx, min_idx, 0);
if (!integer_zerop (elt_offset))
idx = int_const_binop (PLUS_EXPR, idx, elt_offset, 0);
return build4 (ARRAY_REF, orig_type, base, idx, min_idx,
size_int (tree_low_cst (elt_size, 1)
/ (TYPE_ALIGN_UNIT (elt_type))));
}
static 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;
if (TREE_CODE (record_type) != RECORD_TYPE
&& TREE_CODE (record_type) != UNION_TYPE
&& TREE_CODE (record_type) != QUAL_UNION_TYPE)
return NULL_TREE;
if (lang_hooks.types_compatible_p (record_type, orig_type))
return NULL_TREE;
tail_array_field = NULL_TREE;
for (f = TYPE_FIELDS (record_type); f ; f = TREE_CHAIN (f))
{
int cmp;
if (TREE_CODE (f) != FIELD_DECL)
continue;
if (DECL_BIT_FIELD (f))
continue;
field_offset = byte_position (f);
if (TREE_CODE (field_offset) != INTEGER_CST)
continue;
if (!DECL_FIELD_CONTEXT (f))
continue;
tail_array_field = NULL_TREE;
cmp = tree_int_cst_compare (field_offset, offset);
if (cmp > 0)
continue;
field_type = TREE_TYPE (f);
if (cmp == 0
&& lang_hooks.types_compatible_p (orig_type, field_type))
{
if (base_is_ptr)
base = build1 (INDIRECT_REF, record_type, base);
t = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
return t;
}
if (!AGGREGATE_TYPE_P (field_type))
continue;
if (TREE_CODE (field_type) == ARRAY_TYPE)
tail_array_field = f;
if (!DECL_SIZE_UNIT (f)
|| TREE_CODE (DECL_SIZE_UNIT (f)) != INTEGER_CST)
continue;
t = int_const_binop (MINUS_EXPR, offset, field_offset, 1);
if (!tree_int_cst_lt (t, DECL_SIZE_UNIT (f)))
continue;
offset = t;
goto found;
}
if (!tail_array_field)
return NULL_TREE;
f = tail_array_field;
field_type = TREE_TYPE (f);
offset = int_const_binop (MINUS_EXPR, offset, byte_position (f), 1);
found:
if (base_is_ptr)
base = build1 (INDIRECT_REF, record_type, base);
base = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
t = maybe_fold_offset_to_array_ref (base, offset, orig_type);
if (t)
return t;
return maybe_fold_offset_to_component_ref (field_type, base, offset,
orig_type, false);
}
static tree
maybe_fold_stmt_indirect (tree expr, tree base, tree offset)
{
tree t;
base = fold (base);
STRIP_TYPE_NOPS (base);
TREE_OPERAND (expr, 0) = base;
t = fold_read_from_constant_string (expr);
if (t)
return t;
if (TREE_CODE (base) == PLUS_EXPR)
{
tree offset2;
offset2 = TREE_OPERAND (base, 1);
if (TREE_CODE (offset2) != INTEGER_CST)
return NULL_TREE;
base = TREE_OPERAND (base, 0);
offset = int_const_binop (PLUS_EXPR, offset, offset2, 1);
}
if (TREE_CODE (base) == ADDR_EXPR)
{
base = TREE_OPERAND (base, 0);
if (TREE_CODE (base) == CONST_DECL
&& ccp_decl_initial_min_invariant (DECL_INITIAL (base)))
return DECL_INITIAL (base);
t = maybe_fold_offset_to_array_ref (base, offset, TREE_TYPE (expr));
if (t)
return t;
t = maybe_fold_offset_to_component_ref (TREE_TYPE (base), base, offset,
TREE_TYPE (expr), false);
if (t)
return t;
if (integer_zerop (offset)
&& lang_hooks.types_compatible_p (TREE_TYPE (base),
TREE_TYPE (expr)))
return base;
}
else
{
t = base;
STRIP_NOPS (t);
if (TREE_CODE (t) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
{
return integer_zero_node;
}
if (POINTER_TYPE_P (TREE_TYPE (base)))
{
t = maybe_fold_offset_to_component_ref (TREE_TYPE (TREE_TYPE (base)),
base, offset,
TREE_TYPE (expr), true);
if (t)
return t;
}
}
return NULL_TREE;
}
static tree
maybe_fold_stmt_addition (tree expr)
{
tree op0 = TREE_OPERAND (expr, 0);
tree op1 = TREE_OPERAND (expr, 1);
tree ptr_type = TREE_TYPE (expr);
tree ptd_type;
tree t;
bool subtract = (TREE_CODE (expr) == MINUS_EXPR);
if (!POINTER_TYPE_P (ptr_type))
return NULL_TREE;
if (INTEGRAL_TYPE_P (TREE_TYPE (op0)))
{
if (subtract)
return NULL_TREE;
t = op0, op0 = op1, op1 = t;
}
if (TREE_CODE (op1) != INTEGER_CST)
return NULL_TREE;
if (TREE_CODE (op0) != ADDR_EXPR)
return NULL_TREE;
op0 = TREE_OPERAND (op0, 0);
while (TREE_CODE (op0) == ARRAY_REF)
{
tree array_obj = TREE_OPERAND (op0, 0);
tree array_idx = TREE_OPERAND (op0, 1);
tree elt_type = TREE_TYPE (op0);
tree elt_size = TYPE_SIZE_UNIT (elt_type);
tree min_idx;
if (TREE_CODE (array_idx) != INTEGER_CST)
break;
if (TREE_CODE (elt_size) != INTEGER_CST)
break;
min_idx = TYPE_DOMAIN (TREE_TYPE (array_obj));
if (min_idx)
{
min_idx = TYPE_MIN_VALUE (min_idx);
if (min_idx)
{
if (TREE_CODE (min_idx) != INTEGER_CST)
break;
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);
}
}
array_idx = fold_convert (sizetype, array_idx);
array_idx = int_const_binop (MULT_EXPR, array_idx, elt_size, 0);
if (subtract
&& TYPE_UNSIGNED (TREE_TYPE (op1))
&& tree_int_cst_lt (array_idx, op1))
return NULL;
op1 = int_const_binop (subtract ? MINUS_EXPR : PLUS_EXPR,
array_idx, op1, 0);
subtract = false;
op0 = array_obj;
}
if (subtract)
{
if (TYPE_UNSIGNED (TREE_TYPE (op1)))
return NULL;
op1 = fold_unary (NEGATE_EXPR, TREE_TYPE (op1), op1);
if (op1 == NULL || TREE_CODE (op1) != INTEGER_CST)
return NULL;
}
ptd_type = TREE_TYPE (ptr_type);
t = maybe_fold_offset_to_array_ref (op0, op1, ptd_type);
if (!t)
t = maybe_fold_offset_to_component_ref (TREE_TYPE (op0), op0, op1,
ptd_type, false);
if (t)
t = build1 (ADDR_EXPR, ptr_type, t);
return t;
}
struct fold_stmt_r_data
{
tree stmt;
bool *changed_p;
bool *inside_addr_expr_p;
};
static tree
fold_stmt_r (tree *expr_p, int *walk_subtrees, void *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;
switch (TREE_CODE (expr))
{
case INDIRECT_REF:
t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
if (t)
return t;
*walk_subtrees = 0;
t = maybe_fold_stmt_indirect (expr, TREE_OPERAND (expr, 0),
integer_zero_node);
break;
case ARRAY_REF:
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;
if (*changed_p)
recompute_tree_invariant_for_addr_expr (expr);
return NULL_TREE;
case PLUS_EXPR:
case MINUS_EXPR:
t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
if (t)
return t;
t = walk_tree (&TREE_OPERAND (expr, 1), fold_stmt_r, data, NULL);
if (t)
return t;
*walk_subtrees = 0;
t = maybe_fold_stmt_addition (expr);
break;
case COMPONENT_REF:
t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
if (t)
return t;
*walk_subtrees = 0;
{
tree expr_record = TREE_TYPE (TREE_OPERAND (expr, 0));
tree expr_field = TREE_OPERAND (expr, 1);
if (DECL_FIELD_CONTEXT (expr_field) != TYPE_MAIN_VARIANT (expr_record))
{
expr_field = find_compatible_field (expr_record, expr_field);
TREE_OPERAND (expr, 1) = expr_field;
}
}
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 && is_gimple_condexpr (tem);
fold_undefer_overflow_warnings (set, fold_stmt_r_data->stmt, 0);
if (set)
TREE_OPERAND (expr, 0) = tem;
t = expr;
break;
}
default:
return NULL_TREE;
}
if (t)
{
*expr_p = t;
*changed_p = true;
}
return NULL_TREE;
}
static bool
get_maxval_strlen (tree arg, tree *length, bitmap visited, int type)
{
tree var, def_stmt, val;
if (TREE_CODE (arg) != SSA_NAME)
{
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)
{
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;
}
if (bitmap_bit_p (visited, SSA_NAME_VERSION (arg)))
return true;
bitmap_set_bit (visited, SSA_NAME_VERSION (arg));
var = arg;
def_stmt = SSA_NAME_DEF_STMT (var);
switch (TREE_CODE (def_stmt))
{
case MODIFY_EXPR:
{
tree rhs;
rhs = TREE_OPERAND (def_stmt, 1);
STRIP_NOPS (rhs);
return get_maxval_strlen (rhs, length, visited, type);
}
case PHI_NODE:
{
int i;
for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
{
tree arg = PHI_ARG_DEF (def_stmt, i);
if (arg == PHI_RESULT (def_stmt))
continue;
if (!get_maxval_strlen (arg, length, visited, type))
return false;
}
return true;
}
default:
break;
}
return false;
}
static tree
ccp_fold_builtin (tree stmt, tree fn)
{
tree result, val[3];
tree callee, arglist, a;
int arg_mask, i, type;
bitmap visited;
bool ignore;
ignore = TREE_CODE (stmt) != MODIFY_EXPR;
callee = get_callee_fndecl (fn);
arglist = TREE_OPERAND (fn, 1);
result = fold_builtin (callee, arglist, ignore);
if (result)
{
if (ignore)
STRIP_NOPS (result);
return result;
}
if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_MD)
return NULL_TREE;
if (!arglist)
return NULL_TREE;
switch (DECL_FUNCTION_CODE (callee))
{
case BUILT_IN_STRLEN:
case BUILT_IN_FPUTS:
case BUILT_IN_FPUTS_UNLOCKED:
arg_mask = 1;
type = 0;
break;
case BUILT_IN_STRCPY:
case BUILT_IN_STRNCPY:
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;
}
visited = BITMAP_ALLOC (NULL);
memset (val, 0, sizeof (val));
for (i = 0, a = arglist;
arg_mask;
i++, arg_mask >>= 1, a = TREE_CHAIN (a))
if (arg_mask & 1)
{
bitmap_clear (visited);
if (!get_maxval_strlen (TREE_VALUE (a), &val[i], visited, type))
val[i] = NULL_TREE;
}
BITMAP_FREE (visited);
result = NULL_TREE;
switch (DECL_FUNCTION_CODE (callee))
{
case BUILT_IN_STRLEN:
if (val[0])
{
tree new = fold_convert (TREE_TYPE (fn), val[0]);
if (is_gimple_val (new)
|| (is_gimple_cast (new)
&& is_gimple_val (TREE_OPERAND (new, 0))))
return new;
}
break;
case BUILT_IN_STRCPY:
if (val[1] && is_gimple_val (val[1]))
result = fold_builtin_strcpy (callee, arglist, val[1]);
break;
case BUILT_IN_STRNCPY:
if (val[1] && is_gimple_val (val[1]))
result = fold_builtin_strncpy (callee, arglist, val[1]);
break;
case BUILT_IN_FPUTS:
result = fold_builtin_fputs (arglist,
TREE_CODE (stmt) != MODIFY_EXPR, 0,
val[0]);
break;
case BUILT_IN_FPUTS_UNLOCKED:
result = fold_builtin_fputs (arglist,
TREE_CODE (stmt) != MODIFY_EXPR, 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, arglist, 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, arglist, 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 (arglist, 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 (arglist, val[1],
DECL_FUNCTION_CODE (callee));
break;
default:
gcc_unreachable ();
}
if (result && ignore)
result = fold_ignored_result (result);
return result;
}
bool
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 (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);
return true;
}
rhs = get_rhs (stmt);
if (!rhs)
return changed;
result = NULL_TREE;
if (TREE_CODE (rhs) == CALL_EXPR)
{
tree callee;
callee = get_callee_fndecl (rhs);
if (callee && DECL_BUILT_IN (callee))
result = ccp_fold_builtin (stmt, rhs);
else
{
callee = TREE_OPERAND (rhs, 0);
if (TREE_CODE (callee) == OBJ_TYPE_REF
&& lang_hooks.fold_obj_type_ref
&& TREE_CODE (OBJ_TYPE_REF_OBJECT (callee)) == ADDR_EXPR
&& DECL_P (TREE_OPERAND
(OBJ_TYPE_REF_OBJECT (callee), 0)))
{
tree t;
t = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (callee)));
t = lang_hooks.fold_obj_type_ref (callee, t);
if (t)
{
TREE_OPERAND (rhs, 0) = t;
changed = true;
}
}
}
}
if (result == NULL_TREE)
result = fold (rhs);
STRIP_USELESS_TYPE_CONVERSION (result);
if (result != rhs)
changed |= set_rhs (stmt_p, result);
return changed;
}
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;
}
static tree
convert_to_gimple_builtin (block_stmt_iterator *si_p, tree expr)
{
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);
pop_gimplify_context (NULL);
if (EXPR_HAS_LOCATION (stmt))
annotate_all_with_locus (&stmts, EXPR_LOCATION (stmt));
for (ti = tsi_start (stmts); !tsi_end_p (ti); tsi_next (&ti))
{
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));
bsi_next (si_p);
}
return tmp;
}
static unsigned int
execute_fold_all_builtins (void)
{
bool cfg_changed = false;
basic_block bb;
FOR_EACH_BB (bb)
{
block_stmt_iterator 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)
{
bsi_next (&i);
continue;
}
callee = get_callee_fndecl (call);
if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
{
bsi_next (&i);
continue;
}
fcode = DECL_FUNCTION_CODE (callee);
#ifdef ENABLE_LLVM
if (fcode != BUILT_IN_CONSTANT_P)
{
bsi_next (&i);
continue;
}
#endif
result = ccp_fold_builtin (*stmtp, call);
if (!result)
switch (DECL_FUNCTION_CODE (callee))
{
case BUILT_IN_CONSTANT_P:
result = integer_zero_node;
break;
default:
bsi_next (&i);
continue;
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Simplified\n ");
print_generic_stmt (dump_file, *stmtp, dump_flags);
}
if (!set_rhs (stmtp, result))
{
result = convert_to_gimple_builtin (&i, result);
if (result)
{
bool ok = set_rhs (stmtp, result);
gcc_assert (ok);
}
}
mark_new_vars_to_rename (*stmtp);
if (maybe_clean_or_replace_eh_stmt (old_stmt, *stmtp)
&& tree_purge_dead_eh_edges (bb))
cfg_changed = true;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "to\n ");
print_generic_stmt (dump_file, *stmtp, dump_flags);
fprintf (dump_file, "\n");
}
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);
}
}
if (cfg_changed)
cleanup_tree_cfg ();
return 0;
}
struct tree_opt_pass pass_fold_builtins =
{
"fab",
NULL,
execute_fold_all_builtins,
NULL,
NULL,
0,
0,
#ifdef ENABLE_LLVM
PROP_cfg,
#else
PROP_cfg | PROP_ssa | PROP_alias,
#endif
0,
0,
0,
#ifdef ENABLE_LLVM
TODO_dump_func,
#else
TODO_dump_func
| TODO_verify_ssa
| TODO_update_ssa,
#endif
0
};