tree find_instr_node(tree temp)
{
int ret = 0;
tree decl_node;
PWord_t PV;
JSLG(PV, decl_map, mf_varname_tree(temp));
if(PV){
decl_node = ((tree) *PV);
gcc_assert(decl_node != NULL_TREE);
DEBUGLOG("[find_instr] Match found for %s --> %s\n",mf_varname_tree(temp), IDENTIFIER_POINTER(DECL_NAME(decl_node)));
return decl_node;
}else
DEBUGLOG("[find_instr] Match not found for %s\n",mf_varname_tree(temp));
return NULL_TREE;
}
/* Synthesize a CALL_EXPR and a TRY_FINALLY_EXPR, for this chain of
_DECLs if appropriate. Arrange to call the __mf_register function
now, and the __mf_unregister function later for each. Return the
gimple sequence after synthesis. */
gimple_seq
mx_register_decls (tree decl, gimple_seq seq, location_t location)
{
gimple_seq finally_stmts = NULL;
gimple_stmt_iterator initially_stmts = gsi_start (seq);
while (decl != NULL_TREE)
{
if (mf_decl_eligible_p (decl)
/* Not already processed. */
&& ! mf_marked_p (decl)
/* Automatic variable. */
&& ! DECL_EXTERNAL (decl)
&& ! TREE_STATIC (decl))
{
tree size = NULL_TREE, variable_name;
gimple unregister_fncall, register_fncall;
tree unregister_fncall_param, register_fncall_param;
/* Variable-sized objects should have sizes already been
gimplified when we got here. */
size = fold_convert (size_type_node,
TYPE_SIZE_UNIT (TREE_TYPE (decl)));
gcc_assert (is_gimple_val (size));
unregister_fncall_param =
mf_mark (build1 (ADDR_EXPR,
build_pointer_type (TREE_TYPE (decl)),
decl));
/* __mf_unregister (&VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
unregister_fncall = gimple_build_call (mf_unregister_fndecl, 3,
unregister_fncall_param,
size,
integer_three_node);
variable_name = mf_varname_tree (decl);
register_fncall_param =
mf_mark (build1 (ADDR_EXPR,
build_pointer_type (TREE_TYPE (decl)),
decl));
/* __mf_register (&VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK,
"name") */
register_fncall = gimple_build_call (mf_register_fndecl, 4,
register_fncall_param,
size,
integer_three_node,
variable_name);
/* Accumulate the two calls. */
gimple_set_location (register_fncall, location);
gimple_set_location (unregister_fncall, location);
/* Add the __mf_register call at the current appending point. */
if (gsi_end_p (initially_stmts))
{
if (!mf_artificial (decl))
warning (OPT_Wmudflap,
"mudflap cannot track %qE in stub function",
DECL_NAME (decl));
}
else
{
gsi_insert_before (&initially_stmts, register_fncall,
GSI_SAME_STMT);
/* Accumulate the FINALLY piece. */
gimple_seq_add_stmt (&finally_stmts, unregister_fncall);
}
mf_mark (decl);
}
decl = DECL_CHAIN (decl);
}
/* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
if (finally_stmts != NULL)
{
gimple stmt = gimple_build_try (seq, finally_stmts, GIMPLE_TRY_FINALLY);
gimple_seq new_seq = NULL;
gimple_seq_add_stmt (&new_seq, stmt);
return new_seq;
}
else
return seq;
}
/* Synthesize a CALL_EXPR and a TRY_FINALLY_EXPR, for this chain of
_DECLs if appropriate. Arrange to call the __mf_register function
now, and the __mf_unregister function later for each. */
static void
mx_register_decls (tree decl, tree *stmt_list)
{
tree finally_stmts = NULL_TREE;
tree_stmt_iterator initially_stmts = tsi_start (*stmt_list);
while (decl != NULL_TREE)
{
if (mf_decl_eligible_p (decl)
/* Not already processed. */
&& ! mf_marked_p (decl)
/* Automatic variable. */
&& ! DECL_EXTERNAL (decl)
&& ! TREE_STATIC (decl))
{
tree size = NULL_TREE, variable_name;
tree unregister_fncall, unregister_fncall_params;
tree register_fncall, register_fncall_params;
size = convert (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl)));
/* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
unregister_fncall_params =
tree_cons (NULL_TREE,
convert (ptr_type_node,
mf_mark (build1 (ADDR_EXPR,
build_pointer_type (TREE_TYPE (decl)),
decl))),
tree_cons (NULL_TREE,
size,
tree_cons (NULL_TREE,
/* __MF_TYPE_STACK */
build_int_cst (NULL_TREE, 3),
NULL_TREE)));
/* __mf_unregister (...) */
unregister_fncall = build_function_call_expr (mf_unregister_fndecl,
unregister_fncall_params);
/* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK, "name") */
variable_name = mf_varname_tree (decl);
register_fncall_params =
tree_cons (NULL_TREE,
convert (ptr_type_node,
mf_mark (build1 (ADDR_EXPR,
build_pointer_type (TREE_TYPE (decl)),
decl))),
tree_cons (NULL_TREE,
size,
tree_cons (NULL_TREE,
/* __MF_TYPE_STACK */
build_int_cst (NULL_TREE, 3),
tree_cons (NULL_TREE,
variable_name,
NULL_TREE))));
/* __mf_register (...) */
register_fncall = build_function_call_expr (mf_register_fndecl,
register_fncall_params);
/* Accumulate the two calls. */
/* ??? Set EXPR_LOCATION. */
gimplify_stmt (®ister_fncall);
gimplify_stmt (&unregister_fncall);
/* Add the __mf_register call at the current appending point. */
if (tsi_end_p (initially_stmts))
warning (0, "mudflap cannot track %qs in stub function",
IDENTIFIER_POINTER (DECL_NAME (decl)));
else
{
tsi_link_before (&initially_stmts, register_fncall, TSI_SAME_STMT);
/* Accumulate the FINALLY piece. */
append_to_statement_list (unregister_fncall, &finally_stmts);
}
mf_mark (decl);
}
decl = TREE_CHAIN (decl);
}
/* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
if (finally_stmts != NULL_TREE)
{
tree t = build2 (TRY_FINALLY_EXPR, void_type_node,
*stmt_list, finally_stmts);
*stmt_list = NULL;
append_to_statement_list (t, stmt_list);
}
}
/* Synthesize a CALL_EXPR and a TRY_FINALLY_EXPR, for this chain of
_DECLs if appropriate. Arrange to call the __mf_register function
now, and the __mf_unregister function later for each. Return the
gimple sequence after synthesis. */
gimple_seq
mx_register_decls (tree decl, gimple_seq seq, gimple stmt, location_t location, bool func_args)
{
gimple_seq finally_stmts = NULL;
gimple_stmt_iterator initially_stmts = gsi_start (seq);
bool sframe_inserted = false;
size_t front_rz_size, rear_rz_size;
tree fsize, rsize, size;
gimple uninit_fncall_front, uninit_fncall_rear, init_fncall_front, \
init_fncall_rear, init_assign_stmt;
tree fncall_param_front, fncall_param_rear;
int map_ret;
while (decl != NULL_TREE)
{
if ((mf_decl_eligible_p (decl) || TREE_CODE(TREE_TYPE(decl)) == ARRAY_TYPE)
/* Not already processed. */
&& ! mf_marked_p (decl)
/* Automatic variable. */
&& ! DECL_EXTERNAL (decl)
&& ! TREE_STATIC (decl)
&& get_name(decl))
{
DEBUGLOG("DEBUG Instrumenting %s is_complete_type %d\n", IDENTIFIER_POINTER(DECL_NAME(decl)), COMPLETE_TYPE_P(decl));
/* construct a tree corresponding to the type struct{
unsigned int rz_front[6U];
original variable
unsigned int rz_rear[6U];
};
*/
if (!sframe_inserted){
gimple ensure_fn_call = gimple_build_call (lbc_ensure_sframe_bitmap_fndecl, 0);
gimple_set_location (ensure_fn_call, location);
gsi_insert_before (&initially_stmts, ensure_fn_call, GSI_SAME_STMT);
sframe_inserted = true;
}
// Calculate the zone sizes
size_t element_size = 0, request_size = 0;
if (COMPLETE_TYPE_P(decl)){
request_size = TREE_INT_CST_LOW(TYPE_SIZE_UNIT(TREE_TYPE(decl)));
if (TREE_CODE(TREE_TYPE(decl)) == ARRAY_TYPE)
element_size = TREE_INT_CST_LOW(TYPE_SIZE_UNIT(TREE_TYPE(TREE_TYPE(decl))));
else
element_size = request_size;
}
calculate_zone_sizes(element_size, request_size, /*global*/ false, COMPLETE_TYPE_P(decl), &front_rz_size, &rear_rz_size);
DEBUGLOG("DEBUG *SIZES* req_size %u, ele_size %u, fsize %u, rsize %u\n", request_size, element_size, front_rz_size, rear_rz_size);
tree struct_type = create_struct_type(decl, front_rz_size, rear_rz_size);
tree struct_var = create_struct_var(struct_type, decl, location);
declare_vars(struct_var, stmt, 0);
/* Inserting into hashtable */
PWord_t PV;
JSLI(PV, decl_map, mf_varname_tree(decl));
gcc_assert(PV);
*PV = (PWord_t) struct_var;
fsize = convert (unsigned_type_node, size_int(front_rz_size));
gcc_assert (is_gimple_val (fsize));
tree rz_front = TYPE_FIELDS(struct_type);
fncall_param_front = mf_mark (build1 (ADDR_EXPR, ptr_type_node, build3 (COMPONENT_REF, TREE_TYPE(rz_front),
struct_var, rz_front, NULL_TREE)));
uninit_fncall_front = gimple_build_call (lbc_uninit_front_rz_fndecl, 2, fncall_param_front, fsize);
init_fncall_front = gimple_build_call (lbc_init_front_rz_fndecl, 2, fncall_param_front, fsize);
gimple_set_location (init_fncall_front, location);
gimple_set_location (uninit_fncall_front, location);
// In complete types have only a front red zone
if (COMPLETE_TYPE_P(decl)){
rsize = convert (unsigned_type_node, size_int(rear_rz_size));
gcc_assert (is_gimple_val (rsize));
tree rz_rear = DECL_CHAIN(DECL_CHAIN(TYPE_FIELDS (struct_type)));
fncall_param_rear = mf_mark (build1 (ADDR_EXPR, ptr_type_node, build3 (COMPONENT_REF, TREE_TYPE(rz_rear),
struct_var, rz_rear, NULL_TREE)));
init_fncall_rear = gimple_build_call (lbc_init_rear_rz_fndecl, 2, fncall_param_rear, rsize);
uninit_fncall_rear = gimple_build_call (lbc_uninit_rear_rz_fndecl, 2, fncall_param_rear, rsize);
gimple_set_location (init_fncall_rear, location);
gimple_set_location (uninit_fncall_rear, location);
}
// TODO Do I need this?
#if 0
if (DECL_INITIAL(decl) != NULL_TREE){
// This code never seems to be getting executed for somehting like int i = 10;
// I have no idea why? But looking at the tree dump, seems like its because
// by the time it gets here, these kind of statements are split into two statements
// as int i; and i = 10; respectively. I am leaving it in just in case.
tree orig_var_type = DECL_CHAIN(TYPE_FIELDS (struct_type));
tree orig_var_lval = mf_mark (build3 (COMPONENT_REF, TREE_TYPE(orig_var_type),
struct_var, orig_var_type, NULL_TREE));
init_assign_stmt = gimple_build_assign(orig_var_lval, DECL_INITIAL(decl));
gimple_set_location (init_assign_stmt, location);
}
#endif
if (gsi_end_p (initially_stmts))
{
// TODO handle this
if (!DECL_ARTIFICIAL (decl))
warning (OPT_Wmudflap,
"mudflap cannot track %qE in stub function",
DECL_NAME (decl));
}
else
{
#if 0
// Insert the declaration initializer
if (DECL_INITIAL(decl) != NULL_TREE)
gsi_insert_before (&initially_stmts, init_assign_stmt, GSI_SAME_STMT);
#endif
//gsi_insert_before (&initially_stmts, register_fncall, GSI_SAME_STMT);
gsi_insert_before (&initially_stmts, init_fncall_front, GSI_SAME_STMT);
if (COMPLETE_TYPE_P(decl))
gsi_insert_before (&initially_stmts, init_fncall_rear, GSI_SAME_STMT);
/* Accumulate the FINALLY piece. */
//gimple_seq_add_stmt (&finally_stmts, unregister_fncall);
gimple_seq_add_stmt (&finally_stmts, uninit_fncall_front);
if (COMPLETE_TYPE_P(decl))
gimple_seq_add_stmt (&finally_stmts, uninit_fncall_rear);
}
mf_mark (decl);
}
decl = DECL_CHAIN (decl);
}
/* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
if (finally_stmts != NULL)
{
gimple stmt = gimple_build_try (seq, finally_stmts, GIMPLE_TRY_FINALLY);
gimple_seq new_seq = gimple_seq_alloc ();
gimple_seq_add_stmt (&new_seq, stmt);
return new_seq;
}
else
return seq;
}
/* Emit any file-wide instrumentation. */
void
mudflap_finish_file (void)
{
tree ctor_statements = NULL_TREE;
/* No need to continue when there were errors. */
if (errorcount != 0 || sorrycount != 0)
return;
/* Insert a call to __mf_init. */
{
tree call2_stmt = build_function_call_expr (mf_init_fndecl, NULL_TREE);
append_to_statement_list (call2_stmt, &ctor_statements);
}
/* If appropriate, call __mf_set_options to pass along read-ignore mode. */
if (flag_mudflap_ignore_reads)
{
tree arg = tree_cons (NULL_TREE,
mf_build_string ("-ignore-reads"), NULL_TREE);
tree call_stmt = build_function_call_expr (mf_set_options_fndecl, arg);
append_to_statement_list (call_stmt, &ctor_statements);
}
/* Process all enqueued object decls. */
if (deferred_static_decls)
{
size_t i;
tree obj;
for (i = 0; VEC_iterate (tree, deferred_static_decls, i, obj); i++)
{
gcc_assert (DECL_P (obj));
if (mf_marked_p (obj))
continue;
/* Omit registration for static unaddressed objects. NB:
Perform registration for non-static objects regardless of
TREE_USED or TREE_ADDRESSABLE, because they may be used
from other compilation units. */
if (! TREE_PUBLIC (obj) && ! TREE_ADDRESSABLE (obj))
continue;
if (! COMPLETE_TYPE_P (TREE_TYPE (obj)))
{
warning (0, "mudflap cannot track unknown size extern %qs",
IDENTIFIER_POINTER (DECL_NAME (obj)));
continue;
}
mudflap_register_call (obj,
size_in_bytes (TREE_TYPE (obj)),
mf_varname_tree (obj));
}
VEC_truncate (tree, deferred_static_decls, 0);
}
/* Append all the enqueued registration calls. */
if (enqueued_call_stmt_chain)
{
append_to_statement_list (enqueued_call_stmt_chain, &ctor_statements);
enqueued_call_stmt_chain = NULL_TREE;
}
cgraph_build_static_cdtor ('I', ctor_statements,
MAX_RESERVED_INIT_PRIORITY-1);
}
