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>
6 This file is part of GCC.
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
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
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
26 #include "coretypes.h"
28 #include "hard-reg-set.h"
32 #include "basic-block.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"
42 #include "diagnostic.h"
44 #include "langhooks.h"
49 /* Internal function decls */
52 static tree
mf_build_string (const char *string
);
53 static tree
mf_varname_tree (tree
);
54 static tree
mf_file_function_line_tree (location_t
);
56 /* Indirection-related instrumentation. */
57 static void mf_decl_cache_locals (void);
58 static void mf_decl_clear_locals (void);
59 static void mf_xform_derefs (void);
60 static unsigned int execute_mudflap_function_ops (void);
62 /* Addressable variables instrumentation. */
63 static void mf_xform_decls (tree
, tree
);
64 static tree
mx_xfn_xform_decls (tree
*, int *, void *);
65 static void mx_register_decls (tree
, tree
*);
66 static unsigned int execute_mudflap_function_decls (void);
69 /* ------------------------------------------------------------------------ */
70 /* Some generally helpful functions for mudflap instrumentation. */
72 /* Build a reference to a literal string. */
74 mf_build_string (const char *string
)
76 size_t len
= strlen (string
);
77 tree result
= mf_mark (build_string (len
+ 1, string
));
79 TREE_TYPE (result
) = build_array_type
80 (char_type_node
, build_index_type (build_int_cst (NULL_TREE
, len
)));
81 TREE_CONSTANT (result
) = 1;
82 TREE_INVARIANT (result
) = 1;
83 TREE_READONLY (result
) = 1;
84 TREE_STATIC (result
) = 1;
86 result
= build1 (ADDR_EXPR
, build_pointer_type (char_type_node
), result
);
88 return mf_mark (result
);
91 /* Create a properly typed STRING_CST node that describes the given
92 declaration. It will be used as an argument for __mf_register().
93 Try to construct a helpful string, including file/function/variable
97 mf_varname_tree (tree decl
)
99 static pretty_printer buf_rec
;
100 static int initialized
= 0;
101 pretty_printer
*buf
= & buf_rec
;
102 const char *buf_contents
;
109 pp_construct (buf
, /* prefix */ NULL
, /* line-width */ 0);
112 pp_clear_output_area (buf
);
114 /* Add FILENAME[:LINENUMBER[:COLUMNNUMBER]]. */
116 expanded_location xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
117 const char *sourcefile
;
118 unsigned sourceline
= xloc
.line
;
119 unsigned sourcecolumn
= 0;
120 #ifdef USE_MAPPED_LOCATION
121 sourcecolumn
= xloc
.column
;
123 sourcefile
= xloc
.file
;
124 if (sourcefile
== NULL
&& current_function_decl
!= NULL_TREE
)
125 sourcefile
= DECL_SOURCE_FILE (current_function_decl
);
126 if (sourcefile
== NULL
)
127 sourcefile
= "<unknown file>";
129 pp_string (buf
, sourcefile
);
133 pp_string (buf
, ":");
134 pp_decimal_int (buf
, sourceline
);
136 if (sourcecolumn
!= 0)
138 pp_string (buf
, ":");
139 pp_decimal_int (buf
, sourcecolumn
);
144 if (current_function_decl
!= NULL_TREE
)
147 pp_string (buf
, " (");
149 const char *funcname
= NULL
;
150 if (DECL_NAME (current_function_decl
))
151 funcname
= lang_hooks
.decl_printable_name (current_function_decl
, 1);
152 if (funcname
== NULL
)
153 funcname
= "anonymous fn";
155 pp_string (buf
, funcname
);
157 pp_string (buf
, ") ");
160 pp_string (buf
, " ");
162 /* Add <variable-declaration>, possibly demangled. */
164 const char *declname
= NULL
;
166 if (DECL_NAME (decl
) != NULL
)
168 if (strcmp ("GNU C++", lang_hooks
.name
) == 0)
170 /* The gcc/cp decl_printable_name hook doesn't do as good a job as
171 the libiberty demangler. */
172 declname
= cplus_demangle (IDENTIFIER_POINTER (DECL_NAME (decl
)),
173 DMGL_AUTO
| DMGL_VERBOSE
);
175 if (declname
== NULL
)
176 declname
= lang_hooks
.decl_printable_name (decl
, 3);
178 if (declname
== NULL
)
179 declname
= "<unnamed variable>";
181 pp_string (buf
, declname
);
184 /* Return the lot as a new STRING_CST. */
185 buf_contents
= pp_base_formatted_text (buf
);
186 result
= mf_build_string (buf_contents
);
187 pp_clear_output_area (buf
);
193 /* And another friend, for producing a simpler message. */
196 mf_file_function_line_tree (location_t location
)
198 expanded_location xloc
= expand_location (location
);
199 const char *file
= NULL
, *colon
, *line
, *op
, *name
, *cp
;
200 char linecolbuf
[30]; /* Enough for two decimal numbers plus a colon. */
204 /* Add FILENAME[:LINENUMBER[:COLUMNNUMBER]]. */
206 if (file
== NULL
&& current_function_decl
!= NULL_TREE
)
207 file
= DECL_SOURCE_FILE (current_function_decl
);
209 file
= "<unknown file>";
213 #ifdef USE_MAPPED_LOCATION
215 sprintf (linecolbuf
, "%d:%d", xloc
.line
, xloc
.column
);
218 sprintf (linecolbuf
, "%d", xloc
.line
);
225 /* Add (FUNCTION). */
226 name
= lang_hooks
.decl_printable_name (current_function_decl
, 1);
235 string
= concat (file
, colon
, line
, op
, name
, cp
, NULL
);
236 result
= mf_build_string (string
);
243 /* global tree nodes */
245 /* Global tree objects for global variables and functions exported by
246 mudflap runtime library. mf_init_extern_trees must be called
247 before using these. */
249 /* uintptr_t (usually "unsigned long") */
250 static GTY (()) tree mf_uintptr_type
;
252 /* struct __mf_cache { uintptr_t low; uintptr_t high; }; */
253 static GTY (()) tree mf_cache_struct_type
;
255 /* struct __mf_cache * const */
256 static GTY (()) tree mf_cache_structptr_type
;
258 /* extern struct __mf_cache __mf_lookup_cache []; */
259 static GTY (()) tree mf_cache_array_decl
;
261 /* extern unsigned char __mf_lc_shift; */
262 static GTY (()) tree mf_cache_shift_decl
;
264 /* extern uintptr_t __mf_lc_mask; */
265 static GTY (()) tree mf_cache_mask_decl
;
267 /* Their function-scope local shadows, used in single-threaded mode only. */
269 /* auto const unsigned char __mf_lc_shift_l; */
270 static GTY (()) tree mf_cache_shift_decl_l
;
272 /* auto const uintptr_t __mf_lc_mask_l; */
273 static GTY (()) tree mf_cache_mask_decl_l
;
275 /* extern void __mf_check (void *ptr, size_t sz, int type, const char *); */
276 static GTY (()) tree mf_check_fndecl
;
278 /* extern void __mf_register (void *ptr, size_t sz, int type, const char *); */
279 static GTY (()) tree mf_register_fndecl
;
281 /* extern void __mf_unregister (void *ptr, size_t sz, int type); */
282 static GTY (()) tree mf_unregister_fndecl
;
284 /* extern void __mf_init (); */
285 static GTY (()) tree mf_init_fndecl
;
287 /* extern int __mf_set_options (const char*); */
288 static GTY (()) tree mf_set_options_fndecl
;
291 /* Helper for mudflap_init: construct a decl with the given category,
292 name, and type, mark it an external reference, and pushdecl it. */
294 mf_make_builtin (enum tree_code category
, const char *name
, tree type
)
296 tree decl
= mf_mark (build_decl (category
, get_identifier (name
), type
));
297 TREE_PUBLIC (decl
) = 1;
298 DECL_EXTERNAL (decl
) = 1;
299 lang_hooks
.decls
.pushdecl (decl
);
303 /* Helper for mudflap_init: construct a tree corresponding to the type
304 struct __mf_cache { uintptr_t low; uintptr_t high; };
305 where uintptr_t is the FIELD_TYPE argument. */
307 mf_make_mf_cache_struct_type (tree field_type
)
309 /* There is, abominably, no language-independent way to construct a
310 RECORD_TYPE. So we have to call the basic type construction
311 primitives by hand. */
312 tree fieldlo
= build_decl (FIELD_DECL
, get_identifier ("low"), field_type
);
313 tree fieldhi
= build_decl (FIELD_DECL
, get_identifier ("high"), field_type
);
315 tree struct_type
= make_node (RECORD_TYPE
);
316 DECL_CONTEXT (fieldlo
) = struct_type
;
317 DECL_CONTEXT (fieldhi
) = struct_type
;
318 TREE_CHAIN (fieldlo
) = fieldhi
;
319 TYPE_FIELDS (struct_type
) = fieldlo
;
320 TYPE_NAME (struct_type
) = get_identifier ("__mf_cache");
321 layout_type (struct_type
);
326 #define build_function_type_0(rtype) \
327 build_function_type (rtype, void_list_node)
328 #define build_function_type_1(rtype, arg1) \
329 build_function_type (rtype, tree_cons (0, arg1, void_list_node))
330 #define build_function_type_3(rtype, arg1, arg2, arg3) \
331 build_function_type (rtype, tree_cons (0, arg1, tree_cons (0, arg2, \
332 tree_cons (0, arg3, void_list_node))))
333 #define build_function_type_4(rtype, arg1, arg2, arg3, arg4) \
334 build_function_type (rtype, tree_cons (0, arg1, tree_cons (0, arg2, \
335 tree_cons (0, arg3, tree_cons (0, arg4, \
338 /* Initialize the global tree nodes that correspond to mf-runtime.h
343 static bool done
= false;
344 tree mf_const_string_type
;
345 tree mf_cache_array_type
;
346 tree mf_check_register_fntype
;
347 tree mf_unregister_fntype
;
349 tree mf_set_options_fntype
;
355 mf_uintptr_type
= lang_hooks
.types
.type_for_mode (ptr_mode
,
358 = build_pointer_type (build_qualified_type
359 (char_type_node
, TYPE_QUAL_CONST
));
361 mf_cache_struct_type
= mf_make_mf_cache_struct_type (mf_uintptr_type
);
362 mf_cache_structptr_type
= build_pointer_type (mf_cache_struct_type
);
363 mf_cache_array_type
= build_array_type (mf_cache_struct_type
, 0);
364 mf_check_register_fntype
=
365 build_function_type_4 (void_type_node
, ptr_type_node
, size_type_node
,
366 integer_type_node
, mf_const_string_type
);
367 mf_unregister_fntype
=
368 build_function_type_3 (void_type_node
, ptr_type_node
, size_type_node
,
371 build_function_type_0 (void_type_node
);
372 mf_set_options_fntype
=
373 build_function_type_1 (integer_type_node
, mf_const_string_type
);
375 mf_cache_array_decl
= mf_make_builtin (VAR_DECL
, "__mf_lookup_cache",
376 mf_cache_array_type
);
377 mf_cache_shift_decl
= mf_make_builtin (VAR_DECL
, "__mf_lc_shift",
378 unsigned_char_type_node
);
379 mf_cache_mask_decl
= mf_make_builtin (VAR_DECL
, "__mf_lc_mask",
381 /* Don't process these in mudflap_enqueue_decl, should they come by
382 there for some reason. */
383 mf_mark (mf_cache_array_decl
);
384 mf_mark (mf_cache_shift_decl
);
385 mf_mark (mf_cache_mask_decl
);
386 mf_check_fndecl
= mf_make_builtin (FUNCTION_DECL
, "__mf_check",
387 mf_check_register_fntype
);
388 mf_register_fndecl
= mf_make_builtin (FUNCTION_DECL
, "__mf_register",
389 mf_check_register_fntype
);
390 mf_unregister_fndecl
= mf_make_builtin (FUNCTION_DECL
, "__mf_unregister",
391 mf_unregister_fntype
);
392 mf_init_fndecl
= mf_make_builtin (FUNCTION_DECL
, "__mf_init",
394 mf_set_options_fndecl
= mf_make_builtin (FUNCTION_DECL
, "__mf_set_options",
395 mf_set_options_fntype
);
397 #undef build_function_type_4
398 #undef build_function_type_3
399 #undef build_function_type_1
400 #undef build_function_type_0
403 /* ------------------------------------------------------------------------ */
404 /* Memory reference transforms. Perform the mudflap indirection-related
405 tree transforms on the current function.
407 This is the second part of the mudflap instrumentation. It works on
408 low-level GIMPLE using the CFG, because we want to run this pass after
409 tree optimizations have been performed, but we have to preserve the CFG
410 for expansion from trees to RTL. */
413 execute_mudflap_function_ops (void)
415 /* Don't instrument functions such as the synthetic constructor
416 built during mudflap_finish_file. */
417 if (mf_marked_p (current_function_decl
) ||
418 DECL_ARTIFICIAL (current_function_decl
))
421 push_gimplify_context ();
423 /* In multithreaded mode, don't cache the lookup cache parameters. */
424 if (! flag_mudflap_threads
)
425 mf_decl_cache_locals ();
429 if (! flag_mudflap_threads
)
430 mf_decl_clear_locals ();
432 pop_gimplify_context (NULL
);
436 /* Create and initialize local shadow variables for the lookup cache
437 globals. Put their decls in the *_l globals for use by
438 mf_build_check_statement_for. */
441 mf_decl_cache_locals (void)
443 tree t
, shift_init_stmts
, mask_init_stmts
;
444 tree_stmt_iterator tsi
;
446 /* Build the cache vars. */
447 mf_cache_shift_decl_l
448 = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_shift_decl
),
449 "__mf_lookup_shift_l"));
452 = mf_mark (create_tmp_var (TREE_TYPE (mf_cache_mask_decl
),
453 "__mf_lookup_mask_l"));
455 /* Build initialization nodes for the cache vars. We just load the
456 globals into the cache variables. */
457 t
= build2 (MODIFY_EXPR
, TREE_TYPE (mf_cache_shift_decl_l
),
458 mf_cache_shift_decl_l
, mf_cache_shift_decl
);
459 SET_EXPR_LOCATION (t
, DECL_SOURCE_LOCATION (current_function_decl
));
460 gimplify_to_stmt_list (&t
);
461 shift_init_stmts
= t
;
463 t
= build2 (MODIFY_EXPR
, TREE_TYPE (mf_cache_mask_decl_l
),
464 mf_cache_mask_decl_l
, mf_cache_mask_decl
);
465 SET_EXPR_LOCATION (t
, DECL_SOURCE_LOCATION (current_function_decl
));
466 gimplify_to_stmt_list (&t
);
469 /* Anticipating multiple entry points, we insert the cache vars
470 initializers in each successor of the ENTRY_BLOCK_PTR. */
471 for (tsi
= tsi_start (shift_init_stmts
);
474 insert_edge_copies (tsi_stmt (tsi
), ENTRY_BLOCK_PTR
);
476 for (tsi
= tsi_start (mask_init_stmts
);
479 insert_edge_copies (tsi_stmt (tsi
), ENTRY_BLOCK_PTR
);
480 bsi_commit_edge_inserts ();
485 mf_decl_clear_locals (void)
487 /* Unset local shadows. */
488 mf_cache_shift_decl_l
= NULL_TREE
;
489 mf_cache_mask_decl_l
= NULL_TREE
;
493 mf_build_check_statement_for (tree base
, tree limit
,
494 block_stmt_iterator
*instr_bsi
,
495 location_t
*locus
, tree dirflag
)
497 tree_stmt_iterator head
, tsi
;
498 block_stmt_iterator bsi
;
499 basic_block cond_bb
, then_bb
, join_bb
;
506 /* We first need to split the current basic block, and start altering
507 the CFG. This allows us to insert the statements we're about to
508 construct into the right basic blocks. */
510 cond_bb
= bb_for_stmt (bsi_stmt (*instr_bsi
));
513 if (! bsi_end_p (bsi
))
514 e
= split_block (cond_bb
, bsi_stmt (bsi
));
516 e
= split_block_after_labels (cond_bb
);
520 /* A recap at this point: join_bb is the basic block at whose head
521 is the gimple statement for which this check expression is being
522 built. cond_bb is the (possibly new, synthetic) basic block the
523 end of which will contain the cache-lookup code, and a
524 conditional that jumps to the cache-miss code or, much more
525 likely, over to join_bb. */
527 /* Create the bb that contains the cache-miss fallback block (mf_check). */
528 then_bb
= create_empty_bb (cond_bb
);
529 make_edge (cond_bb
, then_bb
, EDGE_TRUE_VALUE
);
530 make_single_succ_edge (then_bb
, join_bb
, EDGE_FALLTHRU
);
532 /* Mark the pseudo-fallthrough edge from cond_bb to join_bb. */
533 e
= find_edge (cond_bb
, join_bb
);
534 e
->flags
= EDGE_FALSE_VALUE
;
535 e
->count
= cond_bb
->count
;
536 e
->probability
= REG_BR_PROB_BASE
;
538 /* Update dominance info. Note that bb_join's data was
539 updated by split_block. */
540 if (dom_info_available_p (CDI_DOMINATORS
))
542 set_immediate_dominator (CDI_DOMINATORS
, then_bb
, cond_bb
);
543 set_immediate_dominator (CDI_DOMINATORS
, join_bb
, cond_bb
);
546 /* Build our local variables. */
547 mf_elem
= create_tmp_var (mf_cache_structptr_type
, "__mf_elem");
548 mf_base
= create_tmp_var (mf_uintptr_type
, "__mf_base");
549 mf_limit
= create_tmp_var (mf_uintptr_type
, "__mf_limit");
551 /* Build: __mf_base = (uintptr_t) <base address expression>. */
552 t
= build2 (MODIFY_EXPR
, void_type_node
, mf_base
,
553 convert (mf_uintptr_type
, unshare_expr (base
)));
554 SET_EXPR_LOCUS (t
, locus
);
555 gimplify_to_stmt_list (&t
);
556 head
= tsi_start (t
);
559 /* Build: __mf_limit = (uintptr_t) <limit address expression>. */
560 t
= build2 (MODIFY_EXPR
, void_type_node
, mf_limit
,
561 convert (mf_uintptr_type
, unshare_expr (limit
)));
562 SET_EXPR_LOCUS (t
, locus
);
563 gimplify_to_stmt_list (&t
);
564 tsi_link_after (&tsi
, t
, TSI_CONTINUE_LINKING
);
566 /* Build: __mf_elem = &__mf_lookup_cache [(__mf_base >> __mf_shift)
568 t
= build2 (RSHIFT_EXPR
, mf_uintptr_type
, mf_base
,
569 (flag_mudflap_threads
? mf_cache_shift_decl
: mf_cache_shift_decl_l
));
570 t
= build2 (BIT_AND_EXPR
, mf_uintptr_type
, t
,
571 (flag_mudflap_threads
? mf_cache_mask_decl
: mf_cache_mask_decl_l
));
572 t
= build4 (ARRAY_REF
,
573 TREE_TYPE (TREE_TYPE (mf_cache_array_decl
)),
574 mf_cache_array_decl
, t
, NULL_TREE
, NULL_TREE
);
575 t
= build1 (ADDR_EXPR
, mf_cache_structptr_type
, t
);
576 t
= build2 (MODIFY_EXPR
, void_type_node
, mf_elem
, t
);
577 SET_EXPR_LOCUS (t
, locus
);
578 gimplify_to_stmt_list (&t
);
579 tsi_link_after (&tsi
, t
, TSI_CONTINUE_LINKING
);
581 /* Quick validity check.
583 if (__mf_elem->low > __mf_base
584 || (__mf_elem_high < __mf_limit))
587 ... and only if single-threaded:
588 __mf_lookup_shift_1 = f...;
589 __mf_lookup_mask_l = ...;
592 It is expected that this body of code is rarely executed so we mark
593 the edge to the THEN clause of the conditional jump as unlikely. */
595 /* Construct t <-- '__mf_elem->low > __mf_base'. */
596 t
= build3 (COMPONENT_REF
, mf_uintptr_type
,
597 build1 (INDIRECT_REF
, mf_cache_struct_type
, mf_elem
),
598 TYPE_FIELDS (mf_cache_struct_type
), NULL_TREE
);
599 t
= build2 (GT_EXPR
, boolean_type_node
, t
, mf_base
);
601 /* Construct '__mf_elem->high < __mf_limit'.
604 1) u <-- '__mf_elem->high'
605 2) v <-- '__mf_limit'.
607 Then build 'u <-- (u < v). */
609 u
= build3 (COMPONENT_REF
, mf_uintptr_type
,
610 build1 (INDIRECT_REF
, mf_cache_struct_type
, mf_elem
),
611 TREE_CHAIN (TYPE_FIELDS (mf_cache_struct_type
)), NULL_TREE
);
615 u
= build2 (LT_EXPR
, boolean_type_node
, u
, v
);
617 /* Build the composed conditional: t <-- 't || u'. Then store the
618 result of the evaluation of 't' in a temporary variable which we
619 can use as the condition for the conditional jump. */
620 t
= build2 (TRUTH_OR_EXPR
, boolean_type_node
, t
, u
);
621 cond
= create_tmp_var (boolean_type_node
, "__mf_unlikely_cond");
622 t
= build2 (MODIFY_EXPR
, boolean_type_node
, cond
, t
);
623 gimplify_to_stmt_list (&t
);
624 tsi_link_after (&tsi
, t
, TSI_CONTINUE_LINKING
);
626 /* Build the conditional jump. 'cond' is just a temporary so we can
627 simply build a void COND_EXPR. We do need labels in both arms though. */
628 t
= build3 (COND_EXPR
, void_type_node
, cond
,
629 build1 (GOTO_EXPR
, void_type_node
, tree_block_label (then_bb
)),
630 build1 (GOTO_EXPR
, void_type_node
, tree_block_label (join_bb
)));
631 SET_EXPR_LOCUS (t
, locus
);
632 tsi_link_after (&tsi
, t
, TSI_CONTINUE_LINKING
);
634 /* At this point, after so much hard work, we have only constructed
635 the conditional jump,
637 if (__mf_elem->low > __mf_base
638 || (__mf_elem_high < __mf_limit))
640 The lowered GIMPLE tree representing this code is in the statement
641 list starting at 'head'.
643 We can insert this now in the current basic block, i.e. the one that
644 the statement we're instrumenting was originally in. */
645 bsi
= bsi_last (cond_bb
);
646 for (tsi
= head
; ! tsi_end_p (tsi
); tsi_next (&tsi
))
647 bsi_insert_after (&bsi
, tsi_stmt (tsi
), BSI_CONTINUE_LINKING
);
649 /* Now build up the body of the cache-miss handling:
654 This is the body of the conditional. */
656 u
= tree_cons (NULL_TREE
,
657 mf_file_function_line_tree (locus
== NULL
? UNKNOWN_LOCATION
660 u
= tree_cons (NULL_TREE
, dirflag
, u
);
661 /* NB: we pass the overall [base..limit] range to mf_check. */
662 u
= tree_cons (NULL_TREE
,
663 fold_build2 (PLUS_EXPR
, integer_type_node
,
664 fold_build2 (MINUS_EXPR
, mf_uintptr_type
, mf_limit
, mf_base
),
667 u
= tree_cons (NULL_TREE
, mf_base
, u
);
668 t
= build_function_call_expr (mf_check_fndecl
, u
);
669 gimplify_to_stmt_list (&t
);
670 head
= tsi_start (t
);
673 if (! flag_mudflap_threads
)
675 t
= build2 (MODIFY_EXPR
, void_type_node
,
676 mf_cache_shift_decl_l
, mf_cache_shift_decl
);
677 tsi_link_after (&tsi
, t
, TSI_CONTINUE_LINKING
);
679 t
= build2 (MODIFY_EXPR
, void_type_node
,
680 mf_cache_mask_decl_l
, mf_cache_mask_decl
);
681 tsi_link_after (&tsi
, t
, TSI_CONTINUE_LINKING
);
684 /* Insert the check code in the THEN block. */
685 bsi
= bsi_start (then_bb
);
686 for (tsi
= head
; ! tsi_end_p (tsi
); tsi_next (&tsi
))
687 bsi_insert_after (&bsi
, tsi_stmt (tsi
), BSI_CONTINUE_LINKING
);
689 *instr_bsi
= bsi_start (join_bb
);
690 bsi_next (instr_bsi
);
694 /* Check whether the given decl, generally a VAR_DECL or PARM_DECL, is
695 eligible for instrumentation. For the mudflap1 pass, this implies
696 that it should be registered with the libmudflap runtime. For the
697 mudflap2 pass this means instrumenting an indirection operation with
698 respect to the object.
701 mf_decl_eligible_p (tree decl
)
703 return ((TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
)
704 /* The decl must have its address taken. In the case of
705 arrays, this flag is also set if the indexes are not
706 compile-time known valid constants. */
707 && TREE_ADDRESSABLE (decl
) /* XXX: not sufficient: return-by-value structs! */
708 /* The type of the variable must be complete. */
709 && COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (decl
))
710 /* The decl hasn't been decomposed somehow. */
711 && !DECL_HAS_VALUE_EXPR_P (decl
));
716 mf_xform_derefs_1 (block_stmt_iterator
*iter
, tree
*tp
,
717 location_t
*locus
, tree dirflag
)
719 tree type
, base
, limit
, addr
, size
, t
;
721 /* Don't instrument read operations. */
722 if (dirflag
== integer_zero_node
&& flag_mudflap_ignore_reads
)
725 /* Don't instrument marked nodes. */
726 if (mf_marked_p (*tp
))
730 type
= TREE_TYPE (t
);
732 if (type
== error_mark_node
)
735 size
= TYPE_SIZE_UNIT (type
);
737 switch (TREE_CODE (t
))
742 /* This is trickier than it may first appear. The reason is
743 that we are looking at expressions from the "inside out" at
744 this point. We may have a complex nested aggregate/array
745 expression (e.g. "a.b[i].c"), maybe with an indirection as
746 the leftmost operator ("p->a.b.d"), where instrumentation
747 is necessary. Or we may have an innocent "a.b.c"
748 expression that must not be instrumented. We need to
749 recurse all the way down the nesting structure to figure it
750 out: looking just at the outer node is not enough. */
752 int component_ref_only
= (TREE_CODE (t
) == COMPONENT_REF
);
753 /* If we have a bitfield component reference, we must note the
754 innermost addressable object in ELT, from which we will
755 construct the byte-addressable bounds of the bitfield. */
756 tree elt
= NULL_TREE
;
757 int bitfield_ref_p
= (TREE_CODE (t
) == COMPONENT_REF
758 && DECL_BIT_FIELD_TYPE (TREE_OPERAND (t
, 1)));
760 /* Iterate to the top of the ARRAY_REF/COMPONENT_REF
761 containment hierarchy to find the outermost VAR_DECL. */
762 var
= TREE_OPERAND (t
, 0);
765 if (bitfield_ref_p
&& elt
== NULL_TREE
766 && (TREE_CODE (var
) == ARRAY_REF
|| TREE_CODE (var
) == COMPONENT_REF
))
769 if (TREE_CODE (var
) == ARRAY_REF
)
771 component_ref_only
= 0;
772 var
= TREE_OPERAND (var
, 0);
774 else if (TREE_CODE (var
) == COMPONENT_REF
)
775 var
= TREE_OPERAND (var
, 0);
776 else if (INDIRECT_REF_P (var
))
778 base
= TREE_OPERAND (var
, 0);
783 gcc_assert (TREE_CODE (var
) == VAR_DECL
784 || TREE_CODE (var
) == PARM_DECL
785 || TREE_CODE (var
) == RESULT_DECL
786 || TREE_CODE (var
) == STRING_CST
);
787 /* Don't instrument this access if the underlying
788 variable is not "eligible". This test matches
789 those arrays that have only known-valid indexes,
790 and thus are not labeled TREE_ADDRESSABLE. */
791 if (! mf_decl_eligible_p (var
) || component_ref_only
)
795 base
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (var
)), var
);
801 /* Handle the case of ordinary non-indirection structure
802 accesses. These have only nested COMPONENT_REF nodes (no
803 INDIRECT_REF), but pass through the above filter loop.
804 Note that it's possible for such a struct variable to match
805 the eligible_p test because someone else might take its
808 /* We need special processing for bitfield components, because
809 their addresses cannot be taken. */
812 tree field
= TREE_OPERAND (t
, 1);
814 if (TREE_CODE (DECL_SIZE_UNIT (field
)) == INTEGER_CST
)
815 size
= DECL_SIZE_UNIT (field
);
818 elt
= build1 (ADDR_EXPR
, build_pointer_type
TREE_TYPE (elt
), elt
);
819 addr
= fold_convert (ptr_type_node
, elt
? elt
: base
);
820 addr
= fold_build2 (PLUS_EXPR
, ptr_type_node
,
821 addr
, fold_convert (ptr_type_node
,
822 byte_position (field
)));
825 addr
= build1 (ADDR_EXPR
, build_pointer_type (type
), t
);
827 limit
= fold_build2 (MINUS_EXPR
, mf_uintptr_type
,
828 fold_build2 (PLUS_EXPR
, mf_uintptr_type
,
829 convert (mf_uintptr_type
, addr
),
836 addr
= TREE_OPERAND (t
, 0);
838 limit
= fold_build2 (MINUS_EXPR
, ptr_type_node
,
839 fold_build2 (PLUS_EXPR
, ptr_type_node
, base
, size
),
844 addr
= tree_mem_ref_addr (ptr_type_node
, t
);
846 limit
= fold_build2 (MINUS_EXPR
, ptr_type_node
,
847 fold_build2 (PLUS_EXPR
, ptr_type_node
, base
, size
),
848 build_int_cst (ptr_type_node
, 1));
851 case ARRAY_RANGE_REF
:
852 warning (0, "mudflap checking not yet implemented for ARRAY_RANGE_REF");
856 /* ??? merge with COMPONENT_REF code above? */
860 /* If we're not dereferencing something, then the access
862 if (TREE_CODE (TREE_OPERAND (t
, 0)) != INDIRECT_REF
)
865 bpu
= bitsize_int (BITS_PER_UNIT
);
866 ofs
= convert (bitsizetype
, TREE_OPERAND (t
, 2));
867 rem
= size_binop (TRUNC_MOD_EXPR
, ofs
, bpu
);
868 ofs
= size_binop (TRUNC_DIV_EXPR
, ofs
, bpu
);
870 size
= convert (bitsizetype
, TREE_OPERAND (t
, 1));
871 size
= size_binop (PLUS_EXPR
, size
, rem
);
872 size
= size_binop (CEIL_DIV_EXPR
, size
, bpu
);
873 size
= convert (sizetype
, size
);
875 addr
= TREE_OPERAND (TREE_OPERAND (t
, 0), 0);
876 addr
= convert (ptr_type_node
, addr
);
877 addr
= fold_build2 (PLUS_EXPR
, ptr_type_node
, addr
, ofs
);
880 limit
= fold_build2 (MINUS_EXPR
, ptr_type_node
,
881 fold_build2 (PLUS_EXPR
, ptr_type_node
, base
, size
),
890 mf_build_check_statement_for (base
, limit
, iter
, locus
, dirflag
);
894 mf_xform_derefs (void)
896 basic_block bb
, next
;
897 block_stmt_iterator i
;
898 int saved_last_basic_block
= last_basic_block
;
900 bb
= ENTRY_BLOCK_PTR
->next_bb
;
904 for (i
= bsi_start (bb
); !bsi_end_p (i
); bsi_next (&i
))
906 tree s
= bsi_stmt (i
);
908 /* Only a few GIMPLE statements can reference memory. */
909 switch (TREE_CODE (s
))
912 mf_xform_derefs_1 (&i
, &TREE_OPERAND (s
, 0), EXPR_LOCUS (s
),
914 mf_xform_derefs_1 (&i
, &TREE_OPERAND (s
, 1), EXPR_LOCUS (s
),
919 if (TREE_OPERAND (s
, 0) != NULL_TREE
)
921 if (TREE_CODE (TREE_OPERAND (s
, 0)) == MODIFY_EXPR
)
922 mf_xform_derefs_1 (&i
, &TREE_OPERAND (TREE_OPERAND (s
, 0), 1),
923 EXPR_LOCUS (s
), integer_zero_node
);
925 mf_xform_derefs_1 (&i
, &TREE_OPERAND (s
, 0), EXPR_LOCUS (s
),
936 while (bb
&& bb
->index
<= saved_last_basic_block
);
939 /* ------------------------------------------------------------------------ */
940 /* ADDR_EXPR transforms. Perform the declaration-related mudflap tree
941 transforms on the current function.
943 This is the first part of the mudflap instrumentation. It works on
944 high-level GIMPLE because after lowering, all variables are moved out
945 of their BIND_EXPR binding context, and we lose liveness information
946 for the declarations we wish to instrument. */
949 execute_mudflap_function_decls (void)
951 /* Don't instrument functions such as the synthetic constructor
952 built during mudflap_finish_file. */
953 if (mf_marked_p (current_function_decl
) ||
954 DECL_ARTIFICIAL (current_function_decl
))
957 push_gimplify_context ();
959 mf_xform_decls (DECL_SAVED_TREE (current_function_decl
),
960 DECL_ARGUMENTS (current_function_decl
));
962 pop_gimplify_context (NULL
);
966 /* This struct is passed between mf_xform_decls to store state needed
967 during the traversal searching for objects that have their
969 struct mf_xform_decls_data
975 /* Synthesize a CALL_EXPR and a TRY_FINALLY_EXPR, for this chain of
976 _DECLs if appropriate. Arrange to call the __mf_register function
977 now, and the __mf_unregister function later for each. */
979 mx_register_decls (tree decl
, tree
*stmt_list
)
981 tree finally_stmts
= NULL_TREE
;
982 tree_stmt_iterator initially_stmts
= tsi_start (*stmt_list
);
984 while (decl
!= NULL_TREE
)
986 if (mf_decl_eligible_p (decl
)
987 /* Not already processed. */
988 && ! mf_marked_p (decl
)
989 /* Automatic variable. */
990 && ! DECL_EXTERNAL (decl
)
991 && ! TREE_STATIC (decl
))
993 tree size
= NULL_TREE
, variable_name
;
994 tree unregister_fncall
, unregister_fncall_params
;
995 tree register_fncall
, register_fncall_params
;
997 size
= convert (size_type_node
, TYPE_SIZE_UNIT (TREE_TYPE (decl
)));
999 /* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
1000 unregister_fncall_params
=
1001 tree_cons (NULL_TREE
,
1002 convert (ptr_type_node
,
1003 mf_mark (build1 (ADDR_EXPR
,
1004 build_pointer_type (TREE_TYPE (decl
)),
1006 tree_cons (NULL_TREE
,
1008 tree_cons (NULL_TREE
,
1009 /* __MF_TYPE_STACK */
1010 build_int_cst (NULL_TREE
, 3),
1012 /* __mf_unregister (...) */
1013 unregister_fncall
= build_function_call_expr (mf_unregister_fndecl
,
1014 unregister_fncall_params
);
1016 /* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK, "name") */
1017 variable_name
= mf_varname_tree (decl
);
1018 register_fncall_params
=
1019 tree_cons (NULL_TREE
,
1020 convert (ptr_type_node
,
1021 mf_mark (build1 (ADDR_EXPR
,
1022 build_pointer_type (TREE_TYPE (decl
)),
1024 tree_cons (NULL_TREE
,
1026 tree_cons (NULL_TREE
,
1027 /* __MF_TYPE_STACK */
1028 build_int_cst (NULL_TREE
, 3),
1029 tree_cons (NULL_TREE
,
1033 /* __mf_register (...) */
1034 register_fncall
= build_function_call_expr (mf_register_fndecl
,
1035 register_fncall_params
);
1037 /* Accumulate the two calls. */
1038 /* ??? Set EXPR_LOCATION. */
1039 gimplify_stmt (®ister_fncall
);
1040 gimplify_stmt (&unregister_fncall
);
1042 /* Add the __mf_register call at the current appending point. */
1043 if (tsi_end_p (initially_stmts
))
1044 warning (0, "mudflap cannot track %qs in stub function",
1045 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1048 tsi_link_before (&initially_stmts
, register_fncall
, TSI_SAME_STMT
);
1050 /* Accumulate the FINALLY piece. */
1051 append_to_statement_list (unregister_fncall
, &finally_stmts
);
1056 decl
= TREE_CHAIN (decl
);
1059 /* Actually, (initially_stmts!=NULL) <=> (finally_stmts!=NULL) */
1060 if (finally_stmts
!= NULL_TREE
)
1062 tree t
= build2 (TRY_FINALLY_EXPR
, void_type_node
,
1063 *stmt_list
, finally_stmts
);
1065 append_to_statement_list (t
, stmt_list
);
1070 /* Process every variable mentioned in BIND_EXPRs. */
1072 mx_xfn_xform_decls (tree
*t
, int *continue_p
, void *data
)
1074 struct mf_xform_decls_data
* d
= (struct mf_xform_decls_data
*) data
;
1076 if (*t
== NULL_TREE
|| *t
== error_mark_node
)
1084 switch (TREE_CODE (*t
))
1088 /* Process function parameters now (but only once). */
1089 mx_register_decls (d
->param_decls
, &BIND_EXPR_BODY (*t
));
1090 d
->param_decls
= NULL_TREE
;
1092 mx_register_decls (BIND_EXPR_VARS (*t
), &BIND_EXPR_BODY (*t
));
1103 /* Perform the object lifetime tracking mudflap transform on the given function
1104 tree. The tree is mutated in place, with possibly copied subtree nodes.
1106 For every auto variable declared, if its address is ever taken
1107 within the function, then supply its lifetime to the mudflap
1108 runtime with the __mf_register and __mf_unregister calls.
1112 mf_xform_decls (tree fnbody
, tree fnparams
)
1114 struct mf_xform_decls_data d
;
1115 d
.param_decls
= fnparams
;
1116 walk_tree_without_duplicates (&fnbody
, mx_xfn_xform_decls
, &d
);
1120 /* ------------------------------------------------------------------------ */
1121 /* Externally visible mudflap functions. */
1124 /* Mark and return the given tree node to prevent further mudflap
1126 static GTY ((param_is (union tree_node
))) htab_t marked_trees
= NULL
;
1133 if (marked_trees
== NULL
)
1134 marked_trees
= htab_create_ggc (31, htab_hash_pointer
, htab_eq_pointer
, NULL
);
1136 slot
= htab_find_slot (marked_trees
, t
, INSERT
);
1142 mf_marked_p (tree t
)
1146 if (marked_trees
== NULL
)
1149 entry
= htab_find (marked_trees
, t
);
1150 return (entry
!= NULL
);
1153 /* Remember given node as a static of some kind: global data,
1154 function-scope static, or an anonymous constant. Its assembler
1157 /* A list of globals whose incomplete declarations we encountered.
1158 Instead of emitting the __mf_register call for them here, it's
1159 delayed until program finish time. If they're still incomplete by
1160 then, warnings are emitted. */
1162 static GTY (()) VEC(tree
,gc
) *deferred_static_decls
;
1164 /* A list of statements for calling __mf_register() at startup time. */
1165 static GTY (()) tree enqueued_call_stmt_chain
;
1168 mudflap_register_call (tree obj
, tree object_size
, tree varname
)
1170 tree arg
, args
, call_stmt
;
1172 args
= tree_cons (NULL_TREE
, varname
, NULL_TREE
);
1174 arg
= build_int_cst (NULL_TREE
, 4); /* __MF_TYPE_STATIC */
1175 args
= tree_cons (NULL_TREE
, arg
, args
);
1177 arg
= convert (size_type_node
, object_size
);
1178 args
= tree_cons (NULL_TREE
, arg
, args
);
1180 arg
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (obj
)), obj
);
1181 arg
= convert (ptr_type_node
, arg
);
1182 args
= tree_cons (NULL_TREE
, arg
, args
);
1184 call_stmt
= build_function_call_expr (mf_register_fndecl
, args
);
1186 append_to_statement_list (call_stmt
, &enqueued_call_stmt_chain
);
1190 mudflap_enqueue_decl (tree obj
)
1192 if (mf_marked_p (obj
))
1195 /* We don't need to process variable decls that are internally
1196 generated extern. If we did, we'd end up with warnings for them
1197 during mudflap_finish_file (). That would confuse the user,
1198 since the text would refer to variables that don't show up in the
1199 user's source code. */
1200 if (DECL_P (obj
) && DECL_EXTERNAL (obj
) && DECL_ARTIFICIAL (obj
))
1203 VEC_safe_push (tree
, gc
, deferred_static_decls
, obj
);
1208 mudflap_enqueue_constant (tree obj
)
1210 tree object_size
, varname
;
1212 if (mf_marked_p (obj
))
1215 if (TREE_CODE (obj
) == STRING_CST
)
1216 object_size
= build_int_cst (NULL_TREE
, TREE_STRING_LENGTH (obj
));
1218 object_size
= size_in_bytes (TREE_TYPE (obj
));
1220 if (TREE_CODE (obj
) == STRING_CST
)
1221 varname
= mf_build_string ("string literal");
1223 varname
= mf_build_string ("constant");
1225 mudflap_register_call (obj
, object_size
, varname
);
1229 /* Emit any file-wide instrumentation. */
1231 mudflap_finish_file (void)
1233 tree ctor_statements
= NULL_TREE
;
1235 /* Insert a call to __mf_init. */
1237 tree call2_stmt
= build_function_call_expr (mf_init_fndecl
, NULL_TREE
);
1238 append_to_statement_list (call2_stmt
, &ctor_statements
);
1241 /* If appropriate, call __mf_set_options to pass along read-ignore mode. */
1242 if (flag_mudflap_ignore_reads
)
1244 tree arg
= tree_cons (NULL_TREE
,
1245 mf_build_string ("-ignore-reads"), NULL_TREE
);
1246 tree call_stmt
= build_function_call_expr (mf_set_options_fndecl
, arg
);
1247 append_to_statement_list (call_stmt
, &ctor_statements
);
1250 /* Process all enqueued object decls. */
1251 if (deferred_static_decls
)
1255 for (i
= 0; VEC_iterate (tree
, deferred_static_decls
, i
, obj
); i
++)
1257 gcc_assert (DECL_P (obj
));
1259 if (TREE_TYPE (obj
) == error_mark_node
)
1262 if (mf_marked_p (obj
))
1265 /* Omit registration for static unaddressed objects. NB:
1266 Perform registration for non-static objects regardless of
1267 TREE_USED or TREE_ADDRESSABLE, because they may be used
1268 from other compilation units. */
1269 if (! TREE_PUBLIC (obj
) && ! TREE_ADDRESSABLE (obj
))
1272 if (! COMPLETE_TYPE_P (TREE_TYPE (obj
)))
1274 warning (0, "mudflap cannot track unknown size extern %qs",
1275 IDENTIFIER_POINTER (DECL_NAME (obj
)));
1279 mudflap_register_call (obj
,
1280 size_in_bytes (TREE_TYPE (obj
)),
1281 mf_varname_tree (obj
));
1284 VEC_truncate (tree
, deferred_static_decls
, 0);
1287 /* Append all the enqueued registration calls. */
1288 if (enqueued_call_stmt_chain
)
1290 append_to_statement_list (enqueued_call_stmt_chain
, &ctor_statements
);
1291 enqueued_call_stmt_chain
= NULL_TREE
;
1294 cgraph_build_static_cdtor ('I', ctor_statements
,
1295 MAX_RESERVED_INIT_PRIORITY
-1);
1302 return flag_mudflap
!= 0;
1305 struct tree_opt_pass pass_mudflap_1
=
1307 "mudflap1", /* name */
1308 gate_mudflap
, /* gate */
1309 execute_mudflap_function_decls
, /* execute */
1312 0, /* static_pass_number */
1314 PROP_gimple_any
, /* properties_required */
1315 0, /* properties_provided */
1316 0, /* properties_destroyed */
1317 0, /* todo_flags_start */
1318 TODO_dump_func
, /* todo_flags_finish */
1322 struct tree_opt_pass pass_mudflap_2
=
1324 "mudflap2", /* name */
1325 gate_mudflap
, /* gate */
1326 execute_mudflap_function_ops
, /* execute */
1329 0, /* static_pass_number */
1331 PROP_gimple_leh
, /* properties_required */
1332 0, /* properties_provided */
1333 0, /* properties_destroyed */
1334 0, /* todo_flags_start */
1335 TODO_verify_flow
| TODO_verify_stmts
1336 | TODO_dump_func
, /* todo_flags_finish */
1340 #include "gt-tree-mudflap.h"