1 /* Read and write coverage files, and associated functionality. 2 Copyright (C) 1990-2015 Free Software Foundation, Inc. 3 Contributed by James E. Wilson, UC Berkeley/Cygnus Support; 4 based on some ideas from Dain Samples of UC Berkeley. 5 Further mangling by Bob Manson, Cygnus Support. 6 Further mangled by Nathan Sidwell, CodeSourcery 7 8 This file is part of GCC. 9 10 GCC is free software; you can redistribute it and/or modify it under 11 the terms of the GNU General Public License as published by the Free 12 Software Foundation; either version 3, or (at your option) any later 13 version. 14 15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 16 WARRANTY; without even the implied warranty of MERCHANTABILITY or 17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 18 for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with GCC; see the file COPYING3. If not see 22 <http://www.gnu.org/licenses/>. */ 23 24 25 #define GCOV_LINKAGE 26 27 #include "config.h" 28 #include "system.h" 29 #include "coretypes.h" 30 #include "tm.h" 31 #include "rtl.h" 32 #include "hash-set.h" 33 #include "machmode.h" 34 #include "vec.h" 35 #include "double-int.h" 36 #include "input.h" 37 #include "alias.h" 38 #include "symtab.h" 39 #include "wide-int.h" 40 #include "inchash.h" 41 #include "tree.h" 42 #include "fold-const.h" 43 #include "stringpool.h" 44 #include "stor-layout.h" 45 #include "flags.h" 46 #include "output.h" 47 #include "regs.h" 48 #include "hashtab.h" 49 #include "hard-reg-set.h" 50 #include "function.h" 51 #include "statistics.h" 52 #include "real.h" 53 #include "fixed-value.h" 54 #include "insn-config.h" 55 #include "expmed.h" 56 #include "dojump.h" 57 #include "explow.h" 58 #include "calls.h" 59 #include "emit-rtl.h" 60 #include "varasm.h" 61 #include "stmt.h" 62 #include "expr.h" 63 #include "predict.h" 64 #include "dominance.h" 65 #include "cfg.h" 66 #include "basic-block.h" 67 #include "toplev.h" 68 #include "tm_p.h" 69 #include "ggc.h" 70 #include "coverage.h" 71 #include "langhooks.h" 72 #include "hash-table.h" 73 #include "tree-iterator.h" 74 #include "context.h" 75 #include "pass_manager.h" 76 #include "tree-pass.h" 77 #include "hash-map.h" 78 #include "is-a.h" 79 #include "plugin-api.h" 80 #include "ipa-ref.h" 81 #include "cgraph.h" 82 #include "dumpfile.h" 83 #include "diagnostic-core.h" 84 #include "intl.h" 85 #include "filenames.h" 86 #include "target.h" 87 #include "params.h" 88 #include "auto-profile.h" 89 90 #include "gcov-io.h" 91 #include "gcov-io.c" 92 93 struct GTY((chain_next ("%h.next"))) coverage_data 94 { 95 struct coverage_data *next; /* next function */ 96 unsigned ident; /* function ident */ 97 unsigned lineno_checksum; /* function lineno checksum */ 98 unsigned cfg_checksum; /* function cfg checksum */ 99 tree fn_decl; /* the function decl */ 100 tree ctr_vars[GCOV_COUNTERS]; /* counter variables. */ 101 }; 102 103 /* Counts information for a function. */ 104 typedef struct counts_entry 105 { 106 /* We hash by */ 107 unsigned ident; 108 unsigned ctr; 109 110 /* Store */ 111 unsigned lineno_checksum; 112 unsigned cfg_checksum; 113 gcov_type *counts; 114 struct gcov_ctr_summary summary; 115 116 /* hash_table support. */ 117 typedef counts_entry value_type; 118 typedef counts_entry compare_type; 119 static inline hashval_t hash (const value_type *); 120 static int equal (const value_type *, const compare_type *); 121 static void remove (value_type *); 122 } counts_entry_t; 123 124 static GTY(()) struct coverage_data *functions_head = 0; 125 static struct coverage_data **functions_tail = &functions_head; 126 static unsigned no_coverage = 0; 127 128 /* Cumulative counter information for whole program. */ 129 static unsigned prg_ctr_mask; /* Mask of counter types generated. */ 130 131 /* Counter information for current function. */ 132 static unsigned fn_ctr_mask; /* Mask of counters used. */ 133 static GTY(()) tree fn_v_ctrs[GCOV_COUNTERS]; /* counter variables. */ 134 static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */ 135 static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */ 136 137 /* Coverage info VAR_DECL and function info type nodes. */ 138 static GTY(()) tree gcov_info_var; 139 static GTY(()) tree gcov_fn_info_type; 140 static GTY(()) tree gcov_fn_info_ptr_type; 141 142 /* Name of the notes (gcno) output file. The "bbg" prefix is for 143 historical reasons, when the notes file contained only the 144 basic block graph notes. 145 If this is NULL we're not writing to the notes file. */ 146 static char *bbg_file_name; 147 148 /* File stamp for notes file. */ 149 static unsigned bbg_file_stamp; 150 151 /* Name of the count data (gcda) file. */ 152 static char *da_file_name; 153 154 /* The names of merge functions for counters. */ 155 #define STR(str) #str 156 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) STR(__gcov_merge ## FN_TYPE), 157 static const char *const ctr_merge_functions[GCOV_COUNTERS] = { 158 #include "gcov-counter.def" 159 }; 160 #undef DEF_GCOV_COUNTER 161 #undef STR 162 163 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) NAME, 164 static const char *const ctr_names[GCOV_COUNTERS] = { 165 #include "gcov-counter.def" 166 }; 167 #undef DEF_GCOV_COUNTER 168 169 /* Forward declarations. */ 170 static void read_counts_file (void); 171 static tree build_var (tree, tree, int); 172 static void build_fn_info_type (tree, unsigned, tree); 173 static void build_info_type (tree, tree); 174 static tree build_fn_info (const struct coverage_data *, tree, tree); 175 static tree build_info (tree, tree); 176 static bool coverage_obj_init (void); 177 static vec<constructor_elt, va_gc> *coverage_obj_fn 178 (vec<constructor_elt, va_gc> *, tree, struct coverage_data const *); 179 static void coverage_obj_finish (vec<constructor_elt, va_gc> *); 180 181 /* Return the type node for gcov_type. */ 182 183 tree 184 get_gcov_type (void) 185 { 186 machine_mode mode = smallest_mode_for_size (GCOV_TYPE_SIZE, MODE_INT); 187 return lang_hooks.types.type_for_mode (mode, false); 188 } 189 190 /* Return the type node for gcov_unsigned_t. */ 191 192 static tree 193 get_gcov_unsigned_t (void) 194 { 195 machine_mode mode = smallest_mode_for_size (32, MODE_INT); 196 return lang_hooks.types.type_for_mode (mode, true); 197 } 198 199 inline hashval_t 200 counts_entry::hash (const value_type *entry) 201 { 202 return entry->ident * GCOV_COUNTERS + entry->ctr; 203 } 204 205 inline int 206 counts_entry::equal (const value_type *entry1, 207 const compare_type *entry2) 208 { 209 return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr; 210 } 211 212 inline void 213 counts_entry::remove (value_type *entry) 214 { 215 free (entry->counts); 216 free (entry); 217 } 218 219 /* Hash table of count data. */ 220 static hash_table<counts_entry> *counts_hash; 221 222 /* Read in the counts file, if available. */ 223 224 static void 225 read_counts_file (void) 226 { 227 gcov_unsigned_t fn_ident = 0; 228 struct gcov_summary summary; 229 unsigned new_summary = 1; 230 gcov_unsigned_t tag; 231 int is_error = 0; 232 unsigned lineno_checksum = 0; 233 unsigned cfg_checksum = 0; 234 235 if (!gcov_open (da_file_name, 1)) 236 return; 237 238 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC)) 239 { 240 warning (0, "%qs is not a gcov data file", da_file_name); 241 gcov_close (); 242 return; 243 } 244 else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION) 245 { 246 char v[4], e[4]; 247 248 GCOV_UNSIGNED2STRING (v, tag); 249 GCOV_UNSIGNED2STRING (e, GCOV_VERSION); 250 251 warning (0, "%qs is version %q.*s, expected version %q.*s", 252 da_file_name, 4, v, 4, e); 253 gcov_close (); 254 return; 255 } 256 257 /* Read the stamp, used for creating a generation count. */ 258 tag = gcov_read_unsigned (); 259 bbg_file_stamp = crc32_unsigned (bbg_file_stamp, tag); 260 261 counts_hash = new hash_table<counts_entry> (10); 262 while ((tag = gcov_read_unsigned ())) 263 { 264 gcov_unsigned_t length; 265 gcov_position_t offset; 266 267 length = gcov_read_unsigned (); 268 offset = gcov_position (); 269 if (tag == GCOV_TAG_FUNCTION) 270 { 271 if (length) 272 { 273 fn_ident = gcov_read_unsigned (); 274 lineno_checksum = gcov_read_unsigned (); 275 cfg_checksum = gcov_read_unsigned (); 276 } 277 else 278 fn_ident = lineno_checksum = cfg_checksum = 0; 279 new_summary = 1; 280 } 281 else if (tag == GCOV_TAG_PROGRAM_SUMMARY) 282 { 283 struct gcov_summary sum; 284 unsigned ix; 285 286 if (new_summary) 287 memset (&summary, 0, sizeof (summary)); 288 289 gcov_read_summary (&sum); 290 for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++) 291 { 292 summary.ctrs[ix].runs += sum.ctrs[ix].runs; 293 summary.ctrs[ix].sum_all += sum.ctrs[ix].sum_all; 294 if (summary.ctrs[ix].run_max < sum.ctrs[ix].run_max) 295 summary.ctrs[ix].run_max = sum.ctrs[ix].run_max; 296 summary.ctrs[ix].sum_max += sum.ctrs[ix].sum_max; 297 } 298 if (new_summary) 299 memcpy (summary.ctrs[GCOV_COUNTER_ARCS].histogram, 300 sum.ctrs[GCOV_COUNTER_ARCS].histogram, 301 sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE); 302 else 303 gcov_histogram_merge (summary.ctrs[GCOV_COUNTER_ARCS].histogram, 304 sum.ctrs[GCOV_COUNTER_ARCS].histogram); 305 new_summary = 0; 306 } 307 else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident) 308 { 309 counts_entry_t **slot, *entry, elt; 310 unsigned n_counts = GCOV_TAG_COUNTER_NUM (length); 311 unsigned ix; 312 313 elt.ident = fn_ident; 314 elt.ctr = GCOV_COUNTER_FOR_TAG (tag); 315 316 slot = counts_hash->find_slot (&elt, INSERT); 317 entry = *slot; 318 if (!entry) 319 { 320 *slot = entry = XCNEW (counts_entry_t); 321 entry->ident = fn_ident; 322 entry->ctr = elt.ctr; 323 entry->lineno_checksum = lineno_checksum; 324 entry->cfg_checksum = cfg_checksum; 325 if (elt.ctr < GCOV_COUNTERS_SUMMABLE) 326 entry->summary = summary.ctrs[elt.ctr]; 327 entry->summary.num = n_counts; 328 entry->counts = XCNEWVEC (gcov_type, n_counts); 329 } 330 else if (entry->lineno_checksum != lineno_checksum 331 || entry->cfg_checksum != cfg_checksum) 332 { 333 error ("Profile data for function %u is corrupted", fn_ident); 334 error ("checksum is (%x,%x) instead of (%x,%x)", 335 entry->lineno_checksum, entry->cfg_checksum, 336 lineno_checksum, cfg_checksum); 337 delete counts_hash; 338 counts_hash = NULL; 339 break; 340 } 341 else if (entry->summary.num != n_counts) 342 { 343 error ("Profile data for function %u is corrupted", fn_ident); 344 error ("number of counters is %d instead of %d", entry->summary.num, n_counts); 345 delete counts_hash; 346 counts_hash = NULL; 347 break; 348 } 349 else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE) 350 { 351 error ("cannot merge separate %s counters for function %u", 352 ctr_names[elt.ctr], fn_ident); 353 goto skip_merge; 354 } 355 else 356 { 357 entry->summary.runs += summary.ctrs[elt.ctr].runs; 358 entry->summary.sum_all += summary.ctrs[elt.ctr].sum_all; 359 if (entry->summary.run_max < summary.ctrs[elt.ctr].run_max) 360 entry->summary.run_max = summary.ctrs[elt.ctr].run_max; 361 entry->summary.sum_max += summary.ctrs[elt.ctr].sum_max; 362 } 363 for (ix = 0; ix != n_counts; ix++) 364 entry->counts[ix] += gcov_read_counter (); 365 skip_merge:; 366 } 367 gcov_sync (offset, length); 368 if ((is_error = gcov_is_error ())) 369 { 370 error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted", 371 da_file_name); 372 delete counts_hash; 373 counts_hash = NULL; 374 break; 375 } 376 } 377 378 gcov_close (); 379 } 380 381 /* Returns the counters for a particular tag. */ 382 383 gcov_type * 384 get_coverage_counts (unsigned counter, unsigned expected, 385 unsigned cfg_checksum, unsigned lineno_checksum, 386 const struct gcov_ctr_summary **summary) 387 { 388 counts_entry_t *entry, elt; 389 390 /* No hash table, no counts. */ 391 if (!counts_hash) 392 { 393 static int warned = 0; 394 395 if (!warned++ && dump_enabled_p ()) 396 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location, 397 (flag_guess_branch_prob 398 ? "file %s not found, execution counts estimated\n" 399 : "file %s not found, execution counts assumed to " 400 "be zero\n"), 401 da_file_name); 402 return NULL; 403 } 404 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID)) 405 elt.ident = current_function_funcdef_no + 1; 406 else 407 { 408 gcc_assert (coverage_node_map_initialized_p ()); 409 elt.ident = cgraph_node::get (cfun->decl)->profile_id; 410 } 411 elt.ctr = counter; 412 entry = counts_hash->find (&elt); 413 if (!entry || !entry->summary.num) 414 /* The function was not emitted, or is weak and not chosen in the 415 final executable. Silently fail, because there's nothing we 416 can do about it. */ 417 return NULL; 418 419 if (entry->cfg_checksum != cfg_checksum 420 || entry->summary.num != expected) 421 { 422 static int warned = 0; 423 bool warning_printed = false; 424 tree id = DECL_ASSEMBLER_NAME (current_function_decl); 425 426 warning_printed = 427 warning_at (input_location, OPT_Wcoverage_mismatch, 428 "the control flow of function %qE does not match " 429 "its profile data (counter %qs)", id, ctr_names[counter]); 430 if (warning_printed && dump_enabled_p ()) 431 { 432 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location, 433 "use -Wno-error=coverage-mismatch to tolerate " 434 "the mismatch but performance may drop if the " 435 "function is hot\n"); 436 437 if (!seen_error () 438 && !warned++) 439 { 440 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location, 441 "coverage mismatch ignored\n"); 442 dump_printf (MSG_OPTIMIZED_LOCATIONS, 443 flag_guess_branch_prob 444 ? G_("execution counts estimated\n") 445 : G_("execution counts assumed to be zero\n")); 446 if (!flag_guess_branch_prob) 447 dump_printf (MSG_OPTIMIZED_LOCATIONS, 448 "this can result in poorly optimized code\n"); 449 } 450 } 451 452 return NULL; 453 } 454 else if (entry->lineno_checksum != lineno_checksum) 455 { 456 warning (OPT_Wcoverage_mismatch, 457 "source locations for function %qE have changed," 458 " the profile data may be out of date", 459 DECL_ASSEMBLER_NAME (current_function_decl)); 460 } 461 462 if (summary) 463 *summary = &entry->summary; 464 465 return entry->counts; 466 } 467 468 /* Allocate NUM counters of type COUNTER. Returns nonzero if the 469 allocation succeeded. */ 470 471 int 472 coverage_counter_alloc (unsigned counter, unsigned num) 473 { 474 if (no_coverage) 475 return 0; 476 477 if (!num) 478 return 1; 479 480 if (!fn_v_ctrs[counter]) 481 { 482 tree array_type = build_array_type (get_gcov_type (), NULL_TREE); 483 484 fn_v_ctrs[counter] 485 = build_var (current_function_decl, array_type, counter); 486 } 487 488 fn_b_ctrs[counter] = fn_n_ctrs[counter]; 489 fn_n_ctrs[counter] += num; 490 491 fn_ctr_mask |= 1 << counter; 492 return 1; 493 } 494 495 /* Generate a tree to access COUNTER NO. */ 496 497 tree 498 tree_coverage_counter_ref (unsigned counter, unsigned no) 499 { 500 tree gcov_type_node = get_gcov_type (); 501 502 gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]); 503 504 no += fn_b_ctrs[counter]; 505 506 /* "no" here is an array index, scaled to bytes later. */ 507 return build4 (ARRAY_REF, gcov_type_node, fn_v_ctrs[counter], 508 build_int_cst (integer_type_node, no), NULL, NULL); 509 } 510 511 /* Generate a tree to access the address of COUNTER NO. */ 512 513 tree 514 tree_coverage_counter_addr (unsigned counter, unsigned no) 515 { 516 tree gcov_type_node = get_gcov_type (); 517 518 gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]); 519 no += fn_b_ctrs[counter]; 520 521 /* "no" here is an array index, scaled to bytes later. */ 522 return build_fold_addr_expr (build4 (ARRAY_REF, gcov_type_node, 523 fn_v_ctrs[counter], 524 build_int_cst (integer_type_node, no), 525 NULL, NULL)); 526 } 527 528 529 /* Generate a checksum for a string. CHKSUM is the current 530 checksum. */ 531 532 static unsigned 533 coverage_checksum_string (unsigned chksum, const char *string) 534 { 535 int i; 536 char *dup = NULL; 537 538 /* Look for everything that looks if it were produced by 539 get_file_function_name and zero out the second part 540 that may result from flag_random_seed. This is not critical 541 as the checksums are used only for sanity checking. */ 542 for (i = 0; string[i]; i++) 543 { 544 int offset = 0; 545 if (!strncmp (string + i, "_GLOBAL__N_", 11)) 546 offset = 11; 547 if (!strncmp (string + i, "_GLOBAL__", 9)) 548 offset = 9; 549 550 /* C++ namespaces do have scheme: 551 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname 552 since filename might contain extra underscores there seems 553 to be no better chance then walk all possible offsets looking 554 for magicnumber. */ 555 if (offset) 556 { 557 for (i = i + offset; string[i]; i++) 558 if (string[i]=='_') 559 { 560 int y; 561 562 for (y = 1; y < 9; y++) 563 if (!(string[i + y] >= '0' && string[i + y] <= '9') 564 && !(string[i + y] >= 'A' && string[i + y] <= 'F')) 565 break; 566 if (y != 9 || string[i + 9] != '_') 567 continue; 568 for (y = 10; y < 18; y++) 569 if (!(string[i + y] >= '0' && string[i + y] <= '9') 570 && !(string[i + y] >= 'A' && string[i + y] <= 'F')) 571 break; 572 if (y != 18) 573 continue; 574 if (!dup) 575 string = dup = xstrdup (string); 576 for (y = 10; y < 18; y++) 577 dup[i + y] = '0'; 578 } 579 break; 580 } 581 } 582 583 chksum = crc32_string (chksum, string); 584 free (dup); 585 586 return chksum; 587 } 588 589 /* Compute checksum for the current function. We generate a CRC32. */ 590 591 unsigned 592 coverage_compute_lineno_checksum (void) 593 { 594 expanded_location xloc 595 = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); 596 unsigned chksum = xloc.line; 597 598 chksum = coverage_checksum_string (chksum, xloc.file); 599 chksum = coverage_checksum_string 600 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl))); 601 602 return chksum; 603 } 604 605 /* Compute profile ID. This is better to be unique in whole program. */ 606 607 unsigned 608 coverage_compute_profile_id (struct cgraph_node *n) 609 { 610 unsigned chksum; 611 612 /* Externally visible symbols have unique name. */ 613 if (TREE_PUBLIC (n->decl) || DECL_EXTERNAL (n->decl) || n->unique_name) 614 { 615 chksum = coverage_checksum_string 616 (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl))); 617 } 618 else 619 { 620 expanded_location xloc 621 = expand_location (DECL_SOURCE_LOCATION (n->decl)); 622 bool use_name_only = (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID) == 0); 623 624 chksum = (use_name_only ? 0 : xloc.line); 625 chksum = coverage_checksum_string (chksum, xloc.file); 626 chksum = coverage_checksum_string 627 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl))); 628 if (!use_name_only && first_global_object_name) 629 chksum = coverage_checksum_string 630 (chksum, first_global_object_name); 631 chksum = coverage_checksum_string 632 (chksum, aux_base_name); 633 } 634 635 /* Non-negative integers are hopefully small enough to fit in all targets. 636 Gcov file formats wants non-zero function IDs. */ 637 chksum = chksum & 0x7fffffff; 638 return chksum + (!chksum); 639 } 640 641 /* Compute cfg checksum for the function FN given as argument. 642 The checksum is calculated carefully so that 643 source code changes that doesn't affect the control flow graph 644 won't change the checksum. 645 This is to make the profile data useable across source code change. 646 The downside of this is that the compiler may use potentially 647 wrong profile data - that the source code change has non-trivial impact 648 on the validity of profile data (e.g. the reversed condition) 649 but the compiler won't detect the change and use the wrong profile data. */ 650 651 unsigned 652 coverage_compute_cfg_checksum (struct function *fn) 653 { 654 basic_block bb; 655 unsigned chksum = n_basic_blocks_for_fn (fn); 656 657 FOR_EACH_BB_FN (bb, fn) 658 { 659 edge e; 660 edge_iterator ei; 661 chksum = crc32_byte (chksum, bb->index); 662 FOR_EACH_EDGE (e, ei, bb->succs) 663 { 664 chksum = crc32_byte (chksum, e->dest->index); 665 } 666 } 667 668 return chksum; 669 } 670 671 /* Begin output to the notes file for the current function. 672 Writes the function header. Returns nonzero if data should be output. */ 673 674 int 675 coverage_begin_function (unsigned lineno_checksum, unsigned cfg_checksum) 676 { 677 expanded_location xloc; 678 unsigned long offset; 679 680 /* We don't need to output .gcno file unless we're under -ftest-coverage 681 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */ 682 if (no_coverage || !bbg_file_name) 683 return 0; 684 685 xloc = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); 686 687 /* Announce function */ 688 offset = gcov_write_tag (GCOV_TAG_FUNCTION); 689 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID)) 690 gcov_write_unsigned (current_function_funcdef_no + 1); 691 else 692 { 693 gcc_assert (coverage_node_map_initialized_p ()); 694 gcov_write_unsigned ( 695 cgraph_node::get (current_function_decl)->profile_id); 696 } 697 698 gcov_write_unsigned (lineno_checksum); 699 gcov_write_unsigned (cfg_checksum); 700 gcov_write_string (IDENTIFIER_POINTER 701 (DECL_ASSEMBLER_NAME (current_function_decl))); 702 gcov_write_string (xloc.file); 703 gcov_write_unsigned (xloc.line); 704 gcov_write_length (offset); 705 706 return !gcov_is_error (); 707 } 708 709 /* Finish coverage data for the current function. Verify no output 710 error has occurred. Save function coverage counts. */ 711 712 void 713 coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum) 714 { 715 unsigned i; 716 717 if (bbg_file_name && gcov_is_error ()) 718 { 719 warning (0, "error writing %qs", bbg_file_name); 720 unlink (bbg_file_name); 721 bbg_file_name = NULL; 722 } 723 724 if (fn_ctr_mask) 725 { 726 struct coverage_data *item = 0; 727 728 item = ggc_alloc<coverage_data> (); 729 730 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID)) 731 item->ident = current_function_funcdef_no + 1; 732 else 733 { 734 gcc_assert (coverage_node_map_initialized_p ()); 735 item->ident = cgraph_node::get (cfun->decl)->profile_id; 736 } 737 738 item->lineno_checksum = lineno_checksum; 739 item->cfg_checksum = cfg_checksum; 740 741 item->fn_decl = current_function_decl; 742 item->next = 0; 743 *functions_tail = item; 744 functions_tail = &item->next; 745 746 for (i = 0; i != GCOV_COUNTERS; i++) 747 { 748 tree var = fn_v_ctrs[i]; 749 750 if (item) 751 item->ctr_vars[i] = var; 752 if (var) 753 { 754 tree array_type = build_index_type (size_int (fn_n_ctrs[i] - 1)); 755 array_type = build_array_type (get_gcov_type (), array_type); 756 TREE_TYPE (var) = array_type; 757 DECL_SIZE (var) = TYPE_SIZE (array_type); 758 DECL_SIZE_UNIT (var) = TYPE_SIZE_UNIT (array_type); 759 varpool_node::finalize_decl (var); 760 } 761 762 fn_b_ctrs[i] = fn_n_ctrs[i] = 0; 763 fn_v_ctrs[i] = NULL_TREE; 764 } 765 prg_ctr_mask |= fn_ctr_mask; 766 fn_ctr_mask = 0; 767 } 768 } 769 770 /* Build a coverage variable of TYPE for function FN_DECL. If COUNTER 771 >= 0 it is a counter array, otherwise it is the function structure. */ 772 773 static tree 774 build_var (tree fn_decl, tree type, int counter) 775 { 776 tree var = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE, type); 777 const char *fn_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl)); 778 char *buf; 779 size_t fn_name_len, len; 780 781 fn_name = targetm.strip_name_encoding (fn_name); 782 fn_name_len = strlen (fn_name); 783 buf = XALLOCAVEC (char, fn_name_len + 8 + sizeof (int) * 3); 784 785 if (counter < 0) 786 strcpy (buf, "__gcov__"); 787 else 788 sprintf (buf, "__gcov%u_", counter); 789 len = strlen (buf); 790 #ifndef NO_DOT_IN_LABEL 791 buf[len - 1] = '.'; 792 #elif !defined NO_DOLLAR_IN_LABEL 793 buf[len - 1] = '$'; 794 #endif 795 memcpy (buf + len, fn_name, fn_name_len + 1); 796 DECL_NAME (var) = get_identifier (buf); 797 TREE_STATIC (var) = 1; 798 TREE_ADDRESSABLE (var) = 1; 799 DECL_NONALIASED (var) = 1; 800 DECL_ALIGN (var) = TYPE_ALIGN (type); 801 802 return var; 803 } 804 805 /* Creates the gcov_fn_info RECORD_TYPE. */ 806 807 static void 808 build_fn_info_type (tree type, unsigned counters, tree gcov_info_type) 809 { 810 tree ctr_info = lang_hooks.types.make_type (RECORD_TYPE); 811 tree field, fields; 812 tree array_type; 813 814 gcc_assert (counters); 815 816 /* ctr_info::num */ 817 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 818 get_gcov_unsigned_t ()); 819 fields = field; 820 821 /* ctr_info::values */ 822 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 823 build_pointer_type (get_gcov_type ())); 824 DECL_CHAIN (field) = fields; 825 fields = field; 826 827 finish_builtin_struct (ctr_info, "__gcov_ctr_info", fields, NULL_TREE); 828 829 /* key */ 830 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 831 build_pointer_type (build_qualified_type 832 (gcov_info_type, TYPE_QUAL_CONST))); 833 fields = field; 834 835 /* ident */ 836 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 837 get_gcov_unsigned_t ()); 838 DECL_CHAIN (field) = fields; 839 fields = field; 840 841 /* lineno_checksum */ 842 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 843 get_gcov_unsigned_t ()); 844 DECL_CHAIN (field) = fields; 845 fields = field; 846 847 /* cfg checksum */ 848 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 849 get_gcov_unsigned_t ()); 850 DECL_CHAIN (field) = fields; 851 fields = field; 852 853 array_type = build_index_type (size_int (counters - 1)); 854 array_type = build_array_type (ctr_info, array_type); 855 856 /* counters */ 857 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, array_type); 858 DECL_CHAIN (field) = fields; 859 fields = field; 860 861 finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE); 862 } 863 864 /* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is 865 the coverage data for the function and TYPE is the gcov_fn_info 866 RECORD_TYPE. KEY is the object file key. */ 867 868 static tree 869 build_fn_info (const struct coverage_data *data, tree type, tree key) 870 { 871 tree fields = TYPE_FIELDS (type); 872 tree ctr_type; 873 unsigned ix; 874 vec<constructor_elt, va_gc> *v1 = NULL; 875 vec<constructor_elt, va_gc> *v2 = NULL; 876 877 /* key */ 878 CONSTRUCTOR_APPEND_ELT (v1, fields, 879 build1 (ADDR_EXPR, TREE_TYPE (fields), key)); 880 fields = DECL_CHAIN (fields); 881 882 /* ident */ 883 CONSTRUCTOR_APPEND_ELT (v1, fields, 884 build_int_cstu (get_gcov_unsigned_t (), 885 data->ident)); 886 fields = DECL_CHAIN (fields); 887 888 /* lineno_checksum */ 889 CONSTRUCTOR_APPEND_ELT (v1, fields, 890 build_int_cstu (get_gcov_unsigned_t (), 891 data->lineno_checksum)); 892 fields = DECL_CHAIN (fields); 893 894 /* cfg_checksum */ 895 CONSTRUCTOR_APPEND_ELT (v1, fields, 896 build_int_cstu (get_gcov_unsigned_t (), 897 data->cfg_checksum)); 898 fields = DECL_CHAIN (fields); 899 900 /* counters */ 901 ctr_type = TREE_TYPE (TREE_TYPE (fields)); 902 for (ix = 0; ix != GCOV_COUNTERS; ix++) 903 if (prg_ctr_mask & (1 << ix)) 904 { 905 vec<constructor_elt, va_gc> *ctr = NULL; 906 tree var = data->ctr_vars[ix]; 907 unsigned count = 0; 908 909 if (var) 910 count 911 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var)))) 912 + 1; 913 914 CONSTRUCTOR_APPEND_ELT (ctr, TYPE_FIELDS (ctr_type), 915 build_int_cstu (get_gcov_unsigned_t (), 916 count)); 917 918 if (var) 919 CONSTRUCTOR_APPEND_ELT (ctr, DECL_CHAIN (TYPE_FIELDS (ctr_type)), 920 build_fold_addr_expr (var)); 921 922 CONSTRUCTOR_APPEND_ELT (v2, NULL, build_constructor (ctr_type, ctr)); 923 } 924 925 CONSTRUCTOR_APPEND_ELT (v1, fields, 926 build_constructor (TREE_TYPE (fields), v2)); 927 928 return build_constructor (type, v1); 929 } 930 931 /* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be 932 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */ 933 934 static void 935 build_info_type (tree type, tree fn_info_ptr_type) 936 { 937 tree field, fields = NULL_TREE; 938 tree merge_fn_type; 939 940 /* Version ident */ 941 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 942 get_gcov_unsigned_t ()); 943 DECL_CHAIN (field) = fields; 944 fields = field; 945 946 /* next pointer */ 947 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 948 build_pointer_type (build_qualified_type 949 (type, TYPE_QUAL_CONST))); 950 DECL_CHAIN (field) = fields; 951 fields = field; 952 953 /* stamp */ 954 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 955 get_gcov_unsigned_t ()); 956 DECL_CHAIN (field) = fields; 957 fields = field; 958 959 /* Filename */ 960 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 961 build_pointer_type (build_qualified_type 962 (char_type_node, TYPE_QUAL_CONST))); 963 DECL_CHAIN (field) = fields; 964 fields = field; 965 966 /* merge fn array */ 967 merge_fn_type 968 = build_function_type_list (void_type_node, 969 build_pointer_type (get_gcov_type ()), 970 get_gcov_unsigned_t (), NULL_TREE); 971 merge_fn_type 972 = build_array_type (build_pointer_type (merge_fn_type), 973 build_index_type (size_int (GCOV_COUNTERS - 1))); 974 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 975 merge_fn_type); 976 DECL_CHAIN (field) = fields; 977 fields = field; 978 979 /* n_functions */ 980 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 981 get_gcov_unsigned_t ()); 982 DECL_CHAIN (field) = fields; 983 fields = field; 984 985 /* function_info pointer pointer */ 986 fn_info_ptr_type = build_pointer_type 987 (build_qualified_type (fn_info_ptr_type, TYPE_QUAL_CONST)); 988 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, 989 fn_info_ptr_type); 990 DECL_CHAIN (field) = fields; 991 fields = field; 992 993 finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE); 994 } 995 996 /* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the 997 gcov_info structure type, FN_ARY is the array of pointers to 998 function info objects. */ 999 1000 static tree 1001 build_info (tree info_type, tree fn_ary) 1002 { 1003 tree info_fields = TYPE_FIELDS (info_type); 1004 tree merge_fn_type, n_funcs; 1005 unsigned ix; 1006 tree filename_string; 1007 int da_file_name_len; 1008 vec<constructor_elt, va_gc> *v1 = NULL; 1009 vec<constructor_elt, va_gc> *v2 = NULL; 1010 1011 /* Version ident */ 1012 CONSTRUCTOR_APPEND_ELT (v1, info_fields, 1013 build_int_cstu (TREE_TYPE (info_fields), 1014 GCOV_VERSION)); 1015 info_fields = DECL_CHAIN (info_fields); 1016 1017 /* next -- NULL */ 1018 CONSTRUCTOR_APPEND_ELT (v1, info_fields, null_pointer_node); 1019 info_fields = DECL_CHAIN (info_fields); 1020 1021 /* stamp */ 1022 CONSTRUCTOR_APPEND_ELT (v1, info_fields, 1023 build_int_cstu (TREE_TYPE (info_fields), 1024 bbg_file_stamp)); 1025 info_fields = DECL_CHAIN (info_fields); 1026 1027 /* Filename */ 1028 da_file_name_len = strlen (da_file_name); 1029 filename_string = build_string (da_file_name_len + 1, da_file_name); 1030 TREE_TYPE (filename_string) = build_array_type 1031 (char_type_node, build_index_type (size_int (da_file_name_len))); 1032 CONSTRUCTOR_APPEND_ELT (v1, info_fields, 1033 build1 (ADDR_EXPR, TREE_TYPE (info_fields), 1034 filename_string)); 1035 info_fields = DECL_CHAIN (info_fields); 1036 1037 /* merge fn array -- NULL slots indicate unmeasured counters */ 1038 merge_fn_type = TREE_TYPE (TREE_TYPE (info_fields)); 1039 for (ix = 0; ix != GCOV_COUNTERS; ix++) 1040 { 1041 tree ptr = null_pointer_node; 1042 1043 if ((1u << ix) & prg_ctr_mask) 1044 { 1045 tree merge_fn = build_decl (BUILTINS_LOCATION, 1046 FUNCTION_DECL, 1047 get_identifier (ctr_merge_functions[ix]), 1048 TREE_TYPE (merge_fn_type)); 1049 DECL_EXTERNAL (merge_fn) = 1; 1050 TREE_PUBLIC (merge_fn) = 1; 1051 DECL_ARTIFICIAL (merge_fn) = 1; 1052 TREE_NOTHROW (merge_fn) = 1; 1053 /* Initialize assembler name so we can stream out. */ 1054 DECL_ASSEMBLER_NAME (merge_fn); 1055 ptr = build1 (ADDR_EXPR, merge_fn_type, merge_fn); 1056 } 1057 CONSTRUCTOR_APPEND_ELT (v2, NULL, ptr); 1058 } 1059 CONSTRUCTOR_APPEND_ELT (v1, info_fields, 1060 build_constructor (TREE_TYPE (info_fields), v2)); 1061 info_fields = DECL_CHAIN (info_fields); 1062 1063 /* n_functions */ 1064 n_funcs = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary))); 1065 n_funcs = fold_build2 (PLUS_EXPR, TREE_TYPE (info_fields), 1066 n_funcs, size_one_node); 1067 CONSTRUCTOR_APPEND_ELT (v1, info_fields, n_funcs); 1068 info_fields = DECL_CHAIN (info_fields); 1069 1070 /* functions */ 1071 CONSTRUCTOR_APPEND_ELT (v1, info_fields, 1072 build1 (ADDR_EXPR, TREE_TYPE (info_fields), fn_ary)); 1073 info_fields = DECL_CHAIN (info_fields); 1074 1075 gcc_assert (!info_fields); 1076 return build_constructor (info_type, v1); 1077 } 1078 1079 /* Generate the constructor function to call __gcov_init. */ 1080 1081 static void 1082 build_init_ctor (tree gcov_info_type) 1083 { 1084 tree ctor, stmt, init_fn; 1085 1086 /* Build a decl for __gcov_init. */ 1087 init_fn = build_pointer_type (gcov_info_type); 1088 init_fn = build_function_type_list (void_type_node, init_fn, NULL); 1089 init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, 1090 get_identifier ("__gcov_init"), init_fn); 1091 TREE_PUBLIC (init_fn) = 1; 1092 DECL_EXTERNAL (init_fn) = 1; 1093 DECL_ASSEMBLER_NAME (init_fn); 1094 1095 /* Generate a call to __gcov_init(&gcov_info). */ 1096 ctor = NULL; 1097 stmt = build_fold_addr_expr (gcov_info_var); 1098 stmt = build_call_expr (init_fn, 1, stmt); 1099 append_to_statement_list (stmt, &ctor); 1100 1101 /* Generate a constructor to run it. */ 1102 cgraph_build_static_cdtor ('I', ctor, DEFAULT_INIT_PRIORITY); 1103 } 1104 1105 /* Create the gcov_info types and object. Generate the constructor 1106 function to call __gcov_init. Does not generate the initializer 1107 for the object. Returns TRUE if coverage data is being emitted. */ 1108 1109 static bool 1110 coverage_obj_init (void) 1111 { 1112 tree gcov_info_type; 1113 unsigned n_counters = 0; 1114 unsigned ix; 1115 struct coverage_data *fn; 1116 struct coverage_data **fn_prev; 1117 char name_buf[32]; 1118 1119 no_coverage = 1; /* Disable any further coverage. */ 1120 1121 if (!prg_ctr_mask) 1122 return false; 1123 1124 if (symtab->dump_file) 1125 fprintf (symtab->dump_file, "Using data file %s\n", da_file_name); 1126 1127 /* Prune functions. */ 1128 for (fn_prev = &functions_head; (fn = *fn_prev);) 1129 if (DECL_STRUCT_FUNCTION (fn->fn_decl)) 1130 fn_prev = &fn->next; 1131 else 1132 /* The function is not being emitted, remove from list. */ 1133 *fn_prev = fn->next; 1134 1135 if (functions_head == NULL) 1136 return false; 1137 1138 for (ix = 0; ix != GCOV_COUNTERS; ix++) 1139 if ((1u << ix) & prg_ctr_mask) 1140 n_counters++; 1141 1142 /* Build the info and fn_info types. These are mutually recursive. */ 1143 gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE); 1144 gcov_fn_info_type = lang_hooks.types.make_type (RECORD_TYPE); 1145 gcov_fn_info_ptr_type = build_pointer_type 1146 (build_qualified_type (gcov_fn_info_type, TYPE_QUAL_CONST)); 1147 build_fn_info_type (gcov_fn_info_type, n_counters, gcov_info_type); 1148 build_info_type (gcov_info_type, gcov_fn_info_ptr_type); 1149 1150 /* Build the gcov info var, this is referred to in its own 1151 initializer. */ 1152 gcov_info_var = build_decl (BUILTINS_LOCATION, 1153 VAR_DECL, NULL_TREE, gcov_info_type); 1154 TREE_STATIC (gcov_info_var) = 1; 1155 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0); 1156 DECL_NAME (gcov_info_var) = get_identifier (name_buf); 1157 1158 build_init_ctor (gcov_info_type); 1159 1160 return true; 1161 } 1162 1163 /* Generate the coverage function info for FN and DATA. Append a 1164 pointer to that object to CTOR and return the appended CTOR. */ 1165 1166 static vec<constructor_elt, va_gc> * 1167 coverage_obj_fn (vec<constructor_elt, va_gc> *ctor, tree fn, 1168 struct coverage_data const *data) 1169 { 1170 tree init = build_fn_info (data, gcov_fn_info_type, gcov_info_var); 1171 tree var = build_var (fn, gcov_fn_info_type, -1); 1172 1173 DECL_INITIAL (var) = init; 1174 varpool_node::finalize_decl (var); 1175 1176 CONSTRUCTOR_APPEND_ELT (ctor, NULL, 1177 build1 (ADDR_EXPR, gcov_fn_info_ptr_type, var)); 1178 return ctor; 1179 } 1180 1181 /* Finalize the coverage data. Generates the array of pointers to 1182 function objects from CTOR. Generate the gcov_info initializer. */ 1183 1184 static void 1185 coverage_obj_finish (vec<constructor_elt, va_gc> *ctor) 1186 { 1187 unsigned n_functions = vec_safe_length (ctor); 1188 tree fn_info_ary_type = build_array_type 1189 (build_qualified_type (gcov_fn_info_ptr_type, TYPE_QUAL_CONST), 1190 build_index_type (size_int (n_functions - 1))); 1191 tree fn_info_ary = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE, 1192 fn_info_ary_type); 1193 char name_buf[32]; 1194 1195 TREE_STATIC (fn_info_ary) = 1; 1196 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 1); 1197 DECL_NAME (fn_info_ary) = get_identifier (name_buf); 1198 DECL_INITIAL (fn_info_ary) = build_constructor (fn_info_ary_type, ctor); 1199 varpool_node::finalize_decl (fn_info_ary); 1200 1201 DECL_INITIAL (gcov_info_var) 1202 = build_info (TREE_TYPE (gcov_info_var), fn_info_ary); 1203 varpool_node::finalize_decl (gcov_info_var); 1204 } 1205 1206 /* Perform file-level initialization. Read in data file, generate name 1207 of notes file. */ 1208 1209 void 1210 coverage_init (const char *filename) 1211 { 1212 int len = strlen (filename); 1213 int prefix_len = 0; 1214 1215 /* Since coverage_init is invoked very early, before the pass 1216 manager, we need to set up the dumping explicitly. This is 1217 similar to the handling in finish_optimization_passes. */ 1218 int profile_pass_num = 1219 g->get_passes ()->get_pass_profile ()->static_pass_number; 1220 g->get_dumps ()->dump_start (profile_pass_num, NULL); 1221 1222 if (!profile_data_prefix && !IS_ABSOLUTE_PATH (filename)) 1223 profile_data_prefix = getpwd (); 1224 1225 if (profile_data_prefix) 1226 prefix_len = strlen (profile_data_prefix); 1227 1228 /* Name of da file. */ 1229 da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX) 1230 + prefix_len + 2); 1231 1232 if (profile_data_prefix) 1233 { 1234 memcpy (da_file_name, profile_data_prefix, prefix_len); 1235 da_file_name[prefix_len++] = '/'; 1236 } 1237 memcpy (da_file_name + prefix_len, filename, len); 1238 strcpy (da_file_name + prefix_len + len, GCOV_DATA_SUFFIX); 1239 1240 bbg_file_stamp = local_tick; 1241 1242 if (flag_auto_profile) 1243 read_autofdo_file (); 1244 else if (flag_branch_probabilities) 1245 read_counts_file (); 1246 1247 /* Name of bbg file. */ 1248 if (flag_test_coverage && !flag_compare_debug) 1249 { 1250 bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1); 1251 memcpy (bbg_file_name, filename, len); 1252 strcpy (bbg_file_name + len, GCOV_NOTE_SUFFIX); 1253 1254 if (!gcov_open (bbg_file_name, -1)) 1255 { 1256 error ("cannot open %s", bbg_file_name); 1257 bbg_file_name = NULL; 1258 } 1259 else 1260 { 1261 gcov_write_unsigned (GCOV_NOTE_MAGIC); 1262 gcov_write_unsigned (GCOV_VERSION); 1263 gcov_write_unsigned (bbg_file_stamp); 1264 } 1265 } 1266 1267 g->get_dumps ()->dump_finish (profile_pass_num); 1268 } 1269 1270 /* Performs file-level cleanup. Close notes file, generate coverage 1271 variables and constructor. */ 1272 1273 void 1274 coverage_finish (void) 1275 { 1276 if (bbg_file_name && gcov_close ()) 1277 unlink (bbg_file_name); 1278 1279 if (!flag_branch_probabilities && flag_test_coverage 1280 && (!local_tick || local_tick == (unsigned)-1)) 1281 /* Only remove the da file, if we're emitting coverage code and 1282 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */ 1283 unlink (da_file_name); 1284 1285 if (coverage_obj_init ()) 1286 { 1287 vec<constructor_elt, va_gc> *fn_ctor = NULL; 1288 struct coverage_data *fn; 1289 1290 for (fn = functions_head; fn; fn = fn->next) 1291 fn_ctor = coverage_obj_fn (fn_ctor, fn->fn_decl, fn); 1292 coverage_obj_finish (fn_ctor); 1293 } 1294 1295 XDELETEVEC (da_file_name); 1296 da_file_name = NULL; 1297 } 1298 1299 #include "gt-coverage.h" 1300