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