static void
test_conversion_to_ssa ()
{
/* As above, construct a trivial function, gimplify it, and build a CFG: */
tree fndecl = build_trivial_high_gimple_function ();
function *fun = DECL_STRUCT_FUNCTION (fndecl);
ASSERT_TRUE (fun != NULL);
build_cfg (fndecl);
convert_to_ssa (fndecl);
verify_three_block_gimple_cfg (fun);
/* For out trivial test function we should now have something like
this:
test_fn ()
{
<bb 2>:
_1 = 42;
return _1;
}
*/
basic_block bb2 = get_real_block (fun);
gimple *stmt_a = gimple_seq_first_stmt (bb_seq (bb2));
ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt_a));
gimple *stmt_b = stmt_a->next;
ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt_b));
ASSERT_EQ (NULL, stmt_b->next);
greturn *return_stmt = as_a <greturn *> (stmt_b);
ASSERT_EQ (SSA_NAME, TREE_CODE (gimple_return_retval (return_stmt)));
}
static void
lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
{
gimple stmt = gsi_stmt (*gsi);
gimple t;
int i;
return_statements_t tmp_rs;
/* Match this up with an existing return statement that's been created. */
for (i = data->return_statements.length () - 1;
i >= 0; i--)
{
tmp_rs = data->return_statements[i];
if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt))
{
/* Remove the line number from the representative return statement.
It now fills in for many such returns. Failure to remove this
will result in incorrect results for coverage analysis. */
gimple_set_location (tmp_rs.stmt, UNKNOWN_LOCATION);
goto found;
}
}
/* Not found. Create a new label and record the return statement. */
tmp_rs.label = create_artificial_label (cfun->function_end_locus);
tmp_rs.stmt = stmt;
data->return_statements.safe_push (tmp_rs);
/* Generate a goto statement and remove the return statement. */
found:
/* When not optimizing, make sure user returns are preserved. */
if (!optimize && gimple_has_location (stmt))
DECL_ARTIFICIAL (tmp_rs.label) = 0;
t = gimple_build_goto (tmp_rs.label);
gimple_set_location (t, gimple_location (stmt));
gimple_set_block (t, gimple_block (stmt));
gsi_insert_before (gsi, t, GSI_SAME_STMT);
gsi_remove (gsi, false);
}
/* Transform
1) Memory references.
*/
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;
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:
mf_xform_derefs_1 (&i, gimple_assign_lhs_ptr (s),
gimple_location (s), integer_one_node);
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;
default:
;
}
}
bb = next;
}
while (bb && bb->index <= saved_last_basic_block);
}
static void
adjust_return_value (basic_block bb, tree m, tree a)
{
tree retval;
gimple ret_stmt = gimple_seq_last_stmt (bb_seq (bb));
gimple_stmt_iterator gsi = gsi_last_bb (bb);
gcc_assert (gimple_code (ret_stmt) == GIMPLE_RETURN);
retval = gimple_return_retval (ret_stmt);
if (!retval || retval == error_mark_node)
return;
if (m)
retval = adjust_return_value_with_ops (MULT_EXPR, "mul_tmp", m_acc, retval,
gsi);
if (a)
retval = adjust_return_value_with_ops (PLUS_EXPR, "acc_tmp", a_acc, retval,
gsi);
gimple_return_set_retval (ret_stmt, retval);
update_stmt (ret_stmt);
}
// Collect interesting stmts for duplication
static void search_interesting_stmts(struct visited *visited)
{
basic_block bb;
bool search_ret;
struct interesting_stmts *head = NULL;
search_ret = is_interesting_function(current_function_decl, 0);
FOR_ALL_BB_FN(bb, cfun) {
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
tree first_node;
gimple stmt = gsi_stmt(gsi);
switch (gimple_code(stmt)) {
case GIMPLE_ASM:
if (!is_size_overflow_insert_check_asm(as_a_gasm(stmt)))
continue;
first_node = get_size_overflow_asm_input(as_a_gasm(stmt));
head = search_interesting_stmt(head, stmt, first_node, 0);
break;
case GIMPLE_RETURN:
if (!search_ret)
continue;
first_node = gimple_return_retval(as_a_greturn(stmt));
if (first_node == NULL_TREE)
break;
head = search_interesting_stmt(head, stmt, first_node, 0);
break;
case GIMPLE_CALL:
head = search_interesting_calls(head, as_a_gcall(stmt));
break;
default:
break;
}
}
}
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;
}
static unsigned int
lower_function_body (void)
{
struct lower_data data;
gimple_seq body = gimple_body (current_function_decl);
gimple_seq lowered_body;
gimple_stmt_iterator i;
gimple bind;
tree t;
gimple x;
/* The gimplifier should've left a body of exactly one statement,
namely a GIMPLE_BIND. */
gcc_assert (gimple_seq_first (body) == gimple_seq_last (body)
&& gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND);
memset (&data, 0, sizeof (data));
data.block = DECL_INITIAL (current_function_decl);
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
BLOCK_CHAIN (data.block) = NULL_TREE;
TREE_ASM_WRITTEN (data.block) = 1;
data.return_statements.create (8);
bind = gimple_seq_first_stmt (body);
lowered_body = NULL;
gimple_seq_add_stmt (&lowered_body, bind);
i = gsi_start (lowered_body);
lower_gimple_bind (&i, &data);
i = gsi_last (lowered_body);
/* If the function falls off the end, we need a null return statement.
If we've already got one in the return_statements vector, we don't
need to do anything special. Otherwise build one by hand. */
if (gimple_seq_may_fallthru (lowered_body)
&& (data.return_statements.is_empty ()
|| gimple_return_retval (data.return_statements.last().stmt) != NULL))
{
x = gimple_build_return (NULL);
gimple_set_location (x, cfun->function_end_locus);
gimple_set_block (x, DECL_INITIAL (current_function_decl));
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
}
/* If we lowered any return statements, emit the representative
at the end of the function. */
while (!data.return_statements.is_empty ())
{
return_statements_t t = data.return_statements.pop ();
x = gimple_build_label (t.label);
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
gsi_insert_after (&i, t.stmt, GSI_CONTINUE_LINKING);
}
/* If the function calls __builtin_setjmp, we need to emit the computed
goto that will serve as the unique dispatcher for all the receivers. */
if (data.calls_builtin_setjmp)
{
tree disp_label, disp_var, arg;
/* Build 'DISP_LABEL:' and insert. */
disp_label = create_artificial_label (cfun->function_end_locus);
/* This mark will create forward edges from every call site. */
DECL_NONLOCAL (disp_label) = 1;
cfun->has_nonlocal_label = 1;
x = gimple_build_label (disp_label);
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
/* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
and insert. */
disp_var = create_tmp_var (ptr_type_node, "setjmpvar");
arg = build_addr (disp_label, current_function_decl);
t = builtin_decl_implicit (BUILT_IN_SETJMP_DISPATCHER);
x = gimple_build_call (t, 1, arg);
gimple_call_set_lhs (x, disp_var);
/* Build 'goto DISP_VAR;' and insert. */
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
x = gimple_build_goto (disp_var);
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
}
/* Once the old body has been lowered, replace it with the new
lowered sequence. */
gimple_set_body (current_function_decl, lowered_body);
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
BLOCK_SUBBLOCKS (data.block)
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
clear_block_marks (data.block);
data.return_statements.release ();
return 0;
}
static unsigned int
lower_function_body (void)
{
struct lower_data data;
gimple_seq body = gimple_body (current_function_decl);
gimple_seq lowered_body;
gimple_stmt_iterator i;
gimple bind;
gimple x;
/* The gimplifier should've left a body of exactly one statement,
namely a GIMPLE_BIND. */
gcc_assert (gimple_seq_first (body) == gimple_seq_last (body)
&& gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND);
memset (&data, 0, sizeof (data));
data.block = DECL_INITIAL (current_function_decl);
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
BLOCK_CHAIN (data.block) = NULL_TREE;
TREE_ASM_WRITTEN (data.block) = 1;
data.return_statements.create (8);
bind = gimple_seq_first_stmt (body);
lowered_body = NULL;
gimple_seq_add_stmt (&lowered_body, bind);
i = gsi_start (lowered_body);
lower_gimple_bind (&i, &data);
i = gsi_last (lowered_body);
/* If the function falls off the end, we need a null return statement.
If we've already got one in the return_statements vector, we don't
need to do anything special. Otherwise build one by hand. */
if (gimple_seq_may_fallthru (lowered_body)
&& (data.return_statements.is_empty ()
|| (gimple_return_retval (data.return_statements.last().stmt)
!= NULL)))
{
x = gimple_build_return (NULL);
gimple_set_location (x, cfun->function_end_locus);
gimple_set_block (x, DECL_INITIAL (current_function_decl));
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
}
/* If we lowered any return statements, emit the representative
at the end of the function. */
while (!data.return_statements.is_empty ())
{
return_statements_t t = data.return_statements.pop ();
x = gimple_build_label (t.label);
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
gsi_insert_after (&i, t.stmt, GSI_CONTINUE_LINKING);
}
/* Once the old body has been lowered, replace it with the new
lowered sequence. */
gimple_set_body (current_function_decl, lowered_body);
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
BLOCK_SUBBLOCKS (data.block)
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
clear_block_marks (data.block);
data.return_statements.release ();
return 0;
}
/* 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 unsigned int
tree_nrv (void)
{
tree result = DECL_RESULT (current_function_decl);
tree result_type = TREE_TYPE (result);
tree found = NULL;
basic_block bb;
gimple_stmt_iterator gsi;
struct nrv_data data;
/* If this function does not return an aggregate type in memory, then
there is nothing to do. */
if (!aggregate_value_p (result, current_function_decl))
return 0;
/* If a GIMPLE type is returned in memory, finalize_nrv_r might create
non-GIMPLE. */
if (is_gimple_reg_type (result_type))
return 0;
/* Look through each block for assignments to the RESULT_DECL. */
FOR_EACH_BB (bb)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
tree ret_val;
if (gimple_code (stmt) == GIMPLE_RETURN)
{
/* In a function with an aggregate return value, the
gimplifier has changed all non-empty RETURN_EXPRs to
return the RESULT_DECL. */
ret_val = gimple_return_retval (stmt);
if (ret_val)
gcc_assert (ret_val == result);
}
else if (is_gimple_assign (stmt)
&& gimple_assign_lhs (stmt) == result)
{
tree rhs;
if (!gimple_assign_copy_p (stmt))
return 0;
rhs = gimple_assign_rhs1 (stmt);
/* Now verify that this return statement uses the same value
as any previously encountered return statement. */
if (found != NULL)
{
/* If we found a return statement using a different variable
than previous return statements, then we can not perform
NRV optimizations. */
if (found != rhs)
return 0;
}
else
found = rhs;
/* The returned value must be a local automatic variable of the
same type and alignment as the function's result. */
if (TREE_CODE (found) != VAR_DECL
|| TREE_THIS_VOLATILE (found)
|| DECL_CONTEXT (found) != current_function_decl
|| TREE_STATIC (found)
|| TREE_ADDRESSABLE (found)
|| DECL_ALIGN (found) > DECL_ALIGN (result)
|| !useless_type_conversion_p (result_type,
TREE_TYPE (found)))
return 0;
}
else if (is_gimple_assign (stmt))
{
tree addr = get_base_address (gimple_assign_lhs (stmt));
/* If there's any MODIFY of component of RESULT,
then bail out. */
if (addr && addr == result)
return 0;
}
}
}
if (!found)
return 0;
/* If dumping details, then note once and only the NRV replacement. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "NRV Replaced: ");
print_generic_expr (dump_file, found, dump_flags);
fprintf (dump_file, " with: ");
print_generic_expr (dump_file, result, dump_flags);
fprintf (dump_file, "\n");
}
/* At this point we know that all the return statements return the
same local which has suitable attributes for NRV. Copy debugging
information from FOUND to RESULT. */
DECL_NAME (result) = DECL_NAME (found);
DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (found);
DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (found);
TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (found);
/* Now walk through the function changing all references to VAR to be
RESULT. */
data.var = found;
data.result = result;
FOR_EACH_BB (bb)
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
{
gimple stmt = gsi_stmt (gsi);
/* If this is a copy from VAR to RESULT, remove it. */
if (gimple_assign_copy_p (stmt)
&& gimple_assign_lhs (stmt) == result
&& gimple_assign_rhs1 (stmt) == found)
gsi_remove (&gsi, true);
else
{
struct walk_stmt_info wi;
memset (&wi, 0, sizeof (wi));
wi.info = &data;
walk_gimple_op (stmt, finalize_nrv_r, &wi);
gsi_next (&gsi);
}
}
}
/* FOUND is no longer used. Ensure it gets removed. */
var_ann (found)->used = 0;
return 0;
}
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
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 ( );
}
}
static unsigned int
lower_function_body (void)
{
struct lower_data data;
gimple_seq body = gimple_body (current_function_decl);
gimple_seq lowered_body;
gimple_stmt_iterator i;
gimple *bind;
gimple *x;
/* The gimplifier should've left a body of exactly one statement,
namely a GIMPLE_BIND. */
gcc_assert (gimple_seq_first (body) == gimple_seq_last (body)
&& gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND);
memset (&data, 0, sizeof (data));
data.block = DECL_INITIAL (current_function_decl);
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
BLOCK_CHAIN (data.block) = NULL_TREE;
TREE_ASM_WRITTEN (data.block) = 1;
data.return_statements.create (8);
bind = gimple_seq_first_stmt (body);
lowered_body = NULL;
gimple_seq_add_stmt (&lowered_body, bind);
i = gsi_start (lowered_body);
lower_gimple_bind (&i, &data);
i = gsi_last (lowered_body);
/* If we had begin stmt markers from e.g. PCH, but this compilation
doesn't want them, lower_stmt will have cleaned them up; we can
now clear the flag that indicates we had them. */
if (!MAY_HAVE_DEBUG_MARKER_STMTS && cfun->debug_nonbind_markers)
{
/* This counter needs not be exact, but before lowering it will
most certainly be. */
gcc_assert (cfun->debug_marker_count == 0);
cfun->debug_nonbind_markers = false;
}
/* If the function falls off the end, we need a null return statement.
If we've already got one in the return_statements vector, we don't
need to do anything special. Otherwise build one by hand. */
bool may_fallthru = gimple_seq_may_fallthru (lowered_body);
if (may_fallthru
&& (data.return_statements.is_empty ()
|| (gimple_return_retval (data.return_statements.last().stmt)
!= NULL)))
{
x = gimple_build_return (NULL);
gimple_set_location (x, cfun->function_end_locus);
gimple_set_block (x, DECL_INITIAL (current_function_decl));
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
may_fallthru = false;
}
/* If we lowered any return statements, emit the representative
at the end of the function. */
while (!data.return_statements.is_empty ())
{
return_statements_t t = data.return_statements.pop ();
x = gimple_build_label (t.label);
gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
gsi_insert_after (&i, t.stmt, GSI_CONTINUE_LINKING);
if (may_fallthru)
{
/* Remove the line number from the representative return statement.
It now fills in for the fallthru too. Failure to remove this
will result in incorrect results for coverage analysis. */
gimple_set_location (t.stmt, UNKNOWN_LOCATION);
may_fallthru = false;
}
}
/* Once the old body has been lowered, replace it with the new
lowered sequence. */
gimple_set_body (current_function_decl, lowered_body);
gcc_assert (data.block == DECL_INITIAL (current_function_decl));
BLOCK_SUBBLOCKS (data.block)
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
clear_block_marks (data.block);
data.return_statements.release ();
return 0;
}
