OSDN Git Service

950ad8c2fd593d12d16c87331bad2a17e57a3ce5
[pf3gnuchains/gcc-fork.git] / gcc / tree-mudflap.c
1 /* Mudflap: narrow-pointer bounds-checking by tree rewriting.
2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
3    Free Software Foundation, Inc.
4    Contributed by Frank Ch. Eigler <fche@redhat.com>
5    and Graydon Hoare <graydon@redhat.com>
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
13
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17 for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
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   /* The decl was declared by the compiler.  */
305   DECL_ARTIFICIAL (decl) = 1;
306   /* And we don't want debug info for it.  */
307   DECL_IGNORED_P (decl) = 1;
308   return decl;
309 }
310
311 /* Helper for mudflap_init: construct a tree corresponding to the type
312      struct __mf_cache { uintptr_t low; uintptr_t high; };
313      where uintptr_t is the FIELD_TYPE argument.  */
314 static inline tree
315 mf_make_mf_cache_struct_type (tree field_type)
316 {
317   /* There is, abominably, no language-independent way to construct a
318      RECORD_TYPE.  So we have to call the basic type construction
319      primitives by hand.  */
320   tree fieldlo = build_decl (FIELD_DECL, get_identifier ("low"), field_type);
321   tree fieldhi = build_decl (FIELD_DECL, get_identifier ("high"), field_type);
322
323   tree struct_type = make_node (RECORD_TYPE);
324   DECL_CONTEXT (fieldlo) = struct_type;
325   DECL_CONTEXT (fieldhi) = struct_type;
326   TREE_CHAIN (fieldlo) = fieldhi;
327   TYPE_FIELDS (struct_type) = fieldlo;
328   TYPE_NAME (struct_type) = get_identifier ("__mf_cache");
329   layout_type (struct_type);
330
331   return struct_type;
332 }
333
334 #define build_function_type_0(rtype)                                    \
335   build_function_type (rtype, void_list_node)
336 #define build_function_type_1(rtype, arg1)                              \
337   build_function_type (rtype, tree_cons (0, arg1, void_list_node))
338 #define build_function_type_3(rtype, arg1, arg2, arg3)                  \
339   build_function_type (rtype,                                           \
340                        tree_cons (0, arg1,                              \
341                                   tree_cons (0, arg2,                   \
342                                               tree_cons (0, arg3,       \
343                                                          void_list_node))))
344 #define build_function_type_4(rtype, arg1, arg2, arg3, arg4)            \
345   build_function_type (rtype,                                           \
346                        tree_cons (0, arg1,                              \
347                                   tree_cons (0, arg2,                   \
348                                              tree_cons (0, arg3,        \
349                                                         tree_cons (0, arg4, \
350                                                                    void_list_node)))))
351
352 /* Initialize the global tree nodes that correspond to mf-runtime.h
353    declarations.  */
354 void
355 mudflap_init (void)
356 {
357   static bool done = false;
358   tree mf_const_string_type;
359   tree mf_cache_array_type;
360   tree mf_check_register_fntype;
361   tree mf_unregister_fntype;
362   tree mf_init_fntype;
363   tree mf_set_options_fntype;
364
365   if (done)
366     return;
367   done = true;
368
369   mf_uintptr_type = lang_hooks.types.type_for_mode (ptr_mode,
370                                                     /*unsignedp=*/true);
371   mf_const_string_type
372     = build_pointer_type (build_qualified_type
373                           (char_type_node, TYPE_QUAL_CONST));
374
375   mf_cache_struct_type = mf_make_mf_cache_struct_type (mf_uintptr_type);
376   mf_cache_structptr_type = build_pointer_type (mf_cache_struct_type);
377   mf_cache_array_type = build_array_type (mf_cache_struct_type, 0);
378   mf_check_register_fntype =
379     build_function_type_4 (void_type_node, ptr_type_node, size_type_node,
380                            integer_type_node, mf_const_string_type);
381   mf_unregister_fntype =
382     build_function_type_3 (void_type_node, ptr_type_node, size_type_node,
383                            integer_type_node);
384   mf_init_fntype =
385     build_function_type_0 (void_type_node);
386   mf_set_options_fntype =
387     build_function_type_1 (integer_type_node, mf_const_string_type);
388
389   mf_cache_array_decl = mf_make_builtin (VAR_DECL, "__mf_lookup_cache",
390                                          mf_cache_array_type);
391   mf_cache_shift_decl = mf_make_builtin (VAR_DECL, "__mf_lc_shift",
392                                          unsigned_char_type_node);
393   mf_cache_mask_decl = mf_make_builtin (VAR_DECL, "__mf_lc_mask",
394                                         mf_uintptr_type);
395   /* Don't process these in mudflap_enqueue_decl, should they come by
396      there for some reason.  */
397   mf_mark (mf_cache_array_decl);
398   mf_mark (mf_cache_shift_decl);
399   mf_mark (mf_cache_mask_decl);
400   mf_check_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_check",
401                                      mf_check_register_fntype);
402   mf_register_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_register",
403                                         mf_check_register_fntype);
404   mf_unregister_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_unregister",
405                                           mf_unregister_fntype);
406   mf_init_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_init",
407                                     mf_init_fntype);
408   mf_set_options_fndecl = mf_make_builtin (FUNCTION_DECL, "__mf_set_options",
409                                            mf_set_options_fntype);
410 }
411 #undef build_function_type_4
412 #undef build_function_type_3
413 #undef build_function_type_1
414 #undef build_function_type_0
415
416
417 /* ------------------------------------------------------------------------ */
418 /* Memory reference transforms. Perform the mudflap indirection-related
419    tree transforms on the current function.
420
421    This is the second part of the mudflap instrumentation.  It works on
422    low-level GIMPLE using the CFG, because we want to run this pass after
423    tree optimizations have been performed, but we have to preserve the CFG
424    for expansion from trees to RTL.  */
425
426 static unsigned int
427 execute_mudflap_function_ops (void)
428 {
429   /* Don't instrument functions such as the synthetic constructor
430      built during mudflap_finish_file.  */
431   if (mf_marked_p (current_function_decl) ||
432       DECL_ARTIFICIAL (current_function_decl))
433     return 0;
434
435   push_gimplify_context ();
436
437   /* In multithreaded mode, don't cache the lookup cache parameters.  */
438   if (! flag_mudflap_threads)
439     mf_decl_cache_locals ();
440
441   mf_xform_derefs ();
442
443   if (! flag_mudflap_threads)
444     mf_decl_clear_locals ();
445
446   pop_gimplify_context (NULL);
447   return 0;
448 }
449
450 /* Create and initialize local shadow variables for the lookup cache
451    globals.  Put their decls in the *_l globals for use by
452    mf_build_check_statement_for.  */
453
454 static void
455 mf_decl_cache_locals (void)
456 {
457   tree t, shift_init_stmts, mask_init_stmts;
458   tree_stmt_iterator tsi;
459
460   /* Build the cache vars.  */
461   mf_cache_shift_decl_l
462     = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_shift_decl),
463                                "__mf_lookup_shift_l"));
464
465   mf_cache_mask_decl_l
466     = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_mask_decl),
467                                "__mf_lookup_mask_l"));
468
469   /* Build initialization nodes for the cache vars.  We just load the
470      globals into the cache variables.  */
471   t = build_gimple_modify_stmt (mf_cache_shift_decl_l, mf_cache_shift_decl);
472   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
473   gimplify_to_stmt_list (&t);
474   shift_init_stmts = t;
475
476   t = build_gimple_modify_stmt (mf_cache_mask_decl_l, mf_cache_mask_decl);
477   SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (current_function_decl));
478   gimplify_to_stmt_list (&t);
479   mask_init_stmts = t;
480
481   /* Anticipating multiple entry points, we insert the cache vars
482      initializers in each successor of the ENTRY_BLOCK_PTR.  */
483   for (tsi = tsi_start (shift_init_stmts);
484        ! tsi_end_p (tsi);
485        tsi_next (&tsi))
486     insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);
487
488   for (tsi = tsi_start (mask_init_stmts);
489        ! tsi_end_p (tsi);
490        tsi_next (&tsi))
491     insert_edge_copies (tsi_stmt (tsi), ENTRY_BLOCK_PTR);
492   bsi_commit_edge_inserts ();
493 }
494
495
496 static void
497 mf_decl_clear_locals (void)
498 {
499   /* Unset local shadows.  */
500   mf_cache_shift_decl_l = NULL_TREE;
501   mf_cache_mask_decl_l = NULL_TREE;
502 }
503
504 static void
505 mf_build_check_statement_for (tree base, tree limit,
506                               block_stmt_iterator *instr_bsi,
507                               location_t *locus, tree dirflag)
508 {
509   tree_stmt_iterator head, tsi;
510   block_stmt_iterator bsi;
511   basic_block cond_bb, then_bb, join_bb;
512   edge e;
513   tree cond, t, u, v;
514   tree mf_base;
515   tree mf_elem;
516   tree mf_limit;
517
518   /* We first need to split the current basic block, and start altering
519      the CFG.  This allows us to insert the statements we're about to
520      construct into the right basic blocks.  */
521
522   cond_bb = bb_for_stmt (bsi_stmt (*instr_bsi));
523   bsi = *instr_bsi;
524   bsi_prev (&bsi);
525   if (! bsi_end_p (bsi))
526     e = split_block (cond_bb, bsi_stmt (bsi));
527   else
528     e = split_block_after_labels (cond_bb);
529   cond_bb = e->src;
530   join_bb = e->dest;
531
532   /* A recap at this point: join_bb is the basic block at whose head
533      is the gimple statement for which this check expression is being
534      built.  cond_bb is the (possibly new, synthetic) basic block the
535      end of which will contain the cache-lookup code, and a
536      conditional that jumps to the cache-miss code or, much more
537      likely, over to join_bb.  */
538
539   /* Create the bb that contains the cache-miss fallback block (mf_check).  */
540   then_bb = create_empty_bb (cond_bb);
541   make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);
542   make_single_succ_edge (then_bb, join_bb, EDGE_FALLTHRU);
543
544   /* Mark the pseudo-fallthrough edge from cond_bb to join_bb.  */
545   e = find_edge (cond_bb, join_bb);
546   e->flags = EDGE_FALSE_VALUE;
547   e->count = cond_bb->count;
548   e->probability = REG_BR_PROB_BASE;
549
550   /* Update dominance info.  Note that bb_join's data was
551      updated by split_block.  */
552   if (dom_info_available_p (CDI_DOMINATORS))
553     {
554       set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
555       set_immediate_dominator (CDI_DOMINATORS, join_bb, cond_bb);
556     }
557
558   /* Build our local variables.  */
559   mf_elem = create_tmp_var (mf_cache_structptr_type, "__mf_elem");
560   mf_base = create_tmp_var (mf_uintptr_type, "__mf_base");
561   mf_limit = create_tmp_var (mf_uintptr_type, "__mf_limit");
562
563   /* Build: __mf_base = (uintptr_t) <base address expression>.  */
564   t = build_gimple_modify_stmt (mf_base,
565                                 fold_convert (mf_uintptr_type,
566                                               unshare_expr (base)));
567   SET_EXPR_LOCUS (t, locus);
568   gimplify_to_stmt_list (&t);
569   head = tsi_start (t);
570   tsi = tsi_last (t);
571
572   /* Build: __mf_limit = (uintptr_t) <limit address expression>.  */
573   t = build_gimple_modify_stmt (mf_limit,
574                                 fold_convert (mf_uintptr_type,
575                                               unshare_expr (limit)));
576   SET_EXPR_LOCUS (t, locus);
577   gimplify_to_stmt_list (&t);
578   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
579
580   /* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift)
581                                             & __mf_mask].  */
582   t = build2 (RSHIFT_EXPR, mf_uintptr_type, mf_base,
583               flag_mudflap_threads ? mf_cache_shift_decl
584                : mf_cache_shift_decl_l);
585   t = build2 (BIT_AND_EXPR, mf_uintptr_type, t,
586               flag_mudflap_threads ? mf_cache_mask_decl
587                : mf_cache_mask_decl_l);
588   t = build4 (ARRAY_REF,
589               TREE_TYPE (TREE_TYPE (mf_cache_array_decl)),
590               mf_cache_array_decl, t, NULL_TREE, NULL_TREE);
591   t = build1 (ADDR_EXPR, mf_cache_structptr_type, t);
592   t = build_gimple_modify_stmt (mf_elem, t);
593   SET_EXPR_LOCUS (t, locus);
594   gimplify_to_stmt_list (&t);
595   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
596
597   /* Quick validity check.
598
599      if (__mf_elem->low > __mf_base
600          || (__mf_elem_high < __mf_limit))
601         {
602           __mf_check ();
603           ... and only if single-threaded:
604           __mf_lookup_shift_1 = f...;
605           __mf_lookup_mask_l = ...;
606         }
607
608      It is expected that this body of code is rarely executed so we mark
609      the edge to the THEN clause of the conditional jump as unlikely.  */
610
611   /* Construct t <-- '__mf_elem->low  > __mf_base'.  */
612   t = build3 (COMPONENT_REF, mf_uintptr_type,
613               build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
614               TYPE_FIELDS (mf_cache_struct_type), NULL_TREE);
615   t = build2 (GT_EXPR, boolean_type_node, t, mf_base);
616
617   /* Construct '__mf_elem->high < __mf_limit'.
618
619      First build:
620         1) u <--  '__mf_elem->high'
621         2) v <--  '__mf_limit'.
622
623      Then build 'u <-- (u < v).  */
624
625   u = build3 (COMPONENT_REF, mf_uintptr_type,
626               build1 (INDIRECT_REF, mf_cache_struct_type, mf_elem),
627               TREE_CHAIN (TYPE_FIELDS (mf_cache_struct_type)), NULL_TREE);
628
629   v = mf_limit;
630
631   u = build2 (LT_EXPR, boolean_type_node, u, v);
632
633   /* Build the composed conditional: t <-- 't || u'.  Then store the
634      result of the evaluation of 't' in a temporary variable which we
635      can use as the condition for the conditional jump.  */
636   t = build2 (TRUTH_OR_EXPR, boolean_type_node, t, u);
637   cond = create_tmp_var (boolean_type_node, "__mf_unlikely_cond");
638   t = build_gimple_modify_stmt (cond, t);
639   gimplify_to_stmt_list (&t);
640   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
641
642   /* Build the conditional jump.  'cond' is just a temporary so we can
643      simply build a void COND_EXPR.  We do need labels in both arms though.  */
644   t = build3 (COND_EXPR, void_type_node, cond, NULL_TREE, NULL_TREE);
645   SET_EXPR_LOCUS (t, locus);
646   tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
647
648   /* At this point, after so much hard work, we have only constructed
649      the conditional jump,
650
651      if (__mf_elem->low > __mf_base
652          || (__mf_elem_high < __mf_limit))
653
654      The lowered GIMPLE tree representing this code is in the statement
655      list starting at 'head'.
656
657      We can insert this now in the current basic block, i.e. the one that
658      the statement we're instrumenting was originally in.  */
659   bsi = bsi_last (cond_bb);
660   for (tsi = head; ! tsi_end_p (tsi); tsi_next (&tsi))
661     bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
662
663   /*  Now build up the body of the cache-miss handling:
664
665      __mf_check();
666      refresh *_l vars.
667
668      This is the body of the conditional.  */
669
670   u = mf_file_function_line_tree (locus == NULL ? UNKNOWN_LOCATION : *locus);
671   /* NB: we pass the overall [base..limit] range to mf_check.  */
672   v = fold_build2 (PLUS_EXPR, integer_type_node,
673                    fold_build2 (MINUS_EXPR, mf_uintptr_type, mf_limit, mf_base),
674                    integer_one_node);
675   t = build_call_expr (mf_check_fndecl, 4, mf_base, v, dirflag, u);
676   gimplify_to_stmt_list (&t);
677   head = tsi_start (t);
678   tsi = tsi_last (t);
679
680   if (! flag_mudflap_threads)
681     {
682       t = build_gimple_modify_stmt (mf_cache_shift_decl_l,
683                                     mf_cache_shift_decl);
684       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
685
686       t = build_gimple_modify_stmt (mf_cache_mask_decl_l,
687                                     mf_cache_mask_decl);
688       tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
689     }
690
691   /* Insert the check code in the THEN block.  */
692   bsi = bsi_start (then_bb);
693   for (tsi = head; ! tsi_end_p (tsi); tsi_next (&tsi))
694     bsi_insert_after (&bsi, tsi_stmt (tsi), BSI_CONTINUE_LINKING);
695
696   *instr_bsi = bsi_start (join_bb);
697 }
698
699
700 /* Check whether the given decl, generally a VAR_DECL or PARM_DECL, is
701    eligible for instrumentation.  For the mudflap1 pass, this implies
702    that it should be registered with the libmudflap runtime.  For the
703    mudflap2 pass this means instrumenting an indirection operation with
704    respect to the object.
705 */
706 static int
707 mf_decl_eligible_p (tree decl)
708 {
709   return ((TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
710           /* The decl must have its address taken.  In the case of
711              arrays, this flag is also set if the indexes are not
712              compile-time known valid constants.  */
713           /* XXX: not sufficient: return-by-value structs! */
714           && TREE_ADDRESSABLE (decl)
715           /* The type of the variable must be complete.  */
716           && COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (decl))
717           /* The decl hasn't been decomposed somehow.  */
718           && !DECL_HAS_VALUE_EXPR_P (decl));
719 }
720
721
722 static void
723 mf_xform_derefs_1 (block_stmt_iterator *iter, tree *tp,
724                    location_t *locus, tree dirflag)
725 {
726   tree type, base, limit, addr, size, t;
727
728   /* Don't instrument read operations.  */
729   if (dirflag == integer_zero_node && flag_mudflap_ignore_reads)
730     return;
731
732   /* Don't instrument marked nodes.  */
733   if (mf_marked_p (*tp))
734     return;
735
736   t = *tp;
737   type = TREE_TYPE (t);
738
739   if (type == error_mark_node)
740     return;
741
742   size = TYPE_SIZE_UNIT (type);
743
744   switch (TREE_CODE (t))
745     {
746     case ARRAY_REF:
747     case COMPONENT_REF:
748       {
749         /* This is trickier than it may first appear.  The reason is
750            that we are looking at expressions from the "inside out" at
751            this point.  We may have a complex nested aggregate/array
752            expression (e.g. "a.b[i].c"), maybe with an indirection as
753            the leftmost operator ("p->a.b.d"), where instrumentation
754            is necessary.  Or we may have an innocent "a.b.c"
755            expression that must not be instrumented.  We need to
756            recurse all the way down the nesting structure to figure it
757            out: looking just at the outer node is not enough.  */          
758         tree var;
759         int component_ref_only = (TREE_CODE (t) == COMPONENT_REF);
760         /* If we have a bitfield component reference, we must note the
761            innermost addressable object in ELT, from which we will
762            construct the byte-addressable bounds of the bitfield.  */
763         tree elt = NULL_TREE;
764         int bitfield_ref_p = (TREE_CODE (t) == COMPONENT_REF
765                               && DECL_BIT_FIELD_TYPE (TREE_OPERAND (t, 1)));
766
767         /* Iterate to the top of the ARRAY_REF/COMPONENT_REF
768            containment hierarchy to find the outermost VAR_DECL.  */
769         var = TREE_OPERAND (t, 0);
770         while (1)
771           {
772             if (bitfield_ref_p && elt == NULL_TREE
773                 && (TREE_CODE (var) == ARRAY_REF
774                     || TREE_CODE (var) == COMPONENT_REF))
775               elt = var;
776         
777             if (TREE_CODE (var) == ARRAY_REF)
778               {
779                 component_ref_only = 0;
780                 var = TREE_OPERAND (var, 0);
781               }
782             else if (TREE_CODE (var) == COMPONENT_REF)
783               var = TREE_OPERAND (var, 0);
784             else if (INDIRECT_REF_P (var))
785               {
786                 base = TREE_OPERAND (var, 0);
787                 break;
788               }
789             else 
790               {
791                 gcc_assert (TREE_CODE (var) == VAR_DECL 
792                             || TREE_CODE (var) == PARM_DECL
793                             || TREE_CODE (var) == RESULT_DECL
794                             || TREE_CODE (var) == STRING_CST);
795                 /* Don't instrument this access if the underlying
796                    variable is not "eligible".  This test matches
797                    those arrays that have only known-valid indexes,
798                    and thus are not labeled TREE_ADDRESSABLE.  */
799                 if (! mf_decl_eligible_p (var) || component_ref_only)
800                   return;
801                 else
802                   {
803                     base = build1 (ADDR_EXPR,
804                                    build_pointer_type (TREE_TYPE (var)), var);
805                     break;
806                   }
807               }
808           }
809
810         /* Handle the case of ordinary non-indirection structure
811            accesses.  These have only nested COMPONENT_REF nodes (no
812            INDIRECT_REF), but pass through the above filter loop.
813            Note that it's possible for such a struct variable to match
814            the eligible_p test because someone else might take its
815            address sometime.  */
816
817         /* We need special processing for bitfield components, because
818            their addresses cannot be taken.  */
819         if (bitfield_ref_p)
820           {
821             tree field = TREE_OPERAND (t, 1);
822
823             if (TREE_CODE (DECL_SIZE_UNIT (field)) == INTEGER_CST)
824               size = DECL_SIZE_UNIT (field);
825             
826             if (elt)
827               elt = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (elt)),
828                             elt);
829             addr = fold_convert (ptr_type_node, elt ? elt : base);
830             addr = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
831                                 addr, fold_convert (sizetype,
832                                                     byte_position (field)));
833           }
834         else
835           addr = build1 (ADDR_EXPR, build_pointer_type (type), t);
836
837         limit = fold_build2 (MINUS_EXPR, mf_uintptr_type,
838                              fold_build2 (PLUS_EXPR, mf_uintptr_type,
839                                           convert (mf_uintptr_type, addr),
840                                           size),
841                              integer_one_node);
842       }
843       break;
844
845     case INDIRECT_REF:
846       addr = TREE_OPERAND (t, 0);
847       base = addr;
848       limit = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
849                            fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, base,
850                                         size),
851                            size_int (-1));
852       break;
853
854     case TARGET_MEM_REF:
855       addr = tree_mem_ref_addr (ptr_type_node, t);
856       base = addr;
857       limit = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
858                            fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, base,
859                                         size),
860                            size_int (-1));
861       break;
862
863     case ARRAY_RANGE_REF:
864       warning (0, "mudflap checking not yet implemented for ARRAY_RANGE_REF");
865       return;
866
867     case BIT_FIELD_REF:
868       /* ??? merge with COMPONENT_REF code above? */
869       {
870         tree ofs, rem, bpu;
871
872         /* If we're not dereferencing something, then the access
873            must be ok.  */
874         if (TREE_CODE (TREE_OPERAND (t, 0)) != INDIRECT_REF)
875           return;
876
877         bpu = bitsize_int (BITS_PER_UNIT);
878         ofs = convert (bitsizetype, TREE_OPERAND (t, 2));
879         rem = size_binop (TRUNC_MOD_EXPR, ofs, bpu);
880         ofs = fold_convert (sizetype, size_binop (TRUNC_DIV_EXPR, ofs, bpu));
881
882         size = convert (bitsizetype, TREE_OPERAND (t, 1));
883         size = size_binop (PLUS_EXPR, size, rem);
884         size = size_binop (CEIL_DIV_EXPR, size, bpu);
885         size = convert (sizetype, size);
886
887         addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
888         addr = convert (ptr_type_node, addr);
889         addr = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, addr, ofs);
890
891         base = addr;
892         limit = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
893                              fold_build2 (POINTER_PLUS_EXPR, ptr_type_node,
894                                            base, size),
895                              size_int (-1));
896       }
897       break;
898
899     default:
900       return;
901     }
902
903   mf_build_check_statement_for (base, limit, iter, locus, dirflag);
904 }
905
906 static void
907 mf_xform_derefs (void)
908 {
909   basic_block bb, next;
910   block_stmt_iterator i;
911   int saved_last_basic_block = last_basic_block;
912
913   bb = ENTRY_BLOCK_PTR ->next_bb;
914   do
915     {
916       next = bb->next_bb;
917       for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
918         {
919           tree s = bsi_stmt (i);
920
921           /* Only a few GIMPLE statements can reference memory.  */
922           switch (TREE_CODE (s))
923             {
924             case GIMPLE_MODIFY_STMT:
925               mf_xform_derefs_1 (&i, &GIMPLE_STMT_OPERAND (s, 0),
926                                  EXPR_LOCUS (s), integer_one_node);
927               mf_xform_derefs_1 (&i, &GIMPLE_STMT_OPERAND (s, 1),
928                                  EXPR_LOCUS (s), integer_zero_node);
929               break;
930
931             case RETURN_EXPR:
932               if (TREE_OPERAND (s, 0) != NULL_TREE)
933                 {
934                   if (TREE_CODE (TREE_OPERAND (s, 0)) == GIMPLE_MODIFY_STMT)
935                     mf_xform_derefs_1 (&i, &GIMPLE_STMT_OPERAND
936                                              (TREE_OPERAND (s, 0), 1),
937                                        EXPR_LOCUS (s), integer_zero_node);
938                   else
939                     mf_xform_derefs_1 (&i, &TREE_OPERAND (s, 0), EXPR_LOCUS (s),
940                                        integer_zero_node);
941                 }
942               break;
943
944             default:
945               ;
946             }
947         }
948       bb = next;
949     }
950   while (bb && bb->index <= saved_last_basic_block);
951 }
952
953 /* ------------------------------------------------------------------------ */
954 /* ADDR_EXPR transforms.  Perform the declaration-related mudflap tree
955    transforms on the current function.
956
957    This is the first part of the mudflap instrumentation.  It works on
958    high-level GIMPLE because after lowering, all variables are moved out
959    of their BIND_EXPR binding context, and we lose liveness information
960    for the declarations we wish to instrument.  */
961
962 static unsigned int
963 execute_mudflap_function_decls (void)
964 {
965   /* Don't instrument functions such as the synthetic constructor
966      built during mudflap_finish_file.  */
967   if (mf_marked_p (current_function_decl) ||
968       DECL_ARTIFICIAL (current_function_decl))
969     return 0;
970
971   push_gimplify_context ();
972
973   mf_xform_decls (DECL_SAVED_TREE (current_function_decl),
974                   DECL_ARGUMENTS (current_function_decl));
975
976   pop_gimplify_context (NULL);
977   return 0;
978 }
979
980 /* This struct is passed between mf_xform_decls to store state needed
981    during the traversal searching for objects that have their
982    addresses taken.  */
983 struct mf_xform_decls_data
984 {
985   tree param_decls;
986 };
987
988
989 /* Synthesize a CALL_EXPR and a TRY_FINALLY_EXPR, for this chain of
990    _DECLs if appropriate.  Arrange to call the __mf_register function
991    now, and the __mf_unregister function later for each.  */
992 static void
993 mx_register_decls (tree decl, tree *stmt_list)
994 {
995   tree finally_stmts = NULL_TREE;
996   tree_stmt_iterator initially_stmts = tsi_start (*stmt_list);
997
998   while (decl != NULL_TREE)
999     {
1000       if (mf_decl_eligible_p (decl) 
1001           /* Not already processed.  */
1002           && ! mf_marked_p (decl)
1003           /* Automatic variable.  */
1004           && ! DECL_EXTERNAL (decl)
1005           && ! TREE_STATIC (decl))
1006         {
1007           tree size = NULL_TREE, variable_name;
1008           tree unregister_fncall, unregister_fncall_param;
1009           tree register_fncall, register_fncall_param;
1010
1011           size = convert (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl)));
1012
1013
1014           unregister_fncall_param =
1015             convert (ptr_type_node,
1016                      mf_mark (build1 (ADDR_EXPR,
1017                                       build_pointer_type (TREE_TYPE (decl)),
1018                                       decl)));
1019           /* __mf_unregister (&VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
1020           unregister_fncall = build_call_expr (mf_unregister_fndecl, 3,
1021                                                unregister_fncall_param,
1022                                                size,
1023                                                build_int_cst (NULL_TREE, 3));
1024
1025
1026           variable_name = mf_varname_tree (decl);
1027           register_fncall_param =
1028             convert (ptr_type_node,
1029                      mf_mark (build1 (ADDR_EXPR,
1030                                       build_pointer_type (TREE_TYPE (decl)),
1031                                       decl)));
1032           /* __mf_register (&VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK,
1033                             "name") */
1034           register_fncall = build_call_expr (mf_register_fndecl, 4,
1035                                              register_fncall_param,
1036                                              size,
1037                                              build_int_cst (NULL_TREE, 3),
1038                                              variable_name);
1039
1040
1041           /* Accumulate the two calls.  */
1042           /* ??? Set EXPR_LOCATION.  */
1043           gimplify_stmt (&register_fncall);
1044           gimplify_stmt (&unregister_fncall);
1045
1046           /* Add the __mf_register call at the current appending point.  */
1047           if (tsi_end_p (initially_stmts))
1048             warning (0, "mudflap cannot track %qs in stub function",
1049                      IDENTIFIER_POINTER (DECL_NAME (decl)));
1050           else
1051             {
1052               tsi_link_before (&initially_stmts, register_fncall,
1053                                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,
1140                                     NULL);
1141
1142   slot = htab_find_slot (marked_trees, t, INSERT);
1143   *slot = t;
1144   return t;
1145 }
1146
1147 int
1148 mf_marked_p (tree t)
1149 {
1150   void *entry;
1151
1152   if (marked_trees == NULL)
1153     return 0;
1154
1155   entry = htab_find (marked_trees, t);
1156   return (entry != NULL);
1157 }
1158
1159 /* Remember given node as a static of some kind: global data,
1160    function-scope static, or an anonymous constant.  Its assembler
1161    label is given.  */
1162
1163 /* A list of globals whose incomplete declarations we encountered.
1164    Instead of emitting the __mf_register call for them here, it's
1165    delayed until program finish time.  If they're still incomplete by
1166    then, warnings are emitted.  */
1167
1168 static GTY (()) VEC(tree,gc) *deferred_static_decls;
1169
1170 /* A list of statements for calling __mf_register() at startup time.  */
1171 static GTY (()) tree enqueued_call_stmt_chain;
1172
1173 static void
1174 mudflap_register_call (tree obj, tree object_size, tree varname)
1175 {
1176   tree arg, call_stmt;
1177
1178   arg = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (obj)), obj);
1179   arg = convert (ptr_type_node, arg);
1180
1181   call_stmt = build_call_expr (mf_register_fndecl, 4,
1182                                arg,
1183                                convert (size_type_node, object_size),
1184                                /* __MF_TYPE_STATIC */
1185                                build_int_cst (NULL_TREE, 4), 
1186                                varname);
1187
1188   append_to_statement_list (call_stmt, &enqueued_call_stmt_chain);
1189 }
1190
1191 void
1192 mudflap_enqueue_decl (tree obj)
1193 {
1194   if (mf_marked_p (obj))
1195     return;
1196
1197   /* We don't need to process variable decls that are internally
1198      generated extern.  If we did, we'd end up with warnings for them
1199      during mudflap_finish_file ().  That would confuse the user,
1200      since the text would refer to variables that don't show up in the
1201      user's source code.  */
1202   if (DECL_P (obj) && DECL_EXTERNAL (obj) && DECL_ARTIFICIAL (obj))
1203     return;
1204
1205   VEC_safe_push (tree, gc, deferred_static_decls, obj);
1206 }
1207
1208
1209 void
1210 mudflap_enqueue_constant (tree obj)
1211 {
1212   tree object_size, varname;
1213
1214   if (mf_marked_p (obj))
1215     return;
1216
1217   if (TREE_CODE (obj) == STRING_CST)
1218     object_size = build_int_cst (NULL_TREE, TREE_STRING_LENGTH (obj));
1219   else
1220     object_size = size_in_bytes (TREE_TYPE (obj));
1221
1222   if (TREE_CODE (obj) == STRING_CST)
1223     varname = mf_build_string ("string literal");
1224   else
1225     varname = mf_build_string ("constant");
1226
1227   mudflap_register_call (obj, object_size, varname);
1228 }
1229
1230
1231 /* Emit any file-wide instrumentation.  */
1232 void
1233 mudflap_finish_file (void)
1234 {
1235   tree ctor_statements = NULL_TREE;
1236
1237   /* No need to continue when there were errors.  */
1238   if (errorcount != 0 || sorrycount != 0)
1239     return;
1240
1241   /* Insert a call to __mf_init.  */
1242   {
1243     tree call2_stmt = build_call_expr (mf_init_fndecl, 0);
1244     append_to_statement_list (call2_stmt, &ctor_statements);
1245   }
1246   
1247   /* If appropriate, call __mf_set_options to pass along read-ignore mode.  */
1248   if (flag_mudflap_ignore_reads)
1249     {
1250       tree arg = mf_build_string ("-ignore-reads");
1251       tree call_stmt = build_call_expr (mf_set_options_fndecl, 1, arg);
1252       append_to_statement_list (call_stmt, &ctor_statements);
1253     }
1254
1255   /* Process all enqueued object decls.  */
1256   if (deferred_static_decls)
1257     {
1258       size_t i;
1259       tree obj;
1260       for (i = 0; VEC_iterate (tree, deferred_static_decls, i, obj); i++)
1261         {
1262           gcc_assert (DECL_P (obj));
1263
1264           if (mf_marked_p (obj))
1265             continue;
1266
1267           /* Omit registration for static unaddressed objects.  NB:
1268              Perform registration for non-static objects regardless of
1269              TREE_USED or TREE_ADDRESSABLE, because they may be used
1270              from other compilation units.  */
1271           if (! TREE_PUBLIC (obj) && ! TREE_ADDRESSABLE (obj))
1272             continue;
1273
1274           if (! COMPLETE_TYPE_P (TREE_TYPE (obj)))
1275             {
1276               warning (0, "mudflap cannot track unknown size extern %qs",
1277                        IDENTIFIER_POINTER (DECL_NAME (obj)));
1278               continue;
1279             }
1280           
1281           mudflap_register_call (obj, 
1282                                  size_in_bytes (TREE_TYPE (obj)),
1283                                  mf_varname_tree (obj));
1284         }
1285
1286       VEC_truncate (tree, deferred_static_decls, 0);
1287     }
1288
1289   /* Append all the enqueued registration calls.  */
1290   if (enqueued_call_stmt_chain)
1291     {
1292       append_to_statement_list (enqueued_call_stmt_chain, &ctor_statements);
1293       enqueued_call_stmt_chain = NULL_TREE;
1294     }
1295
1296   cgraph_build_static_cdtor ('I', ctor_statements, 
1297                              MAX_RESERVED_INIT_PRIORITY-1);
1298 }
1299
1300
1301 static bool
1302 gate_mudflap (void)
1303 {
1304   return flag_mudflap != 0;
1305 }
1306
1307 struct tree_opt_pass pass_mudflap_1 = 
1308 {
1309   "mudflap1",                           /* name */
1310   gate_mudflap,                         /* gate */
1311   execute_mudflap_function_decls,       /* execute */
1312   NULL,                                 /* sub */
1313   NULL,                                 /* next */
1314   0,                                    /* static_pass_number */
1315   0,                                    /* tv_id */
1316   PROP_gimple_any,                      /* properties_required */
1317   0,                                    /* properties_provided */
1318   0,                                    /* properties_destroyed */
1319   0,                                    /* todo_flags_start */
1320   TODO_dump_func,                       /* todo_flags_finish */
1321   0                                     /* letter */
1322 };
1323
1324 struct tree_opt_pass pass_mudflap_2 = 
1325 {
1326   "mudflap2",                           /* name */
1327   gate_mudflap,                         /* gate */
1328   execute_mudflap_function_ops,         /* execute */
1329   NULL,                                 /* sub */
1330   NULL,                                 /* next */
1331   0,                                    /* static_pass_number */
1332   0,                                    /* tv_id */
1333   PROP_gimple_leh,                      /* properties_required */
1334   0,                                    /* properties_provided */
1335   0,                                    /* properties_destroyed */
1336   0,                                    /* todo_flags_start */
1337   TODO_verify_flow | TODO_verify_stmts
1338   | TODO_dump_func,                     /* todo_flags_finish */
1339   0                                     /* letter */
1340 };
1341
1342 #include "gt-tree-mudflap.h"