diff options
Diffstat (limited to 'gcc/coverage.c')
| -rw-r--r-- | gcc/coverage.c | 1392 |
1 files changed, 0 insertions, 1392 deletions
diff --git a/gcc/coverage.c b/gcc/coverage.c deleted file mode 100644 index 03852f2..0000000 --- a/gcc/coverage.c +++ /dev/null @@ -1,1392 +0,0 @@ -/* Read and write coverage files, and associated functionality. - Copyright (C) 1990-2022 Free Software Foundation, Inc. - Contributed by James E. Wilson, UC Berkeley/Cygnus Support; - based on some ideas from Dain Samples of UC Berkeley. - Further mangling by Bob Manson, Cygnus Support. - Further mangled by Nathan Sidwell, CodeSourcery - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify it under -the terms of the GNU General Public License as published by the Free -Software Foundation; either version 3, or (at your option) any later -version. - -GCC is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or -FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -<http://www.gnu.org/licenses/>. */ - - -#define GCOV_LINKAGE - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "backend.h" -#include "target.h" -#include "rtl.h" -#include "tree.h" -#include "tree-pass.h" -#include "memmodel.h" -#include "tm_p.h" -#include "stringpool.h" -#include "cgraph.h" -#include "coverage.h" -#include "diagnostic-core.h" -#include "fold-const.h" -#include "stor-layout.h" -#include "output.h" -#include "toplev.h" -#include "langhooks.h" -#include "tree-iterator.h" -#include "context.h" -#include "pass_manager.h" -#include "intl.h" -#include "auto-profile.h" -#include "profile.h" -#include "diagnostic.h" -#include "varasm.h" -#include "file-prefix-map.h" - -#include "gcov-io.c" - -struct GTY((chain_next ("%h.next"))) coverage_data -{ - struct coverage_data *next; /* next function */ - unsigned ident; /* function ident */ - unsigned lineno_checksum; /* function lineno checksum */ - unsigned cfg_checksum; /* function cfg checksum */ - tree fn_decl; /* the function decl */ - tree ctr_vars[GCOV_COUNTERS]; /* counter variables. */ -}; - -/* Counts information for a function. */ -struct counts_entry : pointer_hash <counts_entry> -{ - /* We hash by */ - unsigned ident; - unsigned ctr; - - /* Store */ - unsigned lineno_checksum; - unsigned cfg_checksum; - gcov_type *counts; - unsigned n_counts; - - /* hash_table support. */ - static inline hashval_t hash (const counts_entry *); - static int equal (const counts_entry *, const counts_entry *); - static void remove (counts_entry *); -}; - -static GTY(()) struct coverage_data *functions_head = 0; -static struct coverage_data **functions_tail = &functions_head; -static unsigned no_coverage = 0; - -/* Cumulative counter information for whole program. */ -static unsigned prg_ctr_mask; /* Mask of counter types generated. */ - -/* Counter information for current function. */ -static unsigned fn_ctr_mask; /* Mask of counters used. */ -static GTY(()) tree fn_v_ctrs[GCOV_COUNTERS]; /* counter variables. */ -static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */ -static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */ - -/* Coverage info VAR_DECL and function info type nodes. */ -static GTY(()) tree gcov_info_var; -static GTY(()) tree gcov_fn_info_type; -static GTY(()) tree gcov_fn_info_ptr_type; - -/* Name of the notes (gcno) output file. The "bbg" prefix is for - historical reasons, when the notes file contained only the - basic block graph notes. - If this is NULL we're not writing to the notes file. */ -static char *bbg_file_name; - -/* File stamp for notes file. */ -static unsigned bbg_file_stamp; - -/* Name of the count data (gcda) file. */ -static char *da_file_name; - -/* The names of merge functions for counters. */ -#define STR(str) #str -#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) STR(__gcov_merge ## FN_TYPE), -static const char *const ctr_merge_functions[GCOV_COUNTERS] = { -#include "gcov-counter.def" -}; -#undef DEF_GCOV_COUNTER -#undef STR - -#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) NAME, -static const char *const ctr_names[GCOV_COUNTERS] = { -#include "gcov-counter.def" -}; -#undef DEF_GCOV_COUNTER - -/* Forward declarations. */ -static tree build_var (tree, tree, int); - -/* Return the type node for gcov_type. */ - -tree -get_gcov_type (void) -{ - scalar_int_mode mode - = smallest_int_mode_for_size (targetm.gcov_type_size ()); - return lang_hooks.types.type_for_mode (mode, false); -} - -/* Return the type node for gcov_unsigned_t. */ - -static tree -get_gcov_unsigned_t (void) -{ - scalar_int_mode mode = smallest_int_mode_for_size (32); - return lang_hooks.types.type_for_mode (mode, true); -} - -inline hashval_t -counts_entry::hash (const counts_entry *entry) -{ - return entry->ident * GCOV_COUNTERS + entry->ctr; -} - -inline int -counts_entry::equal (const counts_entry *entry1, const counts_entry *entry2) -{ - return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr; -} - -inline void -counts_entry::remove (counts_entry *entry) -{ - free (entry->counts); - free (entry); -} - -/* Hash table of count data. */ -static hash_table<counts_entry> *counts_hash; - -/* Read in the counts file, if available. */ - -static void -read_counts_file (void) -{ - gcov_unsigned_t fn_ident = 0; - gcov_unsigned_t tag; - int is_error = 0; - unsigned lineno_checksum = 0; - unsigned cfg_checksum = 0; - - if (!gcov_open (da_file_name, 1)) - return; - - if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC)) - { - warning (0, "%qs is not a gcov data file", da_file_name); - gcov_close (); - return; - } - else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION) - { - char v[4], e[4]; - - GCOV_UNSIGNED2STRING (v, tag); - GCOV_UNSIGNED2STRING (e, GCOV_VERSION); - - warning (0, "%qs is version %q.*s, expected version %q.*s", - da_file_name, 4, v, 4, e); - gcov_close (); - return; - } - - /* Read the stamp, used for creating a generation count. */ - tag = gcov_read_unsigned (); - bbg_file_stamp = crc32_unsigned (bbg_file_stamp, tag); - - /* Read checksum. */ - gcov_read_unsigned (); - - counts_hash = new hash_table<counts_entry> (10); - while ((tag = gcov_read_unsigned ())) - { - gcov_unsigned_t length; - gcov_position_t offset; - - length = gcov_read_unsigned (); - offset = gcov_position (); - if (tag == GCOV_TAG_FUNCTION) - { - if (length) - { - fn_ident = gcov_read_unsigned (); - lineno_checksum = gcov_read_unsigned (); - cfg_checksum = gcov_read_unsigned (); - } - else - fn_ident = lineno_checksum = cfg_checksum = 0; - } - else if (tag == GCOV_TAG_OBJECT_SUMMARY) - { - profile_info = XCNEW (gcov_summary); - profile_info->runs = gcov_read_unsigned (); - profile_info->sum_max = gcov_read_unsigned (); - } - else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident) - { - counts_entry **slot, *entry, elt; - int read_length = (int)length; - length = read_length > 0 ? read_length : 0; - unsigned n_counts = GCOV_TAG_COUNTER_NUM (abs (read_length)); - unsigned ix; - - elt.ident = fn_ident; - elt.ctr = GCOV_COUNTER_FOR_TAG (tag); - - slot = counts_hash->find_slot (&elt, INSERT); - entry = *slot; - if (!entry) - { - *slot = entry = XCNEW (counts_entry); - entry->ident = fn_ident; - entry->ctr = elt.ctr; - entry->lineno_checksum = lineno_checksum; - entry->cfg_checksum = cfg_checksum; - entry->counts = XCNEWVEC (gcov_type, n_counts); - entry->n_counts = n_counts; - } - else if (entry->lineno_checksum != lineno_checksum - || entry->cfg_checksum != cfg_checksum) - { - error ("profile data for function %u is corrupted", fn_ident); - error ("checksum is (%x,%x) instead of (%x,%x)", - entry->lineno_checksum, entry->cfg_checksum, - lineno_checksum, cfg_checksum); - delete counts_hash; - counts_hash = NULL; - break; - } - if (read_length > 0) - for (ix = 0; ix != n_counts; ix++) - entry->counts[ix] = gcov_read_counter (); - } - gcov_sync (offset, length); - if ((is_error = gcov_is_error ())) - { - error (is_error < 0 - ? G_("%qs has overflowed") - : G_("%qs is corrupted"), - da_file_name); - delete counts_hash; - counts_hash = NULL; - break; - } - } - - gcov_close (); -} - -/* Returns the counters for a particular tag. */ - -gcov_type * -get_coverage_counts (unsigned counter, unsigned cfg_checksum, - unsigned lineno_checksum, unsigned int n_counts) -{ - counts_entry *entry, elt; - - /* No hash table, no counts. */ - if (!counts_hash) - { - static int warned = 0; - - if (!warned++) - { - warning (OPT_Wmissing_profile, - "%qs profile count data file not found", - da_file_name); - if (dump_enabled_p ()) - { - dump_user_location_t loc - = dump_user_location_t::from_location_t (input_location); - dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc, - "file %s not found, %s\n", da_file_name, - (flag_guess_branch_prob - ? "execution counts estimated" - : "execution counts assumed to be zero")); - } - } - return NULL; - } - if (param_profile_func_internal_id) - elt.ident = current_function_funcdef_no + 1; - else - { - gcc_assert (coverage_node_map_initialized_p ()); - elt.ident = cgraph_node::get (current_function_decl)->profile_id; - } - elt.ctr = counter; - entry = counts_hash->find (&elt); - if (!entry) - { - if (counter == GCOV_COUNTER_ARCS) - warning_at (DECL_SOURCE_LOCATION (current_function_decl), - OPT_Wmissing_profile, - "profile for function %qD not found in profile data", - current_function_decl); - /* The function was not emitted, or is weak and not chosen in the - final executable. Silently fail, because there's nothing we - can do about it. */ - return NULL; - } - - if (entry->cfg_checksum != cfg_checksum - || (counter != GCOV_COUNTER_V_INDIR - && counter != GCOV_COUNTER_V_TOPN - && entry->n_counts != n_counts)) - { - static int warned = 0; - bool warning_printed = false; - - if (entry->n_counts != n_counts) - warning_printed = - warning_at (DECL_SOURCE_LOCATION (current_function_decl), - OPT_Wcoverage_mismatch, - "number of counters in profile data for function %qD " - "does not match " - "its profile data (counter %qs, expected %i and have %i)", - current_function_decl, - ctr_names[counter], entry->n_counts, n_counts); - else - warning_printed = - warning_at (DECL_SOURCE_LOCATION (current_function_decl), - OPT_Wcoverage_mismatch, - "the control flow of function %qD does not match " - "its profile data (counter %qs)", current_function_decl, - ctr_names[counter]); - if (warning_printed && dump_enabled_p ()) - { - dump_user_location_t loc - = dump_user_location_t::from_function_decl (current_function_decl); - dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc, - "use -Wno-error=coverage-mismatch to tolerate " - "the mismatch but performance may drop if the " - "function is hot\n"); - - if (!seen_error () - && !warned++) - { - dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc, - "coverage mismatch ignored\n"); - dump_printf (MSG_MISSED_OPTIMIZATION, - flag_guess_branch_prob - ? G_("execution counts estimated\n") - : G_("execution counts assumed to be zero\n")); - if (!flag_guess_branch_prob) - dump_printf (MSG_MISSED_OPTIMIZATION, - "this can result in poorly optimized code\n"); - } - } - - return NULL; - } - else if (entry->lineno_checksum != lineno_checksum) - { - warning_at (DECL_SOURCE_LOCATION (current_function_decl), - OPT_Wcoverage_mismatch, - "source locations for function %qD have changed," - " the profile data may be out of date", - current_function_decl); - } - - return entry->counts; -} - -/* Allocate NUM counters of type COUNTER. Returns nonzero if the - allocation succeeded. */ - -int -coverage_counter_alloc (unsigned counter, unsigned num) -{ - if (no_coverage) - return 0; - - if (!num) - return 1; - - if (!fn_v_ctrs[counter]) - { - tree array_type = build_array_type (get_gcov_type (), NULL_TREE); - - fn_v_ctrs[counter] - = build_var (current_function_decl, array_type, counter); - } - - fn_b_ctrs[counter] = fn_n_ctrs[counter]; - fn_n_ctrs[counter] += num; - - fn_ctr_mask |= 1 << counter; - return 1; -} - -/* Generate a tree to access COUNTER NO. */ - -tree -tree_coverage_counter_ref (unsigned counter, unsigned no) -{ - tree gcov_type_node = get_gcov_type (); - - gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]); - - no += fn_b_ctrs[counter]; - - /* "no" here is an array index, scaled to bytes later. */ - return build4 (ARRAY_REF, gcov_type_node, fn_v_ctrs[counter], - build_int_cst (integer_type_node, no), NULL, NULL); -} - -/* Generate a tree to access the address of COUNTER NO. */ - -tree -tree_coverage_counter_addr (unsigned counter, unsigned no) -{ - tree gcov_type_node = get_gcov_type (); - - gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]); - no += fn_b_ctrs[counter]; - - /* "no" here is an array index, scaled to bytes later. */ - return build_fold_addr_expr (build4 (ARRAY_REF, gcov_type_node, - fn_v_ctrs[counter], - build_int_cst (integer_type_node, no), - NULL, NULL)); -} - - -/* Generate a checksum for a string. CHKSUM is the current - checksum. */ - -static unsigned -coverage_checksum_string (unsigned chksum, const char *string) -{ - int i; - char *dup = NULL; - - /* Look for everything that looks if it were produced by - get_file_function_name and zero out the second part - that may result from flag_random_seed. This is not critical - as the checksums are used only for sanity checking. */ - for (i = 0; string[i]; i++) - { - int offset = 0; - if (startswith (string + i, "_GLOBAL__N_")) - offset = 11; - if (startswith (string + i, "_GLOBAL__")) - offset = 9; - - /* C++ namespaces do have scheme: - _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname - since filename might contain extra underscores there seems - to be no better chance then walk all possible offsets looking - for magicnumber. */ - if (offset) - { - for (i = i + offset; string[i]; i++) - if (string[i]=='_') - { - int y; - - for (y = 1; y < 9; y++) - if (!(string[i + y] >= '0' && string[i + y] <= '9') - && !(string[i + y] >= 'A' && string[i + y] <= 'F')) - break; - if (y != 9 || string[i + 9] != '_') - continue; - for (y = 10; y < 18; y++) - if (!(string[i + y] >= '0' && string[i + y] <= '9') - && !(string[i + y] >= 'A' && string[i + y] <= 'F')) - break; - if (y != 18) - continue; - if (!dup) - string = dup = xstrdup (string); - for (y = 10; y < 18; y++) - dup[i + y] = '0'; - } - break; - } - } - - chksum = crc32_string (chksum, string); - free (dup); - - return chksum; -} - -/* Compute checksum for the current function. We generate a CRC32. */ - -unsigned -coverage_compute_lineno_checksum (void) -{ - expanded_location xloc - = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); - unsigned chksum = xloc.line; - - if (xloc.file) - chksum = coverage_checksum_string (chksum, xloc.file); - chksum = coverage_checksum_string - (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl))); - - return chksum; -} - -/* Compute profile ID. This is better to be unique in whole program. */ - -unsigned -coverage_compute_profile_id (struct cgraph_node *n) -{ - unsigned chksum; - - /* Externally visible symbols have unique name. */ - if (TREE_PUBLIC (n->decl) || DECL_EXTERNAL (n->decl) || n->unique_name) - { - chksum = coverage_checksum_string - (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl))); - } - else - { - expanded_location xloc - = expand_location (DECL_SOURCE_LOCATION (n->decl)); - bool use_name_only = (param_profile_func_internal_id == 0); - - chksum = (use_name_only ? 0 : xloc.line); - if (xloc.file) - chksum = coverage_checksum_string (chksum, xloc.file); - chksum = coverage_checksum_string - (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl))); - if (!use_name_only && first_global_object_name) - chksum = coverage_checksum_string - (chksum, first_global_object_name); - char *base_name = xstrdup (aux_base_name); - if (endswith (base_name, ".gk")) - base_name[strlen (base_name) - 3] = '\0'; - chksum = coverage_checksum_string (chksum, base_name); - free (base_name); - } - - /* Non-negative integers are hopefully small enough to fit in all targets. - Gcov file formats wants non-zero function IDs. */ - chksum = chksum & 0x7fffffff; - return chksum + (!chksum); -} - -/* Compute cfg checksum for the function FN given as argument. - The checksum is calculated carefully so that - source code changes that doesn't affect the control flow graph - won't change the checksum. - This is to make the profile data useable across source code change. - The downside of this is that the compiler may use potentially - wrong profile data - that the source code change has non-trivial impact - on the validity of profile data (e.g. the reversed condition) - but the compiler won't detect the change and use the wrong profile data. */ - -unsigned -coverage_compute_cfg_checksum (struct function *fn) -{ - basic_block bb; - unsigned chksum = n_basic_blocks_for_fn (fn); - - FOR_EACH_BB_FN (bb, fn) - { - edge e; - edge_iterator ei; - chksum = crc32_byte (chksum, bb->index); - FOR_EACH_EDGE (e, ei, bb->succs) - { - chksum = crc32_byte (chksum, e->dest->index); - } - } - - return chksum; -} - -/* Begin output to the notes file for the current function. - Writes the function header. Returns nonzero if data should be output. */ - -int -coverage_begin_function (unsigned lineno_checksum, unsigned cfg_checksum) -{ - /* We don't need to output .gcno file unless we're under -ftest-coverage - (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */ - if (no_coverage || !bbg_file_name) - return 0; - - expanded_location startloc - = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); - - /* Announce function */ - unsigned long offset = gcov_write_tag (GCOV_TAG_FUNCTION); - if (param_profile_func_internal_id) - gcov_write_unsigned (current_function_funcdef_no + 1); - else - { - gcc_assert (coverage_node_map_initialized_p ()); - gcov_write_unsigned ( - cgraph_node::get (current_function_decl)->profile_id); - } - - gcov_write_unsigned (lineno_checksum); - gcov_write_unsigned (cfg_checksum); - gcov_write_string (IDENTIFIER_POINTER - (DECL_ASSEMBLER_NAME (current_function_decl))); - gcov_write_unsigned (DECL_ARTIFICIAL (current_function_decl) - && !DECL_FUNCTION_VERSIONED (current_function_decl) - && !DECL_LAMBDA_FUNCTION_P (current_function_decl)); - gcov_write_filename (remap_profile_filename (startloc.file)); - gcov_write_unsigned (startloc.line); - gcov_write_unsigned (startloc.column); - - expanded_location endloc = expand_location (cfun->function_end_locus); - - /* Function can start in a single file and end in another one. */ - int end_line - = endloc.file == startloc.file ? endloc.line : startloc.line; - int end_column - = endloc.file == startloc.file ? endloc.column: startloc.column; - - if (startloc.line > end_line) - { - warning_at (DECL_SOURCE_LOCATION (current_function_decl), - OPT_Wcoverage_invalid_line_number, - "function starts on a higher line number than it ends"); - end_line = startloc.line; - end_column = startloc.column; - } - - gcov_write_unsigned (end_line); - gcov_write_unsigned (end_column); - gcov_write_length (offset); - - return !gcov_is_error (); -} - -/* Finish coverage data for the current function. Verify no output - error has occurred. Save function coverage counts. */ - -void -coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum) -{ - unsigned i; - - if (bbg_file_name && gcov_is_error ()) - { - warning (0, "error writing %qs", bbg_file_name); - unlink (bbg_file_name); - bbg_file_name = NULL; - } - - if (fn_ctr_mask) - { - struct coverage_data *item = 0; - - item = ggc_alloc<coverage_data> (); - - if (param_profile_func_internal_id) - item->ident = current_function_funcdef_no + 1; - else - { - gcc_assert (coverage_node_map_initialized_p ()); - item->ident = cgraph_node::get (cfun->decl)->profile_id; - } - - item->lineno_checksum = lineno_checksum; - item->cfg_checksum = cfg_checksum; - - item->fn_decl = current_function_decl; - item->next = 0; - *functions_tail = item; - functions_tail = &item->next; - - for (i = 0; i != GCOV_COUNTERS; i++) - { - tree var = fn_v_ctrs[i]; - - if (item) - item->ctr_vars[i] = var; - if (var) - { - tree array_type = build_index_type (size_int (fn_n_ctrs[i] - 1)); - array_type = build_array_type (get_gcov_type (), array_type); - TREE_TYPE (var) = array_type; - DECL_SIZE (var) = TYPE_SIZE (array_type); - DECL_SIZE_UNIT (var) = TYPE_SIZE_UNIT (array_type); - varpool_node::finalize_decl (var); - } - - fn_b_ctrs[i] = fn_n_ctrs[i] = 0; - fn_v_ctrs[i] = NULL_TREE; - } - prg_ctr_mask |= fn_ctr_mask; - fn_ctr_mask = 0; - } -} - -/* Remove coverage file if opened. */ - -void -coverage_remove_note_file (void) -{ - if (bbg_file_name) - { - gcov_close (); - unlink (bbg_file_name); - } -} - -/* Build a coverage variable of TYPE for function FN_DECL. If COUNTER - >= 0 it is a counter array, otherwise it is the function structure. */ - -static tree -build_var (tree fn_decl, tree type, int counter) -{ - tree var = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE, type); - const char *fn_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl)); - char *buf; - size_t fn_name_len, len; - - fn_name = targetm.strip_name_encoding (fn_name); - fn_name_len = strlen (fn_name); - buf = XALLOCAVEC (char, fn_name_len + 8 + sizeof (int) * 3); - - if (counter < 0) - strcpy (buf, "__gcov__"); - else - sprintf (buf, "__gcov%u_", counter); - len = strlen (buf); - buf[len - 1] = symbol_table::symbol_suffix_separator (); - memcpy (buf + len, fn_name, fn_name_len + 1); - DECL_NAME (var) = get_identifier (buf); - TREE_STATIC (var) = 1; - TREE_ADDRESSABLE (var) = 1; - DECL_NONALIASED (var) = 1; - SET_DECL_ALIGN (var, TYPE_ALIGN (type)); - - return var; -} - -/* Creates the gcov_fn_info RECORD_TYPE. */ - -static void -build_fn_info_type (tree type, unsigned counters, tree gcov_info_type) -{ - tree ctr_info = lang_hooks.types.make_type (RECORD_TYPE); - tree field, fields; - tree array_type; - - gcc_assert (counters); - - /* ctr_info::num */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - get_gcov_unsigned_t ()); - fields = field; - - /* ctr_info::values */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - build_pointer_type (get_gcov_type ())); - DECL_CHAIN (field) = fields; - fields = field; - - finish_builtin_struct (ctr_info, "__gcov_ctr_info", fields, NULL_TREE); - - /* key */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - build_pointer_type (build_qualified_type - (gcov_info_type, TYPE_QUAL_CONST))); - fields = field; - - /* ident */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - get_gcov_unsigned_t ()); - DECL_CHAIN (field) = fields; - fields = field; - - /* lineno_checksum */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - get_gcov_unsigned_t ()); - DECL_CHAIN (field) = fields; - fields = field; - - /* cfg checksum */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - get_gcov_unsigned_t ()); - DECL_CHAIN (field) = fields; - fields = field; - - array_type = build_index_type (size_int (counters - 1)); - array_type = build_array_type (ctr_info, array_type); - - /* counters */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, array_type); - DECL_CHAIN (field) = fields; - fields = field; - - finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE); -} - -/* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is - the coverage data for the function and TYPE is the gcov_fn_info - RECORD_TYPE. KEY is the object file key. */ - -static tree -build_fn_info (const struct coverage_data *data, tree type, tree key) -{ - tree fields = TYPE_FIELDS (type); - tree ctr_type; - unsigned ix; - vec<constructor_elt, va_gc> *v1 = NULL; - vec<constructor_elt, va_gc> *v2 = NULL; - - /* key */ - CONSTRUCTOR_APPEND_ELT (v1, fields, - build1 (ADDR_EXPR, TREE_TYPE (fields), key)); - fields = DECL_CHAIN (fields); - - /* ident */ - CONSTRUCTOR_APPEND_ELT (v1, fields, - build_int_cstu (get_gcov_unsigned_t (), - data->ident)); - fields = DECL_CHAIN (fields); - - /* lineno_checksum */ - CONSTRUCTOR_APPEND_ELT (v1, fields, - build_int_cstu (get_gcov_unsigned_t (), - data->lineno_checksum)); - fields = DECL_CHAIN (fields); - - /* cfg_checksum */ - CONSTRUCTOR_APPEND_ELT (v1, fields, - build_int_cstu (get_gcov_unsigned_t (), - data->cfg_checksum)); - fields = DECL_CHAIN (fields); - - /* counters */ - ctr_type = TREE_TYPE (TREE_TYPE (fields)); - for (ix = 0; ix != GCOV_COUNTERS; ix++) - if (prg_ctr_mask & (1 << ix)) - { - vec<constructor_elt, va_gc> *ctr = NULL; - tree var = data->ctr_vars[ix]; - unsigned count = 0; - - if (var) - count - = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var)))) - + 1; - - CONSTRUCTOR_APPEND_ELT (ctr, TYPE_FIELDS (ctr_type), - build_int_cstu (get_gcov_unsigned_t (), - count)); - - if (var) - CONSTRUCTOR_APPEND_ELT (ctr, DECL_CHAIN (TYPE_FIELDS (ctr_type)), - build_fold_addr_expr (var)); - - CONSTRUCTOR_APPEND_ELT (v2, NULL, build_constructor (ctr_type, ctr)); - } - - CONSTRUCTOR_APPEND_ELT (v1, fields, - build_constructor (TREE_TYPE (fields), v2)); - - return build_constructor (type, v1); -} - -/* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be - completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */ - -static void -build_info_type (tree type, tree fn_info_ptr_type) -{ - tree field, fields = NULL_TREE; - tree merge_fn_type; - - /* Version ident */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - get_gcov_unsigned_t ()); - DECL_CHAIN (field) = fields; - fields = field; - - /* next pointer */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - build_pointer_type (build_qualified_type - (type, TYPE_QUAL_CONST))); - DECL_CHAIN (field) = fields; - fields = field; - - /* stamp */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - get_gcov_unsigned_t ()); - DECL_CHAIN (field) = fields; - fields = field; - - /* Checksum. */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - get_gcov_unsigned_t ()); - DECL_CHAIN (field) = fields; - fields = field; - - /* Filename */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - build_pointer_type (build_qualified_type - (char_type_node, TYPE_QUAL_CONST))); - DECL_CHAIN (field) = fields; - fields = field; - - /* merge fn array */ - merge_fn_type - = build_function_type_list (void_type_node, - build_pointer_type (get_gcov_type ()), - get_gcov_unsigned_t (), NULL_TREE); - merge_fn_type - = build_array_type (build_pointer_type (merge_fn_type), - build_index_type (size_int (GCOV_COUNTERS - 1))); - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - merge_fn_type); - DECL_CHAIN (field) = fields; - fields = field; - - /* n_functions */ - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - get_gcov_unsigned_t ()); - DECL_CHAIN (field) = fields; - fields = field; - - /* function_info pointer pointer */ - fn_info_ptr_type = build_pointer_type - (build_qualified_type (fn_info_ptr_type, TYPE_QUAL_CONST)); - field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, - fn_info_ptr_type); - DECL_CHAIN (field) = fields; - fields = field; - - finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE); -} - -/* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the - gcov_info structure type, FN_ARY is the array of pointers to - function info objects. */ - -static tree -build_info (tree info_type, tree fn_ary, unsigned object_checksum) -{ - tree info_fields = TYPE_FIELDS (info_type); - tree merge_fn_type, n_funcs; - unsigned ix; - tree filename_string; - int da_file_name_len; - vec<constructor_elt, va_gc> *v1 = NULL; - vec<constructor_elt, va_gc> *v2 = NULL; - - /* Version ident */ - CONSTRUCTOR_APPEND_ELT (v1, info_fields, - build_int_cstu (TREE_TYPE (info_fields), - GCOV_VERSION)); - info_fields = DECL_CHAIN (info_fields); - - /* next -- NULL */ - CONSTRUCTOR_APPEND_ELT (v1, info_fields, null_pointer_node); - info_fields = DECL_CHAIN (info_fields); - - /* stamp */ - CONSTRUCTOR_APPEND_ELT (v1, info_fields, - build_int_cstu (TREE_TYPE (info_fields), - bbg_file_stamp)); - info_fields = DECL_CHAIN (info_fields); - - /* Checksum. */ - CONSTRUCTOR_APPEND_ELT (v1, info_fields, - build_int_cstu (TREE_TYPE (info_fields), - object_checksum)); - info_fields = DECL_CHAIN (info_fields); - - /* Filename */ - da_file_name_len = strlen (da_file_name); - filename_string = build_string (da_file_name_len + 1, da_file_name); - TREE_TYPE (filename_string) = build_array_type - (char_type_node, build_index_type (size_int (da_file_name_len))); - CONSTRUCTOR_APPEND_ELT (v1, info_fields, - build1 (ADDR_EXPR, TREE_TYPE (info_fields), - filename_string)); - info_fields = DECL_CHAIN (info_fields); - - /* merge fn array -- NULL slots indicate unmeasured counters */ - merge_fn_type = TREE_TYPE (TREE_TYPE (info_fields)); - for (ix = 0; ix != GCOV_COUNTERS; ix++) - { - tree ptr = null_pointer_node; - - if ((1u << ix) & prg_ctr_mask) - { - tree merge_fn = build_decl (BUILTINS_LOCATION, - FUNCTION_DECL, - get_identifier (ctr_merge_functions[ix]), - TREE_TYPE (merge_fn_type)); - DECL_EXTERNAL (merge_fn) = 1; - TREE_PUBLIC (merge_fn) = 1; - DECL_ARTIFICIAL (merge_fn) = 1; - TREE_NOTHROW (merge_fn) = 1; - /* Initialize assembler name so we can stream out. */ - DECL_ASSEMBLER_NAME (merge_fn); - ptr = build1 (ADDR_EXPR, merge_fn_type, merge_fn); - } - CONSTRUCTOR_APPEND_ELT (v2, NULL, ptr); - } - CONSTRUCTOR_APPEND_ELT (v1, info_fields, - build_constructor (TREE_TYPE (info_fields), v2)); - info_fields = DECL_CHAIN (info_fields); - - /* n_functions */ - n_funcs = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary))); - n_funcs = fold_build2 (PLUS_EXPR, TREE_TYPE (info_fields), - n_funcs, size_one_node); - CONSTRUCTOR_APPEND_ELT (v1, info_fields, n_funcs); - info_fields = DECL_CHAIN (info_fields); - - /* functions */ - CONSTRUCTOR_APPEND_ELT (v1, info_fields, - build1 (ADDR_EXPR, TREE_TYPE (info_fields), fn_ary)); - info_fields = DECL_CHAIN (info_fields); - - gcc_assert (!info_fields); - return build_constructor (info_type, v1); -} - -/* Generate the constructor function to call __gcov_init. */ - -static void -build_init_ctor (tree gcov_info_type) -{ - tree ctor, stmt, init_fn; - - /* Build a decl for __gcov_init. */ - init_fn = build_pointer_type (gcov_info_type); - init_fn = build_function_type_list (void_type_node, init_fn, NULL); - init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, - get_identifier ("__gcov_init"), init_fn); - TREE_PUBLIC (init_fn) = 1; - DECL_EXTERNAL (init_fn) = 1; - DECL_ASSEMBLER_NAME (init_fn); - - /* Generate a call to __gcov_init(&gcov_info). */ - ctor = NULL; - stmt = build_fold_addr_expr (gcov_info_var); - stmt = build_call_expr (init_fn, 1, stmt); - append_to_statement_list (stmt, &ctor); - - /* Generate a constructor to run it. */ - int priority = SUPPORTS_INIT_PRIORITY - ? MAX_RESERVED_INIT_PRIORITY: DEFAULT_INIT_PRIORITY; - cgraph_build_static_cdtor ('I', ctor, priority); -} - -/* Generate the destructor function to call __gcov_exit. */ - -static void -build_gcov_exit_decl (void) -{ - tree init_fn = build_function_type_list (void_type_node, NULL); - init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, - get_identifier ("__gcov_exit"), init_fn); - TREE_PUBLIC (init_fn) = 1; - DECL_EXTERNAL (init_fn) = 1; - DECL_ASSEMBLER_NAME (init_fn); - - /* Generate a call to __gcov_exit (). */ - tree dtor = NULL; - tree stmt = build_call_expr (init_fn, 0); - append_to_statement_list (stmt, &dtor); - - /* Generate a destructor to run it. */ - int priority = SUPPORTS_INIT_PRIORITY - ? MAX_RESERVED_INIT_PRIORITY: DEFAULT_INIT_PRIORITY; - - cgraph_build_static_cdtor ('D', dtor, priority); -} - -/* Generate the pointer to the gcov_info_var in a dedicated section. */ - -static void -build_gcov_info_var_registration (tree gcov_info_type) -{ - tree var = build_decl (BUILTINS_LOCATION, - VAR_DECL, NULL_TREE, - build_pointer_type (gcov_info_type)); - TREE_STATIC (var) = 1; - TREE_READONLY (var) = 1; - char name_buf[32]; - ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 2); - DECL_NAME (var) = get_identifier (name_buf); - get_section (profile_info_section, SECTION_UNNAMED, NULL); - set_decl_section_name (var, profile_info_section); - mark_decl_referenced (var); - DECL_INITIAL (var) = build_fold_addr_expr (gcov_info_var); - varpool_node::finalize_decl (var); -} - -/* Create the gcov_info types and object. Generate the constructor - function to call __gcov_init. Does not generate the initializer - for the object. Returns TRUE if coverage data is being emitted. */ - -static bool -coverage_obj_init (void) -{ - tree gcov_info_type; - unsigned n_counters = 0; - unsigned ix; - struct coverage_data *fn; - struct coverage_data **fn_prev; - char name_buf[32]; - - no_coverage = 1; /* Disable any further coverage. */ - - if (!prg_ctr_mask) - return false; - - if (symtab->dump_file) - fprintf (symtab->dump_file, "Using data file %s\n", da_file_name); - - /* Prune functions. */ - for (fn_prev = &functions_head; (fn = *fn_prev);) - if (DECL_STRUCT_FUNCTION (fn->fn_decl)) - fn_prev = &fn->next; - else - /* The function is not being emitted, remove from list. */ - *fn_prev = fn->next; - - if (functions_head == NULL) - return false; - - for (ix = 0; ix != GCOV_COUNTERS; ix++) - if ((1u << ix) & prg_ctr_mask) - n_counters++; - - /* Build the info and fn_info types. These are mutually recursive. */ - gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE); - gcov_fn_info_type = lang_hooks.types.make_type (RECORD_TYPE); - build_fn_info_type (gcov_fn_info_type, n_counters, gcov_info_type); - gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE); - gcov_fn_info_ptr_type = build_pointer_type - (build_qualified_type (gcov_fn_info_type, TYPE_QUAL_CONST)); - build_info_type (gcov_info_type, gcov_fn_info_ptr_type); - - /* Build the gcov info var, this is referred to in its own - initializer. */ - gcov_info_var = build_decl (BUILTINS_LOCATION, - VAR_DECL, NULL_TREE, gcov_info_type); - TREE_STATIC (gcov_info_var) = 1; - ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0); - DECL_NAME (gcov_info_var) = get_identifier (name_buf); - - if (profile_info_section) - build_gcov_info_var_registration (gcov_info_type); - else - { - build_init_ctor (gcov_info_type); - build_gcov_exit_decl (); - } - - return true; -} - -/* Generate the coverage function info for FN and DATA. Append a - pointer to that object to CTOR and return the appended CTOR. */ - -static vec<constructor_elt, va_gc> * -coverage_obj_fn (vec<constructor_elt, va_gc> *ctor, tree fn, - struct coverage_data const *data) -{ - tree init = build_fn_info (data, gcov_fn_info_type, gcov_info_var); - tree var = build_var (fn, gcov_fn_info_type, -1); - - DECL_INITIAL (var) = init; - varpool_node::finalize_decl (var); - - CONSTRUCTOR_APPEND_ELT (ctor, NULL, - build1 (ADDR_EXPR, gcov_fn_info_ptr_type, var)); - return ctor; -} - -/* Finalize the coverage data. Generates the array of pointers to - function objects from CTOR. Generate the gcov_info initializer. */ - -static void -coverage_obj_finish (vec<constructor_elt, va_gc> *ctor, - unsigned object_checksum) -{ - unsigned n_functions = vec_safe_length (ctor); - tree fn_info_ary_type = build_array_type - (build_qualified_type (gcov_fn_info_ptr_type, TYPE_QUAL_CONST), - build_index_type (size_int (n_functions - 1))); - tree fn_info_ary = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE, - fn_info_ary_type); - char name_buf[32]; - - TREE_STATIC (fn_info_ary) = 1; - ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 1); - DECL_NAME (fn_info_ary) = get_identifier (name_buf); - DECL_INITIAL (fn_info_ary) = build_constructor (fn_info_ary_type, ctor); - varpool_node::finalize_decl (fn_info_ary); - - DECL_INITIAL (gcov_info_var) - = build_info (TREE_TYPE (gcov_info_var), fn_info_ary, object_checksum); - varpool_node::finalize_decl (gcov_info_var); -} - -/* Perform file-level initialization. Read in data file, generate name - of notes file. */ - -void -coverage_init (const char *filename) -{ - const char *original_filename = filename; - int original_len = strlen (original_filename); -#if HAVE_DOS_BASED_FILE_SYSTEM - const char *separator = "\\"; -#else - const char *separator = "/"; -#endif - int len = strlen (filename); - int prefix_len = 0; - - /* Since coverage_init is invoked very early, before the pass - manager, we need to set up the dumping explicitly. This is - similar to the handling in finish_optimization_passes. */ - int profile_pass_num = - g->get_passes ()->get_pass_profile ()->static_pass_number; - g->get_dumps ()->dump_start (profile_pass_num, NULL); - - if (!IS_ABSOLUTE_PATH (filename)) - { - /* When a profile_data_prefix is provided, then mangle full path - of filename in order to prevent file path clashing. */ - if (profile_data_prefix) - { - filename = concat (getpwd (), separator, filename, NULL); - if (profile_prefix_path) - { - if (startswith (filename, profile_prefix_path)) - { - filename += strlen (profile_prefix_path); - while (*filename == *separator) - filename++; - } - else - warning (0, "filename %qs does not start with profile " - "prefix %qs", filename, profile_prefix_path); - } - filename = mangle_path (filename); - len = strlen (filename); - } - else - profile_data_prefix = getpwd (); - } - - if (profile_data_prefix) - prefix_len = strlen (profile_data_prefix); - - /* Name of da file. */ - da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX) - + prefix_len + 2); - - if (profile_data_prefix) - { - memcpy (da_file_name, profile_data_prefix, prefix_len); - da_file_name[prefix_len++] = *separator; - } - memcpy (da_file_name + prefix_len, filename, len); - strcpy (da_file_name + prefix_len + len, GCOV_DATA_SUFFIX); - - bbg_file_stamp = local_tick; - if (flag_auto_profile) - read_autofdo_file (); - else if (flag_branch_probabilities) - read_counts_file (); - - /* Name of bbg file. */ - if (flag_test_coverage && !flag_compare_debug) - { - if (profile_note_location) - bbg_file_name = xstrdup (profile_note_location); - else - { - bbg_file_name = XNEWVEC (char, original_len + strlen (GCOV_NOTE_SUFFIX) + 1); - memcpy (bbg_file_name, original_filename, original_len); - strcpy (bbg_file_name + original_len, GCOV_NOTE_SUFFIX); - } - - if (!gcov_open (bbg_file_name, -1)) - { - error ("cannot open %s", bbg_file_name); - bbg_file_name = NULL; - } - else - { - gcov_write_unsigned (GCOV_NOTE_MAGIC); - gcov_write_unsigned (GCOV_VERSION); - gcov_write_unsigned (bbg_file_stamp); - /* Use an arbitrary checksum */ - gcov_write_unsigned (0); - gcov_write_string (getpwd ()); - - /* Do not support has_unexecuted_blocks for Ada. */ - gcov_write_unsigned (strcmp (lang_hooks.name, "GNU Ada") != 0); - } - } - - g->get_dumps ()->dump_finish (profile_pass_num); -} - -/* Performs file-level cleanup. Close notes file, generate coverage - variables and constructor. */ - -void -coverage_finish (void) -{ - if (bbg_file_name && gcov_close ()) - unlink (bbg_file_name); - - if (!flag_branch_probabilities && flag_test_coverage - && (!local_tick || local_tick == (unsigned)-1)) - /* Only remove the da file, if we're emitting coverage code and - cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */ - unlink (da_file_name); - - /* Global GCDA checksum that aggregates all functions. */ - unsigned object_checksum = 0; - - if (coverage_obj_init ()) - { - vec<constructor_elt, va_gc> *fn_ctor = NULL; - struct coverage_data *fn; - - for (fn = functions_head; fn; fn = fn->next) - { - fn_ctor = coverage_obj_fn (fn_ctor, fn->fn_decl, fn); - - object_checksum = crc32_unsigned (object_checksum, fn->ident); - object_checksum = crc32_unsigned (object_checksum, - fn->lineno_checksum); - object_checksum = crc32_unsigned (object_checksum, fn->cfg_checksum); - } - coverage_obj_finish (fn_ctor, object_checksum); - } - - XDELETEVEC (da_file_name); - da_file_name = NULL; -} - -#include "gt-coverage.h" |