1*38fd1498Szrj /* File format for coverage information
2*38fd1498Szrj Copyright (C) 1996-2018 Free Software Foundation, Inc.
3*38fd1498Szrj Contributed by Bob Manson <manson@cygnus.com>.
4*38fd1498Szrj Completely remangled by Nathan Sidwell <nathan@codesourcery.com>.
5*38fd1498Szrj
6*38fd1498Szrj This file is part of GCC.
7*38fd1498Szrj
8*38fd1498Szrj GCC is free software; you can redistribute it and/or modify it under
9*38fd1498Szrj the terms of the GNU General Public License as published by the Free
10*38fd1498Szrj Software Foundation; either version 3, or (at your option) any later
11*38fd1498Szrj version.
12*38fd1498Szrj
13*38fd1498Szrj GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14*38fd1498Szrj WARRANTY; without even the implied warranty of MERCHANTABILITY or
15*38fd1498Szrj FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16*38fd1498Szrj for more details.
17*38fd1498Szrj
18*38fd1498Szrj Under Section 7 of GPL version 3, you are granted additional
19*38fd1498Szrj permissions described in the GCC Runtime Library Exception, version
20*38fd1498Szrj 3.1, as published by the Free Software Foundation.
21*38fd1498Szrj
22*38fd1498Szrj You should have received a copy of the GNU General Public License and
23*38fd1498Szrj a copy of the GCC Runtime Library Exception along with this program;
24*38fd1498Szrj see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
25*38fd1498Szrj <http://www.gnu.org/licenses/>. */
26*38fd1498Szrj
27*38fd1498Szrj /* Routines declared in gcov-io.h. This file should be #included by
28*38fd1498Szrj another source file, after having #included gcov-io.h. */
29*38fd1498Szrj
30*38fd1498Szrj #if !IN_GCOV
31*38fd1498Szrj static void gcov_write_block (unsigned);
32*38fd1498Szrj static gcov_unsigned_t *gcov_write_words (unsigned);
33*38fd1498Szrj #endif
34*38fd1498Szrj static const gcov_unsigned_t *gcov_read_words (unsigned);
35*38fd1498Szrj #if !IN_LIBGCOV
36*38fd1498Szrj static void gcov_allocate (unsigned);
37*38fd1498Szrj #endif
38*38fd1498Szrj
39*38fd1498Szrj /* Optimum number of gcov_unsigned_t's read from or written to disk. */
40*38fd1498Szrj #define GCOV_BLOCK_SIZE (1 << 10)
41*38fd1498Szrj
42*38fd1498Szrj struct gcov_var
43*38fd1498Szrj {
44*38fd1498Szrj FILE *file;
45*38fd1498Szrj gcov_position_t start; /* Position of first byte of block */
46*38fd1498Szrj unsigned offset; /* Read/write position within the block. */
47*38fd1498Szrj unsigned length; /* Read limit in the block. */
48*38fd1498Szrj unsigned overread; /* Number of words overread. */
49*38fd1498Szrj int error; /* < 0 overflow, > 0 disk error. */
50*38fd1498Szrj int mode; /* < 0 writing, > 0 reading */
51*38fd1498Szrj #if IN_LIBGCOV
52*38fd1498Szrj /* Holds one block plus 4 bytes, thus all coverage reads & writes
53*38fd1498Szrj fit within this buffer and we always can transfer GCOV_BLOCK_SIZE
54*38fd1498Szrj to and from the disk. libgcov never backtracks and only writes 4
55*38fd1498Szrj or 8 byte objects. */
56*38fd1498Szrj gcov_unsigned_t buffer[GCOV_BLOCK_SIZE + 1];
57*38fd1498Szrj #else
58*38fd1498Szrj int endian; /* Swap endianness. */
59*38fd1498Szrj /* Holds a variable length block, as the compiler can write
60*38fd1498Szrj strings and needs to backtrack. */
61*38fd1498Szrj size_t alloc;
62*38fd1498Szrj gcov_unsigned_t *buffer;
63*38fd1498Szrj #endif
64*38fd1498Szrj } gcov_var;
65*38fd1498Szrj
66*38fd1498Szrj /* Save the current position in the gcov file. */
67*38fd1498Szrj /* We need to expose this function when compiling for gcov-tool. */
68*38fd1498Szrj #ifndef IN_GCOV_TOOL
69*38fd1498Szrj static inline
70*38fd1498Szrj #endif
71*38fd1498Szrj gcov_position_t
gcov_position(void)72*38fd1498Szrj gcov_position (void)
73*38fd1498Szrj {
74*38fd1498Szrj gcov_nonruntime_assert (gcov_var.mode > 0);
75*38fd1498Szrj return gcov_var.start + gcov_var.offset;
76*38fd1498Szrj }
77*38fd1498Szrj
78*38fd1498Szrj /* Return nonzero if the error flag is set. */
79*38fd1498Szrj /* We need to expose this function when compiling for gcov-tool. */
80*38fd1498Szrj #ifndef IN_GCOV_TOOL
81*38fd1498Szrj static inline
82*38fd1498Szrj #endif
83*38fd1498Szrj int
gcov_is_error(void)84*38fd1498Szrj gcov_is_error (void)
85*38fd1498Szrj {
86*38fd1498Szrj return gcov_var.file ? gcov_var.error : 1;
87*38fd1498Szrj }
88*38fd1498Szrj
89*38fd1498Szrj #if IN_LIBGCOV
90*38fd1498Szrj /* Move to beginning of file and initialize for writing. */
91*38fd1498Szrj GCOV_LINKAGE inline void
gcov_rewrite(void)92*38fd1498Szrj gcov_rewrite (void)
93*38fd1498Szrj {
94*38fd1498Szrj gcov_var.mode = -1;
95*38fd1498Szrj gcov_var.start = 0;
96*38fd1498Szrj gcov_var.offset = 0;
97*38fd1498Szrj fseek (gcov_var.file, 0L, SEEK_SET);
98*38fd1498Szrj }
99*38fd1498Szrj #endif
100*38fd1498Szrj
from_file(gcov_unsigned_t value)101*38fd1498Szrj static inline gcov_unsigned_t from_file (gcov_unsigned_t value)
102*38fd1498Szrj {
103*38fd1498Szrj #if !IN_LIBGCOV
104*38fd1498Szrj if (gcov_var.endian)
105*38fd1498Szrj {
106*38fd1498Szrj value = (value >> 16) | (value << 16);
107*38fd1498Szrj value = ((value & 0xff00ff) << 8) | ((value >> 8) & 0xff00ff);
108*38fd1498Szrj }
109*38fd1498Szrj #endif
110*38fd1498Szrj return value;
111*38fd1498Szrj }
112*38fd1498Szrj
113*38fd1498Szrj /* Open a gcov file. NAME is the name of the file to open and MODE
114*38fd1498Szrj indicates whether a new file should be created, or an existing file
115*38fd1498Szrj opened. If MODE is >= 0 an existing file will be opened, if
116*38fd1498Szrj possible, and if MODE is <= 0, a new file will be created. Use
117*38fd1498Szrj MODE=0 to attempt to reopen an existing file and then fall back on
118*38fd1498Szrj creating a new one. If MODE > 0, the file will be opened in
119*38fd1498Szrj read-only mode. Otherwise it will be opened for modification.
120*38fd1498Szrj Return zero on failure, non-zero on success. */
121*38fd1498Szrj
122*38fd1498Szrj GCOV_LINKAGE int
123*38fd1498Szrj #if IN_LIBGCOV
gcov_open(const char * name)124*38fd1498Szrj gcov_open (const char *name)
125*38fd1498Szrj #else
126*38fd1498Szrj gcov_open (const char *name, int mode)
127*38fd1498Szrj #endif
128*38fd1498Szrj {
129*38fd1498Szrj #if IN_LIBGCOV
130*38fd1498Szrj int mode = 0;
131*38fd1498Szrj #endif
132*38fd1498Szrj #if GCOV_LOCKED
133*38fd1498Szrj struct flock s_flock;
134*38fd1498Szrj int fd;
135*38fd1498Szrj
136*38fd1498Szrj s_flock.l_whence = SEEK_SET;
137*38fd1498Szrj s_flock.l_start = 0;
138*38fd1498Szrj s_flock.l_len = 0; /* Until EOF. */
139*38fd1498Szrj s_flock.l_pid = getpid ();
140*38fd1498Szrj #endif
141*38fd1498Szrj
142*38fd1498Szrj gcov_nonruntime_assert (!gcov_var.file);
143*38fd1498Szrj gcov_var.start = 0;
144*38fd1498Szrj gcov_var.offset = gcov_var.length = 0;
145*38fd1498Szrj gcov_var.overread = -1u;
146*38fd1498Szrj gcov_var.error = 0;
147*38fd1498Szrj #if !IN_LIBGCOV
148*38fd1498Szrj gcov_var.endian = 0;
149*38fd1498Szrj #endif
150*38fd1498Szrj #if GCOV_LOCKED
151*38fd1498Szrj if (mode > 0)
152*38fd1498Szrj {
153*38fd1498Szrj /* Read-only mode - acquire a read-lock. */
154*38fd1498Szrj s_flock.l_type = F_RDLCK;
155*38fd1498Szrj /* pass mode (ignored) for compatibility */
156*38fd1498Szrj fd = open (name, O_RDONLY, S_IRUSR | S_IWUSR);
157*38fd1498Szrj }
158*38fd1498Szrj else
159*38fd1498Szrj {
160*38fd1498Szrj /* Write mode - acquire a write-lock. */
161*38fd1498Szrj s_flock.l_type = F_WRLCK;
162*38fd1498Szrj /* Truncate if force new mode. */
163*38fd1498Szrj fd = open (name, O_RDWR | O_CREAT | (mode < 0 ? O_TRUNC : 0), 0666);
164*38fd1498Szrj }
165*38fd1498Szrj if (fd < 0)
166*38fd1498Szrj return 0;
167*38fd1498Szrj
168*38fd1498Szrj while (fcntl (fd, F_SETLKW, &s_flock) && errno == EINTR)
169*38fd1498Szrj continue;
170*38fd1498Szrj
171*38fd1498Szrj gcov_var.file = fdopen (fd, (mode > 0) ? "rb" : "r+b");
172*38fd1498Szrj
173*38fd1498Szrj if (!gcov_var.file)
174*38fd1498Szrj {
175*38fd1498Szrj close (fd);
176*38fd1498Szrj return 0;
177*38fd1498Szrj }
178*38fd1498Szrj #else
179*38fd1498Szrj if (mode >= 0)
180*38fd1498Szrj /* Open an existing file. */
181*38fd1498Szrj gcov_var.file = fopen (name, (mode > 0) ? "rb" : "r+b");
182*38fd1498Szrj
183*38fd1498Szrj if (gcov_var.file)
184*38fd1498Szrj mode = 1;
185*38fd1498Szrj else if (mode <= 0)
186*38fd1498Szrj /* Create a new file. */
187*38fd1498Szrj gcov_var.file = fopen (name, "w+b");
188*38fd1498Szrj
189*38fd1498Szrj if (!gcov_var.file)
190*38fd1498Szrj return 0;
191*38fd1498Szrj #endif
192*38fd1498Szrj
193*38fd1498Szrj gcov_var.mode = mode ? mode : 1;
194*38fd1498Szrj
195*38fd1498Szrj setbuf (gcov_var.file, (char *)0);
196*38fd1498Szrj
197*38fd1498Szrj return 1;
198*38fd1498Szrj }
199*38fd1498Szrj
200*38fd1498Szrj /* Close the current gcov file. Flushes data to disk. Returns nonzero
201*38fd1498Szrj on failure or error flag set. */
202*38fd1498Szrj
203*38fd1498Szrj GCOV_LINKAGE int
gcov_close(void)204*38fd1498Szrj gcov_close (void)
205*38fd1498Szrj {
206*38fd1498Szrj if (gcov_var.file)
207*38fd1498Szrj {
208*38fd1498Szrj #if !IN_GCOV
209*38fd1498Szrj if (gcov_var.offset && gcov_var.mode < 0)
210*38fd1498Szrj gcov_write_block (gcov_var.offset);
211*38fd1498Szrj #endif
212*38fd1498Szrj fclose (gcov_var.file);
213*38fd1498Szrj gcov_var.file = 0;
214*38fd1498Szrj gcov_var.length = 0;
215*38fd1498Szrj }
216*38fd1498Szrj #if !IN_LIBGCOV
217*38fd1498Szrj free (gcov_var.buffer);
218*38fd1498Szrj gcov_var.alloc = 0;
219*38fd1498Szrj gcov_var.buffer = 0;
220*38fd1498Szrj #endif
221*38fd1498Szrj gcov_var.mode = 0;
222*38fd1498Szrj return gcov_var.error;
223*38fd1498Szrj }
224*38fd1498Szrj
225*38fd1498Szrj #if !IN_LIBGCOV
226*38fd1498Szrj /* Check if MAGIC is EXPECTED. Use it to determine endianness of the
227*38fd1498Szrj file. Returns +1 for same endian, -1 for other endian and zero for
228*38fd1498Szrj not EXPECTED. */
229*38fd1498Szrj
230*38fd1498Szrj GCOV_LINKAGE int
gcov_magic(gcov_unsigned_t magic,gcov_unsigned_t expected)231*38fd1498Szrj gcov_magic (gcov_unsigned_t magic, gcov_unsigned_t expected)
232*38fd1498Szrj {
233*38fd1498Szrj if (magic == expected)
234*38fd1498Szrj return 1;
235*38fd1498Szrj magic = (magic >> 16) | (magic << 16);
236*38fd1498Szrj magic = ((magic & 0xff00ff) << 8) | ((magic >> 8) & 0xff00ff);
237*38fd1498Szrj if (magic == expected)
238*38fd1498Szrj {
239*38fd1498Szrj gcov_var.endian = 1;
240*38fd1498Szrj return -1;
241*38fd1498Szrj }
242*38fd1498Szrj return 0;
243*38fd1498Szrj }
244*38fd1498Szrj #endif
245*38fd1498Szrj
246*38fd1498Szrj #if !IN_LIBGCOV
247*38fd1498Szrj static void
gcov_allocate(unsigned length)248*38fd1498Szrj gcov_allocate (unsigned length)
249*38fd1498Szrj {
250*38fd1498Szrj size_t new_size = gcov_var.alloc;
251*38fd1498Szrj
252*38fd1498Szrj if (!new_size)
253*38fd1498Szrj new_size = GCOV_BLOCK_SIZE;
254*38fd1498Szrj new_size += length;
255*38fd1498Szrj new_size *= 2;
256*38fd1498Szrj
257*38fd1498Szrj gcov_var.alloc = new_size;
258*38fd1498Szrj gcov_var.buffer = XRESIZEVAR (gcov_unsigned_t, gcov_var.buffer, new_size << 2);
259*38fd1498Szrj }
260*38fd1498Szrj #endif
261*38fd1498Szrj
262*38fd1498Szrj #if !IN_GCOV
263*38fd1498Szrj /* Write out the current block, if needs be. */
264*38fd1498Szrj
265*38fd1498Szrj static void
gcov_write_block(unsigned size)266*38fd1498Szrj gcov_write_block (unsigned size)
267*38fd1498Szrj {
268*38fd1498Szrj if (fwrite (gcov_var.buffer, size << 2, 1, gcov_var.file) != 1)
269*38fd1498Szrj gcov_var.error = 1;
270*38fd1498Szrj gcov_var.start += size;
271*38fd1498Szrj gcov_var.offset -= size;
272*38fd1498Szrj }
273*38fd1498Szrj
274*38fd1498Szrj /* Allocate space to write BYTES bytes to the gcov file. Return a
275*38fd1498Szrj pointer to those bytes, or NULL on failure. */
276*38fd1498Szrj
277*38fd1498Szrj static gcov_unsigned_t *
gcov_write_words(unsigned words)278*38fd1498Szrj gcov_write_words (unsigned words)
279*38fd1498Szrj {
280*38fd1498Szrj gcov_unsigned_t *result;
281*38fd1498Szrj
282*38fd1498Szrj gcov_nonruntime_assert (gcov_var.mode < 0);
283*38fd1498Szrj #if IN_LIBGCOV
284*38fd1498Szrj if (gcov_var.offset >= GCOV_BLOCK_SIZE)
285*38fd1498Szrj {
286*38fd1498Szrj gcov_write_block (GCOV_BLOCK_SIZE);
287*38fd1498Szrj if (gcov_var.offset)
288*38fd1498Szrj {
289*38fd1498Szrj memcpy (gcov_var.buffer, gcov_var.buffer + GCOV_BLOCK_SIZE, 4);
290*38fd1498Szrj }
291*38fd1498Szrj }
292*38fd1498Szrj #else
293*38fd1498Szrj if (gcov_var.offset + words > gcov_var.alloc)
294*38fd1498Szrj gcov_allocate (gcov_var.offset + words);
295*38fd1498Szrj #endif
296*38fd1498Szrj result = &gcov_var.buffer[gcov_var.offset];
297*38fd1498Szrj gcov_var.offset += words;
298*38fd1498Szrj
299*38fd1498Szrj return result;
300*38fd1498Szrj }
301*38fd1498Szrj
302*38fd1498Szrj /* Write unsigned VALUE to coverage file. Sets error flag
303*38fd1498Szrj appropriately. */
304*38fd1498Szrj
305*38fd1498Szrj GCOV_LINKAGE void
gcov_write_unsigned(gcov_unsigned_t value)306*38fd1498Szrj gcov_write_unsigned (gcov_unsigned_t value)
307*38fd1498Szrj {
308*38fd1498Szrj gcov_unsigned_t *buffer = gcov_write_words (1);
309*38fd1498Szrj
310*38fd1498Szrj buffer[0] = value;
311*38fd1498Szrj }
312*38fd1498Szrj
313*38fd1498Szrj /* Write counter VALUE to coverage file. Sets error flag
314*38fd1498Szrj appropriately. */
315*38fd1498Szrj
316*38fd1498Szrj #if IN_LIBGCOV
317*38fd1498Szrj GCOV_LINKAGE void
gcov_write_counter(gcov_type value)318*38fd1498Szrj gcov_write_counter (gcov_type value)
319*38fd1498Szrj {
320*38fd1498Szrj gcov_unsigned_t *buffer = gcov_write_words (2);
321*38fd1498Szrj
322*38fd1498Szrj buffer[0] = (gcov_unsigned_t) value;
323*38fd1498Szrj if (sizeof (value) > sizeof (gcov_unsigned_t))
324*38fd1498Szrj buffer[1] = (gcov_unsigned_t) (value >> 32);
325*38fd1498Szrj else
326*38fd1498Szrj buffer[1] = 0;
327*38fd1498Szrj }
328*38fd1498Szrj #endif /* IN_LIBGCOV */
329*38fd1498Szrj
330*38fd1498Szrj #if !IN_LIBGCOV
331*38fd1498Szrj /* Write STRING to coverage file. Sets error flag on file
332*38fd1498Szrj error, overflow flag on overflow */
333*38fd1498Szrj
334*38fd1498Szrj GCOV_LINKAGE void
gcov_write_string(const char * string)335*38fd1498Szrj gcov_write_string (const char *string)
336*38fd1498Szrj {
337*38fd1498Szrj unsigned length = 0;
338*38fd1498Szrj unsigned alloc = 0;
339*38fd1498Szrj gcov_unsigned_t *buffer;
340*38fd1498Szrj
341*38fd1498Szrj if (string)
342*38fd1498Szrj {
343*38fd1498Szrj length = strlen (string);
344*38fd1498Szrj alloc = (length + 4) >> 2;
345*38fd1498Szrj }
346*38fd1498Szrj
347*38fd1498Szrj buffer = gcov_write_words (1 + alloc);
348*38fd1498Szrj
349*38fd1498Szrj buffer[0] = alloc;
350*38fd1498Szrj
351*38fd1498Szrj if (alloc > 0)
352*38fd1498Szrj {
353*38fd1498Szrj buffer[alloc] = 0; /* place nul terminators. */
354*38fd1498Szrj memcpy (&buffer[1], string, length);
355*38fd1498Szrj }
356*38fd1498Szrj }
357*38fd1498Szrj #endif
358*38fd1498Szrj
359*38fd1498Szrj #if !IN_LIBGCOV
360*38fd1498Szrj /* Write FILENAME to coverage file. Sets error flag on file
361*38fd1498Szrj error, overflow flag on overflow */
362*38fd1498Szrj
363*38fd1498Szrj GCOV_LINKAGE void
gcov_write_filename(const char * filename)364*38fd1498Szrj gcov_write_filename (const char *filename)
365*38fd1498Szrj {
366*38fd1498Szrj if (profile_abs_path_flag && filename && filename[0]
367*38fd1498Szrj && !(IS_DIR_SEPARATOR (filename[0])
368*38fd1498Szrj #if HAVE_DOS_BASED_FILE_SYSTEM
369*38fd1498Szrj || filename[1] == ':'
370*38fd1498Szrj #endif
371*38fd1498Szrj ))
372*38fd1498Szrj {
373*38fd1498Szrj char *buf = getcwd (NULL, 0);
374*38fd1498Szrj if (buf != NULL && buf[0])
375*38fd1498Szrj {
376*38fd1498Szrj size_t len = strlen (buf);
377*38fd1498Szrj buf = (char*)xrealloc (buf, len + strlen (filename) + 2);
378*38fd1498Szrj if (!IS_DIR_SEPARATOR (buf[len - 1]))
379*38fd1498Szrj strcat (buf, "/");
380*38fd1498Szrj strcat (buf, filename);
381*38fd1498Szrj gcov_write_string (buf);
382*38fd1498Szrj free (buf);
383*38fd1498Szrj return;
384*38fd1498Szrj }
385*38fd1498Szrj }
386*38fd1498Szrj
387*38fd1498Szrj gcov_write_string (filename);
388*38fd1498Szrj }
389*38fd1498Szrj #endif
390*38fd1498Szrj
391*38fd1498Szrj #if !IN_LIBGCOV
392*38fd1498Szrj /* Write a tag TAG and reserve space for the record length. Return a
393*38fd1498Szrj value to be used for gcov_write_length. */
394*38fd1498Szrj
395*38fd1498Szrj GCOV_LINKAGE gcov_position_t
gcov_write_tag(gcov_unsigned_t tag)396*38fd1498Szrj gcov_write_tag (gcov_unsigned_t tag)
397*38fd1498Szrj {
398*38fd1498Szrj gcov_position_t result = gcov_var.start + gcov_var.offset;
399*38fd1498Szrj gcov_unsigned_t *buffer = gcov_write_words (2);
400*38fd1498Szrj
401*38fd1498Szrj buffer[0] = tag;
402*38fd1498Szrj buffer[1] = 0;
403*38fd1498Szrj
404*38fd1498Szrj return result;
405*38fd1498Szrj }
406*38fd1498Szrj
407*38fd1498Szrj /* Write a record length using POSITION, which was returned by
408*38fd1498Szrj gcov_write_tag. The current file position is the end of the
409*38fd1498Szrj record, and is restored before returning. Returns nonzero on
410*38fd1498Szrj overflow. */
411*38fd1498Szrj
412*38fd1498Szrj GCOV_LINKAGE void
gcov_write_length(gcov_position_t position)413*38fd1498Szrj gcov_write_length (gcov_position_t position)
414*38fd1498Szrj {
415*38fd1498Szrj unsigned offset;
416*38fd1498Szrj gcov_unsigned_t length;
417*38fd1498Szrj gcov_unsigned_t *buffer;
418*38fd1498Szrj
419*38fd1498Szrj gcov_nonruntime_assert (gcov_var.mode < 0);
420*38fd1498Szrj gcov_nonruntime_assert (position + 2 <= gcov_var.start + gcov_var.offset);
421*38fd1498Szrj gcov_nonruntime_assert (position >= gcov_var.start);
422*38fd1498Szrj offset = position - gcov_var.start;
423*38fd1498Szrj length = gcov_var.offset - offset - 2;
424*38fd1498Szrj buffer = (gcov_unsigned_t *) &gcov_var.buffer[offset];
425*38fd1498Szrj buffer[1] = length;
426*38fd1498Szrj if (gcov_var.offset >= GCOV_BLOCK_SIZE)
427*38fd1498Szrj gcov_write_block (gcov_var.offset);
428*38fd1498Szrj }
429*38fd1498Szrj
430*38fd1498Szrj #else /* IN_LIBGCOV */
431*38fd1498Szrj
432*38fd1498Szrj /* Write a tag TAG and length LENGTH. */
433*38fd1498Szrj
434*38fd1498Szrj GCOV_LINKAGE void
gcov_write_tag_length(gcov_unsigned_t tag,gcov_unsigned_t length)435*38fd1498Szrj gcov_write_tag_length (gcov_unsigned_t tag, gcov_unsigned_t length)
436*38fd1498Szrj {
437*38fd1498Szrj gcov_unsigned_t *buffer = gcov_write_words (2);
438*38fd1498Szrj
439*38fd1498Szrj buffer[0] = tag;
440*38fd1498Szrj buffer[1] = length;
441*38fd1498Szrj }
442*38fd1498Szrj
443*38fd1498Szrj /* Write a summary structure to the gcov file. Return nonzero on
444*38fd1498Szrj overflow. */
445*38fd1498Szrj
446*38fd1498Szrj GCOV_LINKAGE void
gcov_write_summary(gcov_unsigned_t tag,const struct gcov_summary * summary)447*38fd1498Szrj gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary)
448*38fd1498Szrj {
449*38fd1498Szrj unsigned ix, h_ix, bv_ix, h_cnt = 0;
450*38fd1498Szrj const struct gcov_ctr_summary *csum;
451*38fd1498Szrj unsigned histo_bitvector[GCOV_HISTOGRAM_BITVECTOR_SIZE];
452*38fd1498Szrj
453*38fd1498Szrj /* Count number of non-zero histogram entries, and fill in a bit vector
454*38fd1498Szrj of non-zero indices. The histogram is only currently computed for arc
455*38fd1498Szrj counters. */
456*38fd1498Szrj for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
457*38fd1498Szrj histo_bitvector[bv_ix] = 0;
458*38fd1498Szrj csum = &summary->ctrs[GCOV_COUNTER_ARCS];
459*38fd1498Szrj for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
460*38fd1498Szrj if (csum->histogram[h_ix].num_counters)
461*38fd1498Szrj {
462*38fd1498Szrj histo_bitvector[h_ix / 32] |= 1 << (h_ix % 32);
463*38fd1498Szrj h_cnt++;
464*38fd1498Szrj }
465*38fd1498Szrj gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH (h_cnt));
466*38fd1498Szrj gcov_write_unsigned (summary->checksum);
467*38fd1498Szrj for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
468*38fd1498Szrj {
469*38fd1498Szrj gcov_write_unsigned (csum->num);
470*38fd1498Szrj gcov_write_unsigned (csum->runs);
471*38fd1498Szrj gcov_write_counter (csum->sum_all);
472*38fd1498Szrj gcov_write_counter (csum->run_max);
473*38fd1498Szrj gcov_write_counter (csum->sum_max);
474*38fd1498Szrj if (ix != GCOV_COUNTER_ARCS)
475*38fd1498Szrj {
476*38fd1498Szrj for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
477*38fd1498Szrj gcov_write_unsigned (0);
478*38fd1498Szrj continue;
479*38fd1498Szrj }
480*38fd1498Szrj for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
481*38fd1498Szrj gcov_write_unsigned (histo_bitvector[bv_ix]);
482*38fd1498Szrj for (h_ix = 0; h_ix < GCOV_HISTOGRAM_SIZE; h_ix++)
483*38fd1498Szrj {
484*38fd1498Szrj if (!csum->histogram[h_ix].num_counters)
485*38fd1498Szrj continue;
486*38fd1498Szrj gcov_write_unsigned (csum->histogram[h_ix].num_counters);
487*38fd1498Szrj gcov_write_counter (csum->histogram[h_ix].min_value);
488*38fd1498Szrj gcov_write_counter (csum->histogram[h_ix].cum_value);
489*38fd1498Szrj }
490*38fd1498Szrj }
491*38fd1498Szrj }
492*38fd1498Szrj #endif /* IN_LIBGCOV */
493*38fd1498Szrj
494*38fd1498Szrj #endif /*!IN_GCOV */
495*38fd1498Szrj
496*38fd1498Szrj /* Return a pointer to read BYTES bytes from the gcov file. Returns
497*38fd1498Szrj NULL on failure (read past EOF). */
498*38fd1498Szrj
499*38fd1498Szrj static const gcov_unsigned_t *
gcov_read_words(unsigned words)500*38fd1498Szrj gcov_read_words (unsigned words)
501*38fd1498Szrj {
502*38fd1498Szrj const gcov_unsigned_t *result;
503*38fd1498Szrj unsigned excess = gcov_var.length - gcov_var.offset;
504*38fd1498Szrj
505*38fd1498Szrj if (gcov_var.mode <= 0)
506*38fd1498Szrj return NULL;
507*38fd1498Szrj
508*38fd1498Szrj if (excess < words)
509*38fd1498Szrj {
510*38fd1498Szrj gcov_var.start += gcov_var.offset;
511*38fd1498Szrj if (excess)
512*38fd1498Szrj {
513*38fd1498Szrj #if IN_LIBGCOV
514*38fd1498Szrj memcpy (gcov_var.buffer, gcov_var.buffer + gcov_var.offset, 4);
515*38fd1498Szrj #else
516*38fd1498Szrj memmove (gcov_var.buffer, gcov_var.buffer + gcov_var.offset,
517*38fd1498Szrj excess * 4);
518*38fd1498Szrj #endif
519*38fd1498Szrj }
520*38fd1498Szrj gcov_var.offset = 0;
521*38fd1498Szrj gcov_var.length = excess;
522*38fd1498Szrj #if IN_LIBGCOV
523*38fd1498Szrj excess = GCOV_BLOCK_SIZE;
524*38fd1498Szrj #else
525*38fd1498Szrj if (gcov_var.length + words > gcov_var.alloc)
526*38fd1498Szrj gcov_allocate (gcov_var.length + words);
527*38fd1498Szrj excess = gcov_var.alloc - gcov_var.length;
528*38fd1498Szrj #endif
529*38fd1498Szrj excess = fread (gcov_var.buffer + gcov_var.length,
530*38fd1498Szrj 1, excess << 2, gcov_var.file) >> 2;
531*38fd1498Szrj gcov_var.length += excess;
532*38fd1498Szrj if (gcov_var.length < words)
533*38fd1498Szrj {
534*38fd1498Szrj gcov_var.overread += words - gcov_var.length;
535*38fd1498Szrj gcov_var.length = 0;
536*38fd1498Szrj return 0;
537*38fd1498Szrj }
538*38fd1498Szrj }
539*38fd1498Szrj result = &gcov_var.buffer[gcov_var.offset];
540*38fd1498Szrj gcov_var.offset += words;
541*38fd1498Szrj return result;
542*38fd1498Szrj }
543*38fd1498Szrj
544*38fd1498Szrj /* Read unsigned value from a coverage file. Sets error flag on file
545*38fd1498Szrj error, overflow flag on overflow */
546*38fd1498Szrj
547*38fd1498Szrj GCOV_LINKAGE gcov_unsigned_t
gcov_read_unsigned(void)548*38fd1498Szrj gcov_read_unsigned (void)
549*38fd1498Szrj {
550*38fd1498Szrj gcov_unsigned_t value;
551*38fd1498Szrj const gcov_unsigned_t *buffer = gcov_read_words (1);
552*38fd1498Szrj
553*38fd1498Szrj if (!buffer)
554*38fd1498Szrj return 0;
555*38fd1498Szrj value = from_file (buffer[0]);
556*38fd1498Szrj return value;
557*38fd1498Szrj }
558*38fd1498Szrj
559*38fd1498Szrj /* Read counter value from a coverage file. Sets error flag on file
560*38fd1498Szrj error, overflow flag on overflow */
561*38fd1498Szrj
562*38fd1498Szrj GCOV_LINKAGE gcov_type
gcov_read_counter(void)563*38fd1498Szrj gcov_read_counter (void)
564*38fd1498Szrj {
565*38fd1498Szrj gcov_type value;
566*38fd1498Szrj const gcov_unsigned_t *buffer = gcov_read_words (2);
567*38fd1498Szrj
568*38fd1498Szrj if (!buffer)
569*38fd1498Szrj return 0;
570*38fd1498Szrj value = from_file (buffer[0]);
571*38fd1498Szrj if (sizeof (value) > sizeof (gcov_unsigned_t))
572*38fd1498Szrj value |= ((gcov_type) from_file (buffer[1])) << 32;
573*38fd1498Szrj else if (buffer[1])
574*38fd1498Szrj gcov_var.error = -1;
575*38fd1498Szrj
576*38fd1498Szrj return value;
577*38fd1498Szrj }
578*38fd1498Szrj
579*38fd1498Szrj /* We need to expose the below function when compiling for gcov-tool. */
580*38fd1498Szrj
581*38fd1498Szrj #if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
582*38fd1498Szrj /* Read string from coverage file. Returns a pointer to a static
583*38fd1498Szrj buffer, or NULL on empty string. You must copy the string before
584*38fd1498Szrj calling another gcov function. */
585*38fd1498Szrj
586*38fd1498Szrj GCOV_LINKAGE const char *
gcov_read_string(void)587*38fd1498Szrj gcov_read_string (void)
588*38fd1498Szrj {
589*38fd1498Szrj unsigned length = gcov_read_unsigned ();
590*38fd1498Szrj
591*38fd1498Szrj if (!length)
592*38fd1498Szrj return 0;
593*38fd1498Szrj
594*38fd1498Szrj return (const char *) gcov_read_words (length);
595*38fd1498Szrj }
596*38fd1498Szrj #endif
597*38fd1498Szrj
598*38fd1498Szrj GCOV_LINKAGE void
gcov_read_summary(struct gcov_summary * summary)599*38fd1498Szrj gcov_read_summary (struct gcov_summary *summary)
600*38fd1498Szrj {
601*38fd1498Szrj unsigned ix, h_ix, bv_ix, h_cnt = 0;
602*38fd1498Szrj struct gcov_ctr_summary *csum;
603*38fd1498Szrj unsigned histo_bitvector[GCOV_HISTOGRAM_BITVECTOR_SIZE];
604*38fd1498Szrj unsigned cur_bitvector;
605*38fd1498Szrj
606*38fd1498Szrj summary->checksum = gcov_read_unsigned ();
607*38fd1498Szrj for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
608*38fd1498Szrj {
609*38fd1498Szrj csum->num = gcov_read_unsigned ();
610*38fd1498Szrj csum->runs = gcov_read_unsigned ();
611*38fd1498Szrj csum->sum_all = gcov_read_counter ();
612*38fd1498Szrj csum->run_max = gcov_read_counter ();
613*38fd1498Szrj csum->sum_max = gcov_read_counter ();
614*38fd1498Szrj memset (csum->histogram, 0,
615*38fd1498Szrj sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
616*38fd1498Szrj for (bv_ix = 0; bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE; bv_ix++)
617*38fd1498Szrj {
618*38fd1498Szrj histo_bitvector[bv_ix] = gcov_read_unsigned ();
619*38fd1498Szrj #if IN_LIBGCOV
620*38fd1498Szrj /* When building libgcov we don't include system.h, which includes
621*38fd1498Szrj hwint.h (where popcount_hwi is declared). However, libgcov.a
622*38fd1498Szrj is built by the bootstrapped compiler and therefore the builtins
623*38fd1498Szrj are always available. */
624*38fd1498Szrj h_cnt += __builtin_popcount (histo_bitvector[bv_ix]);
625*38fd1498Szrj #else
626*38fd1498Szrj h_cnt += popcount_hwi (histo_bitvector[bv_ix]);
627*38fd1498Szrj #endif
628*38fd1498Szrj }
629*38fd1498Szrj bv_ix = 0;
630*38fd1498Szrj h_ix = 0;
631*38fd1498Szrj cur_bitvector = 0;
632*38fd1498Szrj while (h_cnt--)
633*38fd1498Szrj {
634*38fd1498Szrj /* Find the index corresponding to the next entry we will read in.
635*38fd1498Szrj First find the next non-zero bitvector and re-initialize
636*38fd1498Szrj the histogram index accordingly, then right shift and increment
637*38fd1498Szrj the index until we find a set bit. */
638*38fd1498Szrj while (!cur_bitvector)
639*38fd1498Szrj {
640*38fd1498Szrj h_ix = bv_ix * 32;
641*38fd1498Szrj if (bv_ix >= GCOV_HISTOGRAM_BITVECTOR_SIZE)
642*38fd1498Szrj gcov_error ("corrupted profile info: summary histogram "
643*38fd1498Szrj "bitvector is corrupt");
644*38fd1498Szrj cur_bitvector = histo_bitvector[bv_ix++];
645*38fd1498Szrj }
646*38fd1498Szrj while (!(cur_bitvector & 0x1))
647*38fd1498Szrj {
648*38fd1498Szrj h_ix++;
649*38fd1498Szrj cur_bitvector >>= 1;
650*38fd1498Szrj }
651*38fd1498Szrj if (h_ix >= GCOV_HISTOGRAM_SIZE)
652*38fd1498Szrj gcov_error ("corrupted profile info: summary histogram "
653*38fd1498Szrj "index is corrupt");
654*38fd1498Szrj
655*38fd1498Szrj csum->histogram[h_ix].num_counters = gcov_read_unsigned ();
656*38fd1498Szrj csum->histogram[h_ix].min_value = gcov_read_counter ();
657*38fd1498Szrj csum->histogram[h_ix].cum_value = gcov_read_counter ();
658*38fd1498Szrj /* Shift off the index we are done with and increment to the
659*38fd1498Szrj corresponding next histogram entry. */
660*38fd1498Szrj cur_bitvector >>= 1;
661*38fd1498Szrj h_ix++;
662*38fd1498Szrj }
663*38fd1498Szrj }
664*38fd1498Szrj }
665*38fd1498Szrj
666*38fd1498Szrj /* We need to expose the below function when compiling for gcov-tool. */
667*38fd1498Szrj
668*38fd1498Szrj #if !IN_LIBGCOV || defined (IN_GCOV_TOOL)
669*38fd1498Szrj /* Reset to a known position. BASE should have been obtained from
670*38fd1498Szrj gcov_position, LENGTH should be a record length. */
671*38fd1498Szrj
672*38fd1498Szrj GCOV_LINKAGE void
gcov_sync(gcov_position_t base,gcov_unsigned_t length)673*38fd1498Szrj gcov_sync (gcov_position_t base, gcov_unsigned_t length)
674*38fd1498Szrj {
675*38fd1498Szrj gcov_nonruntime_assert (gcov_var.mode > 0);
676*38fd1498Szrj base += length;
677*38fd1498Szrj if (base - gcov_var.start <= gcov_var.length)
678*38fd1498Szrj gcov_var.offset = base - gcov_var.start;
679*38fd1498Szrj else
680*38fd1498Szrj {
681*38fd1498Szrj gcov_var.offset = gcov_var.length = 0;
682*38fd1498Szrj fseek (gcov_var.file, base << 2, SEEK_SET);
683*38fd1498Szrj gcov_var.start = ftell (gcov_var.file) >> 2;
684*38fd1498Szrj }
685*38fd1498Szrj }
686*38fd1498Szrj #endif
687*38fd1498Szrj
688*38fd1498Szrj #if IN_LIBGCOV
689*38fd1498Szrj /* Move to a given position in a gcov file. */
690*38fd1498Szrj
691*38fd1498Szrj GCOV_LINKAGE void
gcov_seek(gcov_position_t base)692*38fd1498Szrj gcov_seek (gcov_position_t base)
693*38fd1498Szrj {
694*38fd1498Szrj if (gcov_var.offset)
695*38fd1498Szrj gcov_write_block (gcov_var.offset);
696*38fd1498Szrj fseek (gcov_var.file, base << 2, SEEK_SET);
697*38fd1498Szrj gcov_var.start = ftell (gcov_var.file) >> 2;
698*38fd1498Szrj }
699*38fd1498Szrj #endif
700*38fd1498Szrj
701*38fd1498Szrj #if IN_GCOV > 0
702*38fd1498Szrj /* Return the modification time of the current gcov file. */
703*38fd1498Szrj
704*38fd1498Szrj GCOV_LINKAGE time_t
gcov_time(void)705*38fd1498Szrj gcov_time (void)
706*38fd1498Szrj {
707*38fd1498Szrj struct stat status;
708*38fd1498Szrj
709*38fd1498Szrj if (fstat (fileno (gcov_var.file), &status))
710*38fd1498Szrj return 0;
711*38fd1498Szrj else
712*38fd1498Szrj return status.st_mtime;
713*38fd1498Szrj }
714*38fd1498Szrj #endif /* IN_GCOV */
715*38fd1498Szrj
716*38fd1498Szrj #if !IN_GCOV
717*38fd1498Szrj /* Determine the index into histogram for VALUE. */
718*38fd1498Szrj
719*38fd1498Szrj #if IN_LIBGCOV
720*38fd1498Szrj static unsigned
721*38fd1498Szrj #else
722*38fd1498Szrj GCOV_LINKAGE unsigned
723*38fd1498Szrj #endif
gcov_histo_index(gcov_type value)724*38fd1498Szrj gcov_histo_index (gcov_type value)
725*38fd1498Szrj {
726*38fd1498Szrj gcov_type_unsigned v = (gcov_type_unsigned)value;
727*38fd1498Szrj unsigned r = 0;
728*38fd1498Szrj unsigned prev2bits = 0;
729*38fd1498Szrj
730*38fd1498Szrj /* Find index into log2 scale histogram, where each of the log2
731*38fd1498Szrj sized buckets is divided into 4 linear sub-buckets for better
732*38fd1498Szrj focus in the higher buckets. */
733*38fd1498Szrj
734*38fd1498Szrj /* Find the place of the most-significant bit set. */
735*38fd1498Szrj if (v > 0)
736*38fd1498Szrj {
737*38fd1498Szrj #if IN_LIBGCOV
738*38fd1498Szrj /* When building libgcov we don't include system.h, which includes
739*38fd1498Szrj hwint.h (where floor_log2 is declared). However, libgcov.a
740*38fd1498Szrj is built by the bootstrapped compiler and therefore the builtins
741*38fd1498Szrj are always available. */
742*38fd1498Szrj r = sizeof (long long) * __CHAR_BIT__ - 1 - __builtin_clzll (v);
743*38fd1498Szrj #else
744*38fd1498Szrj /* We use floor_log2 from hwint.c, which takes a HOST_WIDE_INT
745*38fd1498Szrj that is 64 bits and gcov_type_unsigned is 64 bits. */
746*38fd1498Szrj r = floor_log2 (v);
747*38fd1498Szrj #endif
748*38fd1498Szrj }
749*38fd1498Szrj
750*38fd1498Szrj /* If at most the 2 least significant bits are set (value is
751*38fd1498Szrj 0 - 3) then that value is our index into the lowest set of
752*38fd1498Szrj four buckets. */
753*38fd1498Szrj if (r < 2)
754*38fd1498Szrj return (unsigned)value;
755*38fd1498Szrj
756*38fd1498Szrj gcov_nonruntime_assert (r < 64);
757*38fd1498Szrj
758*38fd1498Szrj /* Find the two next most significant bits to determine which
759*38fd1498Szrj of the four linear sub-buckets to select. */
760*38fd1498Szrj prev2bits = (v >> (r - 2)) & 0x3;
761*38fd1498Szrj /* Finally, compose the final bucket index from the log2 index and
762*38fd1498Szrj the next 2 bits. The minimum r value at this point is 2 since we
763*38fd1498Szrj returned above if r was 2 or more, so the minimum bucket at this
764*38fd1498Szrj point is 4. */
765*38fd1498Szrj return (r - 1) * 4 + prev2bits;
766*38fd1498Szrj }
767*38fd1498Szrj
768*38fd1498Szrj /* Merge SRC_HISTO into TGT_HISTO. The counters are assumed to be in
769*38fd1498Szrj the same relative order in both histograms, and are matched up
770*38fd1498Szrj and merged in reverse order. Each counter is assigned an equal portion of
771*38fd1498Szrj its entry's original cumulative counter value when computing the
772*38fd1498Szrj new merged cum_value. */
773*38fd1498Szrj
gcov_histogram_merge(gcov_bucket_type * tgt_histo,gcov_bucket_type * src_histo)774*38fd1498Szrj static void gcov_histogram_merge (gcov_bucket_type *tgt_histo,
775*38fd1498Szrj gcov_bucket_type *src_histo)
776*38fd1498Szrj {
777*38fd1498Szrj int src_i, tgt_i, tmp_i = 0;
778*38fd1498Szrj unsigned src_num, tgt_num, merge_num;
779*38fd1498Szrj gcov_type src_cum, tgt_cum, merge_src_cum, merge_tgt_cum, merge_cum;
780*38fd1498Szrj gcov_type merge_min;
781*38fd1498Szrj gcov_bucket_type tmp_histo[GCOV_HISTOGRAM_SIZE];
782*38fd1498Szrj int src_done = 0;
783*38fd1498Szrj
784*38fd1498Szrj memset (tmp_histo, 0, sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
785*38fd1498Szrj
786*38fd1498Szrj /* Assume that the counters are in the same relative order in both
787*38fd1498Szrj histograms. Walk the histograms from largest to smallest entry,
788*38fd1498Szrj matching up and combining counters in order. */
789*38fd1498Szrj src_num = 0;
790*38fd1498Szrj src_cum = 0;
791*38fd1498Szrj src_i = GCOV_HISTOGRAM_SIZE - 1;
792*38fd1498Szrj for (tgt_i = GCOV_HISTOGRAM_SIZE - 1; tgt_i >= 0 && !src_done; tgt_i--)
793*38fd1498Szrj {
794*38fd1498Szrj tgt_num = tgt_histo[tgt_i].num_counters;
795*38fd1498Szrj tgt_cum = tgt_histo[tgt_i].cum_value;
796*38fd1498Szrj /* Keep going until all of the target histogram's counters at this
797*38fd1498Szrj position have been matched and merged with counters from the
798*38fd1498Szrj source histogram. */
799*38fd1498Szrj while (tgt_num > 0 && !src_done)
800*38fd1498Szrj {
801*38fd1498Szrj /* If this is either the first time through this loop or we just
802*38fd1498Szrj exhausted the previous non-zero source histogram entry, look
803*38fd1498Szrj for the next non-zero source histogram entry. */
804*38fd1498Szrj if (!src_num)
805*38fd1498Szrj {
806*38fd1498Szrj /* Locate the next non-zero entry. */
807*38fd1498Szrj while (src_i >= 0 && !src_histo[src_i].num_counters)
808*38fd1498Szrj src_i--;
809*38fd1498Szrj /* If source histogram has fewer counters, then just copy over the
810*38fd1498Szrj remaining target counters and quit. */
811*38fd1498Szrj if (src_i < 0)
812*38fd1498Szrj {
813*38fd1498Szrj tmp_histo[tgt_i].num_counters += tgt_num;
814*38fd1498Szrj tmp_histo[tgt_i].cum_value += tgt_cum;
815*38fd1498Szrj if (!tmp_histo[tgt_i].min_value ||
816*38fd1498Szrj tgt_histo[tgt_i].min_value < tmp_histo[tgt_i].min_value)
817*38fd1498Szrj tmp_histo[tgt_i].min_value = tgt_histo[tgt_i].min_value;
818*38fd1498Szrj while (--tgt_i >= 0)
819*38fd1498Szrj {
820*38fd1498Szrj tmp_histo[tgt_i].num_counters
821*38fd1498Szrj += tgt_histo[tgt_i].num_counters;
822*38fd1498Szrj tmp_histo[tgt_i].cum_value += tgt_histo[tgt_i].cum_value;
823*38fd1498Szrj if (!tmp_histo[tgt_i].min_value ||
824*38fd1498Szrj tgt_histo[tgt_i].min_value
825*38fd1498Szrj < tmp_histo[tgt_i].min_value)
826*38fd1498Szrj tmp_histo[tgt_i].min_value = tgt_histo[tgt_i].min_value;
827*38fd1498Szrj }
828*38fd1498Szrj
829*38fd1498Szrj src_done = 1;
830*38fd1498Szrj break;
831*38fd1498Szrj }
832*38fd1498Szrj
833*38fd1498Szrj src_num = src_histo[src_i].num_counters;
834*38fd1498Szrj src_cum = src_histo[src_i].cum_value;
835*38fd1498Szrj }
836*38fd1498Szrj
837*38fd1498Szrj /* The number of counters to merge on this pass is the minimum
838*38fd1498Szrj of the remaining counters from the current target and source
839*38fd1498Szrj histogram entries. */
840*38fd1498Szrj merge_num = tgt_num;
841*38fd1498Szrj if (src_num < merge_num)
842*38fd1498Szrj merge_num = src_num;
843*38fd1498Szrj
844*38fd1498Szrj /* The merged min_value is the sum of the min_values from target
845*38fd1498Szrj and source. */
846*38fd1498Szrj merge_min = tgt_histo[tgt_i].min_value + src_histo[src_i].min_value;
847*38fd1498Szrj
848*38fd1498Szrj /* Compute the portion of source and target entries' cum_value
849*38fd1498Szrj that will be apportioned to the counters being merged.
850*38fd1498Szrj The total remaining cum_value from each entry is divided
851*38fd1498Szrj equally among the counters from that histogram entry if we
852*38fd1498Szrj are not merging all of them. */
853*38fd1498Szrj merge_src_cum = src_cum;
854*38fd1498Szrj if (merge_num < src_num)
855*38fd1498Szrj merge_src_cum = merge_num * src_cum / src_num;
856*38fd1498Szrj merge_tgt_cum = tgt_cum;
857*38fd1498Szrj if (merge_num < tgt_num)
858*38fd1498Szrj merge_tgt_cum = merge_num * tgt_cum / tgt_num;
859*38fd1498Szrj /* The merged cum_value is the sum of the source and target
860*38fd1498Szrj components. */
861*38fd1498Szrj merge_cum = merge_src_cum + merge_tgt_cum;
862*38fd1498Szrj
863*38fd1498Szrj /* Update the remaining number of counters and cum_value left
864*38fd1498Szrj to be merged from this source and target entry. */
865*38fd1498Szrj src_cum -= merge_src_cum;
866*38fd1498Szrj tgt_cum -= merge_tgt_cum;
867*38fd1498Szrj src_num -= merge_num;
868*38fd1498Szrj tgt_num -= merge_num;
869*38fd1498Szrj
870*38fd1498Szrj /* The merged counters get placed in the new merged histogram
871*38fd1498Szrj at the entry for the merged min_value. */
872*38fd1498Szrj tmp_i = gcov_histo_index (merge_min);
873*38fd1498Szrj gcov_nonruntime_assert (tmp_i < GCOV_HISTOGRAM_SIZE);
874*38fd1498Szrj tmp_histo[tmp_i].num_counters += merge_num;
875*38fd1498Szrj tmp_histo[tmp_i].cum_value += merge_cum;
876*38fd1498Szrj if (!tmp_histo[tmp_i].min_value ||
877*38fd1498Szrj merge_min < tmp_histo[tmp_i].min_value)
878*38fd1498Szrj tmp_histo[tmp_i].min_value = merge_min;
879*38fd1498Szrj
880*38fd1498Szrj /* Ensure the search for the next non-zero src_histo entry starts
881*38fd1498Szrj at the next smallest histogram bucket. */
882*38fd1498Szrj if (!src_num)
883*38fd1498Szrj src_i--;
884*38fd1498Szrj }
885*38fd1498Szrj }
886*38fd1498Szrj
887*38fd1498Szrj gcov_nonruntime_assert (tgt_i < 0);
888*38fd1498Szrj
889*38fd1498Szrj /* In the case where there were more counters in the source histogram,
890*38fd1498Szrj accumulate the remaining unmerged cumulative counter values. Add
891*38fd1498Szrj those to the smallest non-zero target histogram entry. Otherwise,
892*38fd1498Szrj the total cumulative counter values in the histogram will be smaller
893*38fd1498Szrj than the sum_all stored in the summary, which will complicate
894*38fd1498Szrj computing the working set information from the histogram later on. */
895*38fd1498Szrj if (src_num)
896*38fd1498Szrj src_i--;
897*38fd1498Szrj while (src_i >= 0)
898*38fd1498Szrj {
899*38fd1498Szrj src_cum += src_histo[src_i].cum_value;
900*38fd1498Szrj src_i--;
901*38fd1498Szrj }
902*38fd1498Szrj /* At this point, tmp_i should be the smallest non-zero entry in the
903*38fd1498Szrj tmp_histo. */
904*38fd1498Szrj gcov_nonruntime_assert (tmp_i >= 0 && tmp_i < GCOV_HISTOGRAM_SIZE
905*38fd1498Szrj && tmp_histo[tmp_i].num_counters > 0);
906*38fd1498Szrj tmp_histo[tmp_i].cum_value += src_cum;
907*38fd1498Szrj
908*38fd1498Szrj /* Finally, copy the merged histogram into tgt_histo. */
909*38fd1498Szrj memcpy (tgt_histo, tmp_histo,
910*38fd1498Szrj sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
911*38fd1498Szrj }
912*38fd1498Szrj #endif /* !IN_GCOV */
913*38fd1498Szrj
914*38fd1498Szrj /* This is used by gcov-dump (IN_GCOV == -1) and in the compiler
915*38fd1498Szrj (!IN_GCOV && !IN_LIBGCOV). */
916*38fd1498Szrj #if IN_GCOV <= 0 && !IN_LIBGCOV
917*38fd1498Szrj /* Compute the working set information from the counter histogram in
918*38fd1498Szrj the profile summary. This is an array of information corresponding to a
919*38fd1498Szrj range of percentages of the total execution count (sum_all), and includes
920*38fd1498Szrj the number of counters required to cover that working set percentage and
921*38fd1498Szrj the minimum counter value in that working set. */
922*38fd1498Szrj
923*38fd1498Szrj GCOV_LINKAGE void
compute_working_sets(const struct gcov_ctr_summary * summary,gcov_working_set_t * gcov_working_sets)924*38fd1498Szrj compute_working_sets (const struct gcov_ctr_summary *summary,
925*38fd1498Szrj gcov_working_set_t *gcov_working_sets)
926*38fd1498Szrj {
927*38fd1498Szrj gcov_type working_set_cum_values[NUM_GCOV_WORKING_SETS];
928*38fd1498Szrj gcov_type ws_cum_hotness_incr;
929*38fd1498Szrj gcov_type cum, tmp_cum;
930*38fd1498Szrj const gcov_bucket_type *histo_bucket;
931*38fd1498Szrj unsigned ws_ix, c_num, count;
932*38fd1498Szrj int h_ix;
933*38fd1498Szrj
934*38fd1498Szrj /* Compute the amount of sum_all that the cumulative hotness grows
935*38fd1498Szrj by in each successive working set entry, which depends on the
936*38fd1498Szrj number of working set entries. */
937*38fd1498Szrj ws_cum_hotness_incr = summary->sum_all / NUM_GCOV_WORKING_SETS;
938*38fd1498Szrj
939*38fd1498Szrj /* Next fill in an array of the cumulative hotness values corresponding
940*38fd1498Szrj to each working set summary entry we are going to compute below.
941*38fd1498Szrj Skip 0% statistics, which can be extrapolated from the
942*38fd1498Szrj rest of the summary data. */
943*38fd1498Szrj cum = ws_cum_hotness_incr;
944*38fd1498Szrj for (ws_ix = 0; ws_ix < NUM_GCOV_WORKING_SETS;
945*38fd1498Szrj ws_ix++, cum += ws_cum_hotness_incr)
946*38fd1498Szrj working_set_cum_values[ws_ix] = cum;
947*38fd1498Szrj /* The last summary entry is reserved for (roughly) 99.9% of the
948*38fd1498Szrj working set. Divide by 1024 so it becomes a shift, which gives
949*38fd1498Szrj almost exactly 99.9%. */
950*38fd1498Szrj working_set_cum_values[NUM_GCOV_WORKING_SETS-1]
951*38fd1498Szrj = summary->sum_all - summary->sum_all/1024;
952*38fd1498Szrj
953*38fd1498Szrj /* Next, walk through the histogram in decending order of hotness
954*38fd1498Szrj and compute the statistics for the working set summary array.
955*38fd1498Szrj As histogram entries are accumulated, we check to see which
956*38fd1498Szrj working set entries have had their expected cum_value reached
957*38fd1498Szrj and fill them in, walking the working set entries in increasing
958*38fd1498Szrj size of cum_value. */
959*38fd1498Szrj ws_ix = 0; /* The current entry into the working set array. */
960*38fd1498Szrj cum = 0; /* The current accumulated counter sum. */
961*38fd1498Szrj count = 0; /* The current accumulated count of block counters. */
962*38fd1498Szrj for (h_ix = GCOV_HISTOGRAM_SIZE - 1;
963*38fd1498Szrj h_ix >= 0 && ws_ix < NUM_GCOV_WORKING_SETS; h_ix--)
964*38fd1498Szrj {
965*38fd1498Szrj histo_bucket = &summary->histogram[h_ix];
966*38fd1498Szrj
967*38fd1498Szrj /* If we haven't reached the required cumulative counter value for
968*38fd1498Szrj the current working set percentage, simply accumulate this histogram
969*38fd1498Szrj entry into the running sums and continue to the next histogram
970*38fd1498Szrj entry. */
971*38fd1498Szrj if (cum + histo_bucket->cum_value < working_set_cum_values[ws_ix])
972*38fd1498Szrj {
973*38fd1498Szrj cum += histo_bucket->cum_value;
974*38fd1498Szrj count += histo_bucket->num_counters;
975*38fd1498Szrj continue;
976*38fd1498Szrj }
977*38fd1498Szrj
978*38fd1498Szrj /* If adding the current histogram entry's cumulative counter value
979*38fd1498Szrj causes us to exceed the current working set size, then estimate
980*38fd1498Szrj how many of this histogram entry's counter values are required to
981*38fd1498Szrj reach the working set size, and fill in working set entries
982*38fd1498Szrj as we reach their expected cumulative value. */
983*38fd1498Szrj for (c_num = 0, tmp_cum = cum;
984*38fd1498Szrj c_num < histo_bucket->num_counters && ws_ix < NUM_GCOV_WORKING_SETS;
985*38fd1498Szrj c_num++)
986*38fd1498Szrj {
987*38fd1498Szrj count++;
988*38fd1498Szrj /* If we haven't reached the last histogram entry counter, add
989*38fd1498Szrj in the minimum value again. This will underestimate the
990*38fd1498Szrj cumulative sum so far, because many of the counter values in this
991*38fd1498Szrj entry may have been larger than the minimum. We could add in the
992*38fd1498Szrj average value every time, but that would require an expensive
993*38fd1498Szrj divide operation. */
994*38fd1498Szrj if (c_num + 1 < histo_bucket->num_counters)
995*38fd1498Szrj tmp_cum += histo_bucket->min_value;
996*38fd1498Szrj /* If we have reached the last histogram entry counter, then add
997*38fd1498Szrj in the entire cumulative value. */
998*38fd1498Szrj else
999*38fd1498Szrj tmp_cum = cum + histo_bucket->cum_value;
1000*38fd1498Szrj
1001*38fd1498Szrj /* Next walk through successive working set entries and fill in
1002*38fd1498Szrj the statistics for any whose size we have reached by accumulating
1003*38fd1498Szrj this histogram counter. */
1004*38fd1498Szrj while (ws_ix < NUM_GCOV_WORKING_SETS
1005*38fd1498Szrj && tmp_cum >= working_set_cum_values[ws_ix])
1006*38fd1498Szrj {
1007*38fd1498Szrj gcov_working_sets[ws_ix].num_counters = count;
1008*38fd1498Szrj gcov_working_sets[ws_ix].min_counter
1009*38fd1498Szrj = histo_bucket->min_value;
1010*38fd1498Szrj ws_ix++;
1011*38fd1498Szrj }
1012*38fd1498Szrj }
1013*38fd1498Szrj /* Finally, update the running cumulative value since we were
1014*38fd1498Szrj using a temporary above. */
1015*38fd1498Szrj cum += histo_bucket->cum_value;
1016*38fd1498Szrj }
1017*38fd1498Szrj gcov_nonruntime_assert (ws_ix == NUM_GCOV_WORKING_SETS);
1018*38fd1498Szrj }
1019*38fd1498Szrj #endif /* IN_GCOV <= 0 && !IN_LIBGCOV */
1020