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 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 2, 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 COPYING. If not, write to the Free
23 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
31 #include "coretypes.h"
45 #include "langhooks.h"
52 struct function_list
*next
; /* next function */
53 unsigned ident
; /* function ident */
54 unsigned checksum
; /* function checksum */
55 unsigned n_ctrs
[GCOV_COUNTERS
];/* number of counters. */
58 /* Counts information for a function. */
59 typedef struct counts_entry
68 struct gcov_ctr_summary summary
;
71 struct counts_entry
*chain
;
75 static struct function_list
*functions_head
= 0;
76 static struct function_list
**functions_tail
= &functions_head
;
77 static unsigned no_coverage
= 0;
79 /* Cumulative counter information for whole program. */
80 static unsigned prg_ctr_mask
; /* Mask of counter types generated. */
81 static unsigned prg_n_ctrs
[GCOV_COUNTERS
]; /* Total counters allocated. */
83 /* Counter information for current function. */
84 static unsigned fn_ctr_mask
; /* Mask of counters used. */
85 static unsigned fn_n_ctrs
[GCOV_COUNTERS
]; /* Counters allocated. */
86 static unsigned fn_b_ctrs
[GCOV_COUNTERS
]; /* Allocation base. */
88 /* Name of the output file for coverage output file. */
89 static char *bbg_file_name
;
90 static unsigned bbg_file_opened
;
91 static int bbg_function_announced
;
93 /* Name of the count data file. */
94 static char *da_file_name
;
96 /* Hash table of count data. */
97 static htab_t counts_hash
= NULL
;
99 /* The names of the counter tables. */
100 static GTY(()) rtx ctr_labels
[GCOV_COUNTERS
];
102 /* The names of merge functions for counters. */
103 static const char *const ctr_merge_functions
[GCOV_COUNTERS
] = GCOV_MERGE_FUNCTIONS
;
104 static const char *const ctr_names
[GCOV_COUNTERS
] = GCOV_COUNTER_NAMES
;
106 /* Forward declarations. */
107 static hashval_t
htab_counts_entry_hash (const void *);
108 static int htab_counts_entry_eq (const void *, const void *);
109 static void htab_counts_entry_del (void *);
110 static void read_counts_file (void);
111 static unsigned compute_checksum (void);
112 static unsigned coverage_checksum_string (unsigned, const char *);
113 static tree
build_fn_info_type (unsigned);
114 static tree
build_fn_info_value (const struct function_list
*, tree
);
115 static tree
build_ctr_info_type (void);
116 static tree
build_ctr_info_value (unsigned, tree
);
117 static tree
build_gcov_info (void);
118 static void create_coverage (void);
122 htab_counts_entry_hash (const void *of
)
124 const counts_entry_t
*entry
= of
;
126 return entry
->ident
* GCOV_COUNTERS
+ entry
->ctr
;
130 htab_counts_entry_eq (const void *of1
, const void *of2
)
132 const counts_entry_t
*entry1
= of1
;
133 const counts_entry_t
*entry2
= of2
;
135 return entry1
->ident
== entry2
->ident
&& entry1
->ctr
== entry2
->ctr
;
139 htab_counts_entry_del (void *of
)
141 counts_entry_t
*entry
= of
;
143 free (entry
->counts
);
147 /* Read in the counts file, if available. */
150 read_counts_file (void)
152 gcov_unsigned_t fn_ident
= 0;
153 gcov_unsigned_t checksum
= -1;
154 counts_entry_t
*summaried
= NULL
;
155 unsigned seen_summary
= 0;
159 if (!gcov_open (da_file_name
, 1))
162 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC
))
164 warning ("`%s' is not a gcov data file", da_file_name
);
168 else if ((tag
= gcov_read_unsigned ()) != GCOV_VERSION
)
172 GCOV_UNSIGNED2STRING (v
, tag
);
173 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
175 warning ("`%s' is version `%.4s', expected version `%.4s'",
181 /* Read and discard the stamp. */
182 gcov_read_unsigned ();
184 counts_hash
= htab_create (10,
185 htab_counts_entry_hash
, htab_counts_entry_eq
,
186 htab_counts_entry_del
);
187 while ((tag
= gcov_read_unsigned ()))
189 gcov_unsigned_t length
;
190 gcov_position_t offset
;
192 length
= gcov_read_unsigned ();
193 offset
= gcov_position ();
194 if (tag
== GCOV_TAG_FUNCTION
)
196 fn_ident
= gcov_read_unsigned ();
197 checksum
= gcov_read_unsigned ();
200 /* We have already seen a summary, this means that this
201 new function begins a new set of program runs. We
202 must unlink the summaried chain. */
203 counts_entry_t
*entry
, *chain
;
205 for (entry
= summaried
; entry
; entry
= chain
)
207 chain
= entry
->chain
;
214 else if (tag
== GCOV_TAG_PROGRAM_SUMMARY
)
216 counts_entry_t
*entry
;
217 struct gcov_summary summary
;
219 gcov_read_summary (&summary
);
221 for (entry
= summaried
; entry
; entry
= entry
->chain
)
223 struct gcov_ctr_summary
*csum
= &summary
.ctrs
[entry
->ctr
];
225 entry
->summary
.runs
+= csum
->runs
;
226 entry
->summary
.sum_all
+= csum
->sum_all
;
227 if (entry
->summary
.run_max
< csum
->run_max
)
228 entry
->summary
.run_max
= csum
->run_max
;
229 entry
->summary
.sum_max
+= csum
->sum_max
;
232 else if (GCOV_TAG_IS_COUNTER (tag
) && fn_ident
)
234 counts_entry_t
**slot
, *entry
, elt
;
235 unsigned n_counts
= GCOV_TAG_COUNTER_NUM (length
);
238 elt
.ident
= fn_ident
;
239 elt
.ctr
= GCOV_COUNTER_FOR_TAG (tag
);
241 slot
= (counts_entry_t
**) htab_find_slot
242 (counts_hash
, &elt
, INSERT
);
246 *slot
= entry
= xcalloc (1, sizeof (counts_entry_t
));
247 entry
->ident
= elt
.ident
;
248 entry
->ctr
= elt
.ctr
;
249 entry
->checksum
= checksum
;
250 entry
->summary
.num
= n_counts
;
251 entry
->counts
= xcalloc (n_counts
, sizeof (gcov_type
));
253 else if (entry
->checksum
!= checksum
)
255 error ("coverage mismatch for function %u while reading execution counters.",
257 error ("checksum is %x instead of %x", entry
->checksum
, checksum
);
258 htab_delete (counts_hash
);
261 else if (entry
->summary
.num
!= n_counts
)
263 error ("coverage mismatch for function %u while reading execution counters.",
265 error ("number of counters is %d instead of %d", entry
->summary
.num
, n_counts
);
266 htab_delete (counts_hash
);
269 else if (elt
.ctr
>= GCOV_COUNTERS_SUMMABLE
)
271 error ("cannot merge separate %s counters for function %u",
272 ctr_names
[elt
.ctr
], fn_ident
);
276 if (elt
.ctr
< GCOV_COUNTERS_SUMMABLE
277 /* This should always be true for a just allocated entry,
278 and always false for an existing one. Check this way, in
279 case the gcov file is corrupt. */
280 && (!entry
->chain
|| summaried
!= entry
))
282 entry
->chain
= summaried
;
285 for (ix
= 0; ix
!= n_counts
; ix
++)
286 entry
->counts
[ix
] += gcov_read_counter ();
289 gcov_sync (offset
, length
);
290 if ((is_error
= gcov_is_error ()))
296 error (is_error
< 0 ? "`%s' has overflowed" : "`%s' is corrupted",
298 htab_delete (counts_hash
);
304 /* Returns the counters for a particular tag. */
307 get_coverage_counts (unsigned counter
, unsigned expected
,
308 const struct gcov_ctr_summary
**summary
)
310 counts_entry_t
*entry
, elt
;
311 gcov_unsigned_t checksum
= -1;
313 /* No hash table, no counts. */
316 static int warned
= 0;
319 inform ((flag_guess_branch_prob
320 ? "file %s not found, execution counts estimated"
321 : "file %s not found, execution counts assumed to be zero"),
326 elt
.ident
= current_function_funcdef_no
+ 1;
328 entry
= htab_find (counts_hash
, &elt
);
331 warning ("no coverage for function '%s' found.", IDENTIFIER_POINTER
332 (DECL_ASSEMBLER_NAME (current_function_decl
)));
336 checksum
= compute_checksum ();
337 if (entry
->checksum
!= checksum
)
339 error ("coverage mismatch for function '%s' while reading counter '%s'.",
340 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)),
342 error ("checksum is %x instead of %x", entry
->checksum
, checksum
);
345 else if (entry
->summary
.num
!= expected
)
347 error ("coverage mismatch for function '%s' while reading counter '%s'.",
348 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)),
350 error ("number of counters is %d instead of %d", entry
->summary
.num
, expected
);
355 *summary
= &entry
->summary
;
357 return entry
->counts
;
360 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
361 allocation succeeded. */
364 coverage_counter_alloc (unsigned counter
, unsigned num
)
372 if (!ctr_labels
[counter
])
374 /* Generate and save a copy of this so it can be shared. */
377 ASM_GENERATE_INTERNAL_LABEL (buf
, "LPBX", counter
+ 1);
378 ctr_labels
[counter
] = gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (buf
));
379 SYMBOL_REF_FLAGS (ctr_labels
[counter
]) = SYMBOL_FLAG_LOCAL
;
381 fn_b_ctrs
[counter
] = fn_n_ctrs
[counter
];
382 fn_n_ctrs
[counter
] += num
;
383 fn_ctr_mask
|= 1 << counter
;
387 /* Generate a MEM rtl to access COUNTER NO. */
390 coverage_counter_ref (unsigned counter
, unsigned no
)
392 unsigned gcov_size
= tree_low_cst (TYPE_SIZE (GCOV_TYPE_NODE
), 1);
393 enum machine_mode mode
= mode_for_size (gcov_size
, MODE_INT
, 0);
396 if (no
>= fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
])
398 no
+= prg_n_ctrs
[counter
] + fn_b_ctrs
[counter
];
399 ref
= plus_constant (ctr_labels
[counter
], gcov_size
/ BITS_PER_UNIT
* no
);
400 ref
= gen_rtx_MEM (mode
, ref
);
401 set_mem_alias_set (ref
, new_alias_set ());
402 MEM_NOTRAP_P (ref
) = 1;
407 /* Generate a checksum for a string. CHKSUM is the current
411 coverage_checksum_string (unsigned chksum
, const char *string
)
416 /* Look for everything that looks if it were produced by
417 get_file_function_name_long and zero out the second part
418 that may result from flag_random_seed. This is not critical
419 as the checksums are used only for sanity checking. */
420 for (i
= 0; string
[i
]; i
++)
422 if (!strncmp (string
+ i
, "_GLOBAL__", 9))
423 for (i
= i
+ 9; string
[i
]; i
++)
429 for (y
= 1; y
< 9; y
++)
430 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
431 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
433 if (y
!= 9 || string
[i
+ 9] != '_')
435 for (y
= 10; y
< 18; y
++)
436 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
437 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
441 if (!sscanf (string
+ i
+ 10, "%X", &seed
))
443 if (seed
!= crc32_string (0, flag_random_seed
))
445 string
= dup
= xstrdup (string
);
446 for (y
= 10; y
< 18; y
++)
453 chksum
= crc32_string (chksum
, string
);
460 /* Compute checksum for the current function. We generate a CRC32. */
463 compute_checksum (void)
465 unsigned chksum
= DECL_SOURCE_LINE (current_function_decl
);
467 chksum
= coverage_checksum_string (chksum
,
468 DECL_SOURCE_FILE (current_function_decl
));
469 chksum
= coverage_checksum_string
470 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)));
475 /* Begin output to the graph file for the current function.
476 Opens the output file, if not already done. Writes the
477 function header, if not already done. Returns nonzero if data
481 coverage_begin_output (void)
486 if (!bbg_function_announced
)
488 const char *file
= DECL_SOURCE_FILE (current_function_decl
);
489 unsigned line
= DECL_SOURCE_LINE (current_function_decl
);
490 unsigned long offset
;
492 if (!bbg_file_opened
)
494 if (!gcov_open (bbg_file_name
, -1))
495 error ("cannot open %s", bbg_file_name
);
498 gcov_write_unsigned (GCOV_NOTE_MAGIC
);
499 gcov_write_unsigned (GCOV_VERSION
);
500 gcov_write_unsigned (local_tick
);
505 /* Announce function */
506 offset
= gcov_write_tag (GCOV_TAG_FUNCTION
);
507 gcov_write_unsigned (current_function_funcdef_no
+ 1);
508 gcov_write_unsigned (compute_checksum ());
509 gcov_write_string (IDENTIFIER_POINTER
510 (DECL_ASSEMBLER_NAME (current_function_decl
)));
511 gcov_write_string (file
);
512 gcov_write_unsigned (line
);
513 gcov_write_length (offset
);
515 bbg_function_announced
= 1;
517 return !gcov_is_error ();
520 /* Finish coverage data for the current function. Verify no output
521 error has occurred. Save function coverage counts. */
524 coverage_end_function (void)
528 if (bbg_file_opened
> 1 && gcov_is_error ())
530 warning ("error writing `%s'", bbg_file_name
);
531 bbg_file_opened
= -1;
536 struct function_list
*item
;
538 item
= xmalloc (sizeof (struct function_list
));
540 *functions_tail
= item
;
541 functions_tail
= &item
->next
;
544 item
->ident
= current_function_funcdef_no
+ 1;
545 item
->checksum
= compute_checksum ();
546 for (i
= 0; i
!= GCOV_COUNTERS
; i
++)
548 item
->n_ctrs
[i
] = fn_n_ctrs
[i
];
549 prg_n_ctrs
[i
] += fn_n_ctrs
[i
];
550 fn_n_ctrs
[i
] = fn_b_ctrs
[i
] = 0;
552 prg_ctr_mask
|= fn_ctr_mask
;
555 bbg_function_announced
= 0;
558 /* Creates the gcov_fn_info RECORD_TYPE. */
561 build_fn_info_type (unsigned int counters
)
563 tree type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
568 fields
= build_decl (FIELD_DECL
, NULL_TREE
, unsigned_intSI_type_node
);
571 field
= build_decl (FIELD_DECL
, NULL_TREE
, unsigned_intSI_type_node
);
572 TREE_CHAIN (field
) = fields
;
575 array_type
= build_index_type (build_int_2 (counters
- 1, 0));
576 array_type
= build_array_type (unsigned_type_node
, array_type
);
579 field
= build_decl (FIELD_DECL
, NULL_TREE
, array_type
);
580 TREE_CHAIN (field
) = fields
;
583 finish_builtin_struct (type
, "__gcov_fn_info", fields
, NULL_TREE
);
588 /* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
589 the function being processed and TYPE is the gcov_fn_info
593 build_fn_info_value (const struct function_list
*function
, tree type
)
595 tree value
= NULL_TREE
;
596 tree fields
= TYPE_FIELDS (type
);
598 tree array_value
= NULL_TREE
;
601 value
= tree_cons (fields
,
602 convert (unsigned_intSI_type_node
,
603 build_int_2 (function
->ident
, 0)),
605 fields
= TREE_CHAIN (fields
);
608 value
= tree_cons (fields
,
609 convert (unsigned_intSI_type_node
,
610 build_int_2 (function
->checksum
, 0)),
612 fields
= TREE_CHAIN (fields
);
615 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
616 if (prg_ctr_mask
& (1 << ix
))
618 tree counters
= convert (unsigned_type_node
,
619 build_int_2 (function
->n_ctrs
[ix
], 0));
621 array_value
= tree_cons (NULL_TREE
, counters
, array_value
);
624 array_value
= build_constructor (TREE_TYPE (fields
), nreverse (array_value
));
625 value
= tree_cons (fields
, array_value
, value
);
627 value
= build_constructor (type
, nreverse (value
));
632 /* Creates the gcov_ctr_info RECORD_TYPE. */
635 build_ctr_info_type (void)
637 tree type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
638 tree field
, fields
= NULL_TREE
;
639 tree gcov_ptr_type
= build_pointer_type (GCOV_TYPE_NODE
);
640 tree gcov_merge_fn_type
;
643 field
= build_decl (FIELD_DECL
, NULL_TREE
, unsigned_intSI_type_node
);
644 TREE_CHAIN (field
) = fields
;
648 field
= build_decl (FIELD_DECL
, NULL_TREE
, gcov_ptr_type
);
649 TREE_CHAIN (field
) = fields
;
654 build_function_type_list (void_type_node
,
655 gcov_ptr_type
, unsigned_type_node
,
657 field
= build_decl (FIELD_DECL
, NULL_TREE
,
658 build_pointer_type (gcov_merge_fn_type
));
659 TREE_CHAIN (field
) = fields
;
662 finish_builtin_struct (type
, "__gcov_ctr_info", fields
, NULL_TREE
);
667 /* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
668 the counter being processed and TYPE is the gcov_ctr_info
672 build_ctr_info_value (unsigned int counter
, tree type
)
674 tree value
= NULL_TREE
;
675 tree fields
= TYPE_FIELDS (type
);
679 value
= tree_cons (fields
,
680 convert (unsigned_intSI_type_node
,
681 build_int_2 (prg_n_ctrs
[counter
], 0)),
683 fields
= TREE_CHAIN (fields
);
685 if (prg_n_ctrs
[counter
])
687 tree array_type
, array
;
689 array_type
= build_index_type (build_int_2 (prg_n_ctrs
[counter
] - 1, 0));
690 array_type
= build_array_type (TREE_TYPE (TREE_TYPE (fields
)),
693 array
= build_decl (VAR_DECL
, NULL_TREE
, array_type
);
694 TREE_STATIC (array
) = 1;
695 DECL_NAME (array
) = get_identifier (XSTR (ctr_labels
[counter
], 0));
696 assemble_variable (array
, 0, 0, 0);
698 value
= tree_cons (fields
,
699 build1 (ADDR_EXPR
, TREE_TYPE (fields
), array
),
703 value
= tree_cons (fields
, null_pointer_node
, value
);
704 fields
= TREE_CHAIN (fields
);
706 fn
= build_decl (FUNCTION_DECL
,
707 get_identifier (ctr_merge_functions
[counter
]),
708 TREE_TYPE (TREE_TYPE (fields
)));
709 DECL_EXTERNAL (fn
) = 1;
710 TREE_PUBLIC (fn
) = 1;
711 DECL_ARTIFICIAL (fn
) = 1;
712 TREE_NOTHROW (fn
) = 1;
713 value
= tree_cons (fields
,
714 build1 (ADDR_EXPR
, TREE_TYPE (fields
), fn
),
717 value
= build_constructor (type
, nreverse (value
));
722 /* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
726 build_gcov_info (void)
728 unsigned n_ctr_types
, ix
;
729 tree type
, const_type
;
730 tree fn_info_type
, fn_info_value
= NULL_TREE
;
731 tree fn_info_ptr_type
;
732 tree ctr_info_type
, ctr_info_ary_type
, ctr_info_value
= NULL_TREE
;
733 tree field
, fields
= NULL_TREE
;
734 tree value
= NULL_TREE
;
735 tree filename_string
;
739 const struct function_list
*fn
;
742 /* Count the number of active counters. */
743 for (n_ctr_types
= 0, ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
744 if (prg_ctr_mask
& (1 << ix
))
747 type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
748 const_type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
751 field
= build_decl (FIELD_DECL
, NULL_TREE
, unsigned_intSI_type_node
);
752 TREE_CHAIN (field
) = fields
;
754 value
= tree_cons (field
, convert (unsigned_intSI_type_node
,
755 build_int_2 (GCOV_VERSION
, 0)),
759 field
= build_decl (FIELD_DECL
, NULL_TREE
, build_pointer_type (const_type
));
760 TREE_CHAIN (field
) = fields
;
762 value
= tree_cons (field
, null_pointer_node
, value
);
765 field
= build_decl (FIELD_DECL
, NULL_TREE
, unsigned_intSI_type_node
);
766 TREE_CHAIN (field
) = fields
;
768 value
= tree_cons (field
, convert (unsigned_intSI_type_node
,
769 build_int_2 (local_tick
, 0)),
773 string_type
= build_pointer_type (build_qualified_type (char_type_node
,
775 field
= build_decl (FIELD_DECL
, NULL_TREE
, string_type
);
776 TREE_CHAIN (field
) = fields
;
778 filename
= getpwd ();
779 filename
= (filename
&& da_file_name
[0] != '/'
780 ? concat (filename
, "/", da_file_name
, NULL
)
782 filename_len
= strlen (filename
);
783 filename_string
= build_string (filename_len
+ 1, filename
);
784 if (filename
!= da_file_name
)
786 TREE_TYPE (filename_string
) =
787 build_array_type (char_type_node
,
788 build_index_type (build_int_2 (filename_len
, 0)));
789 value
= tree_cons (field
, build1 (ADDR_EXPR
, string_type
, filename_string
),
792 /* Build the fn_info type and initializer. */
793 fn_info_type
= build_fn_info_type (n_ctr_types
);
794 fn_info_ptr_type
= build_pointer_type (build_qualified_type
795 (fn_info_type
, TYPE_QUAL_CONST
));
796 for (fn
= functions_head
, n_fns
= 0; fn
; fn
= fn
->next
, n_fns
++)
797 fn_info_value
= tree_cons (NULL_TREE
,
798 build_fn_info_value (fn
, fn_info_type
),
804 array_type
= build_index_type (build_int_2 (n_fns
- 1, 0));
805 array_type
= build_array_type (fn_info_type
, array_type
);
807 fn_info_value
= build_constructor (array_type
, nreverse (fn_info_value
));
808 fn_info_value
= build1 (ADDR_EXPR
, fn_info_ptr_type
, fn_info_value
);
811 fn_info_value
= null_pointer_node
;
813 /* number of functions */
814 field
= build_decl (FIELD_DECL
, NULL_TREE
, unsigned_type_node
);
815 TREE_CHAIN (field
) = fields
;
817 value
= tree_cons (field
,
818 convert (unsigned_type_node
, build_int_2 (n_fns
, 0)),
822 field
= build_decl (FIELD_DECL
, NULL_TREE
, fn_info_ptr_type
);
823 TREE_CHAIN (field
) = fields
;
825 value
= tree_cons (field
, fn_info_value
, value
);
828 field
= build_decl (FIELD_DECL
, NULL_TREE
, unsigned_type_node
);
829 TREE_CHAIN (field
) = fields
;
831 value
= tree_cons (field
,
832 convert (unsigned_type_node
,
833 build_int_2 (prg_ctr_mask
, 0)),
837 ctr_info_type
= build_ctr_info_type ();
838 ctr_info_ary_type
= build_index_type (build_int_2 (n_ctr_types
, 0));
839 ctr_info_ary_type
= build_array_type (ctr_info_type
, ctr_info_ary_type
);
840 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
841 if (prg_ctr_mask
& (1 << ix
))
842 ctr_info_value
= tree_cons (NULL_TREE
,
843 build_ctr_info_value (ix
, ctr_info_type
),
845 ctr_info_value
= build_constructor (ctr_info_ary_type
,
846 nreverse (ctr_info_value
));
848 field
= build_decl (FIELD_DECL
, NULL_TREE
, ctr_info_ary_type
);
849 TREE_CHAIN (field
) = fields
;
851 value
= tree_cons (field
, ctr_info_value
, value
);
853 finish_builtin_struct (type
, "__gcov_info", fields
, NULL_TREE
);
855 value
= build_constructor (type
, nreverse (value
));
860 /* Write out the structure which libgcov uses to locate all the
861 counters. The structures used here must match those defined in
862 gcov-io.h. Write out the constructor to call __gcov_init. */
865 create_coverage (void)
867 tree gcov_info
, gcov_info_value
;
871 rtx gcov_info_address
;
873 no_coverage
= 1; /* Disable any further coverage. */
878 gcov_info_value
= build_gcov_info ();
880 gcov_info
= build_decl (VAR_DECL
, NULL_TREE
, TREE_TYPE (gcov_info_value
));
881 DECL_INITIAL (gcov_info
) = gcov_info_value
;
883 TREE_STATIC (gcov_info
) = 1;
884 ASM_GENERATE_INTERNAL_LABEL (name
, "LPBX", 0);
885 DECL_NAME (gcov_info
) = get_identifier (name
);
887 /* Build structure. */
888 assemble_variable (gcov_info
, 0, 0, 0);
890 /* Build the constructor function to invoke __gcov_init. */
891 ctor_name
= concat (IDENTIFIER_POINTER (get_file_function_name ('I')),
893 ctor
= build_decl (FUNCTION_DECL
, get_identifier (ctor_name
),
894 build_function_type (void_type_node
, NULL_TREE
));
896 DECL_EXTERNAL (ctor
) = 0;
898 /* It can be a static function as long as collect2 does not have
899 to scan the object file to find its ctor/dtor routine. */
900 TREE_PUBLIC (ctor
) = ! targetm
.have_ctors_dtors
;
901 TREE_USED (ctor
) = 1;
902 DECL_RESULT (ctor
) = build_decl (RESULT_DECL
, NULL_TREE
, void_type_node
);
903 DECL_UNINLINABLE (ctor
) = 1;
905 ctor
= lang_hooks
.decls
.pushdecl (ctor
);
906 rest_of_decl_compilation (ctor
, 0, 1, 0);
907 announce_function (ctor
);
908 current_function_decl
= ctor
;
909 make_decl_rtl (ctor
, NULL
);
910 init_function_start (ctor
);
911 expand_function_start (ctor
, 0);
912 /* Actually generate the code to call __gcov_init. */
913 gcov_info_address
= force_reg (Pmode
, XEXP (DECL_RTL (gcov_info
), 0));
914 emit_library_call (gcov_init_libfunc
, LCT_NORMAL
, VOIDmode
, 1,
915 gcov_info_address
, Pmode
);
917 expand_function_end ();
918 /* Create a dummy BLOCK. */
919 DECL_INITIAL (ctor
) = make_node (BLOCK
);
920 TREE_USED (DECL_INITIAL (ctor
)) = 1;
922 rest_of_compilation (ctor
);
925 fflush (asm_out_file
);
926 current_function_decl
= NULL_TREE
;
928 if (targetm
.have_ctors_dtors
)
929 (* targetm
.asm_out
.constructor
) (XEXP (DECL_RTL (ctor
), 0),
930 DEFAULT_INIT_PRIORITY
);
933 /* Perform file-level initialization. Read in data file, generate name
937 coverage_init (const char *filename
)
939 int len
= strlen (filename
);
941 /* Name of da file. */
942 da_file_name
= xmalloc (len
+ strlen (GCOV_DATA_SUFFIX
) + 1);
943 strcpy (da_file_name
, filename
);
944 strcat (da_file_name
, GCOV_DATA_SUFFIX
);
946 /* Name of bbg file. */
947 bbg_file_name
= xmalloc (len
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
948 strcpy (bbg_file_name
, filename
);
949 strcat (bbg_file_name
, GCOV_NOTE_SUFFIX
);
954 /* Performs file-level cleanup. Close graph file, generate coverage
955 variables and constructor. */
958 coverage_finish (void)
963 int error
= gcov_close ();
966 unlink (bbg_file_name
);
968 /* Only remove the da file, if we cannot stamp it. If we can
969 stamp it, libgcov will DTRT. */
970 unlink (da_file_name
);
974 #include "gt-coverage.h"