gcc/tree-mudflap.c

   1 /* Mudflap: narrow-pointer bounds-checking by tree rewriting.
   2    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Frank Ch. Eigler <fche@redhat.com>
   4    and Graydon Hoare <graydon@redhat.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to the Free
  20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21 02111-1307, USA.  */
  22
  23
  24 #include "config.h"
  25 #include "errors.h"
  26 #include "system.h"
  27 #include "coretypes.h"
  28 #include "tm.h"
  29 #include "hard-reg-set.h"
  30 #include "rtl.h"
  31 #include "tree.h"
  32 #include "tm_p.h"
  33 #include "basic-block.h"
  34 #include "flags.h"
  35 #include "function.h"
  36 #include "tree-inline.h"
  37 #include "tree-gimple.h"
  38 #include "tree-flow.h"
  39 #include "tree-mudflap.h"
  40 #include "tree-dump.h"
  41 #include "tree-pass.h"
  42 #include "hashtab.h"
  43 #include "diagnostic.h"
  44 #include <demangle.h>
  45 #include "langhooks.h"
  46 #include "ggc.h"
  47 #include "cgraph.h"
  48
  49 /* Internal function decls */
  50
  51 /* Helpers.  */
  52 static tree mf_build_string (const char *string);
  53 static tree mf_varname_tree (tree);
  54 static tree mf_file_function_line_tree (location_t);
  55
  56 /* Indirection-related instrumentation.  */
  57 static void mf_decl_cache_locals (void);
  58 static void mf_decl_clear_locals (void);
  59 static void mf_xform_derefs (void);
  60 static void execute_mudflap_function_ops (void);
  61
  62 /* Addressable variables instrumentation.  */
  63 static void mf_xform_decls (tree, tree);
  64 static tree mx_xfn_xform_decls (tree *, int *, void *);
  65 static void mx_register_decls (tree, tree *);
  66 static void execute_mudflap_function_decls (void);
  67
  68
  69 /* ------------------------------------------------------------------------ */
  70 /* Some generally helpful functions for mudflap instrumentation.  */
  71
  72 /* Build a reference to a literal string.  */
  73 static tree
  74 mf_build_string (const char *string)
  75 {
  76   size_t len = strlen (string);
  77   tree result = mf_mark (build_string (len + 1, string));
  78
  79   TREE_TYPE (result) = build_array_type
  80     (char_type_node, build_index_type (build_int_cst (NULL_TREE, len)));
  81   TREE_CONSTANT (result) = 1;
  82   TREE_INVARIANT (result) = 1;
  83   TREE_READONLY (result) = 1;
  84   TREE_STATIC (result) = 1;
  85
  86   result = build1 (ADDR_EXPR, build_pointer_type (char_type_node), result);
  87
  88   return mf_mark (result);
  89 }
  90
  91 /* Create a properly typed STRING_CST node that describes the given
  92    declaration.  It will be used as an argument for __mf_register().
  93    Try to construct a helpful string, including file/function/variable
  94    name.  */
  95
  96 static tree
  97 mf_varname_tree (tree decl)
  98 {
  99   static pretty_printer buf_rec;
 100   static int initialized = 0;
 101   pretty_printer *buf = & buf_rec;
 102   const char *buf_contents;
 103   tree result;
 104
 105   gcc_assert (decl);
 106
 107   if (!initialized)
 108     {
 109       pp_construct (buf, /* prefix */ NULL, /* line-width */ 0);
 110       initialized = 1;
 111     }
 112   pp_clear_output_area (buf);
 113
 114   /* Add FILENAME[:LINENUMBER[:COLUMNNUMBER]].  */
 115   {
 116     expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (decl));
 117     const char *sourcefile;
 118     unsigned sourceline = xloc.line;
 119     unsigned sourcecolumn = 0;
 120 #ifdef USE_MAPPED_LOCATION
 121     sourcecolumn = xloc.column;
 122 #endif
 123     sourcefile = xloc.file;
 124     if (sourcefile == NULL && current_function_decl != NULL_TREE)
 125       sourcefile = DECL_SOURCE_FILE (current_function_decl);
 126     if (sourcefile == NULL)
 127       sourcefile = "<unknown file>";
 128
 129     pp_string (buf, sourcefile);
 130
 131     if (sourceline != 0)
 132       {
 133         pp_string (buf, ":");
 134         pp_decimal_int (buf, sourceline);
 135
 136         if (sourcecolumn != 0)
 137           {
 138             pp_string (buf, ":");
 139             pp_decimal_int (buf, sourcecolumn);
 140           }
 141       }
 142   }
 143
 144   if (current_function_decl != NULL_TREE)
 145     {
 146       /* Add (FUNCTION) */
 147       pp_string (buf, " (");
 148       {
 149         const char *funcname = NULL;
 150         if (DECL_NAME (current_function_decl))
 151           funcname = lang_hooks.decl_printable_name (current_function_decl, 1);
 152         if (funcname == NULL)
 153           funcname = "anonymous fn";
 154
 155         pp_string (buf, funcname);
 156       }
 157       pp_string (buf, ") ");
 158     }
 159   else
 160     pp_string (buf, " ");
 161
 162   /* Add <variable-declaration>, possibly demangled.  */
 163   {
 164     const char *declname = NULL;
 165
 166     if (strcmp ("GNU C++", lang_hooks.name) == 0 &&
 167         DECL_NAME (decl) != NULL)
 168       {
 169         /* The gcc/cp decl_printable_name hook doesn't do as good a job as
 170            the libiberty demangler.  */
 171         declname = cplus_demangle (IDENTIFIER_POINTER (DECL_NAME (decl)),
 172                                    DMGL_AUTO | DMGL_VERBOSE);
 173       }
 174
 175     if (declname == NULL)
 176       declname = lang_hooks.decl_printable_name (decl, 3);
 177
 178     if (declname == NULL)
 179       declname = "<unnamed variable>";
 180
 181     pp_string (buf, declname);
 182   }
 183
 184   /* Return the lot as a new STRING_CST.  */
 185   buf_contents = pp_base_formatted_text (buf);
 186   result = mf_build_string (buf_contents);
 187   pp_clear_output_area (buf);
 188
 189   return result;
 190 }
 191
 192
 193 /* And another friend, for producing a simpler message.  */
 194
 195 static tree
 196 mf_file_function_line_tree (location_t location)
 197 {
 198   expanded_location xloc = expand_location (location);
 199   const char *file = NULL, *colon, *line, *op, *name, *cp;
 200   char linecolbuf[30]; /* Enough for two decimal numbers plus a colon.  */
 201   char *string;
 202   tree result;
 203
 204   /* Add FILENAME[:LINENUMBER[:COLUMNNUMBER]].  */
 205   file = xloc.file;
 206   if (file == NULL && current_function_decl != NULL_TREE)
 207     file = DECL_SOURCE_FILE (current_function_decl);
 208   if (file == NULL)
 209     file = "<unknown file>";
 210
 211   if (xloc.line > 0)
 212     {
 213 #ifdef USE_MAPPED_LOCATION
 214       if (xloc.column > 0)
 215         sprintf (linecolbuf, "%d:%d", xloc.line, xloc.column);
 216       else
 217 #endif
 218         sprintf (linecolbuf, "%d", xloc.line);
 219       colon = ":";
 220       line = linecolbuf;
 221     }
 222   else
 223     colon = line = "";
 224
 225   /* Add (FUNCTION).  */
 226   name = lang_hooks.decl_printable_name (current_function_decl, 1);
 227   if (name)
 228     {
 229       op = " (";
 230       cp = ")";
 231     }
 232   else
 233     op = name = cp = "";
 234
 235   string = concat (file, colon, line, op, name, cp, NULL);
 236   result = mf_build_string (string);
 237   free (string);
 238
 239   return result;
 240 }
 241
 242
 243 /* global tree nodes */
 244
 245 /* Global tree objects for global variables and functions exported by
 246    mudflap runtime library.  mf_init_extern_trees must be called
 247    before using these.  */
 248
 249 /* uintptr_t (usually "unsigned long") */
 250 static GTY (()) tree mf_uintptr_type;
 251
 252 /* struct __mf_cache { uintptr_t low; uintptr_t high; }; */
 253 static GTY (()) tree mf_cache_struct_type;
 254
 255 /* struct __mf_cache * const */
 256 static GTY (()) tree mf_cache_structptr_type;
 257
 258 /* extern struct __mf_cache __mf_lookup_cache []; */
 259 static GTY (()) tree mf_cache_array_decl;
 260
 261 /* extern unsigned char __mf_lc_shift; */
 262 static GTY (()) tree mf_cache_shift_decl;
 263
 264 /* extern uintptr_t __mf_lc_mask; */
 265 static GTY (()) tree mf_cache_mask_decl;
 266
 267 /* Their function-scope local shadows, used in single-threaded mode only.  */
 268
 269 /* auto const unsigned char __mf_lc_shift_l; */
 270 static GTY (()) tree mf_cache_shift_decl_l;
 271
 272 /* auto const uintptr_t __mf_lc_mask_l; */
 273 static GTY (()) tree mf_cache_mask_decl_l;
 274
 275 /* extern void __mf_check (void *ptr, size_t sz, int type, const char *); */
 276 static GTY (()) tree mf_check_fndecl;
 277
 278 /* extern void __mf_register (void *ptr, size_t sz, int type, const char *); */
 279 static GTY (()) tree mf_register_fndecl;
 280
 281 /* extern void __mf_unregister (void *ptr, size_t sz, int type); */
 282 static GTY (()) tree mf_unregister_fndecl;
 283
 284 /* extern void __mf_init (); */
 285 static GTY (()) tree mf_init_fndecl;
 286
 287 /* extern int __mf_set_options (const char*); */
 288 static GTY (()) tree mf_set_options_fndecl;
 289
 290
 291 /* Helper for mudflap_init: construct a decl with the given category,
 292    name, and type, mark it an external reference, and pushdecl it.  */
 293 static inline tree
 294 mf_make_builtin (enum tree_code category, const char *name, tree type)
 295 {
 296   tree decl = mf_mark (build_decl (category, get_identifier (name), type));
 297   TREE_PUBLIC (decl) = 1;
 298   DECL_EXTERNAL (decl) = 1;
 299   lang_hooks.decls.pushdecl (decl);
 300   return decl;
 301 }
 302
 303 /* Helper for mudflap_init: construct a tree corresponding to the type
 304      struct __mf_cache { uintptr_t low; uintptr_t high; };
 305      where uintptr_t is the FIELD_TYPE argument.  */
 306 static inline tree
 307 mf_make_mf_cache_struct_type (tree field_type)
 308 {
 309   /* There is, abominably, no language-independent way to construct a
 310      RECORD_TYPE.  So we have to call the basic type construction
 311      primitives by hand.  */
 312   tree fieldlo = build_decl (FIELD_DECL, get_identifier ("low"), field_type);
 313   tree fieldhi = build_decl (FIELD_DECL, get_identifier ("high"), field_type);
 314
 315   tree struct_type = make_node (RECORD_TYPE);
 316   DECL_CONTEXT (fieldlo) = struct_type;
 317   DECL_CONTEXT (fieldhi) = struct_type;
 318   TREE_CHAIN (fieldlo) = fieldhi;
 319   TYPE_FIELDS (struct_type) = fieldlo;
 320   TYPE_NAME (struct_type) = get_identifier ("__mf_cache");
 321   layout_type (struct_type);
 322
 323   return struct_type;
 324 }
 325
 326 #define build_function_type_0(rtype)            \
 327   build_function_type (rtype, void_list_node)
 328 #define build_function_type_1(rtype, arg1)                 \
 329   build_function_type (rtype, tree_cons (0, arg1, void_list_node))
 330 #define build_function_type_3(rtype, arg1, arg2, arg3)                  \
 331   build_function_type (rtype, tree_cons (0, arg1, tree_cons (0, arg2,   \
 332                                                              tree_cons (0, arg3, void_list_node))))
 333 #define build_function_type_4(rtype, arg1, arg2, arg3, arg4)            \
 334   build_function_type (rtype, tree_cons (0, arg1, tree_cons (0, arg2,   \
 335                                                              tree_cons (0, arg3, tree_cons (0, arg4, \
 336                                                                                             void_list_node)))))
 337
 338 /* Initialize the global tree nodes that correspond to mf-runtime.h
 339    declarations.  */
 340 void
 341 mudflap_init (void)
 342 {
 343   static bool done = false;
 344   tree mf_const_string_type;
 345   tree mf_cache_array_type;
 346   tree mf_check_register_fntype;
 347   tree mf_unregister_fntype;
 348   tree mf_init_fntype;
 349   tree mf_set_options_fntype;
 350
 351   if (done)
 352     return;
 353   done = true;
 354
 355   mf_uintptr_type = lang_hooks.types.type_for_mode (ptr_mode,
 356                                                     /*unsignedp=*/true);
 357   mf_const_string_type
 358     = build_pointer_type (build_qualified_type
 359                           (char_type_node, TYPE_QUAL_CONST));
 360
 361   mf_cache_struct_type = mf_make_mf_cache_struct_type (mf_uintptr_type);
 362   mf_cache_structptr_type = build_pointer_type (mf_cache_struct_type);
 363   mf_cache_array_type = build_array_type (mf_cache_struct_type, 0);
 364   mf_check_register_fntype =
 365     build_function_type_4 (void_type_node, ptr_type_node, size_type_node,
 366                            integer_type_node, mf_const_string_type);
 367   mf_unregister_fntype =
 368     build_function_type_3 (void_type_node, ptr_type_node, size_type_node,
 369                            integer_type_node);
 370   mf_init_fntype =
 371     build_function_type_0 (void_type_node);
 372   mf_set_options_fntype =
 373     build_function_type_1 (integer_type_node, mf_const_string_type);
 374
 375   mf_cache_array_decl = mf_make_builtin (VAR_DECL, "__mf_lookup_cache",
 376                                          mf_cache_array_type);
 377   mf_cache_shift_decl = mf_make_builtin (VAR_DECL, "__mf_lc_shift",
 378                                          unsigned_char_type_node);
 379   mf_cache_mask_decl = mf_make_builtin (VAR_DECL, "__mf_lc_mask",
 380                                         mf_uintptr_type);
 381   /* Don't process these in mudflap_enqueue_decl, should they come by
 382      there for some reason.  */
 383   mf_mark (mf_cache_array_decl);
 384   mf_mark (mf_cache_shift_decl);
 385   mf_mark (mf_cache_mask_decl);
 386   mf_check_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_check",
 387                                      mf_check_register_fntype);
 388   mf_register_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_register",
 389                                         mf_check_register_fntype);
 390   mf_unregister_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_unregister",
 391                                           mf_unregister_fntype);
 392   mf_init_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_init",
 393                                     mf_init_fntype);
 394   mf_set_options_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_set_options",
 395                                            mf_set_options_fntype);
 396 }
 397 #undef build_function_type_4
 398 #undef build_function_type_3
 399 #undef build_function_type_1
 400 #undef build_function_type_0
 401
 402
 403 /* ------------------------------------------------------------------------ */
 404 /* Memory reference transforms. Perform the mudflap indirection-related
 405    tree transforms on the current function.
 406
 407    This is the second part of the mudflap instrumentation.  It works on
 408    low-level GIMPLE using the CFG, because we want to run this pass after
 409    tree optimizations have been performed, but we have to preserve the CFG
 410    for expansion from trees to RTL.  */
 411
 412 static void
 413 execute_mudflap_function_ops (void)
 414 {
 415   /* Don't instrument functions such as the synthetic constructor
 416      built during mudflap_finish_file.  */
 417   if (mf_marked_p (current_function_decl) ||
 418       DECL_ARTIFICIAL (current_function_decl))
 419     return;
 420
 421   push_gimplify_context ();
 422
 423   /* In multithreaded mode, don't cache the lookup cache parameters.  */
 424   if (! flag_mudflap_threads)
 425     mf_decl_cache_locals ();
 426
 427   mf_xform_derefs ();
 428
 429   if (! flag_mudflap_threads)
 430     mf_decl_clear_locals ();
 431
 432   pop_gimplify_context (NULL);
 433 }
 434
 435 /* Create and initialize local shadow variables for the lookup cache
 436    globals.  Put their decls in the *_l globals for use by
 437    mf_build_check_statement_for.  */
 438
 439 static void
 440 mf_decl_cache_locals (void)
 441 {
 442   tree t, shift_init_stmts, mask_init_stmts;
 443   tree_stmt_iterator tsi;
 444
 445   /* Build the cache vars.  */
 446   mf_cache_shift_decl_l
 447     = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_shift_decl),
 448                                "__mf_lookup_shift_l"));
 449
 450   mf_cache_mask_decl_l
 451     = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_mask_decl),
 452                                "__mf_lookup_mask_l"));
 453
 454   /* Build initialization nodes for the cache vars.  We just load the
 455      globals into the cache variables.  */
 456   t = build (MODIFY_EXPR, TREE_TYPE (mf_cache_shift_decl_l),
 457              mf_cache_shift_decl_l, mf_cache_shift_decl);
 458   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
 459   gimplify_to_stmt_list (&t);
 460   shift_init_stmts = t;
 461
 462   t = build (MODIFY_EXPR, TREE_TYPE (mf_cache_mask_decl_l),
 463              mf_cache_mask_decl_l, mf_cache_mask_decl);
 464   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
 465   gimplify_to_stmt_list (&t);
 466   mask_init_stmts = t;
 467
 468   /* Anticipating multiple entry points, we insert the cache vars
 469      initializers in each successor of the ENTRY_BLOCK_PTR.  */
 470   for (tsi = tsi_start (shift_init_stmts);
 471        ! tsi_end_p (tsi);
 472        tsi_next (&tsi))
 473     insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);
 474
 475   for (tsi = tsi_start (mask_init_stmts);
 476        ! tsi_end_p (tsi);
 477        tsi_next (&tsi))
 478     insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);
 479   bsi_commit_edge_inserts (NULL);
 480 }
 481
 482
 483 static void
 484 mf_decl_clear_locals (void)
 485 {
 486   /* Unset local shadows.  */
 487   mf_cache_shift_decl_l = NULL_TREE;
 488   mf_cache_mask_decl_l = NULL_TREE;
 489 }
 490
 491 static void
 492 mf_build_check_statement_for (tree base, tree limit,
 493                               block_stmt_iterator *instr_bsi,
 494                               location_t *locus, tree dirflag)
 495 {
 496   tree_stmt_iterator head, tsi;
 497   block_stmt_iterator bsi;
 498   basic_block cond_bb, then_bb, join_bb;
 499   edge e;
 500   tree cond, t, u, v, l1, l2;
 501   tree mf_base;
 502   tree mf_elem;
 503   tree mf_limit;
 504
 505   /* We first need to split the current basic block, and start altering
 506      the CFG.  This allows us to insert the statements we're about to
 507      construct into the right basic blocks.  The label l1 is the label
 508      of the block for the THEN clause of the conditional jump we're
 509      about to construct, and l2 is the ELSE clause, which is just the
 510      continuation of the old statement stream.  */
 511   l1 = create_artificial_label ();
 512   l2 = create_artificial_label ();
 513   cond_bb = bb_for_stmt (bsi_stmt (*instr_bsi));
 514   bsi = *instr_bsi;
 515   bsi_prev (&bsi);
 516   if (! bsi_end_p (bsi))
 517     {
 518       /* We're processing a statement in the middle of the block, so
 519          we need to split the block.  This creates a new block and a new
 520          fallthrough edge.  */
 521       e = split_block (cond_bb, bsi_stmt (bsi));
 522       cond_bb = e->src;
 523       join_bb = e->dest;
 524     }
 525   else
 526     {
 527       /* We're processing the first statement in the block, so we need
 528          to split the incoming edge.  This also creates a new block
 529          and a new fallthrough edge.  */
 530       join_bb = cond_bb;
 531       cond_bb = split_edge (find_edge (join_bb->prev_bb, join_bb));
 532     }
 533
 534   /* A recap at this point: join_bb is the basic block at whose head
 535      is the gimple statement for which this check expression is being
 536      built.  cond_bb is the (possibly new, synthetic) basic block the
 537      end of which will contain the cache-lookup code, and a
 538      conditional that jumps to the cache-miss code or, much more
 539      likely, over to join_bb.  */
 540
 541   /* Create the bb that contains the cache-miss fallback block (mf_check).  */
 542   then_bb = create_empty_bb (cond_bb);
 543   make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);
 544   make_single_succ_edge (then_bb, join_bb, EDGE_FALLTHRU);
 545
 546   /* We expect that the conditional jump we will construct will not
 547      be taken very often as it basically is an exception condition.  */
 548   predict_edge_def (EDGE_PRED (then_bb, 0), PRED_MUDFLAP, NOT_TAKEN);
 549
 550   /* Mark the pseudo-fallthrough edge from cond_bb to join_bb.  */
 551   e = find_edge (cond_bb, join_bb);
 552   e->flags = EDGE_FALSE_VALUE;
 553   predict_edge_def (e, PRED_MUDFLAP, TAKEN);
 554
 555   /* Update dominance info.  Note that bb_join's data was
 556      updated by split_block.  */
 557   if (dom_info_available_p (CDI_DOMINATORS))
 558     {
 559       set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
 560       set_immediate_dominator (CDI_DOMINATORS, join_bb, cond_bb);
 561     }
 562
 563   /* Build our local variables.  */
 564   mf_elem = create_tmp_var (mf_cache_structptr_type, "__mf_elem");
 565   mf_base = create_tmp_var (mf_uintptr_type, "__mf_base");
 566   mf_limit = create_tmp_var (mf_uintptr_type, "__mf_limit");
 567
 568   /* Build: __mf_base = (uintptr_t) <base address expression>.  */
 569   t = build (MODIFY_EXPR, void_type_node, mf_base,
 570              convert (mf_uintptr_type, unshare_expr (base)));
 571   SET_EXPR_LOCUS (t, locus);
 572   gimplify_to_stmt_list (&t);
 573   head = tsi_start (t);
 574   tsi = tsi_last (t);
 575
 576   /* Build: __mf_limit = (uintptr_t) <limit address expression>.  */
 577   t = build (MODIFY_EXPR, void_type_node, mf_limit,
 578              convert (mf_uintptr_type, unshare_expr (limit)));
 579   SET_EXPR_LOCUS (t, locus);
 580   gimplify_to_stmt_list (&t);
 581   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 582
 583   /* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift)
 584                                             & __mf_mask].  */
 585   t = build (RSHIFT_EXPR, mf_uintptr_type, mf_base,
 586              (flag_mudflap_threads ? mf_cache_shift_decl : mf_cache_shift_decl_l));
 587   t = build (BIT_AND_EXPR, mf_uintptr_type, t,
 588              (flag_mudflap_threads ? mf_cache_mask_decl : mf_cache_mask_decl_l));
 589   t = build (ARRAY_REF,
 590              TREE_TYPE (TREE_TYPE (mf_cache_array_decl)),
 591              mf_cache_array_decl, t, NULL_TREE, NULL_TREE);
 592   t = build1 (ADDR_EXPR, mf_cache_structptr_type, t);
 593   t = build (MODIFY_EXPR, void_type_node, mf_elem, t);
 594   SET_EXPR_LOCUS (t, locus);
 595   gimplify_to_stmt_list (&t);
 596   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 597
 598   /* Quick validity check.
 599
 600      if (__mf_elem->low > __mf_base
 601          || (__mf_elem_high < __mf_limit))
 602         {
 603           __mf_check ();
 604           ... and only if single-threaded:
 605           __mf_lookup_shift_1 = f...;
 606           __mf_lookup_mask_l = ...;
 607         }
 608
 609      It is expected that this body of code is rarely executed so we mark
 610      the edge to the THEN clause of the conditional jump as unlikely.  */
 611
 612   /* Construct t <-- '__mf_elem->low  > __mf_base'.  */
 613   t = build (COMPONENT_REF, mf_uintptr_type,
 614              build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
 615              TYPE_FIELDS (mf_cache_struct_type), NULL_TREE);
 616   t = build (GT_EXPR, boolean_type_node, t, mf_base);
 617
 618   /* Construct '__mf_elem->high < __mf_limit'.
 619
 620      First build:
 621         1) u <--  '__mf_elem->high'
 622         2) v <--  '__mf_limit'.
 623
 624      Then build 'u <-- (u < v).  */
 625
 626   u = build (COMPONENT_REF, mf_uintptr_type,
 627              build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
 628              TREE_CHAIN (TYPE_FIELDS (mf_cache_struct_type)), NULL_TREE);
 629
 630   v = mf_limit;
 631
 632   u = build (LT_EXPR, boolean_type_node, u, v);
 633
 634   /* Build the composed conditional: t <-- 't || u'.  Then store the
 635      result of the evaluation of 't' in a temporary variable which we
 636      can use as the condition for the conditional jump.  */
 637   t = build (TRUTH_OR_EXPR, boolean_type_node, t, u);
 638   cond = create_tmp_var (boolean_type_node, "__mf_unlikely_cond");
 639   t = build (MODIFY_EXPR, boolean_type_node, cond, t);
 640   gimplify_to_stmt_list (&t);
 641   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 642
 643   /* Build the conditional jump.  'cond' is just a temporary so we can
 644      simply build a void COND_EXPR.  We do need labels in both arms though.  */
 645   t = build (COND_EXPR, void_type_node, cond,
 646              build (GOTO_EXPR, void_type_node, tree_block_label (then_bb)),
 647              build (GOTO_EXPR, void_type_node, tree_block_label (join_bb)));
 648   SET_EXPR_LOCUS (t, locus);
 649   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 650
 651   /* At this point, after so much hard work, we have only constructed
 652      the conditional jump,
 653
 654      if (__mf_elem->low > __mf_base
 655          || (__mf_elem_high < __mf_limit))
 656
 657      The lowered GIMPLE tree representing this code is in the statement
 658      list starting at 'head'.
 659
 660      We can insert this now in the current basic block, i.e. the one that
 661      the statement we're instrumenting was originally in.  */
 662   bsi = bsi_last (cond_bb);
 663   for (tsi = head; ! tsi_end_p (tsi); tsi_next (&tsi))
 664     bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
 665
 666   /*  Now build up the body of the cache-miss handling:
 667
 668      __mf_check();
 669      refresh *_l vars.
 670
 671      This is the body of the conditional.  */
 672
 673   u = tree_cons (NULL_TREE,
 674                  mf_file_function_line_tree (locus == NULL ? UNKNOWN_LOCATION
 675                                              : *locus),
 676                  NULL_TREE);
 677   u = tree_cons (NULL_TREE, dirflag, u);
 678   /* NB: we pass the overall [base..limit] range to mf_check.  */
 679   u = tree_cons (NULL_TREE,
 680                  fold (build (PLUS_EXPR, integer_type_node,
 681                               fold (build (MINUS_EXPR, mf_uintptr_type, mf_limit, mf_base)),
 682                               integer_one_node)),
 683                  u);
 684   u = tree_cons (NULL_TREE, mf_base, u);
 685   t = build_function_call_expr (mf_check_fndecl, u);
 686   gimplify_to_stmt_list (&t);
 687   head = tsi_start (t);
 688   tsi = tsi_last (t);
 689
 690   if (! flag_mudflap_threads)
 691     {
 692       t = build (MODIFY_EXPR, void_type_node,
 693                  mf_cache_shift_decl_l, mf_cache_shift_decl);
 694       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 695
 696       t = build (MODIFY_EXPR, void_type_node,
 697                  mf_cache_mask_decl_l, mf_cache_mask_decl);
 698       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
 699     }
 700
 701   /* Insert the check code in the THEN block.  */
 702   bsi = bsi_start (then_bb);
 703   for (tsi = head; ! tsi_end_p (tsi); tsi_next (&tsi))
 704     bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
 705
 706   *instr_bsi = bsi_start (join_bb);
 707   bsi_next (instr_bsi);
 708 }
 709
 710
 711 /* Check whether the given decl, generally a VAR_DECL or PARM_DECL, is
 712    eligible for instrumentation.  For the mudflap1 pass, this implies
 713    that it should be registered with the libmudflap runtime.  For the
 714    mudflap2 pass this means instrumenting an indirection operation with
 715    respect to the object.
 716 */
 717 static int
 718 mf_decl_eligible_p (tree decl)
 719 {
 720   return ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
 721           /* The decl must have its address taken.  In the case of
 722              arrays, this flag is also set if the indexes are not
 723              compile-time known valid constants.  */
 724           && TREE_ADDRESSABLE (decl)
 725           /* The type of the variable must be complete.  */
 726           && COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (decl))
 727           /* The decl hasn't been decomposed somehow.  */
 728           && DECL_VALUE_EXPR (decl) == NULL);
 729 }
 730
 731
 732 static void
 733 mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
 734                    location_t *locus, tree dirflag)
 735 {
 736   tree type, ptr_type, base, limit, addr, size, t;
 737
 738   /* Don't instrument read operations.  */
 739   if (dirflag == integer_zero_node && flag_mudflap_ignore_reads)
 740     return;
 741
 742   /* Don't instrument marked nodes.  */
 743   if (mf_marked_p (*tp))
 744     return;
 745
 746   t = *tp;
 747   type = TREE_TYPE (t);
 748   size = TYPE_SIZE_UNIT (type);
 749
 750   switch (TREE_CODE (t))
 751     {
 752     case ARRAY_REF:
 753     case COMPONENT_REF:
 754       {
 755         /* This is trickier than it may first appear.  The reason is
 756            that we are looking at expressions from the "inside out" at
 757            this point.  We may have a complex nested aggregate/array
 758            expression (e.g. "a.b[i].c"), maybe with an indirection as
 759            the leftmost operator ("p->a.b.d"), where instrumentation
 760            is necessary.  Or we may have an innocent "a.b.c"
 761            expression that must not be instrumented.  We need to
 762            recurse all the way down the nesting structure to figure it
 763            out: looking just at the outer node is not enough.  */
 764         tree var;
 765         int component_ref_only = TREE_CODE (t) == COMPONENT_REF;
 766
 767         /* Iterate to the top of the ARRAY_REF/COMPONENT_REF
 768            containment hierarchy to find the outermost VAR_DECL.  */
 769         var = TREE_OPERAND (t, 0);
 770         while (1)
 771           {
 772             if (TREE_CODE (var) == ARRAY_REF)
 773               {
 774                 component_ref_only = 0;
 775                 var = TREE_OPERAND (var, 0);
 776               }
 777             else if (TREE_CODE (var) == COMPONENT_REF)
 778               var = TREE_OPERAND (var, 0);
 779             else if (INDIRECT_REF_P (var))
 780               {
 781                 component_ref_only = 0;
 782                 break;
 783               }
 784             else
 785               {
 786                 gcc_assert (TREE_CODE (var) == VAR_DECL
 787                             || TREE_CODE (var) == PARM_DECL);
 788                 /* Don't instrument this access if the underlying
 789                    variable is not "eligible".  This test matches
 790                    those arrays that have only known-valid indexes,
 791                    and thus are not labeled TREE_ADDRESSABLE.  */
 792                 if (! mf_decl_eligible_p (var))
 793                   return;
 794                 else
 795                   break;
 796               }
 797           }
 798
 799         /* Handle the case of ordinary non-indirection structure
 800            accesses.  These have only nested COMPONENT_REF nodes (no
 801            INDIRECT_REF), but pass through the above filter loop.
 802            Note that it's possible for such a struct variable to match
 803            the eligible_p test because someone else might take its
 804            address sometime.  */
 805         if (component_ref_only)
 806           return;
 807
 808         ptr_type = build_pointer_type (type);
 809
 810         /* We need special processing for bitfield components, because
 811            their addresses cannot be taken.  */
 812         if (TREE_CODE (t) == COMPONENT_REF
 813             && DECL_BIT_FIELD_TYPE (TREE_OPERAND (t, 1)))
 814           {
 815             tree field = TREE_OPERAND (t, 1);
 816
 817             if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST)
 818               size = DECL_SIZE_UNIT (field);
 819
 820             addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
 821             addr = fold_convert (ptr_type_node, addr);
 822             addr = fold (build (PLUS_EXPR, ptr_type_node,
 823                                 addr, fold_convert (ptr_type_node,
 824                                                     byte_position (field))));
 825           }
 826         else
 827           addr = build1 (ADDR_EXPR, build_pointer_type (type), t);
 828
 829         if (INDIRECT_REF_P (var))
 830           base = TREE_OPERAND (var, 0);
 831         else
 832           base = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (var)), var);
 833         limit = fold (build (MINUS_EXPR, mf_uintptr_type,
 834                              fold (build2 (PLUS_EXPR, mf_uintptr_type,
 835                                            convert (mf_uintptr_type, addr),
 836                                            size)),
 837                              integer_one_node));
 838       }
 839       break;
 840
 841     case INDIRECT_REF:
 842       addr = TREE_OPERAND (t, 0);
 843       ptr_type = TREE_TYPE (addr);
 844       base = addr;
 845       limit = fold (build (MINUS_EXPR, ptr_type_node,
 846                            fold (build (PLUS_EXPR, ptr_type_node, base, size)),
 847                            integer_one_node));
 848       break;
 849
 850     case ARRAY_RANGE_REF:
 851       warning ("mudflap checking not yet implemented for ARRAY_RANGE_REF");
 852       return;
 853
 854     case BIT_FIELD_REF:
 855       /* ??? merge with COMPONENT_REF code above? */
 856       {
 857         tree ofs, rem, bpu;
 858
 859         /* If we're not dereferencing something, then the access
 860            must be ok.  */
 861         if (TREE_CODE (TREE_OPERAND (t, 0)) != INDIRECT_REF)
 862           return;
 863
 864         bpu = bitsize_int (BITS_PER_UNIT);
 865         ofs = convert (bitsizetype, TREE_OPERAND (t, 2));
 866         rem = size_binop (TRUNC_MOD_EXPR, ofs, bpu);
 867         ofs = size_binop (TRUNC_DIV_EXPR, ofs, bpu);
 868
 869         size = convert (bitsizetype, TREE_OPERAND (t, 1));
 870         size = size_binop (PLUS_EXPR, size, rem);
 871         size = size_binop (CEIL_DIV_EXPR, size, bpu);
 872         size = convert (sizetype, size);
 873
 874         addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
 875         addr = convert (ptr_type_node, addr);
 876         addr = fold (build (PLUS_EXPR, ptr_type_node, addr, ofs));
 877
 878         base = addr;
 879         limit = fold (build (MINUS_EXPR, ptr_type_node,
 880                              fold (build (PLUS_EXPR, ptr_type_node, base, size)),
 881                              integer_one_node));
 882       }
 883       break;
 884
 885     default:
 886       return;
 887     }
 888
 889   mf_build_check_statement_for (base, limit, iter, locus, dirflag);
 890 }
 891
 892 static void
 893 mf_xform_derefs (void)
 894 {
 895   basic_block bb, next;
 896   block_stmt_iterator i;
 897   int saved_last_basic_block = last_basic_block;
 898
 899   bb = ENTRY_BLOCK_PTR ->next_bb;
 900   do
 901     {
 902       next = bb->next_bb;
 903       for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
 904         {
 905           tree s = bsi_stmt (i);
 906
 907           /* Only a few GIMPLE statements can reference memory.  */
 908           switch (TREE_CODE (s))
 909             {
 910             case MODIFY_EXPR:
 911               mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s),
 912                                  integer_one_node);
 913               mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 1), EXPR_LOCUS (s),
 914                                  integer_zero_node);
 915               break;
 916
 917             case RETURN_EXPR:
 918               if (TREE_OPERAND (s, 0) != NULL_TREE)
 919                 {
 920                   if (TREE_CODE (TREE_OPERAND (s, 0)) == MODIFY_EXPR)
 921                     mf_xform_derefs_1 (&i, &TREE_OPERAND (TREE_OPERAND (s, 0), 1),
 922                                        EXPR_LOCUS (s), integer_zero_node);
 923                   else
 924                     mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s),
 925                                        integer_zero_node);
 926                 }
 927               break;
 928
 929             default:
 930               ;
 931             }
 932         }
 933       bb = next;
 934     }
 935   while (bb && bb->index <= saved_last_basic_block);
 936 }
 937
 938 /* ------------------------------------------------------------------------ */
 939 /* ADDR_EXPR transforms.  Perform the declaration-related mudflap tree
 940    transforms on the current function.
 941
 942    This is the first part of the mudflap instrumentation.  It works on
 943    high-level GIMPLE because after lowering, all variables are moved out
 944    of their BIND_EXPR binding context, and we lose liveness information
 945    for the declarations we wish to instrument.  */
 946
 947 static void
 948 execute_mudflap_function_decls (void)
 949 {
 950   /* Don't instrument functions such as the synthetic constructor
 951      built during mudflap_finish_file.  */
 952   if (mf_marked_p (current_function_decl) ||
 953       DECL_ARTIFICIAL (current_function_decl))
 954     return;
 955
 956   push_gimplify_context ();
 957
 958   mf_xform_decls (DECL_SAVED_TREE (current_function_decl),
 959                   DECL_ARGUMENTS (current_function_decl));
 960
 961   pop_gimplify_context (NULL);
 962 }
 963
 964 /* This struct is passed between mf_xform_decls to store state needed
 965    during the traversal searching for objects that have their
 966    addresses taken.  */
 967 struct mf_xform_decls_data
 968 {
 969   tree param_decls;
 970 };
 971
 972
 973 /* Synthesize a CALL_EXPR and a TRY_FINALLY_EXPR, for this chain of
 974    _DECLs if appropriate.  Arrange to call the __mf_register function
 975    now, and the __mf_unregister function later for each.  */
 976 static void
 977 mx_register_decls (tree decl, tree *stmt_list)
 978 {
 979   tree finally_stmts = NULL_TREE;
 980   tree_stmt_iterator initially_stmts = tsi_start (*stmt_list);
 981
 982   while (decl != NULL_TREE)
 983     {
 984       if (mf_decl_eligible_p (decl)
 985           /* Not already processed.  */
 986           && ! mf_marked_p (decl)
 987           /* Automatic variable.  */
 988           && ! DECL_EXTERNAL (decl)
 989           && ! TREE_STATIC (decl))
 990         {
 991           tree size = NULL_TREE, variable_name;
 992           tree unregister_fncall, unregister_fncall_params;
 993           tree register_fncall, register_fncall_params;
 994
 995           size = convert (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl)));
 996
 997           /* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
 998           unregister_fncall_params =
 999             tree_cons (NULL_TREE,
1000                        convert (ptr_type_node,
1001                                 mf_mark (build1 (ADDR_EXPR,
1002                                                  build_pointer_type (TREE_TYPE (decl)),
1003                                                  decl))),
1004                        tree_cons (NULL_TREE,
1005                                   size,
1006                                   tree_cons (NULL_TREE,
1007                                              /* __MF_TYPE_STACK */
1008                                              build_int_cst (NULL_TREE, 3),
1009                                              NULL_TREE)));
1010           /* __mf_unregister (...) */
1011           unregister_fncall = build_function_call_expr (mf_unregister_fndecl,
1012                                                         unregister_fncall_params);
1013
1014           /* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK, "name") */
1015           variable_name = mf_varname_tree (decl);
1016           register_fncall_params =
1017             tree_cons (NULL_TREE,
1018                    convert (ptr_type_node,
1019                             mf_mark (build1 (ADDR_EXPR,
1020                                              build_pointer_type (TREE_TYPE (decl)),
1021                                              decl))),
1022                        tree_cons (NULL_TREE,
1023                                   size,
1024                                   tree_cons (NULL_TREE,
1025                                              /* __MF_TYPE_STACK */
1026                                              build_int_cst (NULL_TREE, 3),
1027                                              tree_cons (NULL_TREE,
1028                                                         variable_name,
1029                                                         NULL_TREE))));
1030
1031           /* __mf_register (...) */
1032           register_fncall = build_function_call_expr (mf_register_fndecl,
1033                                                       register_fncall_params);
1034
1035           /* Accumulate the two calls.  */
1036           /* ??? Set EXPR_LOCATION.  */
1037           gimplify_stmt (&register_fncall);
1038           gimplify_stmt (&unregister_fncall);
1039
1040           /* Add the __mf_register call at the current appending point.  */
1041           if (tsi_end_p (initially_stmts))
1042             internal_error ("mudflap ran off end of BIND_EXPR body");
1043           tsi_link_before (&initially_stmts, register_fncall, TSI_SAME_STMT);
1044
1045           /* Accumulate the FINALLY piece.  */
1046           append_to_statement_list (unregister_fncall, &finally_stmts);
1047
1048           mf_mark (decl);
1049         }
1050
1051       decl = TREE_CHAIN (decl);
1052     }
1053
1054   /* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
1055   if (finally_stmts != NULL_TREE)
1056     {
1057       tree t = build (TRY_FINALLY_EXPR, void_type_node,
1058                       *stmt_list, finally_stmts);
1059       *stmt_list = NULL;
1060       append_to_statement_list (t, stmt_list);
1061     }
1062 }
1063
1064
1065 /* Process every variable mentioned in BIND_EXPRs.  */
1066 static tree
1067 mx_xfn_xform_decls (tree *t, int *continue_p, void *data)
1068 {
1069   struct mf_xform_decls_data* d = (struct mf_xform_decls_data*) data;
1070
1071   if (*t == NULL_TREE || *t == error_mark_node)
1072     {
1073       *continue_p = 0;
1074       return NULL_TREE;
1075     }
1076
1077   *continue_p = 1;
1078
1079   switch (TREE_CODE (*t))
1080     {
1081     case BIND_EXPR:
1082       {
1083         /* Process function parameters now (but only once).  */
1084         mx_register_decls (d->param_decls, &BIND_EXPR_BODY (*t));
1085         d->param_decls = NULL_TREE;
1086
1087         mx_register_decls (BIND_EXPR_VARS (*t), &BIND_EXPR_BODY (*t));
1088       }
1089       break;
1090
1091     default:
1092       break;
1093     }
1094
1095   return NULL;
1096 }
1097
1098 /* Perform the object lifetime tracking mudflap transform on the given function
1099    tree.  The tree is mutated in place, with possibly copied subtree nodes.
1100
1101    For every auto variable declared, if its address is ever taken
1102    within the function, then supply its lifetime to the mudflap
1103    runtime with the __mf_register and __mf_unregister calls.
1104 */
1105
1106 static void
1107 mf_xform_decls (tree fnbody, tree fnparams)
1108 {
1109   struct mf_xform_decls_data d;
1110   d.param_decls = fnparams;
1111   walk_tree_without_duplicates (&fnbody, mx_xfn_xform_decls, &d);
1112 }
1113
1114
1115 /* ------------------------------------------------------------------------ */
1116 /* Externally visible mudflap functions.  */
1117
1118
1119 /* Mark and return the given tree node to prevent further mudflap
1120    transforms.  */
1121 static GTY ((param_is (union tree_node))) htab_t marked_trees = NULL;
1122
1123 tree
1124 mf_mark (tree t)
1125 {
1126   void **slot;
1127
1128   if (marked_trees == NULL)
1129     marked_trees = htab_create_ggc (31, htab_hash_pointer, htab_eq_pointer, NULL);
1130
1131   slot = htab_find_slot (marked_trees, t, INSERT);
1132   *slot = t;
1133   return t;
1134 }
1135
1136 int
1137 mf_marked_p (tree t)
1138 {
1139   void *entry;
1140
1141   if (marked_trees == NULL)
1142     return 0;
1143
1144   entry = htab_find (marked_trees, t);
1145   return (entry != NULL);
1146 }
1147
1148 /* Remember given node as a static of some kind: global data,
1149    function-scope static, or an anonymous constant.  Its assembler
1150    label is given.  */
1151
1152 /* A list of globals whose incomplete declarations we encountered.
1153    Instead of emitting the __mf_register call for them here, it's
1154    delayed until program finish time.  If they're still incomplete by
1155    then, warnings are emitted.  */
1156
1157 static GTY (()) varray_type deferred_static_decls;
1158
1159 /* A list of statements for calling __mf_register() at startup time.  */
1160 static GTY (()) tree enqueued_call_stmt_chain;
1161
1162 static void
1163 mudflap_register_call (tree obj, tree object_size, tree varname)
1164 {
1165   tree arg, args, call_stmt;
1166
1167   args = tree_cons (NULL_TREE, varname, NULL_TREE);
1168
1169   arg = build_int_cst (NULL_TREE, 4); /* __MF_TYPE_STATIC */
1170   args = tree_cons (NULL_TREE, arg, args);
1171
1172   arg = convert (size_type_node, object_size);
1173   args = tree_cons (NULL_TREE, arg, args);
1174
1175   arg = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (obj)), obj);
1176   arg = convert (ptr_type_node, arg);
1177   args = tree_cons (NULL_TREE, arg, args);
1178
1179   call_stmt = build_function_call_expr (mf_register_fndecl, args);
1180
1181   append_to_statement_list (call_stmt, &enqueued_call_stmt_chain);
1182 }
1183
1184 void
1185 mudflap_enqueue_decl (tree obj)
1186 {
1187   if (mf_marked_p (obj))
1188     return;
1189
1190   /* We don't need to process variable decls that are internally
1191      generated extern.  If we did, we'd end up with warnings for them
1192      during mudflap_finish_file ().  That would confuse the user,
1193      since the text would refer to variables that don't show up in the
1194      user's source code.  */
1195   if (DECL_P (obj) && DECL_EXTERNAL (obj) && DECL_ARTIFICIAL (obj))
1196     return;
1197
1198   if (! deferred_static_decls)
1199     VARRAY_TREE_INIT (deferred_static_decls, 10, "deferred static list");
1200
1201   VARRAY_PUSH_TREE (deferred_static_decls, obj);
1202 }
1203
1204
1205 void
1206 mudflap_enqueue_constant (tree obj)
1207 {
1208   tree object_size, varname;
1209
1210   if (mf_marked_p (obj))
1211     return;
1212
1213   if (TREE_CODE (obj) == STRING_CST)
1214     object_size = build_int_cst (NULL_TREE, TREE_STRING_LENGTH (obj));
1215   else
1216     object_size = size_in_bytes (TREE_TYPE (obj));
1217
1218   if (TREE_CODE (obj) == STRING_CST)
1219     varname = mf_build_string ("string literal");
1220   else
1221     varname = mf_build_string ("constant");
1222
1223   mudflap_register_call (obj, object_size, varname);
1224 }
1225
1226
1227 /* Emit any file-wide instrumentation.  */
1228 void
1229 mudflap_finish_file (void)
1230 {
1231   tree ctor_statements = NULL_TREE;
1232
1233   /* Insert a call to __mf_init.  */
1234   {
1235     tree call2_stmt = build_function_call_expr (mf_init_fndecl, NULL_TREE);
1236     append_to_statement_list (call2_stmt, &ctor_statements);
1237   }
1238
1239   /* If appropriate, call __mf_set_options to pass along read-ignore mode.  */
1240   if (flag_mudflap_ignore_reads)
1241     {
1242       tree arg = tree_cons (NULL_TREE,
1243                             mf_build_string ("-ignore-reads"), NULL_TREE);
1244       tree call_stmt = build_function_call_expr (mf_set_options_fndecl, arg);
1245       append_to_statement_list (call_stmt, &ctor_statements);
1246     }
1247
1248   /* Process all enqueued object decls.  */
1249   if (deferred_static_decls)
1250     {
1251       size_t i;
1252       for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_static_decls); i++)
1253         {
1254           tree obj = VARRAY_TREE (deferred_static_decls, i);
1255
1256           gcc_assert (DECL_P (obj));
1257
1258           if (mf_marked_p (obj))
1259             continue;
1260
1261           /* Omit registration for static unaddressed objects.  NB:
1262              Perform registration for non-static objects regardless of
1263              TREE_USED or TREE_ADDRESSABLE, because they may be used
1264              from other compilation units.  */
1265           if (TREE_STATIC (obj) && ! TREE_ADDRESSABLE (obj))
1266             continue;
1267
1268           if (! COMPLETE_TYPE_P (TREE_TYPE (obj)))
1269             {
1270               warning ("mudflap cannot track unknown size extern %qs",
1271                        IDENTIFIER_POINTER (DECL_NAME (obj)));
1272               continue;
1273             }
1274
1275           mudflap_register_call (obj,
1276                                  size_in_bytes (TREE_TYPE (obj)),
1277                                  mf_varname_tree (obj));
1278         }
1279
1280       VARRAY_CLEAR (deferred_static_decls);
1281     }
1282
1283   /* Append all the enqueued registration calls.  */
1284   if (enqueued_call_stmt_chain)
1285     {
1286       append_to_statement_list (enqueued_call_stmt_chain, &ctor_statements);
1287       enqueued_call_stmt_chain = NULL_TREE;
1288     }
1289
1290   cgraph_build_static_cdtor ('I', ctor_statements,
1291                              MAX_RESERVED_INIT_PRIORITY-1);
1292 }
1293
1294
1295 static bool
1296 gate_mudflap (void)
1297 {
1298   return flag_mudflap != 0;
1299 }
1300
1301 struct tree_opt_pass pass_mudflap_1 =
1302 {
1303   "mudflap1",                           /* name */
1304   gate_mudflap,                         /* gate */
1305   execute_mudflap_function_decls,       /* execute */
1306   NULL,                                 /* sub */
1307   NULL,                                 /* next */
1308   0,                                    /* static_pass_number */
1309   0,                                    /* tv_id */
1310   PROP_gimple_any,                      /* properties_required */
1311   0,                                    /* properties_provided */
1312   0,                                    /* properties_destroyed */
1313   0,                                    /* todo_flags_start */
1314   TODO_dump_func,                       /* todo_flags_finish */
1315   0                                     /* letter */
1316 };
1317
1318 struct tree_opt_pass pass_mudflap_2 =
1319 {
1320   "mudflap2",                           /* name */
1321   gate_mudflap,                         /* gate */
1322   execute_mudflap_function_ops,         /* execute */
1323   NULL,                                 /* sub */
1324   NULL,                                 /* next */
1325   0,                                    /* static_pass_number */
1326   0,                                    /* tv_id */
1327   PROP_gimple_leh,                      /* properties_required */
1328   0,                                    /* properties_provided */
1329   0,                                    /* properties_destroyed */
1330   0,                                    /* todo_flags_start */
1331   TODO_verify_flow | TODO_verify_stmts
1332   | TODO_dump_func,                     /* todo_flags_finish */
1333   0                                     /* letter */
1334 };
1335
1336 #include "gt-tree-mudflap.h"