/* Lookup or create the variable for the call statement CALL. */
static varinfo_t
-get_call_vi (gimple call)
+get_call_vi (gcall *call)
{
varinfo_t vi, vi2;
the uses. Returns NULL if there is nothing special about this call. */
static varinfo_t
-lookup_call_use_vi (gimple call)
+lookup_call_use_vi (gcall *call)
{
varinfo_t *slot_p = call_stmt_vars->get (call);
if (slot_p)
the clobbers. Returns NULL if there is nothing special about this call. */
static varinfo_t
-lookup_call_clobber_vi (gimple call)
+lookup_call_clobber_vi (gcall *call)
{
varinfo_t uses = lookup_call_use_vi (call);
if (!uses)
the uses. */
static varinfo_t
-get_call_use_vi (gimple call)
+get_call_use_vi (gcall *call)
{
return get_call_vi (call);
}
the clobbers. */
static varinfo_t ATTRIBUTE_UNUSED
-get_call_clobber_vi (gimple call)
+get_call_clobber_vi (gcall *call)
{
return vi_next (get_call_vi (call));
}
RHS. */
static void
-handle_rhs_call (gimple stmt, vec<ce_s> *results)
+handle_rhs_call (gcall *stmt, vec<ce_s> *results)
{
struct constraint_expr rhsc;
unsigned i;
the LHS point to global and escaped variables. */
static void
-handle_lhs_call (gimple stmt, tree lhs, int flags, vec<ce_s> rhsc,
+handle_lhs_call (gcall *stmt, tree lhs, int flags, vec<ce_s> rhsc,
tree fndecl)
{
auto_vec<ce_s> lhsc;
const function that returns a pointer in the statement STMT. */
static void
-handle_const_call (gimple stmt, vec<ce_s> *results)
+handle_const_call (gcall *stmt, vec<ce_s> *results)
{
struct constraint_expr rhsc;
unsigned int k;
pure function in statement STMT. */
static void
-handle_pure_call (gimple stmt, vec<ce_s> *results)
+handle_pure_call (gcall *stmt, vec<ce_s> *results)
{
struct constraint_expr rhsc;
unsigned i;
/* Return the varinfo for the callee of CALL. */
static varinfo_t
-get_fi_for_callee (gimple call)
+get_fi_for_callee (gcall *call)
{
tree decl, fn = gimple_call_fn (call);
was handled, otherwise false. */
static bool
-find_func_aliases_for_builtin_call (struct function *fn, gimple t)
+find_func_aliases_for_builtin_call (struct function *fn, gcall *t)
{
tree fndecl = gimple_call_fndecl (t);
auto_vec<ce_s, 2> lhsc;
/* Create constraints for the call T. */
static void
-find_func_aliases_for_call (struct function *fn, gimple t)
+find_func_aliases_for_call (struct function *fn, gcall *t)
{
tree fndecl = gimple_call_fndecl (t);
varinfo_t fi;
In non-ipa mode, we need to generate constraints for each
pointer passed by address. */
else if (is_gimple_call (t))
- find_func_aliases_for_call (fn, t);
+ find_func_aliases_for_call (fn, as_a <gcall *> (t));
/* Otherwise, just a regular assignment statement. Only care about
operations with pointer result, others are dealt with as escape
}
/* Handle escapes through return. */
else if (gimple_code (t) == GIMPLE_RETURN
- && gimple_return_retval (t) != NULL_TREE)
+ && gimple_return_retval (as_a <greturn *> (t)) != NULL_TREE)
{
+ greturn *return_stmt = as_a <greturn *> (t);
fi = NULL;
if (!in_ipa_mode
|| !(fi = get_vi_for_tree (fn->decl)))
- make_escape_constraint (gimple_return_retval (t));
+ make_escape_constraint (gimple_return_retval (return_stmt));
else if (in_ipa_mode
&& fi != NULL)
{
unsigned i;
lhs = get_function_part_constraint (fi, fi_result);
- get_constraint_for_rhs (gimple_return_retval (t), &rhsc);
+ get_constraint_for_rhs (gimple_return_retval (return_stmt), &rhsc);
FOR_EACH_VEC_ELT (rhsc, i, rhsp)
process_constraint (new_constraint (lhs, *rhsp));
}
}
/* Handle asms conservatively by adding escape constraints to everything. */
- else if (gimple_code (t) == GIMPLE_ASM)
+ else if (gasm *asm_stmt = dyn_cast <gasm *> (t))
{
unsigned i, noutputs;
const char **oconstraints;
const char *constraint;
bool allows_mem, allows_reg, is_inout;
- noutputs = gimple_asm_noutputs (t);
+ noutputs = gimple_asm_noutputs (asm_stmt);
oconstraints = XALLOCAVEC (const char *, noutputs);
for (i = 0; i < noutputs; ++i)
{
- tree link = gimple_asm_output_op (t, i);
+ tree link = gimple_asm_output_op (asm_stmt, i);
tree op = TREE_VALUE (link);
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
process_constraint (new_constraint (*lhsp, rhsc));
}
}
- for (i = 0; i < gimple_asm_ninputs (t); ++i)
+ for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
{
- tree link = gimple_asm_input_op (t, i);
+ tree link = gimple_asm_input_op (asm_stmt, i);
tree op = TREE_VALUE (link);
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
/* Account for uses in assigments and returns. */
if (gimple_assign_single_p (t)
|| (gimple_code (t) == GIMPLE_RETURN
- && gimple_return_retval (t) != NULL_TREE))
+ && gimple_return_retval (as_a <greturn *> (t)) != NULL_TREE))
{
tree rhs = (gimple_assign_single_p (t)
- ? gimple_assign_rhs1 (t) : gimple_return_retval (t));
+ ? gimple_assign_rhs1 (t)
+ : gimple_return_retval (as_a <greturn *> (t)));
tree tem = rhs;
while (handled_component_p (tem))
tem = TREE_OPERAND (tem, 0);
}
}
- if (is_gimple_call (t))
+ if (gcall *call_stmt = dyn_cast <gcall *> (t))
{
varinfo_t cfi = NULL;
tree decl = gimple_call_fndecl (t);
/* Build constraints for propagating clobbers/uses along the
callgraph edges. */
- cfi = get_fi_for_callee (t);
+ cfi = get_fi_for_callee (call_stmt);
if (cfi->id == anything_id)
{
if (gimple_vdef (t))
make_copy_constraint (first_vi_for_offset (fi, fi_uses), escaped_id);
/* Also honor the call statement use/clobber info. */
- if ((vi = lookup_call_clobber_vi (t)) != NULL)
+ if ((vi = lookup_call_clobber_vi (call_stmt)) != NULL)
make_copy_constraint (first_vi_for_offset (fi, fi_clobbers),
vi->id);
- if ((vi = lookup_call_use_vi (t)) != NULL)
+ if ((vi = lookup_call_use_vi (call_stmt)) != NULL)
make_copy_constraint (first_vi_for_offset (fi, fi_uses),
vi->id);
return;
/* Now walk all statements and build the constraint set. */
FOR_EACH_BB_FN (bb, cfun)
{
- gimple_stmt_iterator gsi;
-
- for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
+ gsi_next (&gsi))
{
- gimple phi = gsi_stmt (gsi);
+ gphi *phi = gsi.phi ();
if (! virtual_operand_p (gimple_phi_result (phi)))
find_func_aliases (cfun, phi);
}
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
+ gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gcall *stmt;
struct pt_solution *pt;
- if (!is_gimple_call (stmt))
+
+ stmt = dyn_cast <gcall *> (gsi_stmt (gsi));
+ if (!stmt)
continue;
pt = gimple_call_use_set (stmt);
/* Build constriants for the function body. */
FOR_EACH_BB_FN (bb, func)
{
- gimple_stmt_iterator gsi;
-
- for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
+ for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
gsi_next (&gsi))
{
- gimple phi = gsi_stmt (gsi);
+ gphi *phi = gsi.phi ();
if (! virtual_operand_p (gimple_phi_result (phi)))
find_func_aliases (func, phi);
}
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
+ gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gcall *stmt;
struct pt_solution *pt;
varinfo_t vi, fi;
tree decl;
- if (!is_gimple_call (stmt))
+ stmt = dyn_cast <gcall *> (gsi_stmt (gsi));
+ if (!stmt)
continue;
/* Handle direct calls to functions with body. */
projects / thirdparty / gcc.git / blobdiff