void
dump_immediate_uses_for (FILE *file, tree var)
{
imm_use_iterator iter;
use_operand_p use_p;
gcc_assert (var && TREE_CODE (var) == SSA_NAME);
print_generic_expr (file, var, TDF_SLIM);
fprintf (file, " : -->");
if (has_zero_uses (var))
fprintf (file, " no uses.\n");
else
if (has_single_use (var))
fprintf (file, " single use.\n");
else
fprintf (file, "%d uses.\n", num_imm_uses (var));
FOR_EACH_IMM_USE_FAST (use_p, iter, var)
{
if (use_p->loc.stmt == NULL && use_p->use == NULL)
fprintf (file, "***end of stmt iterator marker***\n");
else
if (!is_gimple_reg (USE_FROM_PTR (use_p)))
print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_VOPS|TDF_MEMSYMS);
else
print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_SLIM);
}
fprintf(file, "\n");
}
/* For bounds used in CI check if bounds are produced by
intersection and we may use outer bounds instead. If
transformation is possible then fix check statement and
recompute its info. */
static void
chkp_use_outer_bounds_if_possible (struct check_info *ci)
{
gimple *bnd_def;
tree bnd1, bnd2, bnd_res = NULL;
int check_res1, check_res2;
if (TREE_CODE (ci->bounds) != SSA_NAME)
return;
bnd_def = SSA_NAME_DEF_STMT (ci->bounds);
if (gimple_code (bnd_def) != GIMPLE_CALL
|| gimple_call_fndecl (bnd_def) != chkp_intersect_fndecl)
return;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Check if bounds intersection is redundant: \n");
fprintf (dump_file, " check: ");
print_gimple_stmt (dump_file, ci->stmt, 0, 0);
fprintf (dump_file, " intersection: ");
print_gimple_stmt (dump_file, bnd_def, 0, 0);
fprintf (dump_file, "\n");
}
bnd1 = gimple_call_arg (bnd_def, 0);
bnd2 = gimple_call_arg (bnd_def, 1);
check_res1 = chkp_get_check_result (ci, bnd1);
check_res2 = chkp_get_check_result (ci, bnd2);
if (check_res1 == 1)
bnd_res = bnd2;
else if (check_res1 == -1)
bnd_res = bnd1;
else if (check_res2 == 1)
bnd_res = bnd1;
else if (check_res2 == -1)
bnd_res = bnd2;
if (bnd_res)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " action: use ");
print_generic_expr (dump_file, bnd2, 0);
fprintf (dump_file, " instead of ");
print_generic_expr (dump_file, ci->bounds, 0);
fprintf (dump_file, "\n");
}
ci->bounds = bnd_res;
gimple_call_set_arg (ci->stmt, 1, bnd_res);
update_stmt (ci->stmt);
chkp_fill_check_info (ci->stmt, ci);
}
}
static bool
remove_exits_and_undefined_stmts (struct loop *loop, unsigned int npeeled)
{
struct nb_iter_bound *elt;
bool changed = false;
for (elt = loop->bounds; elt; elt = elt->next)
{
/* If statement is known to be undefined after peeling, turn it
into unreachable (or trap when debugging experience is supposed
to be good). */
if (!elt->is_exit
&& wi::ltu_p (elt->bound, npeeled))
{
gimple_stmt_iterator gsi = gsi_for_stmt (elt->stmt);
gcall *stmt = gimple_build_call
(builtin_decl_implicit (BUILT_IN_UNREACHABLE), 0);
gimple_set_location (stmt, gimple_location (elt->stmt));
gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
split_block (gimple_bb (stmt), stmt);
changed = true;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Forced statement unreachable: ");
print_gimple_stmt (dump_file, elt->stmt, 0, 0);
}
}
/* If we know the exit will be taken after peeling, update. */
else if (elt->is_exit
&& wi::leu_p (elt->bound, npeeled))
{
basic_block bb = gimple_bb (elt->stmt);
edge exit_edge = EDGE_SUCC (bb, 0);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Forced exit to be taken: ");
print_gimple_stmt (dump_file, elt->stmt, 0, 0);
}
if (!loop_exit_edge_p (loop, exit_edge))
exit_edge = EDGE_SUCC (bb, 1);
gcc_checking_assert (loop_exit_edge_p (loop, exit_edge));
gcond *cond_stmt = as_a <gcond *> (elt->stmt);
if (exit_edge->flags & EDGE_TRUE_VALUE)
gimple_cond_make_true (cond_stmt);
else
gimple_cond_make_false (cond_stmt);
update_stmt (cond_stmt);
changed = true;
}
}
return changed;
}
static enum ssa_prop_result
copy_prop_visit_cond_stmt (gimple *stmt, edge *taken_edge_p)
{
enum ssa_prop_result retval = SSA_PROP_VARYING;
location_t loc = gimple_location (stmt);
tree op0 = valueize_val (gimple_cond_lhs (stmt));
tree op1 = valueize_val (gimple_cond_rhs (stmt));
/* See if we can determine the predicate's value. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Trying to determine truth value of ");
fprintf (dump_file, "predicate ");
print_gimple_stmt (dump_file, stmt, 0, 0);
}
/* Fold COND and see whether we get a useful result. */
tree folded_cond = fold_binary_loc (loc, gimple_cond_code (stmt),
boolean_type_node, op0, op1);
if (folded_cond)
{
basic_block bb = gimple_bb (stmt);
*taken_edge_p = find_taken_edge (bb, folded_cond);
if (*taken_edge_p)
retval = SSA_PROP_INTERESTING;
}
if (dump_file && (dump_flags & TDF_DETAILS) && *taken_edge_p)
fprintf (dump_file, "\nConditional will always take edge %d->%d\n",
(*taken_edge_p)->src->index, (*taken_edge_p)->dest->index);
return retval;
}
unsigned int pass_verbose()
{
warning(0, "%<%s%>", context);
basic_block bb;
gimple_stmt_iterator gsi;
fprintf( stderr, "* MYPROOF on %s()\n", IDENTIFIER_POINTER(DECL_NAME(cfun->decl)) );
FOR_EACH_BB( bb )
{
fprintf( stderr, " ** BB %d\n", bb->index );
for ( gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi) )
{
print_gimple_stmt ( stdout, gsi_stmt(gsi), 0, 0 );
read_stmt( gsi_stmt(gsi) );
}
}
/* recursively read loops */
if ( cfun->x_current_loops != NULL )
{
read_loop( cfun->x_current_loops->tree_root );
}
return 0;
}
static bool
optimize_tail_call (struct tailcall *t, bool opt_tailcalls)
{
if (t->tail_recursion)
{
eliminate_tail_call (t);
return true;
}
if (opt_tailcalls)
{
gimple stmt = gsi_stmt (t->call_gsi);
gimple_call_set_tail (stmt, true);
cfun->tail_call_marked = true;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Found tail call ");
print_gimple_stmt (dump_file, stmt, 0, dump_flags);
fprintf (dump_file, " in bb %i\n", (gsi_bb (t->call_gsi))->index);
}
}
return false;
}
static void
dump_var_info (tree var, usage_info *info, const char *intro)
{
fprintf (dump_file, "[DEF] %s for ", intro);
print_gimple_stmt (dump_file, SSA_NAME_DEF_STMT (var), 0, TDF_SLIM);
if (info)
dump_usage_info (dump_file, var, info);
}
static void
note_replacement (gimple *stmt, tree old_rhs, tree new_rhs)
{
fprintf (dump_file, "Replacing use of ");
print_generic_expr (dump_file, old_rhs, 0);
fprintf (dump_file, " with ");
print_generic_expr (dump_file, new_rhs, 0);
fprintf (dump_file, " in ");
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}
static void
remove_unused_var (tree var)
{
gimple *stmt = SSA_NAME_DEF_STMT (var);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Deleting ");
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
gsi_remove (&gsi, true);
release_defs (stmt);
}
void
backprop::complete_change (gimple *stmt)
{
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
if (fold_stmt (&gsi))
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " which folds to: ");
print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, TDF_SLIM);
}
}
update_stmt (gsi_stmt (gsi));
}
static bool
remove_redundant_iv_tests (struct loop *loop)
{
struct nb_iter_bound *elt;
bool changed = false;
if (!loop->any_upper_bound)
return false;
for (elt = loop->bounds; elt; elt = elt->next)
{
/* Exit is pointless if it won't be taken before loop reaches
upper bound. */
if (elt->is_exit && loop->any_upper_bound
&& wi::ltu_p (loop->nb_iterations_upper_bound, elt->bound))
{
basic_block bb = gimple_bb (elt->stmt);
edge exit_edge = EDGE_SUCC (bb, 0);
struct tree_niter_desc niter;
if (!loop_exit_edge_p (loop, exit_edge))
exit_edge = EDGE_SUCC (bb, 1);
/* Only when we know the actual number of iterations, not
just a bound, we can remove the exit. */
if (!number_of_iterations_exit (loop, exit_edge,
&niter, false, false)
|| !integer_onep (niter.assumptions)
|| !integer_zerop (niter.may_be_zero)
|| !niter.niter
|| TREE_CODE (niter.niter) != INTEGER_CST
|| !wi::ltu_p (loop->nb_iterations_upper_bound,
wi::to_widest (niter.niter)))
continue;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Removed pointless exit: ");
print_gimple_stmt (dump_file, elt->stmt, 0, 0);
}
gcond *cond_stmt = as_a <gcond *> (elt->stmt);
if (exit_edge->flags & EDGE_TRUE_VALUE)
gimple_cond_make_false (cond_stmt);
else
gimple_cond_make_true (cond_stmt);
update_stmt (cond_stmt);
changed = true;
}
}
return changed;
}
static unsigned int instrument_assignments_plugin_exec(void)
{
#ifdef DEBUG
fprintf(stderr, "* Inspecting function `%s'\n", FN_NAME);
#endif
basic_block bb;
FOR_EACH_BB(bb) {
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb(bb) ; !gsi_end_p(gsi) ; gsi_next(&gsi)) {
gimple curr_stmt = gsi_stmt(gsi);
tree lhs = gimple_get_lhs(curr_stmt);
// We only care about assignments to “real” variables – i.e. not
// variable versions that were created as part of the transformation
// to SSA form.
if (gimple_code(curr_stmt) == GIMPLE_ASSIGN
&& lhs != NULL_TREE && TREE_CODE(lhs) != SSA_NAME && DECL_P(lhs)) {
tree attrlist = DECL_ATTRIBUTES(lhs);
tree attr = lookup_attribute("instrument", attrlist);
// the princess is in another castle
if (attr == NULL_TREE) continue;
// read the variable id that was passed to the `instrument'
// attribute
const_tree arg = TREE_VALUE(TREE_VALUE(attr));
tree var_id = build_int_cst(NULL_TREE, tree_low_cst (arg, 1));
#ifdef DEBUG
fprintf(stderr, " > found assignment to instrumented variable `%s': \n\t", get_name(lhs));
print_gimple_stmt(stderr, curr_stmt, 0, 0);
fprintf(stderr, "\tbase address of `%s' is %p\n", get_name(lhs), get_base_address(lhs));
#endif
// insert our instrumentation function before the current
// statement and pass along the rhs (i.e. the new value)
tree rhs = gimple_op(curr_stmt, 1);
insert_instrumentation_fn(curr_stmt, var_id, rhs);
}
}
}
#ifdef DEBUG
fprintf(stderr, "\n");
#endif
return 0;
}
static enum ssa_prop_result
copy_prop_visit_stmt (gimple stmt, edge *taken_edge_p, tree *result_p)
{
enum ssa_prop_result retval;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\nVisiting statement:\n");
print_gimple_stmt (dump_file, stmt, 0, dump_flags);
fprintf (dump_file, "\n");
}
if (gimple_assign_single_p (stmt)
&& TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME
&& (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
|| is_gimple_min_invariant (gimple_assign_rhs1 (stmt))))
{
/* If the statement is a copy assignment, evaluate its RHS to
see if the lattice value of its output has changed. */
retval = copy_prop_visit_assignment (stmt, result_p);
}
else if (gimple_code (stmt) == GIMPLE_COND)
{
/* See if we can determine which edge goes out of a conditional
jump. */
retval = copy_prop_visit_cond_stmt (stmt, taken_edge_p);
}
else
retval = SSA_PROP_VARYING;
if (retval == SSA_PROP_VARYING)
{
tree def;
ssa_op_iter i;
/* Any other kind of statement is not interesting for constant
propagation and, therefore, not worth simulating. */
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "No interesting values produced.\n");
/* The assignment is not a copy operation. Don't visit this
statement again and mark all the definitions in the statement
to be copies of nothing. */
FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_ALL_DEFS)
set_copy_of_val (def, def);
}
return retval;
}
static unsigned int
tree_call_cdce (void)
{
basic_block bb;
gimple_stmt_iterator i;
bool something_changed = false;
vec<gimple> cond_dead_built_in_calls = vNULL;
FOR_EACH_BB (bb)
{
/* Collect dead call candidates. */
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
{
gimple stmt = gsi_stmt (i);
if (is_gimple_call (stmt)
&& is_call_dce_candidate (stmt))
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Found conditional dead call: ");
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
fprintf (dump_file, "\n");
}
if (!cond_dead_built_in_calls.exists ())
cond_dead_built_in_calls.create (64);
cond_dead_built_in_calls.safe_push (stmt);
}
}
}
if (!cond_dead_built_in_calls.exists ())
return 0;
something_changed
= shrink_wrap_conditional_dead_built_in_calls (cond_dead_built_in_calls);
cond_dead_built_in_calls.release ();
if (something_changed)
{
free_dominance_info (CDI_DOMINATORS);
free_dominance_info (CDI_POST_DOMINATORS);
/* As we introduced new control-flow we need to insert PHI-nodes
for the call-clobbers of the remaining call. */
mark_virtual_operands_for_renaming (cfun);
return TODO_update_ssa;
}
return 0;
}
/* Find all checks in current function and store info about them
in check_infos. */
static void
chkp_gather_checks_info (void)
{
basic_block bb;
gimple_stmt_iterator i;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Gathering information about checks...\n");
chkp_init_check_info ();
FOR_EACH_BB_FN (bb, cfun)
{
struct bb_checks *bbc = &check_infos[bb->index];
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Searching checks in BB%d...\n", bb->index);
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
{
gimple *stmt = gsi_stmt (i);
if (gimple_code (stmt) != GIMPLE_CALL)
continue;
if (gimple_call_fndecl (stmt) == chkp_checkl_fndecl
|| gimple_call_fndecl (stmt) == chkp_checku_fndecl)
{
struct check_info ci;
chkp_fill_check_info (stmt, &ci);
bbc->checks.safe_push (ci);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Adding check information:\n");
fprintf (dump_file, " bounds: ");
print_generic_expr (dump_file, ci.bounds, 0);
fprintf (dump_file, "\n address: ");
chkp_print_addr (ci.addr);
fprintf (dump_file, "\n check: ");
print_gimple_stmt (dump_file, stmt, 0, 0);
}
}
}
}
}
static enum ssa_prop_result
copy_prop_visit_cond_stmt (gimple stmt, edge *taken_edge_p)
{
enum ssa_prop_result retval = SSA_PROP_VARYING;
location_t loc = gimple_location (stmt);
tree op0 = gimple_cond_lhs (stmt);
tree op1 = gimple_cond_rhs (stmt);
/* The only conditionals that we may be able to compute statically
are predicates involving two SSA_NAMEs. */
if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME)
{
op0 = valueize_val (op0);
op1 = valueize_val (op1);
/* See if we can determine the predicate's value. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Trying to determine truth value of ");
fprintf (dump_file, "predicate ");
print_gimple_stmt (dump_file, stmt, 0, 0);
}
/* We can fold COND and get a useful result only when we have
the same SSA_NAME on both sides of a comparison operator. */
if (op0 == op1)
{
tree folded_cond = fold_binary_loc (loc, gimple_cond_code (stmt),
boolean_type_node, op0, op1);
if (folded_cond)
{
basic_block bb = gimple_bb (stmt);
*taken_edge_p = find_taken_edge (bb, folded_cond);
if (*taken_edge_p)
retval = SSA_PROP_INTERESTING;
}
}
}
if (dump_file && (dump_flags & TDF_DETAILS) && *taken_edge_p)
fprintf (dump_file, "\nConditional will always take edge %d->%d\n",
(*taken_edge_p)->src->index, (*taken_edge_p)->dest->index);
return retval;
}
void print_ssa_operands() {
tree var;
ssa_op_iter iter;
gimple_stmt_iterator gsi;
basic_block bb;
fprintf (stdout, "Print all SSA operands\n");
FOR_ALL_BB_FN(bb, cfun) {
for (gsi = gsi_start_bb (bb); !(gsi_end_p (gsi)); gsi_next(&gsi)) {
gimple *stmt = gsi_stmt(gsi);
FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_OPERANDS) {
print_gimple_stmt(stdout, stmt,1, 1);
print_generic_expr (stdout, var, TDF_SLIM);
printf("\n");
tree ref = get_inner_ref (var);
if (ref)
printf ("Inner reference: %s\n", get_name(ref));
}
}
}
/* Try to compare bounds value and address value
used in the check CI. If we can prove that check
always pass then remove it. */
static void
chkp_remove_check_if_pass (struct check_info *ci)
{
int result = 0;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Trying to remove check: ");
print_gimple_stmt (dump_file, ci->stmt, 0, 0);
}
result = chkp_get_check_result (ci, ci->bounds);
if (result == 1)
{
gimple_stmt_iterator i = gsi_for_stmt (ci->stmt);
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " action: delete check (always pass)\n");
gsi_remove (&i, true);
unlink_stmt_vdef (ci->stmt);
release_defs (ci->stmt);
ci->stmt = NULL;
}
else if (result == -1)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " action: keep check (always fail)\n");
warning_at (gimple_location (ci->stmt), OPT_Wchkp,
"memory access check always fail");
}
else if (result == 0)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " action: keep check (cannot compute result)\n");
}
}
static void
dump_rdg_vertex (FILE *file, struct graph *rdg, int i)
{
struct vertex *v = &(rdg->vertices[i]);
struct graph_edge *e;
fprintf (file, "(vertex %d: (%s%s) (in:", i,
RDG_MEM_WRITE_STMT (rdg, i) ? "w" : "",
RDG_MEM_READS_STMT (rdg, i) ? "r" : "");
if (v->pred)
for (e = v->pred; e; e = e->pred_next)
fprintf (file, " %d", e->src);
fprintf (file, ") (out:");
if (v->succ)
for (e = v->succ; e; e = e->succ_next)
fprintf (file, " %d", e->dest);
fprintf (file, ")\n");
print_gimple_stmt (file, RDGV_STMT (v), 0, TDF_VOPS|TDF_MEMSYMS);
fprintf (file, ")\n");
}
static enum ssa_prop_result
copy_prop_visit_phi_node (gimple phi)
{
enum ssa_prop_result retval;
unsigned i;
prop_value_t phi_val = { 0, NULL_TREE };
tree lhs = gimple_phi_result (phi);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\nVisiting PHI node: ");
print_gimple_stmt (dump_file, phi, 0, dump_flags);
fprintf (dump_file, "\n\n");
}
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
prop_value_t *arg_val;
tree arg = gimple_phi_arg_def (phi, i);
edge e = gimple_phi_arg_edge (phi, i);
/* We don't care about values flowing through non-executable
edges. */
if (!(e->flags & EDGE_EXECUTABLE))
continue;
/* Constants in the argument list never generate a useful copy.
Similarly, names that flow through abnormal edges cannot be
used to derive copies. */
if (TREE_CODE (arg) != SSA_NAME || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (arg))
{
phi_val.value = lhs;
break;
}
/* Avoid copy propagation from an inner into an outer loop.
Otherwise, this may move loop variant variables outside of
their loops and prevent coalescing opportunities. If the
value was loop invariant, it will be hoisted by LICM and
exposed for copy propagation. Not a problem for virtual
operands though. */
if (is_gimple_reg (lhs)
&& loop_depth_of_name (arg) > loop_depth_of_name (lhs))
{
phi_val.value = lhs;
break;
}
/* If the LHS appears in the argument list, ignore it. It is
irrelevant as a copy. */
if (arg == lhs || get_last_copy_of (arg) == lhs)
continue;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\tArgument #%d: ", i);
dump_copy_of (dump_file, arg);
fprintf (dump_file, "\n");
}
arg_val = get_copy_of_val (arg);
/* If the LHS didn't have a value yet, make it a copy of the
first argument we find. Notice that while we make the LHS be
a copy of the argument itself, we take the memory reference
from the argument's value so that we can compare it to the
memory reference of all the other arguments. */
if (phi_val.value == NULL_TREE)
{
phi_val.value = arg_val->value ? arg_val->value : arg;
continue;
}
/* If PHI_VAL and ARG don't have a common copy-of chain, then
this PHI node cannot be a copy operation. Also, if we are
copy propagating stores and these two arguments came from
different memory references, they cannot be considered
copies. */
if (get_last_copy_of (phi_val.value) != get_last_copy_of (arg))
{
phi_val.value = lhs;
break;
}
}
if (phi_val.value && may_propagate_copy (lhs, phi_val.value)
&& set_copy_of_val (lhs, phi_val.value))
retval = (phi_val.value != lhs) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING;
else
retval = SSA_PROP_NOT_INTERESTING;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\nPHI node ");
dump_copy_of (dump_file, lhs);
fprintf (dump_file, "\nTelling the propagator to ");
if (retval == SSA_PROP_INTERESTING)
fprintf (dump_file, "add SSA edges out of this PHI and continue.");
else if (retval == SSA_PROP_VARYING)
fprintf (dump_file, "add SSA edges out of this PHI and never visit again.");
else
fprintf (dump_file, "do nothing with SSA edges and keep iterating.");
fprintf (dump_file, "\n\n");
}
return retval;
}
static bool
tree_estimate_loop_size (struct loop *loop, edge exit, edge edge_to_cancel, struct loop_size *size,
int upper_bound)
{
basic_block *body = get_loop_body (loop);
gimple_stmt_iterator gsi;
unsigned int i;
bool after_exit;
vec<basic_block> path = get_loop_hot_path (loop);
size->overall = 0;
size->eliminated_by_peeling = 0;
size->last_iteration = 0;
size->last_iteration_eliminated_by_peeling = 0;
size->num_pure_calls_on_hot_path = 0;
size->num_non_pure_calls_on_hot_path = 0;
size->non_call_stmts_on_hot_path = 0;
size->num_branches_on_hot_path = 0;
size->constant_iv = 0;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Estimating sizes for loop %i\n", loop->num);
for (i = 0; i < loop->num_nodes; i++)
{
if (edge_to_cancel && body[i] != edge_to_cancel->src
&& dominated_by_p (CDI_DOMINATORS, body[i], edge_to_cancel->src))
after_exit = true;
else
after_exit = false;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " BB: %i, after_exit: %i\n", body[i]->index, after_exit);
for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple *stmt = gsi_stmt (gsi);
int num = estimate_num_insns (stmt, &eni_size_weights);
bool likely_eliminated = false;
bool likely_eliminated_last = false;
bool likely_eliminated_peeled = false;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " size: %3i ", num);
print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
}
/* Look for reasons why we might optimize this stmt away. */
if (gimple_has_side_effects (stmt))
;
/* Exit conditional. */
else if (exit && body[i] == exit->src
&& stmt == last_stmt (exit->src))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Exit condition will be eliminated "
"in peeled copies.\n");
likely_eliminated_peeled = true;
}
else if (edge_to_cancel && body[i] == edge_to_cancel->src
&& stmt == last_stmt (edge_to_cancel->src))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Exit condition will be eliminated "
"in last copy.\n");
likely_eliminated_last = true;
}
/* Sets of IV variables */
else if (gimple_code (stmt) == GIMPLE_ASSIGN
&& constant_after_peeling (gimple_assign_lhs (stmt), stmt, loop))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Induction variable computation will"
" be folded away.\n");
likely_eliminated = true;
}
/* Assignments of IV variables. */
else if (gimple_code (stmt) == GIMPLE_ASSIGN
&& TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME
&& constant_after_peeling (gimple_assign_rhs1 (stmt), stmt, loop)
&& (gimple_assign_rhs_class (stmt) != GIMPLE_BINARY_RHS
|| constant_after_peeling (gimple_assign_rhs2 (stmt),
stmt, loop)))
{
size->constant_iv = true;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Constant expression will be folded away.\n");
likely_eliminated = true;
}
/* Conditionals. */
else if ((gimple_code (stmt) == GIMPLE_COND
&& constant_after_peeling (gimple_cond_lhs (stmt), stmt, loop)
&& constant_after_peeling (gimple_cond_rhs (stmt), stmt, loop)
/* We don't simplify all constant compares so make sure
they are not both constant already. See PR70288. */
&& (! is_gimple_min_invariant (gimple_cond_lhs (stmt))
|| ! is_gimple_min_invariant (gimple_cond_rhs (stmt))))
|| (gimple_code (stmt) == GIMPLE_SWITCH
&& constant_after_peeling (gimple_switch_index (
as_a <gswitch *> (stmt)),
stmt, loop)
&& ! is_gimple_min_invariant (gimple_switch_index (
as_a <gswitch *> (stmt)))))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " Constant conditional.\n");
likely_eliminated = true;
}
size->overall += num;
if (likely_eliminated || likely_eliminated_peeled)
size->eliminated_by_peeling += num;
if (!after_exit)
{
size->last_iteration += num;
if (likely_eliminated || likely_eliminated_last)
size->last_iteration_eliminated_by_peeling += num;
}
if ((size->overall * 3 / 2 - size->eliminated_by_peeling
- size->last_iteration_eliminated_by_peeling) > upper_bound)
{
free (body);
path.release ();
return true;
}
}
}
while (path.length ())
{
basic_block bb = path.pop ();
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple *stmt = gsi_stmt (gsi);
if (gimple_code (stmt) == GIMPLE_CALL)
{
int flags = gimple_call_flags (stmt);
tree decl = gimple_call_fndecl (stmt);
if (decl && DECL_IS_BUILTIN (decl)
&& is_inexpensive_builtin (decl))
;
else if (flags & (ECF_PURE | ECF_CONST))
size->num_pure_calls_on_hot_path++;
else
size->num_non_pure_calls_on_hot_path++;
size->num_branches_on_hot_path ++;
}
else if (gimple_code (stmt) != GIMPLE_CALL
&& gimple_code (stmt) != GIMPLE_DEBUG)
size->non_call_stmts_on_hot_path++;
if (((gimple_code (stmt) == GIMPLE_COND
&& (!constant_after_peeling (gimple_cond_lhs (stmt), stmt, loop)
|| constant_after_peeling (gimple_cond_rhs (stmt), stmt, loop)))
|| (gimple_code (stmt) == GIMPLE_SWITCH
&& !constant_after_peeling (gimple_switch_index (
as_a <gswitch *> (stmt)),
stmt, loop)))
&& (!exit || bb != exit->src))
size->num_branches_on_hot_path++;
}
}
path.release ();
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "size: %i-%i, last_iteration: %i-%i\n", size->overall,
size->eliminated_by_peeling, size->last_iteration,
size->last_iteration_eliminated_by_peeling);
free (body);
return false;
}
/* Look into pointer pointed to by GSIP and figure out what interesting side
effects it has. */
static void
check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa)
{
gimple stmt = gsi_stmt (*gsip);
if (is_gimple_debug (stmt))
return;
if (dump_file)
{
fprintf (dump_file, " scanning: ");
print_gimple_stmt (dump_file, stmt, 0, 0);
}
if (gimple_has_volatile_ops (stmt)
&& !gimple_clobber_p (stmt))
{
local->pure_const_state = IPA_NEITHER;
if (dump_file)
fprintf (dump_file, " Volatile stmt is not const/pure\n");
}
/* Look for loads and stores. */
walk_stmt_load_store_ops (stmt, local,
ipa ? check_ipa_load : check_load,
ipa ? check_ipa_store : check_store);
if (gimple_code (stmt) != GIMPLE_CALL
&& stmt_could_throw_p (stmt))
{
if (cfun->can_throw_non_call_exceptions)
{
if (dump_file)
fprintf (dump_file, " can throw; looping\n");
local->looping = true;
}
if (stmt_can_throw_external (stmt))
{
if (dump_file)
fprintf (dump_file, " can throw externally\n");
local->can_throw = true;
}
else
if (dump_file)
fprintf (dump_file, " can throw\n");
}
switch (gimple_code (stmt))
{
case GIMPLE_CALL:
check_call (local, stmt, ipa);
break;
case GIMPLE_LABEL:
if (DECL_NONLOCAL (gimple_label_label (stmt)))
/* Target of long jump. */
{
if (dump_file)
fprintf (dump_file, " nonlocal label is not const/pure\n");
local->pure_const_state = IPA_NEITHER;
}
break;
case GIMPLE_ASM:
if (gimple_asm_clobbers_memory_p (stmt))
{
if (dump_file)
fprintf (dump_file, " memory asm clobber is not const/pure\n");
/* Abandon all hope, ye who enter here. */
local->pure_const_state = IPA_NEITHER;
}
if (gimple_asm_volatile_p (stmt))
{
if (dump_file)
fprintf (dump_file, " volatile is not const/pure\n");
/* Abandon all hope, ye who enter here. */
local->pure_const_state = IPA_NEITHER;
local->looping = true;
}
return;
default:
break;
}
}
static void
my_dump_gimple(gimple gnode, gimple_stmt_iterator *ptrgsi)
{
int gcode;
tree tnode;
tree funcdecl;
tree desc_node;
tree ptr_desc_node;
tree t;
tree tmp_var;
tree const_char_restrict_ptr_type_node;
gimple tmp_gstmt;
gimple new_gnode;
const char *hellocstr = "Hello, GCC!\n";
int i;
struct c_binding *b;
expanded_location xloc;
/*
* Extract the Gimple Code from a gimple node
*/
gcode = gimple_code(gnode);
/*
* Get the line number of cooresponding
* source code from a gimple node
*/
if(gimple_has_location(gnode))
{
xloc = expand_location(gimple_location(gnode));
printf("line %d:", xloc.line);
}
printf("\t\t\t\t%s\n", gimple_code_name[gcode]);
switch(gcode)
{
case GIMPLE_ASSIGN:
/*
* Add a printf("Hello, GCC!\n"); statement
* after the first appearing assignment
* if yes equals to 1, then we have already
* added the statement, and no need to add
* again
*/
if(!yes)
{
/*
* Since printf is a builtin function, we need
* to get the function declaration using
* built_in_decls[]. The index number can be
* found in gcc source gcc/builtins.def
*/
funcdecl = built_in_decls[BUILT_IN_PRINTF];
if(funcdecl == NULL_TREE)
{
printf("cannot find printf\n");
}
else
{
/*
* In gimple, every statement is simplified into
* three oprands mode. And our printf() statement
* is change into following two gimple statements:
*
* <D.XXX> = (const char * restrict) &"Hello, GCC!\n"[0]
* printf(<D.XXX>);
*
* Note that <D.XXX> is a temporary variable, we can
* actually use any name we like as long as no
* confliction.
*/
/*
* Generate a STRING_CST, the value is "Hello, GCC!\n"
*/
desc_node = build_string(strlen(hellocstr), hellocstr);
/*
* Two points need to notice here:
* 1. STRING_CST build by build_string() do
* not have TREE_TYPE set, so we need to
* set it manually.
* 2. build_string() will add a trailing '\0'
* when building the STRING_CST, so we do
* not need to care with it.
*/
TREE_TYPE(desc_node) = build_array_type(
char_type_node,
build_index_type(
build_int_cst(NULL_TREE,
strlen(hellocstr))));
/*
* Define a const char * restrict type node
* here for convertion.
* I'm not sure why we need to add a restrict
* attribute, but GCC really does it when it
* converting a STRING_CST from AST to Gimple.
*/
const_char_restrict_ptr_type_node =
build_qualified_type(
build_pointer_type(
build_qualified_type(
char_type_node,
TYPE_QUAL_CONST)),
TYPE_QUAL_RESTRICT);
/*
* When we in AST, if we want to use STRING_CST
* the form is like this <ADDR_EXPR<STRING_CST>>,
* but when we turn to gimple, it is like this
* <ADDR_EXPR<ADDAR_REF<STRING_CST>>>.
* So we need to do a convertion there.
*/
/*
* First wrap STRING_CST with ARRAY_REF
*/
t = build4(ARRAY_REF, char_type_node,
desc_node, build_int_cst(NULL_TREE, 0),
NULL, NULL);
/*
* Second wrap ARRAY_REF with ADDR_EXPR
*/
ptr_desc_node = build1(ADDR_EXPR,
const_char_restrict_ptr_type_node,
t);
/*
* I'm not sure why we need to use fold_convert()
* here, but if we do not, we cannot make the
* compiling successful.
*/
ptr_desc_node = fold_convert(
const_char_restrict_ptr_type_node,
ptr_desc_node);
/*
* If is_gimple_min_invariant(ptr_desc_node)
* is true, we build a corrent argument, otherwise
* the argument is not suitable for gimple call
*/
if(!is_gimple_min_invariant(ptr_desc_node))
{
printf("Something wrong with is_gimple_min_invariant\n");
return ;
}
/*
* This applies for a temporary variable
*/
tmp_var = make_rename_temp(
const_char_restrict_ptr_type_node,
"plugin_var");
/*
* Build a gimple statement. Still remember that?
* <D.XXX> = (const char * restrict) "Hello, GCC!\n"
*/
tmp_gstmt = gimple_build_assign(tmp_var,
ptr_desc_node);
/*
* Check if the gimple statment is corrent
*/
if(!is_gimple_assign(tmp_gstmt))
{
printf("tmp_gstmt is invalid\n");
}
printf("Insert gimple statment:");
print_gimple_stmt(stdout, tmp_gstmt, 0,
TDF_DETAILS | TDF_VERBOSE | TDF_TREE);
/*
* Insert the gimple statment into the basic block
*/
gsi_insert_after(ptrgsi, tmp_gstmt,
GSI_NEW_STMT);
if(is_gimple_operand(tmp_var))
{
printf("begin to insert printf\n");
yes = 1;
printf("Insert gimple statment:");
/*
* Insert the gimple statment printf
* into the basic block
*/
new_gnode = gimple_build_call(
funcdecl, 1, tmp_var);
print_gimple_stmt(stdout, new_gnode, 0, 0);
gsi_insert_after(ptrgsi, new_gnode,
GSI_NEW_STMT);
}
else
{
print_generic_stmt(stdout, ptr_desc_node,
TDF_DETAILS | TDF_VERBOSE | TDF_TREE);
printf("Not Gimple Operands\n");
}
/*
* Since we have more than one consecutive statements
* to insert, we can actually use build a gimple
* sequence, insert all statement into the sequence,
* and then insert the sequence into the basic block.
* This seems to be a better method.
*/
}
}
else
{
}
break;
default:
break;
}
}
static enum ssa_prop_result
copy_prop_visit_phi_node (gimple phi)
{
enum ssa_prop_result retval;
unsigned i;
prop_value_t phi_val = { NULL_TREE };
tree lhs = gimple_phi_result (phi);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\nVisiting PHI node: ");
print_gimple_stmt (dump_file, phi, 0, dump_flags);
}
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
prop_value_t *arg_val;
tree arg_value;
tree arg = gimple_phi_arg_def (phi, i);
edge e = gimple_phi_arg_edge (phi, i);
/* We don't care about values flowing through non-executable
edges. */
if (!(e->flags & EDGE_EXECUTABLE))
continue;
/* Names that flow through abnormal edges cannot be used to
derive copies. */
if (TREE_CODE (arg) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (arg))
{
phi_val.value = lhs;
break;
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "\tArgument #%d: ", i);
dump_copy_of (dump_file, arg);
fprintf (dump_file, "\n");
}
if (TREE_CODE (arg) == SSA_NAME)
{
arg_val = get_copy_of_val (arg);
/* If we didn't visit the definition of arg yet treat it as
UNDEFINED. This also handles PHI arguments that are the
same as lhs. We'll come here again. */
if (!arg_val->value)
continue;
arg_value = arg_val->value;
}
else
arg_value = valueize_val (arg);
/* Avoid copy propagation from an inner into an outer loop.
Otherwise, this may move loop variant variables outside of
their loops and prevent coalescing opportunities. If the
value was loop invariant, it will be hoisted by LICM and
exposed for copy propagation.
??? The value will be always loop invariant.
In loop-closed SSA form do not copy-propagate through
PHI nodes in blocks with a loop exit edge predecessor. */
if (current_loops
&& TREE_CODE (arg_value) == SSA_NAME
&& (loop_depth_of_name (arg_value) > loop_depth_of_name (lhs)
|| (loops_state_satisfies_p (LOOP_CLOSED_SSA)
&& loop_exit_edge_p (e->src->loop_father, e))))
{
phi_val.value = lhs;
break;
}
/* If the LHS didn't have a value yet, make it a copy of the
first argument we find. */
if (phi_val.value == NULL_TREE)
{
phi_val.value = arg_value;
continue;
}
/* If PHI_VAL and ARG don't have a common copy-of chain, then
this PHI node cannot be a copy operation. */
if (phi_val.value != arg_value
&& !operand_equal_p (phi_val.value, arg_value, 0))
{
phi_val.value = lhs;
break;
}
}
if (phi_val.value
&& may_propagate_copy (lhs, phi_val.value)
&& set_copy_of_val (lhs, phi_val.value))
retval = (phi_val.value != lhs) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING;
else
retval = SSA_PROP_NOT_INTERESTING;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "PHI node ");
dump_copy_of (dump_file, lhs);
fprintf (dump_file, "\nTelling the propagator to ");
if (retval == SSA_PROP_INTERESTING)
fprintf (dump_file, "add SSA edges out of this PHI and continue.");
else if (retval == SSA_PROP_VARYING)
fprintf (dump_file, "add SSA edges out of this PHI and never visit again.");
else
fprintf (dump_file, "do nothing with SSA edges and keep iterating.");
fprintf (dump_file, "\n\n");
}
return retval;
}
/* Return 1 if check CI against BOUNDS always pass,
-1 if check CI against BOUNDS always fails and
0 if we cannot compute check result. */
static int
chkp_get_check_result (struct check_info *ci, tree bounds)
{
gimple *bnd_def;
address_t bound_val;
int sign, res = 0;
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Trying to compute result of the check\n");
fprintf (dump_file, " check: ");
print_gimple_stmt (dump_file, ci->stmt, 0, 0);
fprintf (dump_file, " address: ");
chkp_print_addr (ci->addr);
fprintf (dump_file, "\n bounds: ");
print_generic_expr (dump_file, bounds, 0);
fprintf (dump_file, "\n");
}
if (TREE_CODE (bounds) != SSA_NAME)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " result: bounds tree code is not ssa_name\n");
return 0;
}
bnd_def = SSA_NAME_DEF_STMT (bounds);
/* Currently we handle cases when bounds are result of bndmk
or loaded static bounds var. */
if (gimple_code (bnd_def) == GIMPLE_CALL
&& gimple_call_fndecl (bnd_def) == chkp_bndmk_fndecl)
{
bound_val.pol.create (0);
chkp_collect_value (gimple_call_arg (bnd_def, 0), bound_val);
if (ci->type == CHECK_UPPER_BOUND)
{
address_t size_val;
size_val.pol.create (0);
chkp_collect_value (gimple_call_arg (bnd_def, 1), size_val);
chkp_add_addr_addr (bound_val, size_val);
size_val.pol.release ();
chkp_add_addr_item (bound_val, integer_minus_one_node, NULL);
}
}
else if (gimple_code (bnd_def) == GIMPLE_ASSIGN
&& gimple_assign_rhs1 (bnd_def) == chkp_get_zero_bounds_var ())
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " result: always pass with zero bounds\n");
return 1;
}
else if (gimple_code (bnd_def) == GIMPLE_ASSIGN
&& gimple_assign_rhs1 (bnd_def) == chkp_get_none_bounds_var ())
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " result: always fails with none bounds\n");
return -1;
}
else if (gimple_code (bnd_def) == GIMPLE_ASSIGN
&& TREE_CODE (gimple_assign_rhs1 (bnd_def)) == VAR_DECL)
{
tree bnd_var = gimple_assign_rhs1 (bnd_def);
tree var;
tree size;
if (!DECL_INITIAL (bnd_var)
|| DECL_INITIAL (bnd_var) == error_mark_node)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " result: cannot compute bounds\n");
return 0;
}
gcc_assert (TREE_CODE (DECL_INITIAL (bnd_var)) == ADDR_EXPR);
var = TREE_OPERAND (DECL_INITIAL (bnd_var), 0);
bound_val.pol.create (0);
chkp_collect_value (DECL_INITIAL (bnd_var), bound_val);
if (ci->type == CHECK_UPPER_BOUND)
{
if (TREE_CODE (var) == VAR_DECL)
{
if (DECL_SIZE (var)
&& !chkp_variable_size_type (TREE_TYPE (var)))
size = DECL_SIZE_UNIT (var);
else
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " result: cannot compute bounds\n");
return 0;
}
}
else
{
gcc_assert (TREE_CODE (var) == STRING_CST);
size = build_int_cst (size_type_node,
TREE_STRING_LENGTH (var));
}
address_t size_val;
size_val.pol.create (0);
chkp_collect_value (size, size_val);
chkp_add_addr_addr (bound_val, size_val);
size_val.pol.release ();
chkp_add_addr_item (bound_val, integer_minus_one_node, NULL);
}
}
else
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " result: cannot compute bounds\n");
return 0;
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, " bound value: ");
chkp_print_addr (bound_val);
fprintf (dump_file, "\n");
}
chkp_sub_addr_addr (bound_val, ci->addr);
if (!chkp_is_constant_addr (bound_val, &sign))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " result: cannot compute result\n");
res = 0;
}
else if (sign == 0
|| (ci->type == CHECK_UPPER_BOUND && sign > 0)
|| (ci->type == CHECK_LOWER_BOUND && sign < 0))
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " result: always pass\n");
res = 1;
}
else
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, " result: always fail\n");
res = -1;
}
bound_val.pol.release ();
return res;
}
static void
vect_pattern_recog_1 (
gimple (* vect_recog_func) (gimple, tree *, tree *),
gimple_stmt_iterator si)
{
gimple stmt = gsi_stmt (si), pattern_stmt;
stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
stmt_vec_info pattern_stmt_info;
loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_info);
tree pattern_vectype;
tree type_in, type_out;
enum tree_code code;
int i;
gimple next;
pattern_stmt = (* vect_recog_func) (stmt, &type_in, &type_out);
if (!pattern_stmt)
return;
if (VECTOR_MODE_P (TYPE_MODE (type_in)))
{
/* No need to check target support (already checked by the pattern
recognition function). */
if (type_out)
gcc_assert (VECTOR_MODE_P (TYPE_MODE (type_out)));
pattern_vectype = type_out ? type_out : type_in;
}
else
{
enum machine_mode vec_mode;
enum insn_code icode;
optab optab;
/* Check target support */
type_in = get_vectype_for_scalar_type (type_in);
if (!type_in)
return;
if (type_out)
type_out = get_vectype_for_scalar_type (type_out);
else
type_out = type_in;
if (!type_out)
return;
pattern_vectype = type_out;
if (is_gimple_assign (pattern_stmt))
code = gimple_assign_rhs_code (pattern_stmt);
else
{
gcc_assert (is_gimple_call (pattern_stmt));
code = CALL_EXPR;
}
optab = optab_for_tree_code (code, type_in, optab_default);
vec_mode = TYPE_MODE (type_in);
if (!optab
|| (icode = optab_handler (optab, vec_mode)) == CODE_FOR_nothing
|| (insn_data[icode].operand[0].mode != TYPE_MODE (type_out)))
return;
}
/* Found a vectorizable pattern. */
if (vect_print_dump_info (REPORT_DETAILS))
{
fprintf (vect_dump, "pattern recognized: ");
print_gimple_stmt (vect_dump, pattern_stmt, 0, TDF_SLIM);
}
/* Mark the stmts that are involved in the pattern. */
gsi_insert_before (&si, pattern_stmt, GSI_SAME_STMT);
set_vinfo_for_stmt (pattern_stmt,
new_stmt_vec_info (pattern_stmt, loop_vinfo, NULL));
pattern_stmt_info = vinfo_for_stmt (pattern_stmt);
STMT_VINFO_RELATED_STMT (pattern_stmt_info) = stmt;
STMT_VINFO_DEF_TYPE (pattern_stmt_info) = STMT_VINFO_DEF_TYPE (stmt_info);
STMT_VINFO_VECTYPE (pattern_stmt_info) = pattern_vectype;
STMT_VINFO_IN_PATTERN_P (stmt_info) = true;
STMT_VINFO_RELATED_STMT (stmt_info) = pattern_stmt;
/* Patterns cannot be vectorized using SLP, because they change the order of
computation. */
FOR_EACH_VEC_ELT (gimple, LOOP_VINFO_REDUCTIONS (loop_vinfo), i, next)
if (next == stmt)
VEC_ordered_remove (gimple, LOOP_VINFO_REDUCTIONS (loop_vinfo), i);
}
static void
eliminate_tail_call (struct tailcall *t)
{
tree param, rslt;
gimple stmt, call;
tree arg;
size_t idx;
basic_block bb, first;
edge e;
gimple phi;
gimple_stmt_iterator gsi;
gimple orig_stmt;
stmt = orig_stmt = gsi_stmt (t->call_gsi);
bb = gsi_bb (t->call_gsi);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Eliminated tail recursion in bb %d : ",
bb->index);
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
fprintf (dump_file, "\n");
}
gcc_assert (is_gimple_call (stmt));
first = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
/* Remove the code after call_gsi that will become unreachable. The
possibly unreachable code in other blocks is removed later in
cfg cleanup. */
gsi = t->call_gsi;
gsi_next (&gsi);
while (!gsi_end_p (gsi))
{
gimple t = gsi_stmt (gsi);
/* Do not remove the return statement, so that redirect_edge_and_branch
sees how the block ends. */
if (gimple_code (t) == GIMPLE_RETURN)
break;
gsi_remove (&gsi, true);
release_defs (t);
}
/* Number of executions of function has reduced by the tailcall. */
e = single_succ_edge (gsi_bb (t->call_gsi));
decrease_profile (EXIT_BLOCK_PTR_FOR_FN (cfun), e->count, EDGE_FREQUENCY (e));
decrease_profile (ENTRY_BLOCK_PTR_FOR_FN (cfun), e->count,
EDGE_FREQUENCY (e));
if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
decrease_profile (e->dest, e->count, EDGE_FREQUENCY (e));
/* Replace the call by a jump to the start of function. */
e = redirect_edge_and_branch (single_succ_edge (gsi_bb (t->call_gsi)),
first);
gcc_assert (e);
PENDING_STMT (e) = NULL;
/* Add phi node entries for arguments. The ordering of the phi nodes should
be the same as the ordering of the arguments. */
for (param = DECL_ARGUMENTS (current_function_decl),
idx = 0, gsi = gsi_start_phis (first);
param;
param = DECL_CHAIN (param), idx++)
{
if (!arg_needs_copy_p (param))
continue;
arg = gimple_call_arg (stmt, idx);
phi = gsi_stmt (gsi);
gcc_assert (param == SSA_NAME_VAR (PHI_RESULT (phi)));
add_phi_arg (phi, arg, e, gimple_location (stmt));
gsi_next (&gsi);
}
/* Update the values of accumulators. */
adjust_accumulator_values (t->call_gsi, t->mult, t->add, e);
call = gsi_stmt (t->call_gsi);
rslt = gimple_call_lhs (call);
if (rslt != NULL_TREE)
{
/* Result of the call will no longer be defined. So adjust the
SSA_NAME_DEF_STMT accordingly. */
SSA_NAME_DEF_STMT (rslt) = gimple_build_nop ();
}
gsi_remove (&t->call_gsi, true);
release_defs (call);
}
bool
autofdo_source_profile::update_inlined_ind_target (gcall *stmt,
count_info *info)
{
if (dump_file)
{
fprintf (dump_file, "Checking indirect call -> direct call ");
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}
if (LOCATION_LOCUS (gimple_location (stmt)) == cfun->function_end_locus)
{
if (dump_file)
fprintf (dump_file, " good locus\n");
return false;
}
count_info old_info;
get_count_info (stmt, &old_info);
gcov_type total = 0;
for (icall_target_map::const_iterator iter = old_info.targets.begin ();
iter != old_info.targets.end (); ++iter)
total += iter->second;
/* Program behavior changed, original promoted (and inlined) target is not
hot any more. Will avoid promote the original target.
To check if original promoted target is still hot, we check the total
count of the unpromoted targets (stored in TOTAL). If a callsite count
(stored in INFO) is smaller than half of the total count, the original
promoted target is considered not hot any more. */
if (info->count < total / 2)
{
if (dump_file)
fprintf (dump_file, " not hot anymore %ld < %ld",
(long)info->count,
(long)total /2);
return false;
}
inline_stack stack;
get_inline_stack (gimple_location (stmt), &stack);
if (stack.length () == 0)
{
if (dump_file)
fprintf (dump_file, " no inline stack\n");
return false;
}
function_instance *s = get_function_instance_by_inline_stack (stack);
if (s == NULL)
{
if (dump_file)
fprintf (dump_file, " function not found in inline stack\n");
return false;
}
icall_target_map map;
if (s->find_icall_target_map (stmt, &map) == 0)
{
if (dump_file)
fprintf (dump_file, " no target map\n");
return false;
}
for (icall_target_map::const_iterator iter = map.begin ();
iter != map.end (); ++iter)
info->targets[iter->first] = iter->second;
if (dump_file)
fprintf (dump_file, " looks good\n");
return true;
}
static void
afdo_indirect_call (gimple_stmt_iterator *gsi, const icall_target_map &map,
bool transform)
{
gimple *gs = gsi_stmt (*gsi);
tree callee;
if (map.size () == 0)
return;
gcall *stmt = dyn_cast <gcall *> (gs);
if ((!stmt) || gimple_call_fndecl (stmt) != NULL_TREE)
return;
callee = gimple_call_fn (stmt);
histogram_value hist = gimple_alloc_histogram_value (
cfun, HIST_TYPE_INDIR_CALL, stmt, callee);
hist->n_counters = 3;
hist->hvalue.counters = XNEWVEC (gcov_type, hist->n_counters);
gimple_add_histogram_value (cfun, stmt, hist);
gcov_type total = 0;
icall_target_map::const_iterator max_iter = map.end ();
for (icall_target_map::const_iterator iter = map.begin ();
iter != map.end (); ++iter)
{
total += iter->second;
if (max_iter == map.end () || max_iter->second < iter->second)
max_iter = iter;
}
hist->hvalue.counters[0]
= (unsigned long long)afdo_string_table->get_name (max_iter->first);
hist->hvalue.counters[1] = max_iter->second;
hist->hvalue.counters[2] = total;
if (!transform)
return;
struct cgraph_edge *indirect_edge
= cgraph_node::get (current_function_decl)->get_edge (stmt);
struct cgraph_node *direct_call = cgraph_node::get_for_asmname (
get_identifier ((const char *) hist->hvalue.counters[0]));
if (dump_file)
{
fprintf (dump_file, "Indirect call -> direct call ");
print_generic_expr (dump_file, callee, TDF_SLIM);
fprintf (dump_file, " => ");
print_generic_expr (dump_file, direct_call->decl, TDF_SLIM);
}
if (direct_call == NULL || !check_ic_target (stmt, direct_call))
{
if (dump_file)
fprintf (dump_file, " not transforming\n");
return;
}
if (DECL_STRUCT_FUNCTION (direct_call->decl) == NULL)
{
if (dump_file)
fprintf (dump_file, " no declaration\n");
return;
}
if (dump_file)
{
fprintf (dump_file, " transformation on insn ");
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
fprintf (dump_file, "\n");
}
/* FIXME: Count should be initialized. */
struct cgraph_edge *new_edge
= indirect_edge->make_speculative (direct_call,
profile_count::uninitialized ());
new_edge->redirect_call_stmt_to_callee ();
gimple_remove_histogram_value (cfun, stmt, hist);
inline_call (new_edge, true, NULL, NULL, false);
}
/* Find memcpy, mempcpy, memmove and memset calls, perform
checks before call and then call no_chk version of
functions. We do it on O2 to enable inlining of these
functions during expand.
Also try to find memcpy, mempcpy, memmove and memset calls
which are known to not write pointers to memory and use
faster function versions for them. */
static void
chkp_optimize_string_function_calls (void)
{
basic_block bb;
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Searching for replaceable string function calls...\n");
FOR_EACH_BB_FN (bb, cfun)
{
gimple_stmt_iterator i;
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
{
gimple *stmt = gsi_stmt (i);
tree fndecl;
if (gimple_code (stmt) != GIMPLE_CALL
|| !gimple_call_with_bounds_p (stmt))
continue;
fndecl = gimple_call_fndecl (stmt);
if (!fndecl || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
continue;
if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMCPY_CHKP
|| DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMPCPY_CHKP
|| DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMMOVE_CHKP
|| DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMSET_CHKP)
{
tree dst = gimple_call_arg (stmt, 0);
tree dst_bnd = gimple_call_arg (stmt, 1);
bool is_memset = DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMSET_CHKP;
tree size = gimple_call_arg (stmt, is_memset ? 3 : 4);
tree fndecl_nochk;
gimple_stmt_iterator j;
basic_block check_bb;
address_t size_val;
int sign;
bool known;
/* We may replace call with corresponding __chkp_*_nobnd
call in case destination pointer base type is not
void or pointer. */
if (POINTER_TYPE_P (TREE_TYPE (dst))
&& !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (dst)))
&& !chkp_type_has_pointer (TREE_TYPE (TREE_TYPE (dst))))
{
tree fndecl_nobnd
= chkp_get_nobnd_fndecl (DECL_FUNCTION_CODE (fndecl));
if (fndecl_nobnd)
fndecl = fndecl_nobnd;
}
fndecl_nochk = chkp_get_nochk_fndecl (DECL_FUNCTION_CODE (fndecl));
if (fndecl_nochk)
fndecl = fndecl_nochk;
if (fndecl != gimple_call_fndecl (stmt))
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Replacing call: ");
print_gimple_stmt (dump_file, stmt, 0,
TDF_VOPS|TDF_MEMSYMS);
}
gimple_call_set_fndecl (stmt, fndecl);
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "With a new call: ");
print_gimple_stmt (dump_file, stmt, 0,
TDF_VOPS|TDF_MEMSYMS);
}
}
/* If there is no nochk version of function then
do nothing. Otherwise insert checks before
the call. */
if (!fndecl_nochk)
continue;
/* If size passed to call is known and > 0
then we may insert checks unconditionally. */
size_val.pol.create (0);
chkp_collect_value (size, size_val);
known = chkp_is_constant_addr (size_val, &sign);
size_val.pol.release ();
/* If we are not sure size is not zero then we have
to perform runtime check for size and perform
checks only when size is not zero. */
if (!known)
{
gimple *check = gimple_build_cond (NE_EXPR,
size,
size_zero_node,
NULL_TREE,
NULL_TREE);
/* Split block before string function call. */
gsi_prev (&i);
check_bb = insert_cond_bb (bb, gsi_stmt (i), check);
/* Set position for checks. */
j = gsi_last_bb (check_bb);
/* The block was splitted and therefore we
need to set iterator to its end. */
i = gsi_last_bb (bb);
}
/* If size is known to be zero then no checks
should be performed. */
else if (!sign)
continue;
else
j = i;
size = size_binop (MINUS_EXPR, size, size_one_node);
if (!is_memset)
{
tree src = gimple_call_arg (stmt, 2);
tree src_bnd = gimple_call_arg (stmt, 3);
chkp_check_mem_access (src, fold_build_pointer_plus (src, size),
src_bnd, j, gimple_location (stmt),
integer_zero_node);
}
chkp_check_mem_access (dst, fold_build_pointer_plus (dst, size),
dst_bnd, j, gimple_location (stmt),
integer_one_node);
}
}
}
