1 /* Read and write coverage files, and associated functionality.
2 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
3 2000, 2001, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
4 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
5 based on some ideas from Dain Samples of UC Berkeley.
6 Further mangling by Bob Manson, Cygnus Support.
7 Further mangled by Nathan Sidwell, CodeSourcery
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
30 #include "coretypes.h"
42 #include "langhooks.h"
44 #include "tree-iterator.h"
51 struct function_list
*next
; /* next function */
52 unsigned ident
; /* function ident */
53 unsigned checksum
; /* function checksum */
54 unsigned n_ctrs
[GCOV_COUNTERS
];/* number of counters. */
57 /* Counts information for a function. */
58 typedef struct counts_entry
67 struct gcov_ctr_summary summary
;
70 struct counts_entry
*chain
;
74 static struct function_list
*functions_head
= 0;
75 static struct function_list
**functions_tail
= &functions_head
;
76 static unsigned no_coverage
= 0;
78 /* Cumulative counter information for whole program. */
79 static unsigned prg_ctr_mask
; /* Mask of counter types generated. */
80 static unsigned prg_n_ctrs
[GCOV_COUNTERS
]; /* Total counters allocated. */
82 /* Counter information for current function. */
83 static unsigned fn_ctr_mask
; /* Mask of counters used. */
84 static unsigned fn_n_ctrs
[GCOV_COUNTERS
]; /* Counters allocated. */
85 static unsigned fn_b_ctrs
[GCOV_COUNTERS
]; /* Allocation base. */
87 /* Name of the output file for coverage output file. */
88 static char *bbg_file_name
;
89 static unsigned bbg_file_opened
;
90 static int bbg_function_announced
;
92 /* Name of the count data file. */
93 static char *da_file_name
;
95 /* Hash table of count data. */
96 static htab_t counts_hash
= NULL
;
98 /* Trees representing the counter table arrays. */
99 static GTY(()) tree tree_ctr_tables
[GCOV_COUNTERS
];
101 /* The names of the counter tables. Not used if we're
102 generating counters at tree level. */
103 static GTY(()) rtx ctr_labels
[GCOV_COUNTERS
];
105 /* The names of merge functions for counters. */
106 static const char *const ctr_merge_functions
[GCOV_COUNTERS
] = GCOV_MERGE_FUNCTIONS
;
107 static const char *const ctr_names
[GCOV_COUNTERS
] = GCOV_COUNTER_NAMES
;
109 /* Forward declarations. */
110 static hashval_t
htab_counts_entry_hash (const void *);
111 static int htab_counts_entry_eq (const void *, const void *);
112 static void htab_counts_entry_del (void *);
113 static void read_counts_file (void);
114 static unsigned compute_checksum (void);
115 static unsigned coverage_checksum_string (unsigned, const char *);
116 static tree
build_fn_info_type (unsigned);
117 static tree
build_fn_info_value (const struct function_list
*, tree
);
118 static tree
build_ctr_info_type (void);
119 static tree
build_ctr_info_value (unsigned, tree
);
120 static tree
build_gcov_info (void);
121 static void create_coverage (void);
123 /* Return the type node for gcov_type. */
128 return lang_hooks
.types
.type_for_size (GCOV_TYPE_SIZE
, false);
131 /* Return the type node for gcov_unsigned_t. */
134 get_gcov_unsigned_t (void)
136 return lang_hooks
.types
.type_for_size (32, true);
140 htab_counts_entry_hash (const void *of
)
142 const counts_entry_t
*entry
= of
;
144 return entry
->ident
* GCOV_COUNTERS
+ entry
->ctr
;
148 htab_counts_entry_eq (const void *of1
, const void *of2
)
150 const counts_entry_t
*entry1
= of1
;
151 const counts_entry_t
*entry2
= of2
;
153 return entry1
->ident
== entry2
->ident
&& entry1
->ctr
== entry2
->ctr
;
157 htab_counts_entry_del (void *of
)
159 counts_entry_t
*entry
= of
;
161 free (entry
->counts
);
165 /* Read in the counts file, if available. */
168 read_counts_file (void)
170 gcov_unsigned_t fn_ident
= 0;
171 gcov_unsigned_t checksum
= -1;
172 counts_entry_t
*summaried
= NULL
;
173 unsigned seen_summary
= 0;
177 if (!gcov_open (da_file_name
, 1))
180 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC
))
182 warning (0, "%qs is not a gcov data file", da_file_name
);
186 else if ((tag
= gcov_read_unsigned ()) != GCOV_VERSION
)
190 GCOV_UNSIGNED2STRING (v
, tag
);
191 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
193 warning (0, "%qs is version %q.*s, expected version %q.*s",
194 da_file_name
, 4, v
, 4, e
);
199 /* Read and discard the stamp. */
200 gcov_read_unsigned ();
202 counts_hash
= htab_create (10,
203 htab_counts_entry_hash
, htab_counts_entry_eq
,
204 htab_counts_entry_del
);
205 while ((tag
= gcov_read_unsigned ()))
207 gcov_unsigned_t length
;
208 gcov_position_t offset
;
210 length
= gcov_read_unsigned ();
211 offset
= gcov_position ();
212 if (tag
== GCOV_TAG_FUNCTION
)
214 fn_ident
= gcov_read_unsigned ();
215 checksum
= gcov_read_unsigned ();
218 /* We have already seen a summary, this means that this
219 new function begins a new set of program runs. We
220 must unlink the summaried chain. */
221 counts_entry_t
*entry
, *chain
;
223 for (entry
= summaried
; entry
; entry
= chain
)
225 chain
= entry
->chain
;
232 else if (tag
== GCOV_TAG_PROGRAM_SUMMARY
)
234 counts_entry_t
*entry
;
235 struct gcov_summary summary
;
237 gcov_read_summary (&summary
);
239 for (entry
= summaried
; entry
; entry
= entry
->chain
)
241 struct gcov_ctr_summary
*csum
= &summary
.ctrs
[entry
->ctr
];
243 entry
->summary
.runs
+= csum
->runs
;
244 entry
->summary
.sum_all
+= csum
->sum_all
;
245 if (entry
->summary
.run_max
< csum
->run_max
)
246 entry
->summary
.run_max
= csum
->run_max
;
247 entry
->summary
.sum_max
+= csum
->sum_max
;
250 else if (GCOV_TAG_IS_COUNTER (tag
) && fn_ident
)
252 counts_entry_t
**slot
, *entry
, elt
;
253 unsigned n_counts
= GCOV_TAG_COUNTER_NUM (length
);
256 elt
.ident
= fn_ident
;
257 elt
.ctr
= GCOV_COUNTER_FOR_TAG (tag
);
259 slot
= (counts_entry_t
**) htab_find_slot
260 (counts_hash
, &elt
, INSERT
);
264 *slot
= entry
= XCNEW (counts_entry_t
);
265 entry
->ident
= elt
.ident
;
266 entry
->ctr
= elt
.ctr
;
267 entry
->checksum
= checksum
;
268 entry
->summary
.num
= n_counts
;
269 entry
->counts
= XCNEWVEC (gcov_type
, n_counts
);
271 else if (entry
->checksum
!= checksum
)
273 error ("coverage mismatch for function %u while reading execution counters",
275 error ("checksum is %x instead of %x", entry
->checksum
, checksum
);
276 htab_delete (counts_hash
);
279 else if (entry
->summary
.num
!= n_counts
)
281 error ("coverage mismatch for function %u while reading execution counters",
283 error ("number of counters is %d instead of %d", entry
->summary
.num
, n_counts
);
284 htab_delete (counts_hash
);
287 else if (elt
.ctr
>= GCOV_COUNTERS_SUMMABLE
)
289 error ("cannot merge separate %s counters for function %u",
290 ctr_names
[elt
.ctr
], fn_ident
);
294 if (elt
.ctr
< GCOV_COUNTERS_SUMMABLE
295 /* This should always be true for a just allocated entry,
296 and always false for an existing one. Check this way, in
297 case the gcov file is corrupt. */
298 && (!entry
->chain
|| summaried
!= entry
))
300 entry
->chain
= summaried
;
303 for (ix
= 0; ix
!= n_counts
; ix
++)
304 entry
->counts
[ix
] += gcov_read_counter ();
307 gcov_sync (offset
, length
);
308 if ((is_error
= gcov_is_error ()))
310 error (is_error
< 0 ? "%qs has overflowed" : "%qs is corrupted",
312 htab_delete (counts_hash
);
320 /* Returns the counters for a particular tag. */
323 get_coverage_counts (unsigned counter
, unsigned expected
,
324 const struct gcov_ctr_summary
**summary
)
326 counts_entry_t
*entry
, elt
;
327 gcov_unsigned_t checksum
= -1;
329 /* No hash table, no counts. */
332 static int warned
= 0;
335 inform ((flag_guess_branch_prob
336 ? "file %s not found, execution counts estimated"
337 : "file %s not found, execution counts assumed to be zero"),
342 elt
.ident
= current_function_funcdef_no
+ 1;
344 entry
= htab_find (counts_hash
, &elt
);
347 warning (0, "no coverage for function %qs found", IDENTIFIER_POINTER
348 (DECL_ASSEMBLER_NAME (current_function_decl
)));
352 checksum
= compute_checksum ();
353 if (entry
->checksum
!= checksum
)
355 error ("coverage mismatch for function %qs while reading counter %qs",
356 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)),
358 error ("checksum is %x instead of %x", entry
->checksum
, checksum
);
361 else if (entry
->summary
.num
!= expected
)
363 error ("coverage mismatch for function %qs while reading counter %qs",
364 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)),
366 error ("number of counters is %d instead of %d", entry
->summary
.num
, expected
);
371 *summary
= &entry
->summary
;
373 return entry
->counts
;
376 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
377 allocation succeeded. */
380 coverage_counter_alloc (unsigned counter
, unsigned num
)
388 if (!tree_ctr_tables
[counter
])
390 /* Generate and save a copy of this so it can be shared. Leave
391 the index type unspecified for now; it will be set after all
392 functions have been compiled. */
394 tree gcov_type_node
= get_gcov_type ();
395 tree gcov_type_array_type
396 = build_array_type (gcov_type_node
, NULL_TREE
);
397 tree_ctr_tables
[counter
]
398 = build_decl (VAR_DECL
, NULL_TREE
, gcov_type_array_type
);
399 TREE_STATIC (tree_ctr_tables
[counter
]) = 1;
400 ASM_GENERATE_INTERNAL_LABEL (buf
, "LPBX", counter
+ 1);
401 DECL_NAME (tree_ctr_tables
[counter
]) = get_identifier (buf
);
402 DECL_ALIGN (tree_ctr_tables
[counter
]) = TYPE_ALIGN (gcov_type_node
);
404 fn_b_ctrs
[counter
] = fn_n_ctrs
[counter
];
405 fn_n_ctrs
[counter
] += num
;
406 fn_ctr_mask
|= 1 << counter
;
410 /* Generate a tree to access COUNTER NO. */
413 tree_coverage_counter_ref (unsigned counter
, unsigned no
)
415 tree gcov_type_node
= get_gcov_type ();
417 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
418 no
+= prg_n_ctrs
[counter
] + fn_b_ctrs
[counter
];
420 /* "no" here is an array index, scaled to bytes later. */
421 return build4 (ARRAY_REF
, gcov_type_node
, tree_ctr_tables
[counter
],
422 build_int_cst (NULL_TREE
, no
), NULL
, NULL
);
425 /* Generate a checksum for a string. CHKSUM is the current
429 coverage_checksum_string (unsigned chksum
, const char *string
)
434 /* Look for everything that looks if it were produced by
435 get_file_function_name_long and zero out the second part
436 that may result from flag_random_seed. This is not critical
437 as the checksums are used only for sanity checking. */
438 for (i
= 0; string
[i
]; i
++)
441 if (!strncmp (string
+ i
, "_GLOBAL__N_", 11))
443 if (!strncmp (string
+ i
, "_GLOBAL__", 9))
446 /* C++ namespaces do have scheme:
447 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
448 since filename might contain extra underscores there seems
449 to be no better chance then walk all possible offsets looking
453 for (i
= i
+ offset
; string
[i
]; i
++)
458 for (y
= 1; y
< 9; y
++)
459 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
460 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
462 if (y
!= 9 || string
[i
+ 9] != '_')
464 for (y
= 10; y
< 18; y
++)
465 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
466 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
471 string
= dup
= xstrdup (string
);
472 for (y
= 10; y
< 18; y
++)
479 chksum
= crc32_string (chksum
, string
);
486 /* Compute checksum for the current function. We generate a CRC32. */
489 compute_checksum (void)
491 expanded_location xloc
492 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
493 unsigned chksum
= xloc
.line
;
495 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
496 chksum
= coverage_checksum_string
497 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)));
502 /* Begin output to the graph file for the current function.
503 Opens the output file, if not already done. Writes the
504 function header, if not already done. Returns nonzero if data
508 coverage_begin_output (void)
513 if (!bbg_function_announced
)
515 expanded_location xloc
516 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
517 unsigned long offset
;
519 if (!bbg_file_opened
)
521 if (!gcov_open (bbg_file_name
, -1))
522 error ("cannot open %s", bbg_file_name
);
525 gcov_write_unsigned (GCOV_NOTE_MAGIC
);
526 gcov_write_unsigned (GCOV_VERSION
);
527 gcov_write_unsigned (local_tick
);
532 /* Announce function */
533 offset
= gcov_write_tag (GCOV_TAG_FUNCTION
);
534 gcov_write_unsigned (current_function_funcdef_no
+ 1);
535 gcov_write_unsigned (compute_checksum ());
536 gcov_write_string (IDENTIFIER_POINTER
537 (DECL_ASSEMBLER_NAME (current_function_decl
)));
538 gcov_write_string (xloc
.file
);
539 gcov_write_unsigned (xloc
.line
);
540 gcov_write_length (offset
);
542 bbg_function_announced
= 1;
544 return !gcov_is_error ();
547 /* Finish coverage data for the current function. Verify no output
548 error has occurred. Save function coverage counts. */
551 coverage_end_function (void)
555 if (bbg_file_opened
> 1 && gcov_is_error ())
557 warning (0, "error writing %qs", bbg_file_name
);
558 bbg_file_opened
= -1;
563 struct function_list
*item
;
565 item
= XNEW (struct function_list
);
567 *functions_tail
= item
;
568 functions_tail
= &item
->next
;
571 item
->ident
= current_function_funcdef_no
+ 1;
572 item
->checksum
= compute_checksum ();
573 for (i
= 0; i
!= GCOV_COUNTERS
; i
++)
575 item
->n_ctrs
[i
] = fn_n_ctrs
[i
];
576 prg_n_ctrs
[i
] += fn_n_ctrs
[i
];
577 fn_n_ctrs
[i
] = fn_b_ctrs
[i
] = 0;
579 prg_ctr_mask
|= fn_ctr_mask
;
582 bbg_function_announced
= 0;
585 /* Creates the gcov_fn_info RECORD_TYPE. */
588 build_fn_info_type (unsigned int counters
)
590 tree type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
595 fields
= build_decl (FIELD_DECL
, NULL_TREE
, get_gcov_unsigned_t ());
598 field
= build_decl (FIELD_DECL
, NULL_TREE
, get_gcov_unsigned_t ());
599 TREE_CHAIN (field
) = fields
;
602 array_type
= build_int_cst (NULL_TREE
, counters
- 1);
603 array_type
= build_index_type (array_type
);
604 array_type
= build_array_type (get_gcov_unsigned_t (), array_type
);
607 field
= build_decl (FIELD_DECL
, NULL_TREE
, array_type
);
608 TREE_CHAIN (field
) = fields
;
611 finish_builtin_struct (type
, "__gcov_fn_info", fields
, NULL_TREE
);
616 /* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
617 the function being processed and TYPE is the gcov_fn_info
621 build_fn_info_value (const struct function_list
*function
, tree type
)
623 tree value
= NULL_TREE
;
624 tree fields
= TYPE_FIELDS (type
);
626 tree array_value
= NULL_TREE
;
629 value
= tree_cons (fields
, build_int_cstu (get_gcov_unsigned_t (),
630 function
->ident
), value
);
631 fields
= TREE_CHAIN (fields
);
634 value
= tree_cons (fields
, build_int_cstu (get_gcov_unsigned_t (),
635 function
->checksum
), value
);
636 fields
= TREE_CHAIN (fields
);
639 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
640 if (prg_ctr_mask
& (1 << ix
))
642 tree counters
= build_int_cstu (get_gcov_unsigned_t (),
643 function
->n_ctrs
[ix
]);
645 array_value
= tree_cons (NULL_TREE
, counters
, array_value
);
648 /* FIXME: use build_constructor directly. */
649 array_value
= build_constructor_from_list (TREE_TYPE (fields
),
650 nreverse (array_value
));
651 value
= tree_cons (fields
, array_value
, value
);
653 /* FIXME: use build_constructor directly. */
654 value
= build_constructor_from_list (type
, nreverse (value
));
659 /* Creates the gcov_ctr_info RECORD_TYPE. */
662 build_ctr_info_type (void)
664 tree type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
665 tree field
, fields
= NULL_TREE
;
666 tree gcov_ptr_type
= build_pointer_type (get_gcov_type ());
667 tree gcov_merge_fn_type
;
670 field
= build_decl (FIELD_DECL
, NULL_TREE
, get_gcov_unsigned_t ());
671 TREE_CHAIN (field
) = fields
;
675 field
= build_decl (FIELD_DECL
, NULL_TREE
, gcov_ptr_type
);
676 TREE_CHAIN (field
) = fields
;
681 build_function_type_list (void_type_node
,
682 gcov_ptr_type
, get_gcov_unsigned_t (),
684 field
= build_decl (FIELD_DECL
, NULL_TREE
,
685 build_pointer_type (gcov_merge_fn_type
));
686 TREE_CHAIN (field
) = fields
;
689 finish_builtin_struct (type
, "__gcov_ctr_info", fields
, NULL_TREE
);
694 /* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
695 the counter being processed and TYPE is the gcov_ctr_info
699 build_ctr_info_value (unsigned int counter
, tree type
)
701 tree value
= NULL_TREE
;
702 tree fields
= TYPE_FIELDS (type
);
706 value
= tree_cons (fields
,
707 build_int_cstu (get_gcov_unsigned_t (),
708 prg_n_ctrs
[counter
]),
710 fields
= TREE_CHAIN (fields
);
712 if (prg_n_ctrs
[counter
])
716 array_type
= build_int_cstu (get_gcov_unsigned_t (),
717 prg_n_ctrs
[counter
] - 1);
718 array_type
= build_index_type (array_type
);
719 array_type
= build_array_type (TREE_TYPE (TREE_TYPE (fields
)),
722 TREE_TYPE (tree_ctr_tables
[counter
]) = array_type
;
723 DECL_SIZE (tree_ctr_tables
[counter
]) = TYPE_SIZE (array_type
);
724 DECL_SIZE_UNIT (tree_ctr_tables
[counter
]) = TYPE_SIZE_UNIT (array_type
);
725 assemble_variable (tree_ctr_tables
[counter
], 0, 0, 0);
727 value
= tree_cons (fields
,
728 build1 (ADDR_EXPR
, TREE_TYPE (fields
),
729 tree_ctr_tables
[counter
]),
733 value
= tree_cons (fields
, null_pointer_node
, value
);
734 fields
= TREE_CHAIN (fields
);
736 fn
= build_decl (FUNCTION_DECL
,
737 get_identifier (ctr_merge_functions
[counter
]),
738 TREE_TYPE (TREE_TYPE (fields
)));
739 DECL_EXTERNAL (fn
) = 1;
740 TREE_PUBLIC (fn
) = 1;
741 DECL_ARTIFICIAL (fn
) = 1;
742 TREE_NOTHROW (fn
) = 1;
743 value
= tree_cons (fields
,
744 build1 (ADDR_EXPR
, TREE_TYPE (fields
), fn
),
747 /* FIXME: use build_constructor directly. */
748 value
= build_constructor_from_list (type
, nreverse (value
));
753 /* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
757 build_gcov_info (void)
759 unsigned n_ctr_types
, ix
;
760 tree type
, const_type
;
761 tree fn_info_type
, fn_info_value
= NULL_TREE
;
762 tree fn_info_ptr_type
;
763 tree ctr_info_type
, ctr_info_ary_type
, ctr_info_value
= NULL_TREE
;
764 tree field
, fields
= NULL_TREE
;
765 tree value
= NULL_TREE
;
766 tree filename_string
;
770 const struct function_list
*fn
;
773 /* Count the number of active counters. */
774 for (n_ctr_types
= 0, ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
775 if (prg_ctr_mask
& (1 << ix
))
778 type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
779 const_type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
782 field
= build_decl (FIELD_DECL
, NULL_TREE
, get_gcov_unsigned_t ());
783 TREE_CHAIN (field
) = fields
;
785 value
= tree_cons (field
, build_int_cstu (TREE_TYPE (field
), GCOV_VERSION
),
789 field
= build_decl (FIELD_DECL
, NULL_TREE
, build_pointer_type (const_type
));
790 TREE_CHAIN (field
) = fields
;
792 value
= tree_cons (field
, null_pointer_node
, value
);
795 field
= build_decl (FIELD_DECL
, NULL_TREE
, get_gcov_unsigned_t ());
796 TREE_CHAIN (field
) = fields
;
798 value
= tree_cons (field
, build_int_cstu (TREE_TYPE (field
), local_tick
),
802 string_type
= build_pointer_type (build_qualified_type (char_type_node
,
804 field
= build_decl (FIELD_DECL
, NULL_TREE
, string_type
);
805 TREE_CHAIN (field
) = fields
;
807 filename
= getpwd ();
808 filename
= (filename
&& da_file_name
[0] != '/'
809 ? concat (filename
, "/", da_file_name
, NULL
)
811 filename_len
= strlen (filename
);
812 filename_string
= build_string (filename_len
+ 1, filename
);
813 if (filename
!= da_file_name
)
815 TREE_TYPE (filename_string
) = build_array_type
816 (char_type_node
, build_index_type
817 (build_int_cst (NULL_TREE
, filename_len
)));
818 value
= tree_cons (field
, build1 (ADDR_EXPR
, string_type
, filename_string
),
821 /* Build the fn_info type and initializer. */
822 fn_info_type
= build_fn_info_type (n_ctr_types
);
823 fn_info_ptr_type
= build_pointer_type (build_qualified_type
824 (fn_info_type
, TYPE_QUAL_CONST
));
825 for (fn
= functions_head
, n_fns
= 0; fn
; fn
= fn
->next
, n_fns
++)
826 fn_info_value
= tree_cons (NULL_TREE
,
827 build_fn_info_value (fn
, fn_info_type
),
833 array_type
= build_index_type (build_int_cst (NULL_TREE
, n_fns
- 1));
834 array_type
= build_array_type (fn_info_type
, array_type
);
836 /* FIXME: use build_constructor directly. */
837 fn_info_value
= build_constructor_from_list (array_type
,
838 nreverse (fn_info_value
));
839 fn_info_value
= build1 (ADDR_EXPR
, fn_info_ptr_type
, fn_info_value
);
842 fn_info_value
= null_pointer_node
;
844 /* number of functions */
845 field
= build_decl (FIELD_DECL
, NULL_TREE
, get_gcov_unsigned_t ());
846 TREE_CHAIN (field
) = fields
;
848 value
= tree_cons (field
,
849 build_int_cstu (get_gcov_unsigned_t (), n_fns
),
853 field
= build_decl (FIELD_DECL
, NULL_TREE
, fn_info_ptr_type
);
854 TREE_CHAIN (field
) = fields
;
856 value
= tree_cons (field
, fn_info_value
, value
);
859 field
= build_decl (FIELD_DECL
, NULL_TREE
, get_gcov_unsigned_t ());
860 TREE_CHAIN (field
) = fields
;
862 value
= tree_cons (field
,
863 build_int_cstu (get_gcov_unsigned_t (), prg_ctr_mask
),
867 ctr_info_type
= build_ctr_info_type ();
868 ctr_info_ary_type
= build_index_type (build_int_cst (NULL_TREE
,
870 ctr_info_ary_type
= build_array_type (ctr_info_type
, ctr_info_ary_type
);
871 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
872 if (prg_ctr_mask
& (1 << ix
))
873 ctr_info_value
= tree_cons (NULL_TREE
,
874 build_ctr_info_value (ix
, ctr_info_type
),
876 /* FIXME: use build_constructor directly. */
877 ctr_info_value
= build_constructor_from_list (ctr_info_ary_type
,
878 nreverse (ctr_info_value
));
880 field
= build_decl (FIELD_DECL
, NULL_TREE
, ctr_info_ary_type
);
881 TREE_CHAIN (field
) = fields
;
883 value
= tree_cons (field
, ctr_info_value
, value
);
885 finish_builtin_struct (type
, "__gcov_info", fields
, NULL_TREE
);
887 /* FIXME: use build_constructor directly. */
888 value
= build_constructor_from_list (type
, nreverse (value
));
893 /* Write out the structure which libgcov uses to locate all the
894 counters. The structures used here must match those defined in
895 gcov-io.h. Write out the constructor to call __gcov_init. */
898 create_coverage (void)
900 tree gcov_info
, gcov_init
, body
, t
;
903 no_coverage
= 1; /* Disable any further coverage. */
908 t
= build_gcov_info ();
910 gcov_info
= build_decl (VAR_DECL
, NULL_TREE
, TREE_TYPE (t
));
911 TREE_STATIC (gcov_info
) = 1;
912 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 0);
913 DECL_NAME (gcov_info
) = get_identifier (name_buf
);
914 DECL_INITIAL (gcov_info
) = t
;
916 /* Build structure. */
917 assemble_variable (gcov_info
, 0, 0, 0);
919 /* Build a decl for __gcov_init. */
920 t
= build_pointer_type (TREE_TYPE (gcov_info
));
921 t
= build_function_type_list (void_type_node
, t
, NULL
);
922 t
= build_decl (FUNCTION_DECL
, get_identifier ("__gcov_init"), t
);
924 DECL_EXTERNAL (t
) = 1;
927 /* Generate a call to __gcov_init(&gcov_info). */
929 t
= build_fold_addr_expr (gcov_info
);
930 t
= tree_cons (NULL
, t
, NULL
);
931 t
= build_function_call_expr (gcov_init
, t
);
932 append_to_statement_list (t
, &body
);
934 /* Generate a constructor to run it. */
935 cgraph_build_static_cdtor ('I', body
, DEFAULT_INIT_PRIORITY
);
938 /* Perform file-level initialization. Read in data file, generate name
942 coverage_init (const char *filename
)
944 int len
= strlen (filename
);
946 /* Name of da file. */
947 da_file_name
= XNEWVEC (char, len
+ strlen (GCOV_DATA_SUFFIX
) + 1);
948 strcpy (da_file_name
, filename
);
949 strcat (da_file_name
, GCOV_DATA_SUFFIX
);
951 /* Name of bbg file. */
952 bbg_file_name
= XNEWVEC (char, len
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
953 strcpy (bbg_file_name
, filename
);
954 strcat (bbg_file_name
, GCOV_NOTE_SUFFIX
);
959 /* Performs file-level cleanup. Close graph file, generate coverage
960 variables and constructor. */
963 coverage_finish (void)
968 int error
= gcov_close ();
971 unlink (bbg_file_name
);
973 /* Only remove the da file, if we cannot stamp it. If we can
974 stamp it, libgcov will DTRT. */
975 unlink (da_file_name
);
979 #include "gt-coverage.h"