diff options
Diffstat (limited to 'gcc/tree-mudflap.c')
| -rw-r--r-- | gcc/tree-mudflap.c | 1093 |
1 files changed, 1093 insertions, 0 deletions
diff --git a/gcc/tree-mudflap.c b/gcc/tree-mudflap.c new file mode 100644 index 00000000000..9172541af39 --- /dev/null +++ b/gcc/tree-mudflap.c @@ -0,0 +1,1093 @@ +/* Mudflap: narrow-pointer bounds-checking by tree rewriting. + Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. + Contributed by Frank Ch. Eigler <fche@redhat.com> + and Graydon Hoare <graydon@redhat.com> + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. + +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ + + +#include "config.h" +#include "errors.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "tree.h" +#include "flags.h" +#include "function.h" +#include "tree-inline.h" +#include "tree-simple.h" +#include "tree-flow.h" +#include "tree-mudflap.h" +#include "tree-dump.h" +#include "tree-pass.h" +#include "hashtab.h" +#include "diagnostic.h" +#include <demangle.h> +#include "langhooks.h" +#include "ggc.h" + +/* Internal function decls */ + +static void mf_xform_derefs (tree); +static void mf_xform_decls (tree, tree); +static void mf_init_extern_trees (void); +static void mf_decl_cache_locals (tree *); +static void mf_decl_clear_locals (void); +static tree mf_varname_tree (tree); +static tree mx_xfn_xform_decls (tree *, int *, void *); + +static void mx_register_decls (tree, tree *); + + +/* extern mudflap functions */ + +static GTY ((param_is (union tree_node))) htab_t marked_trees = NULL; + + +/* Mark and return the given tree node to prevent further mudflap + transforms. */ +tree +mf_mark (tree t) +{ + void **slot; + + if (marked_trees == NULL) + marked_trees = htab_create_ggc (31, htab_hash_pointer, htab_eq_pointer, NULL); + + slot = htab_find_slot (marked_trees, t, INSERT); + *slot = t; + return t; +} + + +int +mf_marked_p (tree t) +{ + void *entry; + + if (marked_trees == NULL) + return 0; + + entry = htab_find (marked_trees, t); + return (entry != NULL); +} + +static tree +mf_build_string (const char *string) +{ + size_t len = strlen (string); + tree result = mf_mark (build_string (len + 1, string)); + + TREE_TYPE (result) + = build_array_type (char_type_node, + build_index_type (build_int_2 (len, 0))); + TREE_CONSTANT (result) = 1; + TREE_INVARIANT (result) = 1; + TREE_READONLY (result) = 1; + TREE_STATIC (result) = 1; + + result = build1 (ADDR_EXPR, build_pointer_type (char_type_node), result); + + return mf_mark (result); +} + +/* Perform the declaration-related mudflap tree transforms on the + given function. Update its DECL_SAVED_TREE. */ + +static void +mudflap_function_decls (void) +{ + if (mf_marked_p (current_function_decl)) + return; + + push_gimplify_context (); + + mf_init_extern_trees (); + mf_xform_decls (DECL_SAVED_TREE (current_function_decl), + DECL_ARGUMENTS (current_function_decl)); + + pop_gimplify_context (NULL); +} + +static bool +gate_mudflap (void) +{ + return flag_mudflap != 0; +} + +struct tree_opt_pass pass_mudflap_1 = +{ + "mudflap1", /* name */ + gate_mudflap, /* gate */ + mudflap_function_decls, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + 0, /* tv_id */ + PROP_gimple_any, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ +}; + + +/* Same as above, for the indirection-related transforms. */ + +static void +mudflap_function_ops (void) +{ + if (mf_marked_p (current_function_decl)) + return; + + push_gimplify_context (); + + /* In multithreaded mode, don't cache the lookup cache parameters. */ + if (! flag_mudflap_threads) + mf_decl_cache_locals (&DECL_SAVED_TREE (current_function_decl)); + + mf_xform_derefs (DECL_SAVED_TREE (current_function_decl)); + + if (! flag_mudflap_threads) + mf_decl_clear_locals (); + + pop_gimplify_context (NULL); +} + +struct tree_opt_pass pass_mudflap_2 = +{ + "mudflap2", /* name */ + gate_mudflap, /* gate */ + mudflap_function_ops, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + 0, /* tv_id */ + PROP_gimple_leh, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ +}; + +/* global tree nodes */ + +/* Global tree objects for global variables and functions exported by + mudflap runtime library. mf_init_extern_trees must be called + before using these. */ + +/* uintptr_t (usually "unsigned long") */ +static GTY (()) tree mf_uintptr_type; + +/* struct __mf_cache { uintptr_t low; uintptr_t high; }; */ +static GTY (()) tree mf_cache_struct_type; + +/* struct __mf_cache * const */ +static GTY (()) tree mf_cache_structptr_type; + +/* extern struct __mf_cache __mf_lookup_cache []; */ +static GTY (()) tree mf_cache_array_decl; + +/* extern const unsigned char __mf_lc_shift; */ +static GTY (()) tree mf_cache_shift_decl; + +/* extern const uintptr_t __mf_lc_mask; */ +static GTY (()) tree mf_cache_mask_decl; + +/* Their function-scope local shadows, used in single-threaded mode only. */ + +/* auto const unsigned char __mf_lc_shift_l; */ +static GTY (()) tree mf_cache_shift_decl_l; + +/* auto const uintptr_t __mf_lc_mask_l; */ +static GTY (()) tree mf_cache_mask_decl_l; + +/* extern void __mf_check (void *ptr, size_t sz, int type, const char *); */ +static GTY (()) tree mf_check_fndecl; + +/* extern void __mf_register (void *ptr, size_t sz, int type, const char *); */ +static GTY (()) tree mf_register_fndecl; + +/* extern void __mf_unregister (void *ptr, size_t sz); */ +static GTY (()) tree mf_unregister_fndecl; + + +/* Initialize the global tree nodes that correspond to mf-runtime.h + declarations. */ +static void +mf_init_extern_trees (void) +{ + static bool done = false; + + if (done) + return; + done = true; + + mf_uintptr_type = TREE_TYPE (mflang_lookup_decl ("uintptr_t")); + mf_cache_array_decl = mf_mark (mflang_lookup_decl ("__mf_lookup_cache")); + mf_cache_struct_type = TREE_TYPE (TREE_TYPE (mf_cache_array_decl)); + mf_cache_structptr_type = build_pointer_type (mf_cache_struct_type); + mf_cache_shift_decl = mf_mark (mflang_lookup_decl ("__mf_lc_shift")); + mf_cache_mask_decl = mf_mark (mflang_lookup_decl ("__mf_lc_mask")); + mf_check_fndecl = mflang_lookup_decl ("__mf_check"); + mf_register_fndecl = mflang_lookup_decl ("__mf_register"); + mf_unregister_fndecl = mflang_lookup_decl ("__mf_unregister"); +} + + + +/* Create and initialize local shadow variables for the lookup cache + globals. Put their decls in the *_l globals for use by + mf_build_check_statement_for. */ + +static void +mf_decl_cache_locals (tree* body) +{ + tree_stmt_iterator i = tsi_start (*body); + tree t; + + mf_cache_shift_decl_l + = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_shift_decl), + "__mf_lookup_shift_l")); + + mf_cache_mask_decl_l + = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_mask_decl), + "__mf_lookup_mask_l")); + + /* Build initialization nodes for them. */ + t = build (MODIFY_EXPR, TREE_TYPE (mf_cache_shift_decl_l), + mf_cache_shift_decl_l, mf_cache_shift_decl); + annotate_with_locus (t, DECL_SOURCE_LOCATION (current_function_decl)); + gimplify_stmt (&t); + tsi_link_before (&i, t, TSI_NEW_STMT); + + t = build (MODIFY_EXPR, TREE_TYPE (mf_cache_mask_decl_l), + mf_cache_mask_decl_l, mf_cache_mask_decl); + annotate_with_locus (t, DECL_SOURCE_LOCATION (current_function_decl)); + gimplify_stmt (&t); + tsi_link_before (&i, t, TSI_NEW_STMT); +} + + +static void +mf_decl_clear_locals (void) +{ + /* Unset local shadows. */ + mf_cache_shift_decl_l = NULL_TREE; + mf_cache_mask_decl_l = NULL_TREE; +} + +/* Create a properly typed STRING_CST node that describes the given + declaration. It will be used as an argument for __mf_register(). + Try to construct a helpful string, including file/function/variable + name. */ + +static tree +mf_varname_tree (tree decl) +{ + static pretty_printer buf_rec; + static int initialized = 0; + pretty_printer *buf = & buf_rec; + const char *buf_contents; + tree result; + + if (decl == NULL_TREE) + abort (); + + if (!initialized) + { + pp_construct (buf, /* prefix */ NULL, /* line-width */ 0); + initialized = 1; + } + pp_clear_output_area (buf); + + /* Add FILENAME[:LINENUMBER]. */ + { + const char *sourcefile; + unsigned sourceline; + + sourcefile = DECL_SOURCE_FILE (decl); + if (sourcefile == NULL && current_function_decl != NULL_TREE) + sourcefile = DECL_SOURCE_FILE (current_function_decl); + if (sourcefile == NULL) + sourcefile = "<unknown file>"; + + pp_string (buf, sourcefile); + + sourceline = DECL_SOURCE_LINE (decl); + if (sourceline != 0) + { + pp_string (buf, ":"); + pp_decimal_int (buf, sourceline); + } + } + + if (current_function_decl != NULL_TREE) + { + /* Add (FUNCTION): */ + pp_string (buf, " ("); + { + const char *funcname = NULL; + if (DECL_NAME (current_function_decl)) + funcname = (*lang_hooks.decl_printable_name) (current_function_decl, 1); + if (funcname == NULL) + funcname = "anonymous fn"; + + pp_string (buf, funcname); + } + pp_string (buf, ") "); + } + else + pp_string (buf, " "); + + /* Add <variable-declaration>, possibly demangled. */ + { + const char *declname = NULL; + + if (strcmp ("GNU C++", lang_hooks.name) == 0 && + DECL_NAME (decl) != NULL) + { + /* The gcc/cp decl_printable_name hook doesn't do as good a job as + the libiberty demangler. */ + declname = cplus_demangle (IDENTIFIER_POINTER (DECL_NAME (decl)), + DMGL_AUTO | DMGL_VERBOSE); + } + + if (declname == NULL) + declname = (*lang_hooks.decl_printable_name) (decl, 3); + + if (declname == NULL) + declname = "<unnamed variable>"; + + pp_string (buf, declname); + } + + /* Return the lot as a new STRING_CST. */ + buf_contents = pp_base_formatted_text (buf); + result = mf_build_string (buf_contents); + pp_clear_output_area (buf); + + return result; +} + + +/* And another friend, for producing a simpler message. */ + +static tree +mf_file_function_line_tree (location_t *locus) +{ + const char *file = NULL, *colon, *line, *op, *name, *cp; + char linebuf[18]; + char *string; + tree result; + + /* Add FILENAME. */ + if (locus != NULL) + file = locus->file; + if (file == NULL && current_function_decl != NULL_TREE) + file = DECL_SOURCE_FILE (current_function_decl); + if (file == NULL) + file = "<unknown file>"; + + /* Add :LINENUMBER. */ + if (locus != NULL && locus->line > 0) + { + sprintf (linebuf, "%d", locus->line); + colon = ":"; + line = linebuf; + } + else + colon = line = ""; + + /* Add (FUNCTION). */ + name = (*lang_hooks.decl_printable_name) (current_function_decl, 1); + if (name) + { + op = " ("; + cp = ")"; + } + else + op = name = cp = ""; + + string = concat (file, colon, line, op, name, cp, NULL); + result = mf_build_string (string); + free (string); + + return result; +} + + +static void +mf_build_check_statement_for (tree addr, tree size, tree_stmt_iterator *iter, + location_t *locus, tree dirflag) +{ + tree ptrtype = TREE_TYPE (addr); + tree stmt, cond, t, u, v; + tree mf_value; + tree mf_base; + tree mf_elem; + + /* Build our local variables. */ + mf_value = create_tmp_var (ptrtype, "__mf_value"); + mf_elem = create_tmp_var (mf_cache_structptr_type, "__mf_elem"); + mf_base = create_tmp_var (mf_uintptr_type, "__mf_base"); + + /* Build: __mf_value = <address expression>. */ + stmt = build (MODIFY_EXPR, void_type_node, mf_value, addr); + if (locus != NULL) + annotate_with_locus (stmt, *locus); + gimplify_stmt (&stmt); + tsi_link_before (iter, stmt, TSI_SAME_STMT); + + /* Build: __mf_base = (uintptr_t)__mf_value. */ + stmt = build (MODIFY_EXPR, void_type_node, mf_base, + build1 (NOP_EXPR, mf_uintptr_type, mf_value)); + if (locus != NULL) + annotate_with_locus (stmt, *locus); + gimplify_stmt (&stmt); + tsi_link_before (iter, stmt, TSI_SAME_STMT); + + /* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift) + & __mf_mask]. */ + t = build (RSHIFT_EXPR, mf_uintptr_type, mf_base, + (flag_mudflap_threads ? mf_cache_shift_decl : mf_cache_shift_decl_l)); + t = build (BIT_AND_EXPR, mf_uintptr_type, t, + (flag_mudflap_threads ? mf_cache_mask_decl : mf_cache_mask_decl_l)); + t = build (ARRAY_REF, + TREE_TYPE (TREE_TYPE (mf_cache_array_decl)), + mf_cache_array_decl, t); + t = build1 (ADDR_EXPR, mf_cache_structptr_type, t); + stmt = build (MODIFY_EXPR, void_type_node, mf_elem, t); + if (locus != NULL) + annotate_with_locus (stmt, *locus); + gimplify_stmt (&stmt); + tsi_link_before (iter, stmt, TSI_SAME_STMT); + + /* Quick validity check. + if (__builtin_expect ((__mf_elem->low > __mf_base) + | (__mf_elem_high < __mf_base + sizeof(T) - 1), + 0)) + { + __mf_check (); + ... and only if single-threaded: + __mf_lookup_shift_1 = f...; + __mf_lookup_mask_l = ...; + } + */ + + /* __mf_elem->low */ + t = build (COMPONENT_REF, mf_uintptr_type, + build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem), + TYPE_FIELDS (mf_cache_struct_type)); + + /* __mf_elem->high */ + u = build (COMPONENT_REF, mf_uintptr_type, + build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem), + TREE_CHAIN (TYPE_FIELDS (mf_cache_struct_type))); + + /* __mf_base + sizeof (T) - 1 */ + v = size_binop (MINUS_EXPR, size, size_one_node); + v = convert (mf_uintptr_type, v); + v = fold (build (PLUS_EXPR, mf_uintptr_type, mf_base, v)); + + t = build (TRUTH_OR_EXPR, boolean_type_node, + build (GT_EXPR, boolean_type_node, t, mf_base), + build (LT_EXPR, boolean_type_node, u, v)); + + /* Mark condition as UNLIKELY using __builtin_expect. */ + u = tree_cons (NULL_TREE, integer_zero_node, NULL_TREE); + u = tree_cons (NULL_TREE, convert (long_integer_type_node, t), u); + cond = build_function_call_expr (built_in_decls[BUILT_IN_EXPECT], u); + + /* Build up the body of the cache-miss handling: + __mf_check(); refresh *_l vars. */ + + stmt = NULL; + + u = tree_cons (NULL_TREE, mf_file_function_line_tree (locus), NULL_TREE); + u = tree_cons (NULL_TREE, dirflag, u); + u = tree_cons (NULL_TREE, size, u); + u = tree_cons (NULL_TREE, mf_value, u); + t = build_function_call_expr (mf_check_fndecl, u); + append_to_statement_list (t, &stmt); + + if (! flag_mudflap_threads) + { + t = build (MODIFY_EXPR, void_type_node, + mf_cache_shift_decl_l, mf_cache_shift_decl); + append_to_statement_list (t, &stmt); + + t = build (MODIFY_EXPR, void_type_node, + mf_cache_mask_decl_l, mf_cache_mask_decl); + append_to_statement_list (t, &stmt); + } + + stmt = build (COND_EXPR, void_type_node, cond, stmt, build_empty_stmt ()); + if (locus != NULL) + annotate_with_locus (stmt, *locus); + gimplify_to_stmt_list (&stmt); + lower_stmt_body (stmt, NULL); + tsi_link_before (iter, stmt, TSI_SAME_STMT); +} + +static void +mf_xform_derefs_1 (tree_stmt_iterator *iter, tree *tp, + location_t *locus, tree dirflag) +{ + tree type, ptr_type, addr, size, t; + + /* Don't instrument read operations. */ + if (dirflag == integer_zero_node && flag_mudflap_ignore_reads) + return; + + t = *tp; + type = TREE_TYPE (t); + size = TYPE_SIZE_UNIT (type); + + switch (TREE_CODE (t)) + { + case ARRAY_REF: + { + /* Omit checking if we can statically determine that the access is + valid. For non-addressable local arrays this is not optional, + since we won't have called __mf_register for the object. */ + tree op0, op1; + + op0 = TREE_OPERAND (t, 0); + op1 = TREE_OPERAND (t, 1); + while (TREE_CODE (op1) == INTEGER_CST) + { + tree dom = TYPE_DOMAIN (TREE_TYPE (op0)); + + /* Test for index in range. Break if not. */ + if (!dom) + break; + if (!TYPE_MIN_VALUE (dom) || !really_constant_p (TYPE_MIN_VALUE (dom))) + break; + if (!TYPE_MAX_VALUE (dom) || !really_constant_p (TYPE_MAX_VALUE (dom))) + break; + if (tree_int_cst_lt (op1, TYPE_MIN_VALUE (dom)) + || tree_int_cst_lt (TYPE_MAX_VALUE (dom), op1)) + break; + + /* If we're looking at a non-external VAR_DECL, then the + access must be ok. */ + if (TREE_CODE (op0) == VAR_DECL && !DECL_EXTERNAL (op0)) + return; + + /* Only continue if we're still looking at an array. */ + if (TREE_CODE (op0) != ARRAY_REF) + break; + + op1 = TREE_OPERAND (op0, 1); + op0 = TREE_OPERAND (op0, 0); + } + + /* If we got here, we couldn't statically the check. */ + ptr_type = build_pointer_type (type); + addr = build1 (ADDR_EXPR, ptr_type, t); + } + break; + + case INDIRECT_REF: + addr = TREE_OPERAND (t, 0); + ptr_type = TREE_TYPE (addr); + break; + + case ARRAY_RANGE_REF: + warning ("mudflap checking not yet implemented for ARRAY_RANGE_REF"); + return; + + case COMPONENT_REF: + { + tree field; + + /* If we're not dereferencing something, then the access + must be ok. */ + if (TREE_CODE (TREE_OPERAND (t, 0)) != INDIRECT_REF) + return; + + field = TREE_OPERAND (t, 1); + + /* If we're looking at a bit field, then we can't take its address + with ADDR_EXPR -- lang_hooks.mark_addressable will error. Do + things the hard way with PLUS. */ + if (DECL_BIT_FIELD_TYPE (field)) + { + size = bitsize_int (BITS_PER_UNIT); + size = size_binop (CEIL_DIV_EXPR, DECL_SIZE (field), size); + size = convert (sizetype, size); + + addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0); + addr = convert (ptr_type_node, addr); + addr = fold (build (PLUS_EXPR, ptr_type_node, + addr, byte_position (field))); + } + else + { + ptr_type = build_pointer_type (type); + addr = build1 (ADDR_EXPR, ptr_type, t); + } + } + break; + + case BIT_FIELD_REF: + { + tree ofs, rem, bpu; + + /* If we're not dereferencing something, then the access + must be ok. */ + if (TREE_CODE (TREE_OPERAND (t, 0)) != INDIRECT_REF) + return; + + bpu = bitsize_int (BITS_PER_UNIT); + ofs = convert (bitsizetype, TREE_OPERAND (t, 2)); + rem = size_binop (TRUNC_MOD_EXPR, ofs, bpu); + ofs = size_binop (TRUNC_DIV_EXPR, ofs, bpu); + + size = convert (bitsizetype, TREE_OPERAND (t, 1)); + size = size_binop (PLUS_EXPR, size, rem); + size = size_binop (CEIL_DIV_EXPR, size, bpu); + size = convert (sizetype, size); + + addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0); + addr = convert (ptr_type_node, addr); + addr = fold (build (PLUS_EXPR, ptr_type_node, addr, ofs)); + } + break; + + default: + return; + } + + mf_build_check_statement_for (addr, size, iter, locus, dirflag); +} + +static void +mf_xform_derefs (tree fnbody) +{ + tree_stmt_iterator i = tsi_start (fnbody); + + for (i = tsi_start (fnbody); !tsi_end_p (i); tsi_next (&i)) + { + tree s = tsi_stmt (i); + + /* Only a few GIMPLE statements can reference memory. */ + switch (TREE_CODE (s)) + { + case MODIFY_EXPR: /* This includes INIT_EXPR after gimplification. */ + mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s), + integer_one_node); + mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 1), EXPR_LOCUS (s), + integer_zero_node); + break; + + case RETURN_EXPR: + if (TREE_OPERAND (s, 0) != NULL_TREE) + { + if (TREE_CODE (TREE_OPERAND (s, 0)) == MODIFY_EXPR) + mf_xform_derefs_1 (&i, &TREE_OPERAND (TREE_OPERAND (s, 0), 1), EXPR_LOCUS (s), + integer_zero_node); + else + mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s), + integer_zero_node); + } + break; + + default: + ; + } + } +} + +/* ------------------------------------------------------------------------ */ +/* ADDR_EXPR transform */ + + +/* This struct is passed between mf_xform_decls to store state needed + during the traversal searching for objects that have their + addresses taken. */ +struct mf_xform_decls_data +{ + tree param_decls; +}; + + +/* 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) + { + /* Eligible decl? */ + if ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL) && + (! TREE_STATIC (decl)) && /* auto variable */ + (! DECL_EXTERNAL (decl)) && /* not extern variable */ + (COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (decl))) && /* complete type */ + (! mf_marked_p (decl)) && /* not already processed */ + (TREE_ADDRESSABLE (decl))) /* has address taken */ + { + tree size = NULL_TREE, variable_name; + tree unregister_fncall, unregister_fncall_params; + tree register_fncall, register_fncall_params; + + if (DECL_DEFER_OUTPUT (decl)) + { + /* Oh no ... it's probably a variable-length array (VLA). + The size and address cannot be computed by merely + looking at the DECL. See gimplfiy_decl_stmt for the + method by which VLA declarations turn into calls to + BUILT_IN_STACK_ALLOC. We assume that multiple + VLAs declared later in the same block get allocation + code later than the others. */ + tree stack_alloc_call = NULL_TREE; + + while(! tsi_end_p (initially_stmts)) + { + tree t = tsi_stmt (initially_stmts); + + tree call = NULL_TREE; + if (TREE_CODE (t) == CALL_EXPR) + call = t; + else if (TREE_CODE (t) == MODIFY_EXPR && + TREE_CODE (TREE_OPERAND (t, 1)) == CALL_EXPR) + call = TREE_OPERAND (t, 1); + else if (TREE_CODE (t) == TRY_FINALLY_EXPR) + { + /* We hope that this is the try/finally block sometimes + constructed by gimplify_bind_expr() for a BIND_EXPR + that contains VLAs. This very naive recursion + appears to be sufficient. */ + initially_stmts = tsi_start (TREE_OPERAND (t, 0)); + } + + if (call != NULL_TREE) + { + if (TREE_CODE (TREE_OPERAND(call, 0)) == ADDR_EXPR && + TREE_OPERAND (TREE_OPERAND (call, 0), 0) == + implicit_built_in_decls [BUILT_IN_STACK_ALLOC]) + { + tree stack_alloc_args = TREE_OPERAND (call, 1); + tree stack_alloc_op1 = TREE_VALUE (stack_alloc_args); + tree stack_alloc_op2 = TREE_VALUE (TREE_CHAIN (stack_alloc_args)); + + if (TREE_CODE (stack_alloc_op1) == ADDR_EXPR && + TREE_OPERAND (stack_alloc_op1, 0) == decl) + { + /* Got it! */ + size = stack_alloc_op2; + stack_alloc_call = call; + /* Advance iterator to point past this allocation call. */ + tsi_next (&initially_stmts); + break; + } + } + } + + tsi_next (&initially_stmts); + } + + if (stack_alloc_call == NULL_TREE) + { + warning ("mudflap cannot handle variable-sized declaration `%s'", + IDENTIFIER_POINTER (DECL_NAME (decl))); + break; + } + } + else + { + size = convert (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl))); + } + + /* (& VARIABLE, sizeof (VARIABLE)) */ + 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, NULL_TREE)); + /* __mf_unregister (...) */ + unregister_fncall = build_function_call_expr (mf_unregister_fndecl, + unregister_fncall_params); + + /* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */ + 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, + build_int_2 (3, 0), /* __MF_TYPE_STACK */ + 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_LOCUS. */ + gimplify_stmt (®ister_fncall); + gimplify_stmt (&unregister_fncall); + + /* Add the __mf_register call at the current appending point. */ + if (tsi_end_p (initially_stmts)) + internal_error ("mudflap ran off end of BIND_EXPR body"); + 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 = build (TRY_FINALLY_EXPR, void_type_node, + *stmt_list, finally_stmts); + *stmt_list = NULL; + append_to_statement_list (t, stmt_list); + } +} + + +/* Process every variable mentioned in BIND_EXPRs. */ +static tree +mx_xfn_xform_decls (tree *t, int *continue_p, void *data) +{ + struct mf_xform_decls_data* d = (struct mf_xform_decls_data*) data; + + if (*t == NULL_TREE || *t == error_mark_node) + { + *continue_p = 0; + return NULL_TREE; + } + + *continue_p = 1; + + switch (TREE_CODE (*t)) + { + case BIND_EXPR: + { + /* Process function parameters now (but only once). */ + mx_register_decls (d->param_decls, &BIND_EXPR_BODY (*t)); + d->param_decls = NULL_TREE; + + mx_register_decls (BIND_EXPR_VARS (*t), &BIND_EXPR_BODY (*t)); + } + break; + + default: + break; + } + + return NULL; +} + +/* Perform the object lifetime tracking mudflap transform on the given function + tree. The tree is mutated in place, with possibly copied subtree nodes. + + For every auto variable declared, if its address is ever taken + within the function, then supply its lifetime to the mudflap + runtime with the __mf_register and __mf_unregister calls. +*/ + +static void +mf_xform_decls (tree fnbody, tree fnparams) +{ + struct mf_xform_decls_data d; + d.param_decls = fnparams; + walk_tree_without_duplicates (&fnbody, mx_xfn_xform_decls, &d); +} + + +/* ------------------------------------------------------------------------ */ + + +/* Remember given node as a static of some kind: global data, + function-scope static, or an anonymous constant. Its assembler + label is given. +*/ + + +/* A list of globals whose incomplete declarations we encountered. + Instead of emitting the __mf_register call for them here, it's + delayed until program finish time. If they're still incomplete by + then, warnings are emitted. */ + +static GTY (()) varray_type deferred_static_decls; + +/* A list of statements for calling __mf_register() at startup time. */ +static GTY (()) tree enqueued_call_stmt_chain; + +static void +mudflap_register_call (tree obj, tree object_size, tree varname) +{ + tree arg, args, call_stmt; + + args = tree_cons (NULL_TREE, varname, NULL_TREE); + + arg = build_int_2 (4, 0); /* __MF_TYPE_STATIC */ + args = tree_cons (NULL_TREE, arg, args); + + arg = convert (size_type_node, object_size); + args = tree_cons (NULL_TREE, arg, args); + + arg = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (obj)), obj); + arg = convert (ptr_type_node, arg); + args = tree_cons (NULL_TREE, arg, args); + + mf_init_extern_trees (); + call_stmt = build_function_call_expr (mf_register_fndecl, args); + + append_to_statement_list (call_stmt, &enqueued_call_stmt_chain); +} + +void +mudflap_enqueue_decl (tree obj) +{ + if (mf_marked_p (obj)) + return; + + /* We don't need to process variable decls that are internally + generated extern. If we did, we'd end up with warnings for them + during mudflap_finish_file (). That would confuse the user, + since the text would refer to variables that don't show up in the + user's source code. */ + if (DECL_P (obj) && DECL_EXTERNAL (obj) && DECL_ARTIFICIAL (obj)) + return; + + if (COMPLETE_TYPE_P (TREE_TYPE (obj))) + { + tree object_size; + + mf_mark (obj); + + object_size = size_in_bytes (TREE_TYPE (obj)); + + if (dump_file) + { + fprintf (dump_file, "enqueue_decl obj=`"); + print_generic_expr (dump_file, obj, dump_flags); + fprintf (dump_file, "' size="); + print_generic_expr (dump_file, object_size, dump_flags); + fprintf (dump_file, "\n"); + } + + /* NB: the above condition doesn't require TREE_USED or + TREE_ADDRESSABLE. That's because this object may be a global + only used from other compilation units. XXX: Maybe static + objects could require those attributes being set. */ + + mudflap_register_call (obj, object_size, mf_varname_tree (obj)); + } + else + { + size_t i; + + if (! deferred_static_decls) + VARRAY_TREE_INIT (deferred_static_decls, 10, "deferred static list"); + + /* Ugh, linear search... */ + for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_static_decls); i++) + if (VARRAY_TREE (deferred_static_decls, i) == obj) + { + warning ("mudflap cannot track lifetime of `%s'", + IDENTIFIER_POINTER (DECL_NAME (obj))); + return; + } + + VARRAY_PUSH_TREE (deferred_static_decls, obj); + } +} + +void +mudflap_enqueue_constant (tree obj) +{ + tree object_size, varname; + + if (mf_marked_p (obj)) + return; + + if (TREE_CODE (obj) == STRING_CST) + object_size = build_int_2 (TREE_STRING_LENGTH (obj), 0); + else + object_size = size_in_bytes (TREE_TYPE (obj)); + + if (dump_file) + { + fprintf (dump_file, "enqueue_constant obj=`"); + print_generic_expr (dump_file, obj, dump_flags); + fprintf (dump_file, "' size="); + print_generic_expr (dump_file, object_size, dump_flags); + fprintf (dump_file, "\n"); + } + + if (TREE_CODE (obj) == STRING_CST) + varname = mf_build_string ("string literal"); + else + varname = mf_build_string ("constant"); + + mudflap_register_call (obj, object_size, varname); +} + + + +/* Emit any file-wide instrumentation. */ +void +mudflap_finish_file (void) +{ + /* Try to give the deferred objects one final try. */ + if (deferred_static_decls) + { + size_t i; + + for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_static_decls); i++) + { + tree obj = VARRAY_TREE (deferred_static_decls, i); + + /* Call enqueue_decl again on the same object it has previously + put into the table. (It won't modify the table this time, so + infinite iteration is not a problem.) */ + mudflap_enqueue_decl (obj); + } + + VARRAY_CLEAR (deferred_static_decls); + } + + mflang_flush_calls (enqueued_call_stmt_chain); +} + + + +#include "gt-tree-mudflap.h" |