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