static gcall *
check_for_named_call (gimple *stmt,
const char *funcname, unsigned int num_args)
{
gcc_assert (funcname);
gcall *call = dyn_cast <gcall *> (stmt);
if (!call)
return NULL;
tree fndecl = gimple_call_fndecl (call);
if (!fndecl)
return NULL;
if (strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), funcname))
return NULL;
if (gimple_call_num_args (call) != num_args)
{
error_at (stmt->location, "expected number of args: %i (got %i)",
num_args, gimple_call_num_args (call));
return NULL;
}
return call;
}
static unsigned HOST_WIDE_INT
alloc_object_size (const_gimple call, int object_size_type)
{
tree callee, bytes = NULL_TREE;
tree alloc_size;
int arg1 = -1, arg2 = -1;
gcc_assert (is_gimple_call (call));
callee = gimple_call_fndecl (call);
if (!callee)
return unknown[object_size_type];
alloc_size = lookup_attribute ("alloc_size",
TYPE_ATTRIBUTES (TREE_TYPE (callee)));
if (alloc_size && TREE_VALUE (alloc_size))
{
tree p = TREE_VALUE (alloc_size);
arg1 = TREE_INT_CST_LOW (TREE_VALUE (p))-1;
if (TREE_CHAIN (p))
arg2 = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (p)))-1;
}
if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
switch (DECL_FUNCTION_CODE (callee))
{
case BUILT_IN_CALLOC:
arg2 = 1;
/* fall through */
case BUILT_IN_MALLOC:
case BUILT_IN_ALLOCA:
case BUILT_IN_ALLOCA_WITH_ALIGN:
arg1 = 0;
default:
break;
}
if (arg1 < 0 || arg1 >= (int)gimple_call_num_args (call)
|| TREE_CODE (gimple_call_arg (call, arg1)) != INTEGER_CST
|| (arg2 >= 0
&& (arg2 >= (int)gimple_call_num_args (call)
|| TREE_CODE (gimple_call_arg (call, arg2)) != INTEGER_CST)))
return unknown[object_size_type];
if (arg2 >= 0)
bytes = size_binop (MULT_EXPR,
fold_convert (sizetype, gimple_call_arg (call, arg1)),
fold_convert (sizetype, gimple_call_arg (call, arg2)));
else if (arg1 >= 0)
bytes = fold_convert (sizetype, gimple_call_arg (call, arg1));
if (bytes && host_integerp (bytes, 1))
return tree_low_cst (bytes, 1);
return unknown[object_size_type];
}
// Start stmt duplication on marked function parameters
static struct interesting_stmts *search_interesting_calls(struct interesting_stmts *head, gcall *call_stmt)
{
tree decl;
unsigned int i, len;
len = gimple_call_num_args(call_stmt);
if (len == 0)
return head;
decl = get_fn_or_fnptr_decl(call_stmt);
if (decl == NULL_TREE)
return head;
for (i = 0; i < len; i++) {
tree arg;
arg = gimple_call_arg(call_stmt, i);
if (is_gimple_constant(arg))
continue;
if (skip_types(arg))
continue;
if (is_interesting_function(decl, i + 1))
head = search_interesting_stmt(head, call_stmt, arg, i + 1);
}
return head;
}
void
ubsan_expand_bounds_ifn (gimple_stmt_iterator *gsi)
{
gimple stmt = gsi_stmt (*gsi);
location_t loc = gimple_location (stmt);
gcc_assert (gimple_call_num_args (stmt) == 3);
/* Pick up the arguments of the UBSAN_BOUNDS call. */
tree type = TREE_TYPE (TREE_TYPE (gimple_call_arg (stmt, 0)));
tree index = gimple_call_arg (stmt, 1);
tree orig_index_type = TREE_TYPE (index);
tree bound = gimple_call_arg (stmt, 2);
gimple_stmt_iterator gsi_orig = *gsi;
/* Create condition "if (index > bound)". */
basic_block then_bb, fallthru_bb;
gimple_stmt_iterator cond_insert_point
= create_cond_insert_point (gsi, 0/*before_p*/, false, true,
&then_bb, &fallthru_bb);
index = fold_convert (TREE_TYPE (bound), index);
index = force_gimple_operand_gsi (&cond_insert_point, index,
true/*simple_p*/, NULL_TREE,
false/*before*/, GSI_NEW_STMT);
gimple g = gimple_build_cond (GT_EXPR, index, bound, NULL_TREE, NULL_TREE);
gimple_set_location (g, loc);
gsi_insert_after (&cond_insert_point, g, GSI_NEW_STMT);
/* Generate __ubsan_handle_out_of_bounds call. */
*gsi = gsi_after_labels (then_bb);
if (flag_sanitize_undefined_trap_on_error)
g = gimple_build_call (builtin_decl_explicit (BUILT_IN_TRAP), 0);
else
{
tree data
= ubsan_create_data ("__ubsan_out_of_bounds_data", &loc, NULL,
ubsan_type_descriptor (type, UBSAN_PRINT_ARRAY),
ubsan_type_descriptor (orig_index_type),
NULL_TREE);
data = build_fold_addr_expr_loc (loc, data);
enum built_in_function bcode
= flag_sanitize_recover
? BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS
: BUILT_IN_UBSAN_HANDLE_OUT_OF_BOUNDS_ABORT;
tree fn = builtin_decl_explicit (bcode);
tree val = force_gimple_operand_gsi (gsi, ubsan_encode_value (index),
true, NULL_TREE, true,
GSI_SAME_STMT);
g = gimple_build_call (fn, 2, data, val);
}
gimple_set_location (g, loc);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
/* Get rid of the UBSAN_BOUNDS call from the IR. */
unlink_stmt_vdef (stmt);
gsi_remove (&gsi_orig, true);
/* Point GSI to next logical statement. */
*gsi = gsi_start_bb (fallthru_bb);
}
static tree
pass_through_call (const_gimple call)
{
tree callee = gimple_call_fndecl (call);
if (callee
&& DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
switch (DECL_FUNCTION_CODE (callee))
{
case BUILT_IN_MEMCPY:
case BUILT_IN_MEMMOVE:
case BUILT_IN_MEMSET:
case BUILT_IN_STRCPY:
case BUILT_IN_STRNCPY:
case BUILT_IN_STRCAT:
case BUILT_IN_STRNCAT:
case BUILT_IN_MEMCPY_CHK:
case BUILT_IN_MEMMOVE_CHK:
case BUILT_IN_MEMSET_CHK:
case BUILT_IN_STRCPY_CHK:
case BUILT_IN_STRNCPY_CHK:
case BUILT_IN_STPNCPY_CHK:
case BUILT_IN_STRCAT_CHK:
case BUILT_IN_STRNCAT_CHK:
case BUILT_IN_ASSUME_ALIGNED:
if (gimple_call_num_args (call) >= 1)
return gimple_call_arg (call, 0);
break;
default:
break;
}
return NULL_TREE;
}
bool
aarch64_gimple_fold_builtin (gimple_stmt_iterator *gsi)
{
bool changed = false;
gimple stmt = gsi_stmt (*gsi);
tree call = gimple_call_fn (stmt);
tree fndecl;
gimple new_stmt = NULL;
if (call)
{
fndecl = gimple_call_fndecl (stmt);
if (fndecl)
{
int fcode = DECL_FUNCTION_CODE (fndecl);
int nargs = gimple_call_num_args (stmt);
tree *args = (nargs > 0
? gimple_call_arg_ptr (stmt, 0)
: &error_mark_node);
/* We use gimple's REDUC_(PLUS|MIN|MAX)_EXPRs for float, signed int
and unsigned int; it will distinguish according to the types of
the arguments to the __builtin. */
switch (fcode)
{
BUILTIN_VALL (UNOP, reduc_plus_scal_, 10)
new_stmt = gimple_build_assign (gimple_call_lhs (stmt),
REDUC_PLUS_EXPR, args[0]);
break;
BUILTIN_VDQIF (UNOP, reduc_smax_scal_, 10)
BUILTIN_VDQ_BHSI (UNOPU, reduc_umax_scal_, 10)
new_stmt = gimple_build_assign (gimple_call_lhs (stmt),
REDUC_MAX_EXPR, args[0]);
break;
BUILTIN_VDQIF (UNOP, reduc_smin_scal_, 10)
BUILTIN_VDQ_BHSI (UNOPU, reduc_umin_scal_, 10)
new_stmt = gimple_build_assign (gimple_call_lhs (stmt),
REDUC_MIN_EXPR, args[0]);
break;
default:
break;
}
}
}
if (new_stmt)
{
gsi_replace (gsi, new_stmt, true);
changed = true;
}
return changed;
}
bool
gimple_simplify (gimple *stmt,
code_helper *rcode, tree *ops,
gimple_seq *seq,
tree (*valueize)(tree), tree (*top_valueize)(tree))
{
switch (gimple_code (stmt))
{
case GIMPLE_ASSIGN:
{
enum tree_code code = gimple_assign_rhs_code (stmt);
tree type = TREE_TYPE (gimple_assign_lhs (stmt));
switch (gimple_assign_rhs_class (stmt))
{
case GIMPLE_SINGLE_RHS:
if (code == REALPART_EXPR
|| code == IMAGPART_EXPR
|| code == VIEW_CONVERT_EXPR)
{
tree op0 = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
bool valueized = false;
op0 = do_valueize (op0, top_valueize, valueized);
*rcode = code;
ops[0] = op0;
return (gimple_resimplify1 (seq, rcode, type, ops, valueize)
|| valueized);
}
else if (code == BIT_FIELD_REF)
{
tree rhs1 = gimple_assign_rhs1 (stmt);
tree op0 = TREE_OPERAND (rhs1, 0);
bool valueized = false;
op0 = do_valueize (op0, top_valueize, valueized);
*rcode = code;
ops[0] = op0;
ops[1] = TREE_OPERAND (rhs1, 1);
ops[2] = TREE_OPERAND (rhs1, 2);
return (gimple_resimplify3 (seq, rcode, type, ops, valueize)
|| valueized);
}
else if (code == SSA_NAME
&& top_valueize)
{
tree op0 = gimple_assign_rhs1 (stmt);
tree valueized = top_valueize (op0);
if (!valueized || op0 == valueized)
return false;
ops[0] = valueized;
*rcode = TREE_CODE (op0);
return true;
}
break;
case GIMPLE_UNARY_RHS:
{
tree rhs1 = gimple_assign_rhs1 (stmt);
bool valueized = false;
rhs1 = do_valueize (rhs1, top_valueize, valueized);
*rcode = code;
ops[0] = rhs1;
return (gimple_resimplify1 (seq, rcode, type, ops, valueize)
|| valueized);
}
case GIMPLE_BINARY_RHS:
{
tree rhs1 = gimple_assign_rhs1 (stmt);
tree rhs2 = gimple_assign_rhs2 (stmt);
bool valueized = false;
rhs1 = do_valueize (rhs1, top_valueize, valueized);
rhs2 = do_valueize (rhs2, top_valueize, valueized);
*rcode = code;
ops[0] = rhs1;
ops[1] = rhs2;
return (gimple_resimplify2 (seq, rcode, type, ops, valueize)
|| valueized);
}
case GIMPLE_TERNARY_RHS:
{
bool valueized = false;
tree rhs1 = gimple_assign_rhs1 (stmt);
/* If this is a [VEC_]COND_EXPR first try to simplify an
embedded GENERIC condition. */
if (code == COND_EXPR
|| code == VEC_COND_EXPR)
{
if (COMPARISON_CLASS_P (rhs1))
{
tree lhs = TREE_OPERAND (rhs1, 0);
tree rhs = TREE_OPERAND (rhs1, 1);
lhs = do_valueize (lhs, top_valueize, valueized);
rhs = do_valueize (rhs, top_valueize, valueized);
code_helper rcode2 = TREE_CODE (rhs1);
tree ops2[3] = {};
ops2[0] = lhs;
ops2[1] = rhs;
if ((gimple_resimplify2 (seq, &rcode2, TREE_TYPE (rhs1),
ops2, valueize)
|| valueized)
&& rcode2.is_tree_code ())
{
valueized = true;
if (TREE_CODE_CLASS ((enum tree_code)rcode2)
== tcc_comparison)
rhs1 = build2 (rcode2, TREE_TYPE (rhs1),
ops2[0], ops2[1]);
else if (rcode2 == SSA_NAME
|| rcode2 == INTEGER_CST)
rhs1 = ops2[0];
else
valueized = false;
}
}
}
tree rhs2 = gimple_assign_rhs2 (stmt);
tree rhs3 = gimple_assign_rhs3 (stmt);
rhs1 = do_valueize (rhs1, top_valueize, valueized);
rhs2 = do_valueize (rhs2, top_valueize, valueized);
rhs3 = do_valueize (rhs3, top_valueize, valueized);
*rcode = code;
ops[0] = rhs1;
ops[1] = rhs2;
ops[2] = rhs3;
return (gimple_resimplify3 (seq, rcode, type, ops, valueize)
|| valueized);
}
default:
gcc_unreachable ();
}
break;
}
case GIMPLE_CALL:
/* ??? This way we can't simplify calls with side-effects. */
if (gimple_call_lhs (stmt) != NULL_TREE
&& gimple_call_num_args (stmt) >= 1
&& gimple_call_num_args (stmt) <= 3)
{
tree fn = gimple_call_fn (stmt);
/* ??? Internal function support missing. */
if (!fn)
return false;
bool valueized = false;
fn = do_valueize (fn, top_valueize, valueized);
if (TREE_CODE (fn) != ADDR_EXPR
|| TREE_CODE (TREE_OPERAND (fn, 0)) != FUNCTION_DECL)
return false;
tree decl = TREE_OPERAND (fn, 0);
if (DECL_BUILT_IN_CLASS (decl) != BUILT_IN_NORMAL
|| !builtin_decl_implicit (DECL_FUNCTION_CODE (decl))
|| !gimple_builtin_call_types_compatible_p (stmt, decl))
return false;
tree type = TREE_TYPE (gimple_call_lhs (stmt));
*rcode = DECL_FUNCTION_CODE (decl);
for (unsigned i = 0; i < gimple_call_num_args (stmt); ++i)
{
tree arg = gimple_call_arg (stmt, i);
ops[i] = do_valueize (arg, top_valueize, valueized);
}
switch (gimple_call_num_args (stmt))
{
case 1:
return (gimple_resimplify1 (seq, rcode, type, ops, valueize)
|| valueized);
case 2:
return (gimple_resimplify2 (seq, rcode, type, ops, valueize)
|| valueized);
case 3:
return (gimple_resimplify3 (seq, rcode, type, ops, valueize)
|| valueized);
default:
gcc_unreachable ();
}
}
break;
case GIMPLE_COND:
{
tree lhs = gimple_cond_lhs (stmt);
tree rhs = gimple_cond_rhs (stmt);
bool valueized = false;
lhs = do_valueize (lhs, top_valueize, valueized);
rhs = do_valueize (rhs, top_valueize, valueized);
*rcode = gimple_cond_code (stmt);
ops[0] = lhs;
ops[1] = rhs;
return (gimple_resimplify2 (seq, rcode,
boolean_type_node, ops, valueize)
|| valueized);
}
default:
break;
}
return false;
}
tree
walk_gimple_op (gimple *stmt, walk_tree_fn callback_op,
struct walk_stmt_info *wi)
{
hash_set<tree> *pset = (wi) ? wi->pset : NULL;
unsigned i;
tree ret = NULL_TREE;
switch (gimple_code (stmt))
{
case GIMPLE_ASSIGN:
/* Walk the RHS operands. If the LHS is of a non-renamable type or
is a register variable, we may use a COMPONENT_REF on the RHS. */
if (wi)
{
tree lhs = gimple_assign_lhs (stmt);
wi->val_only
= (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
|| gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
}
for (i = 1; i < gimple_num_ops (stmt); i++)
{
ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
pset);
if (ret)
return ret;
}
/* Walk the LHS. If the RHS is appropriate for a memory, we
may use a COMPONENT_REF on the LHS. */
if (wi)
{
/* If the RHS is of a non-renamable type or is a register variable,
we may use a COMPONENT_REF on the LHS. */
tree rhs1 = gimple_assign_rhs1 (stmt);
wi->val_only
= (is_gimple_reg_type (TREE_TYPE (rhs1)) && !is_gimple_reg (rhs1))
|| gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
wi->is_lhs = true;
}
ret = walk_tree (gimple_op_ptr (stmt, 0), callback_op, wi, pset);
if (ret)
return ret;
if (wi)
{
wi->val_only = true;
wi->is_lhs = false;
}
break;
case GIMPLE_CALL:
if (wi)
{
wi->is_lhs = false;
wi->val_only = true;
}
ret = walk_tree (gimple_call_chain_ptr (as_a <gcall *> (stmt)),
callback_op, wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
if (ret)
return ret;
for (i = 0; i < gimple_call_num_args (stmt); i++)
{
if (wi)
wi->val_only
= is_gimple_reg_type (TREE_TYPE (gimple_call_arg (stmt, i)));
ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
pset);
if (ret)
return ret;
}
if (gimple_call_lhs (stmt))
{
if (wi)
{
wi->is_lhs = true;
wi->val_only
= is_gimple_reg_type (TREE_TYPE (gimple_call_lhs (stmt)));
}
ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
if (ret)
return ret;
}
if (wi)
{
wi->is_lhs = false;
wi->val_only = true;
}
break;
case GIMPLE_CATCH:
ret = walk_tree (gimple_catch_types_ptr (as_a <gcatch *> (stmt)),
callback_op, wi, pset);
if (ret)
return ret;
break;
case GIMPLE_EH_FILTER:
ret = walk_tree (gimple_eh_filter_types_ptr (stmt), callback_op, wi,
pset);
if (ret)
return ret;
break;
case GIMPLE_ASM:
ret = walk_gimple_asm (as_a <gasm *> (stmt), callback_op, wi);
if (ret)
return ret;
break;
case GIMPLE_OMP_CONTINUE:
{
gomp_continue *cont_stmt = as_a <gomp_continue *> (stmt);
ret = walk_tree (gimple_omp_continue_control_def_ptr (cont_stmt),
callback_op, wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_continue_control_use_ptr (cont_stmt),
callback_op, wi, pset);
if (ret)
return ret;
}
break;
case GIMPLE_OMP_CRITICAL:
{
gomp_critical *omp_stmt = as_a <gomp_critical *> (stmt);
ret = walk_tree (gimple_omp_critical_name_ptr (omp_stmt),
callback_op, wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_critical_clauses_ptr (omp_stmt),
callback_op, wi, pset);
if (ret)
return ret;
}
break;
case GIMPLE_OMP_ORDERED:
{
gomp_ordered *omp_stmt = as_a <gomp_ordered *> (stmt);
ret = walk_tree (gimple_omp_ordered_clauses_ptr (omp_stmt),
callback_op, wi, pset);
if (ret)
return ret;
}
break;
case GIMPLE_OMP_FOR:
ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi,
pset);
if (ret)
return ret;
for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
{
ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op,
wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op,
wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op,
wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op,
wi, pset);
if (ret)
return ret;
}
break;
case GIMPLE_OMP_PARALLEL:
{
gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
ret = walk_tree (gimple_omp_parallel_clauses_ptr (omp_par_stmt),
callback_op, wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_parallel_child_fn_ptr (omp_par_stmt),
callback_op, wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_parallel_data_arg_ptr (omp_par_stmt),
callback_op, wi, pset);
if (ret)
return ret;
}
break;
case GIMPLE_OMP_TASK:
ret = walk_tree (gimple_omp_task_clauses_ptr (stmt), callback_op,
wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_task_child_fn_ptr (stmt), callback_op,
wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_task_data_arg_ptr (stmt), callback_op,
wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_task_copy_fn_ptr (stmt), callback_op,
wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_task_arg_size_ptr (stmt), callback_op,
wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_task_arg_align_ptr (stmt), callback_op,
wi, pset);
if (ret)
return ret;
break;
case GIMPLE_OMP_SECTIONS:
ret = walk_tree (gimple_omp_sections_clauses_ptr (stmt), callback_op,
wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_sections_control_ptr (stmt), callback_op,
wi, pset);
if (ret)
return ret;
break;
case GIMPLE_OMP_SINGLE:
ret = walk_tree (gimple_omp_single_clauses_ptr (stmt), callback_op, wi,
pset);
if (ret)
return ret;
break;
case GIMPLE_OMP_TARGET:
{
gomp_target *omp_stmt = as_a <gomp_target *> (stmt);
ret = walk_tree (gimple_omp_target_clauses_ptr (omp_stmt),
callback_op, wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_target_child_fn_ptr (omp_stmt),
callback_op, wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_target_data_arg_ptr (omp_stmt),
callback_op, wi, pset);
if (ret)
return ret;
}
break;
case GIMPLE_OMP_TEAMS:
ret = walk_tree (gimple_omp_teams_clauses_ptr (stmt), callback_op, wi,
pset);
if (ret)
return ret;
break;
case GIMPLE_OMP_ATOMIC_LOAD:
{
gomp_atomic_load *omp_stmt = as_a <gomp_atomic_load *> (stmt);
ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (omp_stmt),
callback_op, wi, pset);
if (ret)
return ret;
ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (omp_stmt),
callback_op, wi, pset);
if (ret)
return ret;
}
break;
case GIMPLE_OMP_ATOMIC_STORE:
{
gomp_atomic_store *omp_stmt = as_a <gomp_atomic_store *> (stmt);
ret = walk_tree (gimple_omp_atomic_store_val_ptr (omp_stmt),
callback_op, wi, pset);
if (ret)
return ret;
}
break;
case GIMPLE_TRANSACTION:
ret = walk_tree (gimple_transaction_label_ptr (
as_a <gtransaction *> (stmt)),
callback_op, wi, pset);
if (ret)
return ret;
break;
case GIMPLE_OMP_RETURN:
ret = walk_tree (gimple_omp_return_lhs_ptr (stmt), callback_op, wi,
pset);
if (ret)
return ret;
break;
/* Tuples that do not have operands. */
case GIMPLE_NOP:
case GIMPLE_RESX:
case GIMPLE_PREDICT:
break;
default:
{
enum gimple_statement_structure_enum gss;
gss = gimple_statement_structure (stmt);
if (gss == GSS_WITH_OPS || gss == GSS_WITH_MEM_OPS)
for (i = 0; i < gimple_num_ops (stmt); i++)
{
ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi, pset);
if (ret)
return ret;
}
}
break;
}
return NULL_TREE;
}
static void
lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
{
gimple stmt = gsi_stmt (*gsi);
gimple_set_block (stmt, data->block);
switch (gimple_code (stmt))
{
case GIMPLE_BIND:
lower_gimple_bind (gsi, data);
/* Propagate fallthruness. */
return;
case GIMPLE_COND:
case GIMPLE_GOTO:
case GIMPLE_SWITCH:
data->cannot_fallthru = true;
gsi_next (gsi);
return;
case GIMPLE_RETURN:
if (data->cannot_fallthru)
{
gsi_remove (gsi, false);
/* Propagate fallthruness. */
}
else
{
lower_gimple_return (gsi, data);
data->cannot_fallthru = true;
}
return;
case GIMPLE_TRY:
if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
lower_try_catch (gsi, data);
else
{
/* It must be a GIMPLE_TRY_FINALLY. */
bool cannot_fallthru;
lower_sequence (gimple_try_eval_ptr (stmt), data);
cannot_fallthru = data->cannot_fallthru;
/* The finally clause is always executed after the try clause,
so if it does not fall through, then the try-finally will not
fall through. Otherwise, if the try clause does not fall
through, then when the finally clause falls through it will
resume execution wherever the try clause was going. So the
whole try-finally will only fall through if both the try
clause and the finally clause fall through. */
data->cannot_fallthru = false;
lower_sequence (gimple_try_cleanup_ptr (stmt), data);
data->cannot_fallthru |= cannot_fallthru;
gsi_next (gsi);
}
return;
case GIMPLE_EH_ELSE:
lower_sequence (gimple_eh_else_n_body_ptr (stmt), data);
lower_sequence (gimple_eh_else_e_body_ptr (stmt), data);
break;
case GIMPLE_NOP:
case GIMPLE_ASM:
case GIMPLE_ASSIGN:
case GIMPLE_PREDICT:
case GIMPLE_LABEL:
case GIMPLE_EH_MUST_NOT_THROW:
case GIMPLE_OMP_FOR:
case GIMPLE_OMP_SECTIONS:
case GIMPLE_OMP_SECTIONS_SWITCH:
case GIMPLE_OMP_SECTION:
case GIMPLE_OMP_SINGLE:
case GIMPLE_OMP_MASTER:
case GIMPLE_OMP_ORDERED:
case GIMPLE_OMP_CRITICAL:
case GIMPLE_OMP_RETURN:
case GIMPLE_OMP_ATOMIC_LOAD:
case GIMPLE_OMP_ATOMIC_STORE:
case GIMPLE_OMP_CONTINUE:
break;
case GIMPLE_CALL:
{
tree decl = gimple_call_fndecl (stmt);
unsigned i;
for (i = 0; i < gimple_call_num_args (stmt); i++)
{
tree arg = gimple_call_arg (stmt, i);
if (EXPR_P (arg))
TREE_SET_BLOCK (arg, data->block);
}
if (decl
&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
&& DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
{
lower_builtin_setjmp (gsi);
data->cannot_fallthru = false;
data->calls_builtin_setjmp = true;
return;
}
if (decl && (flags_from_decl_or_type (decl) & ECF_NORETURN))
{
data->cannot_fallthru = true;
gsi_next (gsi);
return;
}
}
break;
case GIMPLE_OMP_PARALLEL:
case GIMPLE_OMP_TASK:
data->cannot_fallthru = false;
lower_omp_directive (gsi, data);
data->cannot_fallthru = false;
return;
case GIMPLE_TRANSACTION:
lower_sequence (gimple_transaction_body_ptr (stmt), data);
break;
default:
gcc_unreachable ();
}
data->cannot_fallthru = false;
gsi_next (gsi);
}
static bool
gimple_check_call_args (gimple stmt, tree fndecl, bool args_count_match)
{
tree parms, p;
unsigned int i, nargs;
/* Calls to internal functions always match their signature. */
if (gimple_call_internal_p (stmt))
return true;
nargs = gimple_call_num_args (stmt);
/* Get argument types for verification. */
if (fndecl)
parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
else
parms = TYPE_ARG_TYPES (gimple_call_fntype (stmt));
/* Verify if the type of the argument matches that of the function
declaration. If we cannot verify this or there is a mismatch,
return false. */
if (fndecl && DECL_ARGUMENTS (fndecl))
{
for (i = 0, p = DECL_ARGUMENTS (fndecl);
i < nargs;
i++, p = DECL_CHAIN (p))
{
tree arg;
/* We cannot distinguish a varargs function from the case
of excess parameters, still deferring the inlining decision
to the callee is possible. */
if (!p)
break;
arg = gimple_call_arg (stmt, i);
if (p == error_mark_node
|| arg == error_mark_node
|| (!types_compatible_p (DECL_ARG_TYPE (p), TREE_TYPE (arg))
&& !fold_convertible_p (DECL_ARG_TYPE (p), arg)))
return false;
}
if (args_count_match && p)
return false;
}
else if (parms)
{
for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
{
tree arg;
/* If this is a varargs function defer inlining decision
to callee. */
if (!p)
break;
arg = gimple_call_arg (stmt, i);
if (TREE_VALUE (p) == error_mark_node
|| arg == error_mark_node
|| TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
|| (!types_compatible_p (TREE_VALUE (p), TREE_TYPE (arg))
&& !fold_convertible_p (TREE_VALUE (p), arg)))
return false;
}
}
else
{
if (nargs != 0)
return false;
}
return true;
}
expr_hash_elt::expr_hash_elt (gimple *stmt, tree orig_lhs)
{
enum gimple_code code = gimple_code (stmt);
struct hashable_expr *expr = this->expr ();
if (code == GIMPLE_ASSIGN)
{
enum tree_code subcode = gimple_assign_rhs_code (stmt);
switch (get_gimple_rhs_class (subcode))
{
case GIMPLE_SINGLE_RHS:
expr->kind = EXPR_SINGLE;
expr->type = TREE_TYPE (gimple_assign_rhs1 (stmt));
expr->ops.single.rhs = gimple_assign_rhs1 (stmt);
break;
case GIMPLE_UNARY_RHS:
expr->kind = EXPR_UNARY;
expr->type = TREE_TYPE (gimple_assign_lhs (stmt));
if (CONVERT_EXPR_CODE_P (subcode))
subcode = NOP_EXPR;
expr->ops.unary.op = subcode;
expr->ops.unary.opnd = gimple_assign_rhs1 (stmt);
break;
case GIMPLE_BINARY_RHS:
expr->kind = EXPR_BINARY;
expr->type = TREE_TYPE (gimple_assign_lhs (stmt));
expr->ops.binary.op = subcode;
expr->ops.binary.opnd0 = gimple_assign_rhs1 (stmt);
expr->ops.binary.opnd1 = gimple_assign_rhs2 (stmt);
break;
case GIMPLE_TERNARY_RHS:
expr->kind = EXPR_TERNARY;
expr->type = TREE_TYPE (gimple_assign_lhs (stmt));
expr->ops.ternary.op = subcode;
expr->ops.ternary.opnd0 = gimple_assign_rhs1 (stmt);
expr->ops.ternary.opnd1 = gimple_assign_rhs2 (stmt);
expr->ops.ternary.opnd2 = gimple_assign_rhs3 (stmt);
break;
default:
gcc_unreachable ();
}
}
else if (code == GIMPLE_COND)
{
expr->type = boolean_type_node;
expr->kind = EXPR_BINARY;
expr->ops.binary.op = gimple_cond_code (stmt);
expr->ops.binary.opnd0 = gimple_cond_lhs (stmt);
expr->ops.binary.opnd1 = gimple_cond_rhs (stmt);
}
else if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
{
size_t nargs = gimple_call_num_args (call_stmt);
size_t i;
gcc_assert (gimple_call_lhs (call_stmt));
expr->type = TREE_TYPE (gimple_call_lhs (call_stmt));
expr->kind = EXPR_CALL;
expr->ops.call.fn_from = call_stmt;
if (gimple_call_flags (call_stmt) & (ECF_CONST | ECF_PURE))
expr->ops.call.pure = true;
else
expr->ops.call.pure = false;
expr->ops.call.nargs = nargs;
expr->ops.call.args = XCNEWVEC (tree, nargs);
for (i = 0; i < nargs; i++)
expr->ops.call.args[i] = gimple_call_arg (call_stmt, i);
}
else if (gswitch *swtch_stmt = dyn_cast <gswitch *> (stmt))
{
expr->type = TREE_TYPE (gimple_switch_index (swtch_stmt));
expr->kind = EXPR_SINGLE;
expr->ops.single.rhs = gimple_switch_index (swtch_stmt);
}
else if (code == GIMPLE_GOTO)
{
expr->type = TREE_TYPE (gimple_goto_dest (stmt));
expr->kind = EXPR_SINGLE;
expr->ops.single.rhs = gimple_goto_dest (stmt);
}
else if (code == GIMPLE_PHI)
{
size_t nargs = gimple_phi_num_args (stmt);
size_t i;
expr->type = TREE_TYPE (gimple_phi_result (stmt));
expr->kind = EXPR_PHI;
expr->ops.phi.nargs = nargs;
expr->ops.phi.args = XCNEWVEC (tree, nargs);
for (i = 0; i < nargs; i++)
expr->ops.phi.args[i] = gimple_phi_arg_def (stmt, i);
}
else
gcc_unreachable ();
m_lhs = orig_lhs;
m_vop = gimple_vuse (stmt);
m_hash = avail_expr_hash (this);
m_stamp = this;
}
static void
myprof_read_stmt ( gimple g, int *nbop)
{
unsigned int i;
enum gimple_code gc;
/* nbloads = 0;*/
/* nbstores = 0;*/
/* fprintf(stderr, "nbop dans mihp_read_stmt: %d\n", *nbop);*/
gc = gimple_code ( g );
switch ( gc )
{
case GIMPLE_ASSIGN:
(*nbop)++;
//fprintf(stderr, "dans mihp_read_stmt, nombre d'operations: %d\n", *nbop);
//Premier opérande à droite de l'égalité
myprof_read_operand ( gimple_op(g,1), RIGHT ); /* op1 */
if ( gimple_num_ops(g) > 2 ) {/* op2 */
/* printf("Plus de 2 operandes\n");*/
/* printf("Type d'operation: %d\n", gimple_assign_rhs_code(g));*/
/* printf("Type d'operation: %s\n", tree_code_name[gimple_assign_rhs_code(g)]);*/
//nb2opSuperior++;
myprof_read_operand ( gimple_op(g,2), RIGHT );
//debug_tree(gimple_op(gsi_stmt(gsi),1));
tree type1 = TREE_TYPE(gimple_op(g,1));
tree type2 = TREE_TYPE(gimple_op(g,2));
/* debug_tree(type1);*/
/* debug_tree(type2);*/
int tc = TREE_CODE(type1);
int tc2 = TREE_CODE(type2);
if((tc == REAL_TYPE) || (tc2 == REAL_TYPE)) {
/* fprintf(stderr, "l'operation est de type reel\n");*/
}
else {
/* fprintf(stderr, "l'operation est de type entier\n");*/
}
/* if(tc == REAL_TYPE) {*/
/* fprintf(stderr, "type Réel\n");*/
/* } */
/* else if(tc == INTEGER_TYPE) {*/
/* fprintf(stderr, "type Entier\n");*/
/* }*/
}
myprof_read_operand ( gimple_op(g,0), LEFT ); /* op def */
break;
case GIMPLE_CALL:
for ( i=0; i<gimple_call_num_args(g); ++i )
myprof_read_operand ( gimple_call_arg(g,i), 2 );
if ( gimple_call_lhs(g) != NULL_TREE )
myprof_read_operand ( gimple_call_lhs(g), 2 );
break;
case GIMPLE_COND:
myprof_read_operand ( gimple_cond_lhs(g), 2 ); /* op1 */
myprof_read_operand ( gimple_cond_rhs(g), 2 ); /* op2 */
break;
case GIMPLE_RETURN:
if ( gimple_return_retval(g) != NULL_TREE )
myprof_read_operand ( gimple_return_retval(g), 2 );
break;
default:
fprintf ( stderr, "mihp: mihp_read_stmt(): unhandled \'%s\'\n", gimple_code_name[gc] );
gcc_unreachable ( );
}
}
bool
gimple_simplify (gimple stmt,
code_helper *rcode, tree *ops,
gimple_seq *seq, tree (*valueize)(tree))
{
switch (gimple_code (stmt))
{
case GIMPLE_ASSIGN:
{
enum tree_code code = gimple_assign_rhs_code (stmt);
tree type = TREE_TYPE (gimple_assign_lhs (stmt));
switch (gimple_assign_rhs_class (stmt))
{
case GIMPLE_SINGLE_RHS:
if (code == REALPART_EXPR
|| code == IMAGPART_EXPR
|| code == VIEW_CONVERT_EXPR)
{
tree op0 = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
if (valueize && TREE_CODE (op0) == SSA_NAME)
{
tree tem = valueize (op0);
if (tem)
op0 = tem;
}
*rcode = code;
ops[0] = op0;
return gimple_resimplify1 (seq, rcode, type, ops, valueize);
}
else if (code == BIT_FIELD_REF)
{
tree rhs1 = gimple_assign_rhs1 (stmt);
tree op0 = TREE_OPERAND (rhs1, 0);
if (valueize && TREE_CODE (op0) == SSA_NAME)
{
tree tem = valueize (op0);
if (tem)
op0 = tem;
}
*rcode = code;
ops[0] = op0;
ops[1] = TREE_OPERAND (rhs1, 1);
ops[2] = TREE_OPERAND (rhs1, 2);
return gimple_resimplify3 (seq, rcode, type, ops, valueize);
}
else if (code == SSA_NAME
&& valueize)
{
tree op0 = gimple_assign_rhs1 (stmt);
tree valueized = valueize (op0);
if (!valueized || op0 == valueized)
return false;
ops[0] = valueized;
*rcode = TREE_CODE (op0);
return true;
}
break;
case GIMPLE_UNARY_RHS:
{
tree rhs1 = gimple_assign_rhs1 (stmt);
if (valueize && TREE_CODE (rhs1) == SSA_NAME)
{
tree tem = valueize (rhs1);
if (tem)
rhs1 = tem;
}
*rcode = code;
ops[0] = rhs1;
return gimple_resimplify1 (seq, rcode, type, ops, valueize);
}
case GIMPLE_BINARY_RHS:
{
tree rhs1 = gimple_assign_rhs1 (stmt);
if (valueize && TREE_CODE (rhs1) == SSA_NAME)
{
tree tem = valueize (rhs1);
if (tem)
rhs1 = tem;
}
tree rhs2 = gimple_assign_rhs2 (stmt);
if (valueize && TREE_CODE (rhs2) == SSA_NAME)
{
tree tem = valueize (rhs2);
if (tem)
rhs2 = tem;
}
*rcode = code;
ops[0] = rhs1;
ops[1] = rhs2;
return gimple_resimplify2 (seq, rcode, type, ops, valueize);
}
case GIMPLE_TERNARY_RHS:
{
tree rhs1 = gimple_assign_rhs1 (stmt);
if (valueize && TREE_CODE (rhs1) == SSA_NAME)
{
tree tem = valueize (rhs1);
if (tem)
rhs1 = tem;
}
tree rhs2 = gimple_assign_rhs2 (stmt);
if (valueize && TREE_CODE (rhs2) == SSA_NAME)
{
tree tem = valueize (rhs2);
if (tem)
rhs2 = tem;
}
tree rhs3 = gimple_assign_rhs3 (stmt);
if (valueize && TREE_CODE (rhs3) == SSA_NAME)
{
tree tem = valueize (rhs3);
if (tem)
rhs3 = tem;
}
*rcode = code;
ops[0] = rhs1;
ops[1] = rhs2;
ops[2] = rhs3;
return gimple_resimplify3 (seq, rcode, type, ops, valueize);
}
default:
gcc_unreachable ();
}
break;
}
case GIMPLE_CALL:
/* ??? This way we can't simplify calls with side-effects. */
if (gimple_call_lhs (stmt) != NULL_TREE)
{
tree fn = gimple_call_fn (stmt);
/* ??? Internal function support missing. */
if (!fn)
return false;
if (valueize && TREE_CODE (fn) == SSA_NAME)
{
tree tem = valueize (fn);
if (tem)
fn = tem;
}
if (!fn
|| TREE_CODE (fn) != ADDR_EXPR
|| TREE_CODE (TREE_OPERAND (fn, 0)) != FUNCTION_DECL
|| DECL_BUILT_IN_CLASS (TREE_OPERAND (fn, 0)) != BUILT_IN_NORMAL
|| !builtin_decl_implicit (DECL_FUNCTION_CODE (TREE_OPERAND (fn, 0)))
|| !gimple_builtin_call_types_compatible_p (stmt,
TREE_OPERAND (fn, 0)))
return false;
tree decl = TREE_OPERAND (fn, 0);
tree type = TREE_TYPE (gimple_call_lhs (stmt));
switch (gimple_call_num_args (stmt))
{
case 1:
{
tree arg1 = gimple_call_arg (stmt, 0);
if (valueize && TREE_CODE (arg1) == SSA_NAME)
{
tree tem = valueize (arg1);
if (tem)
arg1 = tem;
}
*rcode = DECL_FUNCTION_CODE (decl);
ops[0] = arg1;
return gimple_resimplify1 (seq, rcode, type, ops, valueize);
}
case 2:
{
tree arg1 = gimple_call_arg (stmt, 0);
if (valueize && TREE_CODE (arg1) == SSA_NAME)
{
tree tem = valueize (arg1);
if (tem)
arg1 = tem;
}
tree arg2 = gimple_call_arg (stmt, 1);
if (valueize && TREE_CODE (arg2) == SSA_NAME)
{
tree tem = valueize (arg2);
if (tem)
arg2 = tem;
}
*rcode = DECL_FUNCTION_CODE (decl);
ops[0] = arg1;
ops[1] = arg2;
return gimple_resimplify2 (seq, rcode, type, ops, valueize);
}
case 3:
{
tree arg1 = gimple_call_arg (stmt, 0);
if (valueize && TREE_CODE (arg1) == SSA_NAME)
{
tree tem = valueize (arg1);
if (tem)
arg1 = tem;
}
tree arg2 = gimple_call_arg (stmt, 1);
if (valueize && TREE_CODE (arg2) == SSA_NAME)
{
tree tem = valueize (arg2);
if (tem)
arg2 = tem;
}
tree arg3 = gimple_call_arg (stmt, 2);
if (valueize && TREE_CODE (arg3) == SSA_NAME)
{
tree tem = valueize (arg3);
if (tem)
arg3 = tem;
}
*rcode = DECL_FUNCTION_CODE (decl);
ops[0] = arg1;
ops[1] = arg2;
ops[2] = arg3;
return gimple_resimplify3 (seq, rcode, type, ops, valueize);
}
default:
return false;
}
}
break;
case GIMPLE_COND:
{
tree lhs = gimple_cond_lhs (stmt);
if (valueize && TREE_CODE (lhs) == SSA_NAME)
{
tree tem = valueize (lhs);
if (tem)
lhs = tem;
}
tree rhs = gimple_cond_rhs (stmt);
if (valueize && TREE_CODE (rhs) == SSA_NAME)
{
tree tem = valueize (rhs);
if (tem)
rhs = tem;
}
*rcode = gimple_cond_code (stmt);
ops[0] = lhs;
ops[1] = rhs;
return gimple_resimplify2 (seq, rcode, boolean_type_node, ops, valueize);
}
default:
break;
}
return false;
}
/* Transform
1) Memory references.
2) BUILTIN_ALLOCA calls.
*/
static void
mf_xform_statements (void)
{
basic_block bb, next;
gimple_stmt_iterator i;
int saved_last_basic_block = last_basic_block;
enum gimple_rhs_class grhs_class;
unsigned argc, j;
bb = ENTRY_BLOCK_PTR ->next_bb;
do
{
next = bb->next_bb;
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
{
gimple s = gsi_stmt (i);
/* Only a few GIMPLE statements can reference memory. */
switch (gimple_code (s))
{
case GIMPLE_ASSIGN:
DEBUGLOG("\n\n******** Gimlpe Assign LHS ***********\n");
mf_xform_derefs_1 (&i, gimple_assign_lhs_ptr (s),
gimple_location (s), integer_one_node);
DEBUGLOG("******** Gimlpe Assign RHS ***********\n");
mf_xform_derefs_1 (&i, gimple_assign_rhs1_ptr (s),
gimple_location (s), integer_zero_node);
grhs_class = get_gimple_rhs_class (gimple_assign_rhs_code (s));
if (grhs_class == GIMPLE_BINARY_RHS)
mf_xform_derefs_1 (&i, gimple_assign_rhs2_ptr (s),
gimple_location (s), integer_zero_node);
break;
case GIMPLE_RETURN:
if (gimple_return_retval (s) != NULL_TREE)
{
mf_xform_derefs_1 (&i, gimple_return_retval_ptr (s),
gimple_location (s),
integer_zero_node);
}
break;
case GIMPLE_CALL:
{
tree fndecl = gimple_call_fndecl (s);
//if (fndecl && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA))
// gimple_call_set_cannot_inline (s, true);
argc = gimple_call_num_args(s);
for (j = 0; j < argc; j++){
mf_xform_derefs_1 (&i, gimple_call_arg_ptr (s, j),
gimple_location (s), integer_zero_node);
}
}
break;
default:
;
}
}
bb = next;
}
while (bb && bb->index <= saved_last_basic_block);
}
static void
use_internal_fn (gcall *call)
{
/* We'll be inserting another call with the same arguments after the
lhs has been set, so prevent any possible coalescing failure from
having both values live at once. See PR 71020. */
replace_abnormal_ssa_names (call);
unsigned nconds = 0;
auto_vec<gimple *, 12> conds;
if (can_test_argument_range (call))
{
gen_shrink_wrap_conditions (call, conds, &nconds);
gcc_assert (nconds != 0);
}
else
gcc_assert (edom_only_function (call));
internal_fn ifn = replacement_internal_fn (call);
gcc_assert (ifn != IFN_LAST);
/* Construct the new call, with the same arguments as the original one. */
auto_vec <tree, 16> args;
unsigned int nargs = gimple_call_num_args (call);
for (unsigned int i = 0; i < nargs; ++i)
args.safe_push (gimple_call_arg (call, i));
gcall *new_call = gimple_build_call_internal_vec (ifn, args);
gimple_set_location (new_call, gimple_location (call));
gimple_call_set_nothrow (new_call, gimple_call_nothrow_p (call));
/* Transfer the LHS to the new call. */
tree lhs = gimple_call_lhs (call);
gimple_call_set_lhs (new_call, lhs);
gimple_call_set_lhs (call, NULL_TREE);
SSA_NAME_DEF_STMT (lhs) = new_call;
/* Insert the new call. */
gimple_stmt_iterator gsi = gsi_for_stmt (call);
gsi_insert_before (&gsi, new_call, GSI_SAME_STMT);
if (nconds == 0)
{
/* Skip the call if LHS == LHS. If we reach here, EDOM is the only
valid errno value and it is used iff the result is NaN. */
conds.quick_push (gimple_build_cond (EQ_EXPR, lhs, lhs,
NULL_TREE, NULL_TREE));
nconds++;
/* Try replacing the original call with a direct assignment to
errno, via an internal function. */
if (set_edom_supported_p () && !stmt_ends_bb_p (call))
{
gimple_stmt_iterator gsi = gsi_for_stmt (call);
gcall *new_call = gimple_build_call_internal (IFN_SET_EDOM, 0);
gimple_set_vuse (new_call, gimple_vuse (call));
gimple_set_vdef (new_call, gimple_vdef (call));
SSA_NAME_DEF_STMT (gimple_vdef (new_call)) = new_call;
gimple_set_location (new_call, gimple_location (call));
gsi_replace (&gsi, new_call, false);
call = new_call;
}
}
shrink_wrap_one_built_in_call_with_conds (call, conds, nconds);
}
static void read_stmt( gimple g, t_myproof_function *function )
{
unsigned int i;
enum gimple_code gc;
gc = gimple_code( g );
switch ( gc )
{
case GIMPLE_ASSIGN:
{
t_myproof_variable *op1 = read_operand( gimple_op(g,1), function ); /* op1 */
if ( op1 )
{
op1->visited++;
}
if ( gimple_num_ops(g) > 2 ) /* op2 */
{
t_myproof_variable *op2 = read_operand( gimple_op(g,2), function );
if ( op2 )
{
op2->visited++;
}
}
t_myproof_variable *opdef = read_operand( gimple_op(g,0), function ); /* op def */
if ( opdef )
{
opdef->modified++;
}
}
break;
case GIMPLE_CALL:
for ( i = 0; i < gimple_call_num_args(g); ++i )
{
read_operand( gimple_call_arg(g,i), function );
}
if ( gimple_call_lhs(g) != NULL_TREE )
{
read_operand( gimple_call_lhs(g), function );
}
break;
case GIMPLE_COND:
read_operand( gimple_cond_lhs(g), function ); /* op1 */
read_operand( gimple_cond_rhs(g), function ); /* op2 */
break;
case GIMPLE_RETURN:
if ( gimple_return_retval(g) != NULL_TREE )
{
read_operand( gimple_return_retval(g), function );
}
break;
case GIMPLE_DEBUG: break;
default:
fprintf( stderr, "myproof: read_stmt(): unhandled \'%s\'\n", gimple_code_name[gc] );
gcc_unreachable ( );
}
}
static void read_stmt( gimple g )
{
unsigned int i;
enum gimple_code gc;
gc = gimple_code( g );
/* debug_tree(type1); */
//debug_tree(type1);
/* switch ( gc ) */
/* { */
/* case GIMPLE_ASSIGN: */
/* case GIMPLE_CALL: */
/* case GIMPLE_COND: */
/* case GIMPLE_RETURN: */
/* num_all_ops += gimple_num_ops(g); */
/* } */
switch ( gc )
{
case GIMPLE_ASSIGN:
read_operand( gimple_op(g,1) ); /* op1 */
/* num_all_ops_write++; */
tree type1 = TREE_TYPE( gimple_op( g, 1 ) );
int tc = TREE_CODE( type1 );
if ( tc == REAL_TYPE )
{
//debug_tree(type1);
/* printf("this is a real variable\n"); */
}
/* enum tree_code tr = gimple_assign_rhs_code(g); */
/* printf("Doing %s\n", tree_code_name[tr]); */
if ( gimple_num_ops(g) > 2 ) /* op2 */
{
read_operand( gimple_op(g,2) );
}
read_operand( gimple_op(g,0) ); /* op def */
break;
case GIMPLE_CALL:
for ( i = 0; i < gimple_call_num_args(g); ++i )
{
read_operand( gimple_call_arg(g,i) );
}
if ( gimple_call_lhs(g) != NULL_TREE )
{
read_operand( gimple_call_lhs(g) );
}
break;
case GIMPLE_COND:
read_operand( gimple_cond_lhs(g) ); /* op1 */
read_operand( gimple_cond_rhs(g) ); /* op2 */
break;
case GIMPLE_RETURN:
if ( gimple_return_retval(g) != NULL_TREE )
{
read_operand( gimple_return_retval(g) );
}
break;
case GIMPLE_DEBUG: break;
default:
fprintf( stderr, "myproof: read_stmt(): unhandled \'%s\'\n", gimple_code_name[gc] );
gcc_unreachable ( );
}
}
static void
find_tail_calls (basic_block bb, struct tailcall **ret)
{
tree ass_var = NULL_TREE, ret_var, func, param;
gimple stmt, call = NULL;
gimple_stmt_iterator gsi, agsi;
bool tail_recursion;
struct tailcall *nw;
edge e;
tree m, a;
basic_block abb;
size_t idx;
tree var;
if (!single_succ_p (bb))
return;
for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
{
stmt = gsi_stmt (gsi);
/* Ignore labels, returns, clobbers and debug stmts. */
if (gimple_code (stmt) == GIMPLE_LABEL
|| gimple_code (stmt) == GIMPLE_RETURN
|| gimple_clobber_p (stmt)
|| is_gimple_debug (stmt))
continue;
/* Check for a call. */
if (is_gimple_call (stmt))
{
call = stmt;
ass_var = gimple_call_lhs (stmt);
break;
}
/* If the statement references memory or volatile operands, fail. */
if (gimple_references_memory_p (stmt)
|| gimple_has_volatile_ops (stmt))
return;
}
if (gsi_end_p (gsi))
{
edge_iterator ei;
/* Recurse to the predecessors. */
FOR_EACH_EDGE (e, ei, bb->preds)
find_tail_calls (e->src, ret);
return;
}
/* If the LHS of our call is not just a simple register, we can't
transform this into a tail or sibling call. This situation happens,
in (e.g.) "*p = foo()" where foo returns a struct. In this case
we won't have a temporary here, but we need to carry out the side
effect anyway, so tailcall is impossible.
??? In some situations (when the struct is returned in memory via
invisible argument) we could deal with this, e.g. by passing 'p'
itself as that argument to foo, but it's too early to do this here,
and expand_call() will not handle it anyway. If it ever can, then
we need to revisit this here, to allow that situation. */
if (ass_var && !is_gimple_reg (ass_var))
return;
/* We found the call, check whether it is suitable. */
tail_recursion = false;
func = gimple_call_fndecl (call);
if (func
&& !DECL_BUILT_IN (func)
&& recursive_call_p (current_function_decl, func))
{
tree arg;
for (param = DECL_ARGUMENTS (func), idx = 0;
param && idx < gimple_call_num_args (call);
param = DECL_CHAIN (param), idx ++)
{
arg = gimple_call_arg (call, idx);
if (param != arg)
{
/* Make sure there are no problems with copying. The parameter
have a copyable type and the two arguments must have reasonably
equivalent types. The latter requirement could be relaxed if
we emitted a suitable type conversion statement. */
if (!is_gimple_reg_type (TREE_TYPE (param))
|| !useless_type_conversion_p (TREE_TYPE (param),
TREE_TYPE (arg)))
break;
/* The parameter should be a real operand, so that phi node
created for it at the start of the function has the meaning
of copying the value. This test implies is_gimple_reg_type
from the previous condition, however this one could be
relaxed by being more careful with copying the new value
of the parameter (emitting appropriate GIMPLE_ASSIGN and
updating the virtual operands). */
if (!is_gimple_reg (param))
break;
}
}
if (idx == gimple_call_num_args (call) && !param)
tail_recursion = true;
}
/* Make sure the tail invocation of this function does not refer
to local variables. */
FOR_EACH_LOCAL_DECL (cfun, idx, var)
{
if (TREE_CODE (var) != PARM_DECL
&& auto_var_in_fn_p (var, cfun->decl)
&& (ref_maybe_used_by_stmt_p (call, var)
|| call_may_clobber_ref_p (call, var)))
return;
}
/* Now check the statements after the call. None of them has virtual
operands, so they may only depend on the call through its return
value. The return value should also be dependent on each of them,
since we are running after dce. */
m = NULL_TREE;
a = NULL_TREE;
abb = bb;
agsi = gsi;
while (1)
{
tree tmp_a = NULL_TREE;
tree tmp_m = NULL_TREE;
gsi_next (&agsi);
while (gsi_end_p (agsi))
{
ass_var = propagate_through_phis (ass_var, single_succ_edge (abb));
abb = single_succ (abb);
agsi = gsi_start_bb (abb);
}
stmt = gsi_stmt (agsi);
if (gimple_code (stmt) == GIMPLE_LABEL)
continue;
if (gimple_code (stmt) == GIMPLE_RETURN)
break;
if (gimple_clobber_p (stmt))
continue;
if (is_gimple_debug (stmt))
continue;
if (gimple_code (stmt) != GIMPLE_ASSIGN)
return;
/* This is a gimple assign. */
if (! process_assignment (stmt, gsi, &tmp_m, &tmp_a, &ass_var))
return;
if (tmp_a)
{
tree type = TREE_TYPE (tmp_a);
if (a)
a = fold_build2 (PLUS_EXPR, type, fold_convert (type, a), tmp_a);
else
a = tmp_a;
}
if (tmp_m)
{
tree type = TREE_TYPE (tmp_m);
if (m)
m = fold_build2 (MULT_EXPR, type, fold_convert (type, m), tmp_m);
else
m = tmp_m;
if (a)
a = fold_build2 (MULT_EXPR, type, fold_convert (type, a), tmp_m);
}
}
/* See if this is a tail call we can handle. */
ret_var = gimple_return_retval (stmt);
/* We may proceed if there either is no return value, or the return value
is identical to the call's return. */
if (ret_var
&& (ret_var != ass_var))
return;
/* If this is not a tail recursive call, we cannot handle addends or
multiplicands. */
if (!tail_recursion && (m || a))
return;
/* For pointers only allow additions. */
if (m && POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (current_function_decl))))
return;
nw = XNEW (struct tailcall);
nw->call_gsi = gsi;
nw->tail_recursion = tail_recursion;
nw->mult = m;
nw->add = a;
nw->next = *ret;
*ret = nw;
}
void
ubsan_expand_null_ifn (gimple_stmt_iterator gsi)
{
gimple stmt = gsi_stmt (gsi);
location_t loc = gimple_location (stmt);
gcc_assert (gimple_call_num_args (stmt) == 2);
tree ptr = gimple_call_arg (stmt, 0);
tree ckind = gimple_call_arg (stmt, 1);
basic_block cur_bb = gsi_bb (gsi);
/* Split the original block holding the pointer dereference. */
edge e = split_block (cur_bb, stmt);
/* Get a hold on the 'condition block', the 'then block' and the
'else block'. */
basic_block cond_bb = e->src;
basic_block fallthru_bb = e->dest;
basic_block then_bb = create_empty_bb (cond_bb);
add_bb_to_loop (then_bb, cond_bb->loop_father);
loops_state_set (LOOPS_NEED_FIXUP);
/* Make an edge coming from the 'cond block' into the 'then block';
this edge is unlikely taken, so set up the probability accordingly. */
e = make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);
e->probability = PROB_VERY_UNLIKELY;
/* Connect 'then block' with the 'else block'. This is needed
as the ubsan routines we call in the 'then block' are not noreturn.
The 'then block' only has one outcoming edge. */
make_single_succ_edge (then_bb, fallthru_bb, EDGE_FALLTHRU);
/* Set up the fallthrough basic block. */
e = find_edge (cond_bb, fallthru_bb);
e->flags = EDGE_FALSE_VALUE;
e->count = cond_bb->count;
e->probability = REG_BR_PROB_BASE - PROB_VERY_UNLIKELY;
/* Update dominance info for the newly created then_bb; note that
fallthru_bb's dominance info has already been updated by
split_bock. */
if (dom_info_available_p (CDI_DOMINATORS))
set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
/* Put the ubsan builtin call into the newly created BB. */
gimple g;
if (flag_sanitize_undefined_trap_on_error)
g = gimple_build_call (builtin_decl_implicit (BUILT_IN_TRAP), 0);
else
{
enum built_in_function bcode
= flag_sanitize_recover
? BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH
: BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH_ABORT;
tree fn = builtin_decl_implicit (bcode);
const struct ubsan_mismatch_data m
= { build_zero_cst (pointer_sized_int_node), ckind };
tree data
= ubsan_create_data ("__ubsan_null_data", &loc, &m,
ubsan_type_descriptor (TREE_TYPE (ptr),
UBSAN_PRINT_POINTER),
NULL_TREE);
data = build_fold_addr_expr_loc (loc, data);
g = gimple_build_call (fn, 2, data,
build_zero_cst (pointer_sized_int_node));
}
gimple_set_location (g, loc);
gimple_stmt_iterator gsi2 = gsi_start_bb (then_bb);
gsi_insert_after (&gsi2, g, GSI_NEW_STMT);
/* Unlink the UBSAN_NULLs vops before replacing it. */
unlink_stmt_vdef (stmt);
g = gimple_build_cond (EQ_EXPR, ptr, build_int_cst (TREE_TYPE (ptr), 0),
NULL_TREE, NULL_TREE);
gimple_set_location (g, loc);
/* Replace the UBSAN_NULL with a GIMPLE_COND stmt. */
gsi_replace (&gsi, g, false);
}
static bool
check_pow (gimple pow_call)
{
tree base, expn;
enum tree_code bc, ec;
if (gimple_call_num_args (pow_call) != 2)
return false;
base = gimple_call_arg (pow_call, 0);
expn = gimple_call_arg (pow_call, 1);
if (!check_target_format (expn))
return false;
bc = TREE_CODE (base);
ec = TREE_CODE (expn);
/* Folding candidates are not interesting.
Can actually assert that it is already folded. */
if (ec == REAL_CST && bc == REAL_CST)
return false;
if (bc == REAL_CST)
{
/* Only handle a fixed range of constant. */
REAL_VALUE_TYPE mv;
REAL_VALUE_TYPE bcv = TREE_REAL_CST (base);
if (REAL_VALUES_EQUAL (bcv, dconst1))
return false;
if (REAL_VALUES_LESS (bcv, dconst1))
return false;
real_from_integer (&mv, TYPE_MODE (TREE_TYPE (base)), 256, 0, 1);
if (REAL_VALUES_LESS (mv, bcv))
return false;
return true;
}
else if (bc == SSA_NAME)
{
tree base_val0, base_var, type;
gimple base_def;
int bit_sz;
/* Only handles cases where base value is converted
from integer values. */
base_def = SSA_NAME_DEF_STMT (base);
if (gimple_code (base_def) != GIMPLE_ASSIGN)
return false;
if (gimple_assign_rhs_code (base_def) != FLOAT_EXPR)
return false;
base_val0 = gimple_assign_rhs1 (base_def);
base_var = SSA_NAME_VAR (base_val0);
if (!DECL_P (base_var))
return false;
type = TREE_TYPE (base_var);
if (TREE_CODE (type) != INTEGER_TYPE)
return false;
bit_sz = TYPE_PRECISION (type);
/* If the type of the base is too wide,
the resulting shrink wrapping condition
will be too conservative. */
if (bit_sz > MAX_BASE_INT_BIT_SIZE)
return false;
return true;
}
else
return false;
}
static void
lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
{
gimple *stmt = gsi_stmt (*gsi);
gimple_set_block (stmt, data->block);
switch (gimple_code (stmt))
{
case GIMPLE_BIND:
lower_gimple_bind (gsi, data);
/* Propagate fallthruness. */
return;
case GIMPLE_COND:
case GIMPLE_GOTO:
case GIMPLE_SWITCH:
data->cannot_fallthru = true;
gsi_next (gsi);
return;
case GIMPLE_RETURN:
if (data->cannot_fallthru)
{
gsi_remove (gsi, false);
/* Propagate fallthruness. */
}
else
{
lower_gimple_return (gsi, data);
data->cannot_fallthru = true;
}
return;
case GIMPLE_TRY:
if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
lower_try_catch (gsi, data);
else
{
/* It must be a GIMPLE_TRY_FINALLY. */
bool cannot_fallthru;
lower_sequence (gimple_try_eval_ptr (stmt), data);
cannot_fallthru = data->cannot_fallthru;
/* The finally clause is always executed after the try clause,
so if it does not fall through, then the try-finally will not
fall through. Otherwise, if the try clause does not fall
through, then when the finally clause falls through it will
resume execution wherever the try clause was going. So the
whole try-finally will only fall through if both the try
clause and the finally clause fall through. */
data->cannot_fallthru = false;
lower_sequence (gimple_try_cleanup_ptr (stmt), data);
data->cannot_fallthru |= cannot_fallthru;
gsi_next (gsi);
}
return;
case GIMPLE_EH_ELSE:
{
geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
lower_sequence (gimple_eh_else_n_body_ptr (eh_else_stmt), data);
lower_sequence (gimple_eh_else_e_body_ptr (eh_else_stmt), data);
}
break;
case GIMPLE_DEBUG:
gcc_checking_assert (cfun->debug_nonbind_markers);
/* We can't possibly have debug bind stmts before lowering, we
first emit them when entering SSA. */
gcc_checking_assert (gimple_debug_nonbind_marker_p (stmt));
/* Propagate fallthruness. */
/* If the function (e.g. from PCH) had debug stmts, but they're
disabled for this compilation, remove them. */
if (!MAY_HAVE_DEBUG_MARKER_STMTS)
gsi_remove (gsi, true);
else
gsi_next (gsi);
return;
case GIMPLE_NOP:
case GIMPLE_ASM:
case GIMPLE_ASSIGN:
case GIMPLE_PREDICT:
case GIMPLE_LABEL:
case GIMPLE_EH_MUST_NOT_THROW:
case GIMPLE_OMP_FOR:
case GIMPLE_OMP_SECTIONS:
case GIMPLE_OMP_SECTIONS_SWITCH:
case GIMPLE_OMP_SECTION:
case GIMPLE_OMP_SINGLE:
case GIMPLE_OMP_MASTER:
case GIMPLE_OMP_TASKGROUP:
case GIMPLE_OMP_ORDERED:
case GIMPLE_OMP_CRITICAL:
case GIMPLE_OMP_RETURN:
case GIMPLE_OMP_ATOMIC_LOAD:
case GIMPLE_OMP_ATOMIC_STORE:
case GIMPLE_OMP_CONTINUE:
break;
case GIMPLE_CALL:
{
tree decl = gimple_call_fndecl (stmt);
unsigned i;
for (i = 0; i < gimple_call_num_args (stmt); i++)
{
tree arg = gimple_call_arg (stmt, i);
if (EXPR_P (arg))
TREE_SET_BLOCK (arg, data->block);
}
if (decl
&& DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
{
if (DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
{
lower_builtin_setjmp (gsi);
data->cannot_fallthru = false;
return;
}
else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_POSIX_MEMALIGN
&& flag_tree_bit_ccp
&& gimple_builtin_call_types_compatible_p (stmt, decl))
{
lower_builtin_posix_memalign (gsi);
return;
}
}
if (decl && (flags_from_decl_or_type (decl) & ECF_NORETURN))
{
data->cannot_fallthru = true;
gsi_next (gsi);
return;
}
}
break;
case GIMPLE_OMP_PARALLEL:
case GIMPLE_OMP_TASK:
case GIMPLE_OMP_TARGET:
case GIMPLE_OMP_TEAMS:
case GIMPLE_OMP_GRID_BODY:
data->cannot_fallthru = false;
lower_omp_directive (gsi, data);
data->cannot_fallthru = false;
return;
case GIMPLE_TRANSACTION:
lower_sequence (gimple_transaction_body_ptr (
as_a <gtransaction *> (stmt)),
data);
break;
default:
gcc_unreachable ();
}
data->cannot_fallthru = false;
gsi_next (gsi);
}
