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