1 /* File format for coverage information
2 Copyright (C) 1996-2013 Free Software Foundation, Inc.
3 Contributed by Bob Manson <manson@cygnus.com>.
4 Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 Under Section 7 of GPL version 3, you are granted additional
19 permissions described in the GCC Runtime Library Exception, version
20 3.1, as published by the Free Software Foundation.
22 You should have received a copy of the GNU General Public License and
23 a copy of the GCC Runtime Library Exception along with this program;
24 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
25 <http://www.gnu.org/licenses/>. */
27 /* Routines declared in gcov-io.h. This file should be #included by
28 another source file, after having #included gcov-io.h. */
31 static void gcov_write_block (unsigned);
32 static gcov_unsigned_t
*gcov_write_words (unsigned);
34 static const gcov_unsigned_t
*gcov_read_words (unsigned);
36 static void gcov_allocate (unsigned);
39 /* Optimum number of gcov_unsigned_t's read from or written to disk. */
40 #define GCOV_BLOCK_SIZE (1 << 10)
42 GCOV_LINKAGE
struct gcov_var
45 gcov_position_t start
; /* Position of first byte of block */
46 unsigned offset
; /* Read/write position within the block. */
47 unsigned length
; /* Read limit in the block. */
48 unsigned overread
; /* Number of words overread. */
49 int error
; /* < 0 overflow, > 0 disk error. */
50 int mode
; /* < 0 writing, > 0 reading */
52 /* Holds one block plus 4 bytes, thus all coverage reads & writes
53 fit within this buffer and we always can transfer GCOV_BLOCK_SIZE
54 to and from the disk. libgcov never backtracks and only writes 4
56 gcov_unsigned_t buffer
[GCOV_BLOCK_SIZE
+ 1];
58 int endian
; /* Swap endianness. */
59 /* Holds a variable length block, as the compiler can write
60 strings and needs to backtrack. */
62 gcov_unsigned_t
*buffer
;
66 /* Save the current position in the gcov file. */
67 static inline gcov_position_t
70 return gcov_var
.start
+ gcov_var
.offset
;
73 /* Return nonzero if the error flag is set. */
77 return gcov_var
.file
? gcov_var
.error
: 1;
80 /* Move to beginning of file and initialize for writing. */
84 gcc_assert (gcov_var
.mode
> 0);
88 fseek (gcov_var
.file
, 0L, SEEK_SET
);
91 static inline gcov_unsigned_t
from_file (gcov_unsigned_t value
)
96 value
= (value
>> 16) | (value
<< 16);
97 value
= ((value
& 0xff00ff) << 8) | ((value
>> 8) & 0xff00ff);
103 /* Open a gcov file. NAME is the name of the file to open and MODE
104 indicates whether a new file should be created, or an existing file
105 opened. If MODE is >= 0 an existing file will be opened, if
106 possible, and if MODE is <= 0, a new file will be created. Use
107 MODE=0 to attempt to reopen an existing file and then fall back on
108 creating a new one. If MODE < 0, the file will be opened in
109 read-only mode. Otherwise it will be opened for modification.
110 Return zero on failure, >0 on opening an existing file and <0 on
111 creating a new one. */
115 gcov_open (const char *name
)
117 gcov_open (const char *name
, int mode
)
124 struct flock s_flock
;
127 s_flock
.l_whence
= SEEK_SET
;
129 s_flock
.l_len
= 0; /* Until EOF. */
130 s_flock
.l_pid
= getpid ();
133 gcc_assert (!gcov_var
.file
);
135 gcov_var
.offset
= gcov_var
.length
= 0;
136 gcov_var
.overread
= -1u;
144 /* Read-only mode - acquire a read-lock. */
145 s_flock
.l_type
= F_RDLCK
;
146 /* pass mode (ignored) for compatibility */
147 fd
= open (name
, O_RDONLY
, S_IRUSR
| S_IWUSR
);
151 /* Write mode - acquire a write-lock. */
152 s_flock
.l_type
= F_WRLCK
;
153 fd
= open (name
, O_RDWR
| O_CREAT
, 0666);
158 while (fcntl (fd
, F_SETLKW
, &s_flock
) && errno
== EINTR
)
161 gcov_var
.file
= fdopen (fd
, (mode
> 0) ? "rb" : "r+b");
175 if (fstat (fd
, &st
) < 0)
177 fclose (gcov_var
.file
);
184 gcov_var
.mode
= mode
* 2 + 1;
187 gcov_var
.mode
= mode
* 2 + 1;
190 gcov_var
.file
= fopen (name
, (mode
> 0) ? "rb" : "r+b");
196 gcov_var
.file
= fopen (name
, "w+b");
198 gcov_var
.mode
= mode
* 2 + 1;
204 setbuf (gcov_var
.file
, (char *)0);
209 /* Close the current gcov file. Flushes data to disk. Returns nonzero
210 on failure or error flag set. */
218 if (gcov_var
.offset
&& gcov_var
.mode
< 0)
219 gcov_write_block (gcov_var
.offset
);
221 fclose (gcov_var
.file
);
226 free (gcov_var
.buffer
);
231 return gcov_var
.error
;
235 /* Check if MAGIC is EXPECTED. Use it to determine endianness of the
236 file. Returns +1 for same endian, -1 for other endian and zero for
240 gcov_magic (gcov_unsigned_t magic
, gcov_unsigned_t expected
)
242 if (magic
== expected
)
244 magic
= (magic
>> 16) | (magic
<< 16);
245 magic
= ((magic
& 0xff00ff) << 8) | ((magic
>> 8) & 0xff00ff);
246 if (magic
== expected
)
257 gcov_allocate (unsigned length
)
259 size_t new_size
= gcov_var
.alloc
;
262 new_size
= GCOV_BLOCK_SIZE
;
266 gcov_var
.alloc
= new_size
;
267 gcov_var
.buffer
= XRESIZEVAR (gcov_unsigned_t
, gcov_var
.buffer
, new_size
<< 2);
272 /* Write out the current block, if needs be. */
275 gcov_write_block (unsigned size
)
277 if (fwrite (gcov_var
.buffer
, size
<< 2, 1, gcov_var
.file
) != 1)
279 gcov_var
.start
+= size
;
280 gcov_var
.offset
-= size
;
283 /* Allocate space to write BYTES bytes to the gcov file. Return a
284 pointer to those bytes, or NULL on failure. */
286 static gcov_unsigned_t
*
287 gcov_write_words (unsigned words
)
289 gcov_unsigned_t
*result
;
291 gcc_assert (gcov_var
.mode
< 0);
293 if (gcov_var
.offset
>= GCOV_BLOCK_SIZE
)
295 gcov_write_block (GCOV_BLOCK_SIZE
);
298 gcc_assert (gcov_var
.offset
== 1);
299 memcpy (gcov_var
.buffer
, gcov_var
.buffer
+ GCOV_BLOCK_SIZE
, 4);
303 if (gcov_var
.offset
+ words
> gcov_var
.alloc
)
304 gcov_allocate (gcov_var
.offset
+ words
);
306 result
= &gcov_var
.buffer
[gcov_var
.offset
];
307 gcov_var
.offset
+= words
;
312 /* Write unsigned VALUE to coverage file. Sets error flag
316 gcov_write_unsigned (gcov_unsigned_t value
)
318 gcov_unsigned_t
*buffer
= gcov_write_words (1);
323 /* Write counter VALUE to coverage file. Sets error flag
328 gcov_write_counter (gcov_type value
)
330 gcov_unsigned_t
*buffer
= gcov_write_words (2);
332 buffer
[0] = (gcov_unsigned_t
) value
;
333 if (sizeof (value
) > sizeof (gcov_unsigned_t
))
334 buffer
[1] = (gcov_unsigned_t
) (value
>> 32);
338 #endif /* IN_LIBGCOV */
341 /* Write STRING to coverage file. Sets error flag on file
342 error, overflow flag on overflow */
345 gcov_write_string (const char *string
)
349 gcov_unsigned_t
*buffer
;
353 length
= strlen (string
);
354 alloc
= (length
+ 4) >> 2;
357 buffer
= gcov_write_words (1 + alloc
);
361 memcpy (&buffer
[1], string
, length
);
366 /* Write a tag TAG and reserve space for the record length. Return a
367 value to be used for gcov_write_length. */
369 GCOV_LINKAGE gcov_position_t
370 gcov_write_tag (gcov_unsigned_t tag
)
372 gcov_position_t result
= gcov_var
.start
+ gcov_var
.offset
;
373 gcov_unsigned_t
*buffer
= gcov_write_words (2);
381 /* Write a record length using POSITION, which was returned by
382 gcov_write_tag. The current file position is the end of the
383 record, and is restored before returning. Returns nonzero on
387 gcov_write_length (gcov_position_t position
)
390 gcov_unsigned_t length
;
391 gcov_unsigned_t
*buffer
;
393 gcc_assert (gcov_var
.mode
< 0);
394 gcc_assert (position
+ 2 <= gcov_var
.start
+ gcov_var
.offset
);
395 gcc_assert (position
>= gcov_var
.start
);
396 offset
= position
- gcov_var
.start
;
397 length
= gcov_var
.offset
- offset
- 2;
398 buffer
= (gcov_unsigned_t
*) &gcov_var
.buffer
[offset
];
400 if (gcov_var
.offset
>= GCOV_BLOCK_SIZE
)
401 gcov_write_block (gcov_var
.offset
);
404 #else /* IN_LIBGCOV */
406 /* Write a tag TAG and length LENGTH. */
409 gcov_write_tag_length (gcov_unsigned_t tag
, gcov_unsigned_t length
)
411 gcov_unsigned_t
*buffer
= gcov_write_words (2);
417 /* Write a summary structure to the gcov file. Return nonzero on
421 gcov_write_summary (gcov_unsigned_t tag
, const struct gcov_summary
*summary
)
423 unsigned ix
, h_ix
, bv_ix
, h_cnt
= 0;
424 const struct gcov_ctr_summary
*csum
;
425 unsigned histo_bitvector
[GCOV_HISTOGRAM_BITVECTOR_SIZE
];
427 /* Count number of non-zero histogram entries, and fill in a bit vector
428 of non-zero indices. The histogram is only currently computed for arc
430 for (bv_ix
= 0; bv_ix
< GCOV_HISTOGRAM_BITVECTOR_SIZE
; bv_ix
++)
431 histo_bitvector
[bv_ix
] = 0;
432 csum
= &summary
->ctrs
[GCOV_COUNTER_ARCS
];
433 for (h_ix
= 0; h_ix
< GCOV_HISTOGRAM_SIZE
; h_ix
++)
435 if (csum
->histogram
[h_ix
].num_counters
> 0)
437 histo_bitvector
[h_ix
/ 32] |= 1 << (h_ix
% 32);
441 gcov_write_tag_length (tag
, GCOV_TAG_SUMMARY_LENGTH(h_cnt
));
442 gcov_write_unsigned (summary
->checksum
);
443 for (csum
= summary
->ctrs
, ix
= GCOV_COUNTERS_SUMMABLE
; ix
--; csum
++)
445 gcov_write_unsigned (csum
->num
);
446 gcov_write_unsigned (csum
->runs
);
447 gcov_write_counter (csum
->sum_all
);
448 gcov_write_counter (csum
->run_max
);
449 gcov_write_counter (csum
->sum_max
);
450 if (ix
!= GCOV_COUNTER_ARCS
)
452 for (bv_ix
= 0; bv_ix
< GCOV_HISTOGRAM_BITVECTOR_SIZE
; bv_ix
++)
453 gcov_write_unsigned (0);
456 for (bv_ix
= 0; bv_ix
< GCOV_HISTOGRAM_BITVECTOR_SIZE
; bv_ix
++)
457 gcov_write_unsigned (histo_bitvector
[bv_ix
]);
458 for (h_ix
= 0; h_ix
< GCOV_HISTOGRAM_SIZE
; h_ix
++)
460 if (!csum
->histogram
[h_ix
].num_counters
)
462 gcov_write_unsigned (csum
->histogram
[h_ix
].num_counters
);
463 gcov_write_counter (csum
->histogram
[h_ix
].min_value
);
464 gcov_write_counter (csum
->histogram
[h_ix
].cum_value
);
468 #endif /* IN_LIBGCOV */
472 /* Return a pointer to read BYTES bytes from the gcov file. Returns
473 NULL on failure (read past EOF). */
475 static const gcov_unsigned_t
*
476 gcov_read_words (unsigned words
)
478 const gcov_unsigned_t
*result
;
479 unsigned excess
= gcov_var
.length
- gcov_var
.offset
;
481 gcc_assert (gcov_var
.mode
> 0);
484 gcov_var
.start
+= gcov_var
.offset
;
488 gcc_assert (excess
== 1);
489 memcpy (gcov_var
.buffer
, gcov_var
.buffer
+ gcov_var
.offset
, 4);
492 memmove (gcov_var
.buffer
, gcov_var
.buffer
+ gcov_var
.offset
, excess
* 4);
495 gcov_var
.length
= excess
;
497 gcc_assert (!gcov_var
.length
|| gcov_var
.length
== 1);
498 excess
= GCOV_BLOCK_SIZE
;
500 if (gcov_var
.length
+ words
> gcov_var
.alloc
)
501 gcov_allocate (gcov_var
.length
+ words
);
502 excess
= gcov_var
.alloc
- gcov_var
.length
;
504 excess
= fread (gcov_var
.buffer
+ gcov_var
.length
,
505 1, excess
<< 2, gcov_var
.file
) >> 2;
506 gcov_var
.length
+= excess
;
507 if (gcov_var
.length
< words
)
509 gcov_var
.overread
+= words
- gcov_var
.length
;
514 result
= &gcov_var
.buffer
[gcov_var
.offset
];
515 gcov_var
.offset
+= words
;
519 /* Read unsigned value from a coverage file. Sets error flag on file
520 error, overflow flag on overflow */
522 GCOV_LINKAGE gcov_unsigned_t
523 gcov_read_unsigned (void)
525 gcov_unsigned_t value
;
526 const gcov_unsigned_t
*buffer
= gcov_read_words (1);
530 value
= from_file (buffer
[0]);
534 /* Read counter value from a coverage file. Sets error flag on file
535 error, overflow flag on overflow */
537 GCOV_LINKAGE gcov_type
538 gcov_read_counter (void)
541 const gcov_unsigned_t
*buffer
= gcov_read_words (2);
545 value
= from_file (buffer
[0]);
546 if (sizeof (value
) > sizeof (gcov_unsigned_t
))
547 value
|= ((gcov_type
) from_file (buffer
[1])) << 32;
554 /* Read string from coverage file. Returns a pointer to a static
555 buffer, or NULL on empty string. You must copy the string before
556 calling another gcov function. */
558 #if !IN_LIBGCOV || IN_GCOV_TOOL
559 GCOV_LINKAGE
const char *
560 gcov_read_string (void)
562 unsigned length
= gcov_read_unsigned ();
567 return (const char *) gcov_read_words (length
);
572 gcov_read_summary (struct gcov_summary
*summary
)
574 unsigned ix
, h_ix
, bv_ix
, h_cnt
= 0;
575 struct gcov_ctr_summary
*csum
;
576 unsigned histo_bitvector
[GCOV_HISTOGRAM_BITVECTOR_SIZE
];
577 unsigned cur_bitvector
;
579 summary
->checksum
= gcov_read_unsigned ();
580 for (csum
= summary
->ctrs
, ix
= GCOV_COUNTERS_SUMMABLE
; ix
--; csum
++)
582 csum
->num
= gcov_read_unsigned ();
583 csum
->runs
= gcov_read_unsigned ();
584 csum
->sum_all
= gcov_read_counter ();
585 csum
->run_max
= gcov_read_counter ();
586 csum
->sum_max
= gcov_read_counter ();
587 memset (csum
->histogram
, 0,
588 sizeof (gcov_bucket_type
) * GCOV_HISTOGRAM_SIZE
);
589 for (bv_ix
= 0; bv_ix
< GCOV_HISTOGRAM_BITVECTOR_SIZE
; bv_ix
++)
591 histo_bitvector
[bv_ix
] = gcov_read_unsigned ();
593 /* When building libgcov we don't include system.h, which includes
594 hwint.h (where popcount_hwi is declared). However, libgcov.a
595 is built by the bootstrapped compiler and therefore the builtins
596 are always available. */
597 h_cnt
+= __builtin_popcount (histo_bitvector
[bv_ix
]);
599 h_cnt
+= popcount_hwi (histo_bitvector
[bv_ix
]);
607 /* Find the index corresponding to the next entry we will read in.
608 First find the next non-zero bitvector and re-initialize
609 the histogram index accordingly, then right shift and increment
610 the index until we find a set bit. */
611 while (!cur_bitvector
)
614 gcc_assert(bv_ix
< GCOV_HISTOGRAM_BITVECTOR_SIZE
);
615 cur_bitvector
= histo_bitvector
[bv_ix
++];
617 while (!(cur_bitvector
& 0x1))
622 gcc_assert(h_ix
< GCOV_HISTOGRAM_SIZE
);
624 csum
->histogram
[h_ix
].num_counters
= gcov_read_unsigned ();
625 csum
->histogram
[h_ix
].min_value
= gcov_read_counter ();
626 csum
->histogram
[h_ix
].cum_value
= gcov_read_counter ();
627 /* Shift off the index we are done with and increment to the
628 corresponding next histogram entry. */
635 #if IN_GCOV_TOOL || !IN_LIBGCOV && IN_GCOV != 1
636 /* Read LEN words (unsigned type) and construct MOD_INFO. */
639 gcov_read_module_info (struct gcov_module_info
*mod_info
,
642 gcov_unsigned_t src_filename_len
, filename_len
, i
, j
, num_strings
;
643 mod_info
->ident
= gcov_read_unsigned ();
644 mod_info
->is_primary
= gcov_read_unsigned ();
645 mod_info
->flags
= gcov_read_unsigned ();
646 mod_info
->lang
= gcov_read_unsigned ();
647 mod_info
->ggc_memory
= gcov_read_unsigned ();
648 mod_info
->num_quote_paths
= gcov_read_unsigned ();
649 mod_info
->num_bracket_paths
= gcov_read_unsigned ();
650 mod_info
->num_system_paths
= gcov_read_unsigned ();
651 mod_info
->num_cpp_defines
= gcov_read_unsigned ();
652 mod_info
->num_cpp_includes
= gcov_read_unsigned ();
653 mod_info
->num_cl_args
= gcov_read_unsigned ();
656 filename_len
= gcov_read_unsigned ();
657 mod_info
->da_filename
= (char *) xmalloc (filename_len
*
658 sizeof (gcov_unsigned_t
));
659 for (i
= 0; i
< filename_len
; i
++)
660 ((gcov_unsigned_t
*) mod_info
->da_filename
)[i
] = gcov_read_unsigned ();
661 len
-= (filename_len
+ 1);
663 src_filename_len
= gcov_read_unsigned ();
664 mod_info
->source_filename
= (char *) xmalloc (src_filename_len
*
665 sizeof (gcov_unsigned_t
));
666 for (i
= 0; i
< src_filename_len
; i
++)
667 ((gcov_unsigned_t
*) mod_info
->source_filename
)[i
] = gcov_read_unsigned ();
668 len
-= (src_filename_len
+ 1);
670 num_strings
= mod_info
->num_quote_paths
+ mod_info
->num_bracket_paths
671 + mod_info
->num_system_paths
672 + mod_info
->num_cpp_defines
+ mod_info
->num_cpp_includes
673 + mod_info
->num_cl_args
;
674 for (j
= 0; j
< num_strings
; j
++)
676 gcov_unsigned_t string_len
= gcov_read_unsigned ();
677 mod_info
->string_array
[j
] =
678 (char *) xmalloc (string_len
* sizeof (gcov_unsigned_t
));
679 for (i
= 0; i
< string_len
; i
++)
680 ((gcov_unsigned_t
*) mod_info
->string_array
[j
])[i
] =
681 gcov_read_unsigned ();
682 len
-= (string_len
+ 1);
688 #if !IN_LIBGCOV || IN_GCOV_TOOL
689 /* Reset to a known position. BASE should have been obtained from
690 gcov_position, LENGTH should be a record length. */
693 gcov_sync (gcov_position_t base
, gcov_unsigned_t length
)
695 gcc_assert (gcov_var
.mode
> 0);
697 if (base
- gcov_var
.start
<= gcov_var
.length
)
698 gcov_var
.offset
= base
- gcov_var
.start
;
701 gcov_var
.offset
= gcov_var
.length
= 0;
702 fseek (gcov_var
.file
, base
<< 2, SEEK_SET
);
703 gcov_var
.start
= ftell (gcov_var
.file
) >> 2;
709 /* Move to a given position in a gcov file. */
712 gcov_seek (gcov_position_t base
)
714 gcc_assert (gcov_var
.mode
< 0);
716 gcov_write_block (gcov_var
.offset
);
717 fseek (gcov_var
.file
, base
<< 2, SEEK_SET
);
718 gcov_var
.start
= ftell (gcov_var
.file
) >> 2;
721 /* Truncate the gcov file at the current position. */
728 gcc_assert (gcov_var
.mode
< 0);
730 gcov_write_block (gcov_var
.offset
);
731 offs
= ftell (gcov_var
.file
);
732 filenum
= fileno (gcov_var
.file
);
733 if (offs
== -1 || filenum
== -1 || ftruncate (filenum
, offs
))
739 /* Return the modification time of the current gcov file. */
746 if (fstat (fileno (gcov_var
.file
), &status
))
749 return status
.st_mtime
;
754 /* Determine the index into histogram for VALUE. */
759 GCOV_LINKAGE
unsigned
761 gcov_histo_index (gcov_type value
)
763 gcov_type_unsigned v
= (gcov_type_unsigned
)value
;
765 unsigned prev2bits
= 0;
767 /* Find index into log2 scale histogram, where each of the log2
768 sized buckets is divided into 4 linear sub-buckets for better
769 focus in the higher buckets. */
771 /* Find the place of the most-significant bit set. */
775 /* When building libgcov we don't include system.h, which includes
776 hwint.h (where floor_log2 is declared). However, libgcov.a
777 is built by the bootstrapped compiler and therefore the builtins
778 are always available. */
779 r
= sizeof (long long) * __CHAR_BIT__
- 1 - __builtin_clzll (v
);
781 /* We use floor_log2 from hwint.c, which takes a HOST_WIDE_INT
782 that is either 32 or 64 bits, and gcov_type_unsigned may be 64 bits.
783 Need to check for the case where gcov_type_unsigned is 64 bits
784 and HOST_WIDE_INT is 32 bits and handle it specially. */
785 #if HOST_BITS_PER_WIDEST_INT == HOST_BITS_PER_WIDE_INT
787 #elif HOST_BITS_PER_WIDEST_INT == 2 * HOST_BITS_PER_WIDE_INT
788 HOST_WIDE_INT hwi_v
= v
>> HOST_BITS_PER_WIDE_INT
;
790 r
= floor_log2 (hwi_v
) + HOST_BITS_PER_WIDE_INT
;
792 r
= floor_log2 ((HOST_WIDE_INT
)v
);
799 /* If at most the 2 least significant bits are set (value is
800 0 - 3) then that value is our index into the lowest set of
803 return (unsigned)value
;
807 /* Find the two next most significant bits to determine which
808 of the four linear sub-buckets to select. */
809 prev2bits
= (v
>> (r
- 2)) & 0x3;
810 /* Finally, compose the final bucket index from the log2 index and
811 the next 2 bits. The minimum r value at this point is 2 since we
812 returned above if r was 2 or more, so the minimum bucket at this
814 return (r
- 1) * 4 + prev2bits
;
817 /* Merge SRC_HISTO into TGT_HISTO. The counters are assumed to be in
818 the same relative order in both histograms, and are matched up
819 and merged in reverse order. Each counter is assigned an equal portion of
820 its entry's original cumulative counter value when computing the
821 new merged cum_value. */
823 static void gcov_histogram_merge (gcov_bucket_type
*tgt_histo
,
824 gcov_bucket_type
*src_histo
)
826 int src_i
, tgt_i
, tmp_i
= 0;
827 unsigned src_num
, tgt_num
, merge_num
;
828 gcov_type src_cum
, tgt_cum
, merge_src_cum
, merge_tgt_cum
, merge_cum
;
830 gcov_bucket_type tmp_histo
[GCOV_HISTOGRAM_SIZE
];
833 memset(tmp_histo
, 0, sizeof (gcov_bucket_type
) * GCOV_HISTOGRAM_SIZE
);
835 /* Assume that the counters are in the same relative order in both
836 histograms. Walk the histograms from largest to smallest entry,
837 matching up and combining counters in order. */
840 src_i
= GCOV_HISTOGRAM_SIZE
- 1;
841 for (tgt_i
= GCOV_HISTOGRAM_SIZE
- 1; tgt_i
>= 0 && !src_done
; tgt_i
--)
843 tgt_num
= tgt_histo
[tgt_i
].num_counters
;
844 tgt_cum
= tgt_histo
[tgt_i
].cum_value
;
845 /* Keep going until all of the target histogram's counters at this
846 position have been matched and merged with counters from the
848 while (tgt_num
> 0 && !src_done
)
850 /* If this is either the first time through this loop or we just
851 exhausted the previous non-zero source histogram entry, look
852 for the next non-zero source histogram entry. */
855 /* Locate the next non-zero entry. */
856 while (src_i
>= 0 && !src_histo
[src_i
].num_counters
)
858 /* If source histogram has fewer counters, then just copy over the
859 remaining target counters and quit. */
862 tmp_histo
[tgt_i
].num_counters
+= tgt_num
;
863 tmp_histo
[tgt_i
].cum_value
+= tgt_cum
;
864 if (!tmp_histo
[tgt_i
].min_value
||
865 tgt_histo
[tgt_i
].min_value
< tmp_histo
[tgt_i
].min_value
)
866 tmp_histo
[tgt_i
].min_value
= tgt_histo
[tgt_i
].min_value
;
869 tmp_histo
[tgt_i
].num_counters
870 += tgt_histo
[tgt_i
].num_counters
;
871 tmp_histo
[tgt_i
].cum_value
+= tgt_histo
[tgt_i
].cum_value
;
872 if (!tmp_histo
[tgt_i
].min_value
||
873 tgt_histo
[tgt_i
].min_value
874 < tmp_histo
[tgt_i
].min_value
)
875 tmp_histo
[tgt_i
].min_value
= tgt_histo
[tgt_i
].min_value
;
882 src_num
= src_histo
[src_i
].num_counters
;
883 src_cum
= src_histo
[src_i
].cum_value
;
886 /* The number of counters to merge on this pass is the minimum
887 of the remaining counters from the current target and source
888 histogram entries. */
890 if (src_num
< merge_num
)
893 /* The merged min_value is the sum of the min_values from target
895 merge_min
= tgt_histo
[tgt_i
].min_value
+ src_histo
[src_i
].min_value
;
897 /* Compute the portion of source and target entries' cum_value
898 that will be apportioned to the counters being merged.
899 The total remaining cum_value from each entry is divided
900 equally among the counters from that histogram entry if we
901 are not merging all of them. */
902 merge_src_cum
= src_cum
;
903 if (merge_num
< src_num
)
904 merge_src_cum
= merge_num
* src_cum
/ src_num
;
905 merge_tgt_cum
= tgt_cum
;
906 if (merge_num
< tgt_num
)
907 merge_tgt_cum
= merge_num
* tgt_cum
/ tgt_num
;
908 /* The merged cum_value is the sum of the source and target
910 merge_cum
= merge_src_cum
+ merge_tgt_cum
;
912 /* Update the remaining number of counters and cum_value left
913 to be merged from this source and target entry. */
914 src_cum
-= merge_src_cum
;
915 tgt_cum
-= merge_tgt_cum
;
916 src_num
-= merge_num
;
917 tgt_num
-= merge_num
;
919 /* The merged counters get placed in the new merged histogram
920 at the entry for the merged min_value. */
921 tmp_i
= gcov_histo_index(merge_min
);
922 gcc_assert (tmp_i
< GCOV_HISTOGRAM_SIZE
);
923 tmp_histo
[tmp_i
].num_counters
+= merge_num
;
924 tmp_histo
[tmp_i
].cum_value
+= merge_cum
;
925 if (!tmp_histo
[tmp_i
].min_value
||
926 merge_min
< tmp_histo
[tmp_i
].min_value
)
927 tmp_histo
[tmp_i
].min_value
= merge_min
;
929 /* Ensure the search for the next non-zero src_histo entry starts
930 at the next smallest histogram bucket. */
936 gcc_assert (tgt_i
< 0);
938 /* In the case where there were more counters in the source histogram,
939 accumulate the remaining unmerged cumulative counter values. Add
940 those to the smallest non-zero target histogram entry. Otherwise,
941 the total cumulative counter values in the histogram will be smaller
942 than the sum_all stored in the summary, which will complicate
943 computing the working set information from the histogram later on. */
948 src_cum
+= src_histo
[src_i
].cum_value
;
951 /* At this point, tmp_i should be the smallest non-zero entry in the
953 gcc_assert(tmp_i
>= 0 && tmp_i
< GCOV_HISTOGRAM_SIZE
954 && tmp_histo
[tmp_i
].num_counters
> 0);
955 tmp_histo
[tmp_i
].cum_value
+= src_cum
;
957 /* Finally, copy the merged histogram into tgt_histo. */
958 memcpy(tgt_histo
, tmp_histo
, sizeof (gcov_bucket_type
) * GCOV_HISTOGRAM_SIZE
);
960 #endif /* !IN_GCOV */
962 /* This is used by gcov-dump (IN_GCOV == -1) and in the compiler
963 (!IN_GCOV && !IN_LIBGCOV). */
964 #if IN_GCOV <= 0 && !IN_LIBGCOV
965 /* Compute the working set information from the counter histogram in
966 the profile summary. This is an array of information corresponding to a
967 range of percentages of the total execution count (sum_all), and includes
968 the number of counters required to cover that working set percentage and
969 the minimum counter value in that working set. */
972 compute_working_sets (const struct gcov_ctr_summary
*summary
,
973 gcov_working_set_t
*gcov_working_sets
)
975 gcov_type working_set_cum_values
[NUM_GCOV_WORKING_SETS
];
976 gcov_type ws_cum_hotness_incr
;
977 gcov_type cum
, tmp_cum
;
978 const gcov_bucket_type
*histo_bucket
;
979 unsigned ws_ix
, c_num
, count
;
982 /* Compute the amount of sum_all that the cumulative hotness grows
983 by in each successive working set entry, which depends on the
984 number of working set entries. */
985 ws_cum_hotness_incr
= summary
->sum_all
/ NUM_GCOV_WORKING_SETS
;
987 /* Next fill in an array of the cumulative hotness values corresponding
988 to each working set summary entry we are going to compute below.
989 Skip 0% statistics, which can be extrapolated from the
990 rest of the summary data. */
991 cum
= ws_cum_hotness_incr
;
992 for (ws_ix
= 0; ws_ix
< NUM_GCOV_WORKING_SETS
;
993 ws_ix
++, cum
+= ws_cum_hotness_incr
)
994 working_set_cum_values
[ws_ix
] = cum
;
995 /* The last summary entry is reserved for (roughly) 99.9% of the
996 working set. Divide by 1024 so it becomes a shift, which gives
997 almost exactly 99.9%. */
998 working_set_cum_values
[NUM_GCOV_WORKING_SETS
-1]
999 = summary
->sum_all
- summary
->sum_all
/1024;
1001 /* Next, walk through the histogram in decending order of hotness
1002 and compute the statistics for the working set summary array.
1003 As histogram entries are accumulated, we check to see which
1004 working set entries have had their expected cum_value reached
1005 and fill them in, walking the working set entries in increasing
1006 size of cum_value. */
1007 ws_ix
= 0; /* The current entry into the working set array. */
1008 cum
= 0; /* The current accumulated counter sum. */
1009 count
= 0; /* The current accumulated count of block counters. */
1010 for (h_ix
= GCOV_HISTOGRAM_SIZE
- 1;
1011 h_ix
>= 0 && ws_ix
< NUM_GCOV_WORKING_SETS
; h_ix
--)
1013 histo_bucket
= &summary
->histogram
[h_ix
];
1015 /* If we haven't reached the required cumulative counter value for
1016 the current working set percentage, simply accumulate this histogram
1017 entry into the running sums and continue to the next histogram
1019 if (cum
+ histo_bucket
->cum_value
< working_set_cum_values
[ws_ix
])
1021 cum
+= histo_bucket
->cum_value
;
1022 count
+= histo_bucket
->num_counters
;
1026 /* If adding the current histogram entry's cumulative counter value
1027 causes us to exceed the current working set size, then estimate
1028 how many of this histogram entry's counter values are required to
1029 reach the working set size, and fill in working set entries
1030 as we reach their expected cumulative value. */
1031 for (c_num
= 0, tmp_cum
= cum
;
1032 c_num
< histo_bucket
->num_counters
&& ws_ix
< NUM_GCOV_WORKING_SETS
;
1036 /* If we haven't reached the last histogram entry counter, add
1037 in the minimum value again. This will underestimate the
1038 cumulative sum so far, because many of the counter values in this
1039 entry may have been larger than the minimum. We could add in the
1040 average value every time, but that would require an expensive
1041 divide operation. */
1042 if (c_num
+ 1 < histo_bucket
->num_counters
)
1043 tmp_cum
+= histo_bucket
->min_value
;
1044 /* If we have reached the last histogram entry counter, then add
1045 in the entire cumulative value. */
1047 tmp_cum
= cum
+ histo_bucket
->cum_value
;
1049 /* Next walk through successive working set entries and fill in
1050 the statistics for any whose size we have reached by accumulating
1051 this histogram counter. */
1052 while (ws_ix
< NUM_GCOV_WORKING_SETS
1053 && tmp_cum
>= working_set_cum_values
[ws_ix
])
1055 gcov_working_sets
[ws_ix
].num_counters
= count
;
1056 gcov_working_sets
[ws_ix
].min_counter
1057 = histo_bucket
->min_value
;
1061 /* Finally, update the running cumulative value since we were
1062 using a temporary above. */
1063 cum
+= histo_bucket
->cum_value
;
1065 gcc_assert (ws_ix
== NUM_GCOV_WORKING_SETS
);
1067 #endif /* IN_GCOV <= 0 && !IN_LIBGCOV */