gcc/tree-mudflap.c

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