Martin Roth | fb8876d | 2022-08-07 15:12:12 -0600 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-3.0-only WITH GCC-exception-3.1 */ |
| 2 | |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 3 | /* File format for coverage information |
| 4 | Copyright (C) 1996, 1997, 1998, 2000, 2002, |
| 5 | 2003, 2004, 2005, 2008, 2009 Free Software Foundation, Inc. |
| 6 | Contributed by Bob Manson <manson@cygnus.com>. |
| 7 | Completely remangled by Nathan Sidwell <nathan@codesourcery.com>. |
| 8 | |
| 9 | This file is part of GCC. |
| 10 | |
| 11 | GCC is free software; you can redistribute it and/or modify it under |
| 12 | the terms of the GNU General Public License as published by the Free |
| 13 | Software Foundation; either version 3, or (at your option) any later |
| 14 | version. |
| 15 | |
| 16 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| 17 | WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| 18 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| 19 | for more details. |
| 20 | |
| 21 | Under Section 7 of GPL version 3, you are granted additional |
| 22 | permissions described in the GCC Runtime Library Exception, version |
| 23 | 3.1, as published by the Free Software Foundation. |
Patrick Georgi | a73b931 | 2015-10-31 11:55:10 +0100 | [diff] [blame] | 24 | */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 25 | |
| 26 | |
| 27 | /* Coverage information is held in two files. A notes file, which is |
| 28 | generated by the compiler, and a data file, which is generated by |
| 29 | the program under test. Both files use a similar structure. We do |
| 30 | not attempt to make these files backwards compatible with previous |
| 31 | versions, as you only need coverage information when developing a |
| 32 | program. We do hold version information, so that mismatches can be |
| 33 | detected, and we use a format that allows tools to skip information |
| 34 | they do not understand or are not interested in. |
| 35 | |
| 36 | Numbers are recorded in the 32 bit unsigned binary form of the |
| 37 | endianness of the machine generating the file. 64 bit numbers are |
| 38 | stored as two 32 bit numbers, the low part first. Strings are |
| 39 | padded with 1 to 4 NUL bytes, to bring the length up to a multiple |
| 40 | of 4. The number of 4 bytes is stored, followed by the padded |
| 41 | string. Zero length and NULL strings are simply stored as a length |
| 42 | of zero (they have no trailing NUL or padding). |
| 43 | |
| 44 | int32: byte3 byte2 byte1 byte0 | byte0 byte1 byte2 byte3 |
| 45 | int64: int32:low int32:high |
| 46 | string: int32:0 | int32:length char* char:0 padding |
| 47 | padding: | char:0 | char:0 char:0 | char:0 char:0 char:0 |
| 48 | item: int32 | int64 | string |
| 49 | |
| 50 | The basic format of the files is |
| 51 | |
| 52 | file : int32:magic int32:version int32:stamp record* |
| 53 | |
| 54 | The magic ident is different for the notes and the data files. The |
| 55 | magic ident is used to determine the endianness of the file, when |
| 56 | reading. The version is the same for both files and is derived |
| 57 | from gcc's version number. The stamp value is used to synchronize |
| 58 | note and data files and to synchronize merging within a data |
| 59 | file. It need not be an absolute time stamp, merely a ticker that |
| 60 | increments fast enough and cycles slow enough to distinguish |
| 61 | different compile/run/compile cycles. |
| 62 | |
| 63 | Although the ident and version are formally 32 bit numbers, they |
| 64 | are derived from 4 character ASCII strings. The version number |
| 65 | consists of the single character major version number, a two |
| 66 | character minor version number (leading zero for versions less than |
| 67 | 10), and a single character indicating the status of the release. |
| 68 | That will be 'e' experimental, 'p' prerelease and 'r' for release. |
| 69 | Because, by good fortune, these are in alphabetical order, string |
| 70 | collating can be used to compare version strings. Be aware that |
| 71 | the 'e' designation will (naturally) be unstable and might be |
| 72 | incompatible with itself. For gcc 3.4 experimental, it would be |
| 73 | '304e' (0x33303465). When the major version reaches 10, the |
| 74 | letters A-Z will be used. Assuming minor increments releases every |
| 75 | 6 months, we have to make a major increment every 50 years. |
| 76 | Assuming major increments releases every 5 years, we're ok for the |
| 77 | next 155 years -- good enough for me. |
| 78 | |
| 79 | A record has a tag, length and variable amount of data. |
| 80 | |
| 81 | record: header data |
| 82 | header: int32:tag int32:length |
| 83 | data: item* |
| 84 | |
| 85 | Records are not nested, but there is a record hierarchy. Tag |
| 86 | numbers reflect this hierarchy. Tags are unique across note and |
| 87 | data files. Some record types have a varying amount of data. The |
| 88 | LENGTH is the number of 4bytes that follow and is usually used to |
| 89 | determine how much data. The tag value is split into 4 8-bit |
| 90 | fields, one for each of four possible levels. The most significant |
| 91 | is allocated first. Unused levels are zero. Active levels are |
| 92 | odd-valued, so that the LSB of the level is one. A sub-level |
| 93 | incorporates the values of its superlevels. This formatting allows |
| 94 | you to determine the tag hierarchy, without understanding the tags |
| 95 | themselves, and is similar to the standard section numbering used |
| 96 | in technical documents. Level values [1..3f] are used for common |
| 97 | tags, values [41..9f] for the notes file and [a1..ff] for the data |
| 98 | file. |
| 99 | |
| 100 | The basic block graph file contains the following records |
| 101 | note: unit function-graph* |
| 102 | unit: header int32:checksum string:source |
| 103 | function-graph: announce_function basic_blocks {arcs | lines}* |
| 104 | announce_function: header int32:ident |
| 105 | int32:lineno_checksum int32:cfg_checksum |
| 106 | string:name string:source int32:lineno |
| 107 | basic_block: header int32:flags* |
| 108 | arcs: header int32:block_no arc* |
| 109 | arc: int32:dest_block int32:flags |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 110 | lines: header int32:block_no line* |
| 111 | int32:0 string:NULL |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 112 | line: int32:line_no | int32:0 string:filename |
| 113 | |
| 114 | The BASIC_BLOCK record holds per-bb flags. The number of blocks |
| 115 | can be inferred from its data length. There is one ARCS record per |
| 116 | basic block. The number of arcs from a bb is implicit from the |
| 117 | data length. It enumerates the destination bb and per-arc flags. |
| 118 | There is one LINES record per basic block, it enumerates the source |
| 119 | lines which belong to that basic block. Source file names are |
| 120 | introduced by a line number of 0, following lines are from the new |
| 121 | source file. The initial source file for the function is NULL, but |
| 122 | the current source file should be remembered from one LINES record |
| 123 | to the next. The end of a block is indicated by an empty filename |
| 124 | - this does not reset the current source file. Note there is no |
| 125 | ordering of the ARCS and LINES records: they may be in any order, |
| 126 | interleaved in any manner. The current filename follows the order |
| 127 | the LINES records are stored in the file, *not* the ordering of the |
| 128 | blocks they are for. |
| 129 | |
| 130 | The data file contains the following records. |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 131 | data: {unit summary:object summary:program* function-data*}* |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 132 | unit: header int32:checksum |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 133 | function-data: announce_function present counts |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 134 | announce_function: header int32:ident |
| 135 | int32:lineno_checksum int32:cfg_checksum |
| 136 | present: header int32:present |
| 137 | counts: header int64:count* |
| 138 | summary: int32:checksum {count-summary}GCOV_COUNTERS_SUMMABLE |
| 139 | count-summary: int32:num int32:runs int64:sum |
| 140 | int64:max int64:sum_max |
| 141 | |
| 142 | The ANNOUNCE_FUNCTION record is the same as that in the note file, |
| 143 | but without the source location. The COUNTS gives the |
| 144 | counter values for instrumented features. The about the whole |
| 145 | program. The checksum is used for whole program summaries, and |
| 146 | disambiguates different programs which include the same |
| 147 | instrumented object file. There may be several program summaries, |
| 148 | each with a unique checksum. The object summary's checksum is |
| 149 | zero. Note that the data file might contain information from |
| 150 | several runs concatenated, or the data might be merged. |
| 151 | |
| 152 | This file is included by both the compiler, gcov tools and the |
| 153 | runtime support library libgcov. IN_LIBGCOV and IN_GCOV are used to |
| 154 | distinguish which case is which. If IN_LIBGCOV is nonzero, |
| 155 | libgcov is being built. If IN_GCOV is nonzero, the gcov tools are |
| 156 | being built. Otherwise the compiler is being built. IN_GCOV may be |
| 157 | positive or negative. If positive, we are compiling a tool that |
| 158 | requires additional functions (see the code for knowledge of what |
| 159 | those functions are). */ |
| 160 | |
| 161 | #ifndef GCC_GCOV_IO_H |
| 162 | #define GCC_GCOV_IO_H |
| 163 | |
| 164 | #ifdef __COREBOOT__ |
| 165 | #define GCOV_LINKAGE /* nothing */ |
| 166 | /* We need the definitions for |
| 167 | BITS_PER_UNIT and |
| 168 | LONG_LONG_TYPE_SIZE |
| 169 | They are defined in gcc/defaults.h and gcc/config/<arch_depend_files> |
| 170 | (like, gcc/config/i386/i386.h). And it can be overridden by setting |
| 171 | in build scripts. Here I hardcoded the value for x86. */ |
| 172 | #define BITS_PER_UNIT 8 |
| 173 | #define LONG_LONG_TYPE_SIZE 64 |
| 174 | |
Martin Roth | cbf2bd7 | 2013-07-09 21:51:14 -0600 | [diff] [blame] | 175 | /* There are many gcc_assertions. Set the value to 1 if we want a warning |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 176 | message if the assertion fails. */ |
| 177 | #ifndef ENABLE_ASSERT_CHECKING |
| 178 | #define ENABLE_ASSERT_CHECKING 1 |
| 179 | #endif |
| 180 | #endif /* __COREBOOT__ */ |
| 181 | |
| 182 | #if IN_LIBGCOV |
| 183 | /* About the target */ |
| 184 | |
| 185 | #if BITS_PER_UNIT == 8 |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 186 | typedef unsigned int gcov_unsigned_t __attribute__((mode(SI))); |
| 187 | typedef unsigned int gcov_position_t __attribute__((mode(SI))); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 188 | #if LONG_LONG_TYPE_SIZE > 32 |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 189 | typedef signed gcov_type __attribute__((mode(DI))); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 190 | #else |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 191 | typedef signed gcov_type __attribute__((mode(SI))); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 192 | #endif |
| 193 | #else |
| 194 | #if BITS_PER_UNIT == 16 |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 195 | typedef unsigned int gcov_unsigned_t __attribute__((mode(HI))); |
| 196 | typedef unsigned int gcov_position_t __attribute__((mode(HI))); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 197 | #if LONG_LONG_TYPE_SIZE > 32 |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 198 | typedef signed gcov_type __attribute__((mode(SI))); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 199 | #else |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 200 | typedef signed gcov_type __attribute__((mode(HI))); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 201 | #endif |
| 202 | #else |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 203 | typedef unsigned int gcov_unsigned_t __attribute__((mode(QI))); |
| 204 | typedef unsigned int gcov_position_t __attribute__((mode(QI))); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 205 | #if LONG_LONG_TYPE_SIZE > 32 |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 206 | typedef signed gcov_type __attribute__((mode(HI))); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 207 | #else |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 208 | typedef signed gcov_type __attribute__((mode(QI))); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 209 | #endif |
| 210 | #endif |
| 211 | #endif |
| 212 | |
| 213 | |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 214 | #if defined(TARGET_POSIX_IO) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 215 | #define GCOV_LOCKED 1 |
| 216 | #else |
| 217 | #define GCOV_LOCKED 0 |
| 218 | #endif |
| 219 | |
| 220 | #else /* !IN_LIBGCOV */ |
| 221 | /* About the host */ |
| 222 | |
Lee Leahy | 75b8599 | 2017-03-08 16:34:12 -0800 | [diff] [blame] | 223 | typedef unsigned int gcov_unsigned_t; |
| 224 | typedef unsigned int gcov_position_t; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 225 | /* gcov_type is typedef'd elsewhere for the compiler */ |
| 226 | #if IN_GCOV |
| 227 | #define GCOV_LINKAGE static |
| 228 | typedef HOST_WIDEST_INT gcov_type; |
| 229 | #if IN_GCOV > 0 |
| 230 | #include <sys/types.h> |
| 231 | #endif |
| 232 | #else /*!IN_GCOV */ |
| 233 | #define GCOV_TYPE_SIZE (LONG_LONG_TYPE_SIZE > 32 ? 64 : 32) |
| 234 | #endif |
| 235 | |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 236 | #if defined(HOST_HAS_F_SETLKW) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 237 | #define GCOV_LOCKED 1 |
| 238 | #else |
| 239 | #define GCOV_LOCKED 0 |
| 240 | #endif |
| 241 | |
| 242 | #endif /* !IN_LIBGCOV */ |
| 243 | |
| 244 | /* In gcov we want function linkage to be static. In the compiler we want |
| 245 | it extern, so that they can be accessed from elsewhere. In libgcov we |
| 246 | need these functions to be extern, so prefix them with __gcov. In |
| 247 | libgcov they must also be hidden so that the instance in the executable |
| 248 | is not also used in a DSO. */ |
| 249 | #if IN_LIBGCOV |
| 250 | |
| 251 | #ifndef __COREBOOT__ |
| 252 | #include "tconfig.h" |
| 253 | #endif /* __COREBOOT__ */ |
| 254 | |
| 255 | #define gcov_var __gcov_var |
| 256 | #define gcov_open __gcov_open |
| 257 | #define gcov_close __gcov_close |
| 258 | #define gcov_write_tag_length __gcov_write_tag_length |
| 259 | #define gcov_position __gcov_position |
| 260 | #define gcov_seek __gcov_seek |
| 261 | #define gcov_rewrite __gcov_rewrite |
| 262 | #define gcov_is_error __gcov_is_error |
| 263 | #define gcov_write_unsigned __gcov_write_unsigned |
| 264 | #define gcov_write_counter __gcov_write_counter |
| 265 | #define gcov_write_summary __gcov_write_summary |
| 266 | #define gcov_read_unsigned __gcov_read_unsigned |
| 267 | #define gcov_read_counter __gcov_read_counter |
| 268 | #define gcov_read_summary __gcov_read_summary |
| 269 | |
| 270 | /* Poison these, so they don't accidentally slip in. */ |
| 271 | #pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length |
| 272 | #pragma GCC poison gcov_read_string gcov_sync gcov_time gcov_magic |
| 273 | |
| 274 | #ifdef HAVE_GAS_HIDDEN |
Stefan Reinauer | 6a00113 | 2017-07-13 02:20:27 +0200 | [diff] [blame] | 275 | #define ATTRIBUTE_HIDDEN __attribute__((__visibility__("hidden"))) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 276 | #else |
| 277 | #define ATTRIBUTE_HIDDEN |
| 278 | #endif |
| 279 | |
| 280 | #else |
| 281 | |
| 282 | #define ATTRIBUTE_HIDDEN |
| 283 | |
| 284 | #endif |
| 285 | |
| 286 | #ifndef GCOV_LINKAGE |
| 287 | #define GCOV_LINKAGE extern |
| 288 | #endif |
| 289 | |
| 290 | /* File suffixes. */ |
| 291 | #define GCOV_DATA_SUFFIX ".gcda" |
| 292 | #define GCOV_NOTE_SUFFIX ".gcno" |
| 293 | |
| 294 | /* File magic. Must not be palindromes. */ |
| 295 | #define GCOV_DATA_MAGIC ((gcov_unsigned_t)0x67636461) /* "gcda" */ |
| 296 | #define GCOV_NOTE_MAGIC ((gcov_unsigned_t)0x67636e6f) /* "gcno" */ |
| 297 | |
| 298 | /* gcov-iov.h is automatically generated by the makefile from |
| 299 | version.c, it looks like |
| 300 | #define GCOV_VERSION ((gcov_unsigned_t)0x89abcdef) |
| 301 | */ |
| 302 | #include "gcov-iov.h" |
| 303 | |
| 304 | /* Convert a magic or version number to a 4 character string. */ |
Lee Leahy | 35af5c4 | 2017-03-09 17:35:28 -0800 | [diff] [blame] | 305 | #define GCOV_UNSIGNED2STRING(ARRAY, VALUE) \ |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 306 | ((ARRAY)[0] = (char)((VALUE) >> 24), \ |
| 307 | (ARRAY)[1] = (char)((VALUE) >> 16), \ |
| 308 | (ARRAY)[2] = (char)((VALUE) >> 8), \ |
| 309 | (ARRAY)[3] = (char)((VALUE) >> 0)) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 310 | |
| 311 | /* The record tags. Values [1..3f] are for tags which may be in either |
| 312 | file. Values [41..9f] for those in the note file and [a1..ff] for |
| 313 | the data file. The tag value zero is used as an explicit end of |
| 314 | file marker -- it is not required to be present. */ |
| 315 | |
| 316 | #define GCOV_TAG_FUNCTION ((gcov_unsigned_t)0x01000000) |
| 317 | #define GCOV_TAG_FUNCTION_LENGTH (3) |
| 318 | #define GCOV_TAG_BLOCKS ((gcov_unsigned_t)0x01410000) |
| 319 | #define GCOV_TAG_BLOCKS_LENGTH(NUM) (NUM) |
| 320 | #define GCOV_TAG_BLOCKS_NUM(LENGTH) (LENGTH) |
| 321 | #define GCOV_TAG_ARCS ((gcov_unsigned_t)0x01430000) |
| 322 | #define GCOV_TAG_ARCS_LENGTH(NUM) (1 + (NUM) * 2) |
| 323 | #define GCOV_TAG_ARCS_NUM(LENGTH) (((LENGTH) - 1) / 2) |
| 324 | #define GCOV_TAG_LINES ((gcov_unsigned_t)0x01450000) |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 325 | #define GCOV_TAG_COUNTER_BASE ((gcov_unsigned_t)0x01a10000) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 326 | #define GCOV_TAG_COUNTER_LENGTH(NUM) ((NUM) * 2) |
| 327 | #define GCOV_TAG_COUNTER_NUM(LENGTH) ((LENGTH) / 2) |
| 328 | #define GCOV_TAG_OBJECT_SUMMARY ((gcov_unsigned_t)0xa1000000) /* Obsolete */ |
| 329 | #define GCOV_TAG_PROGRAM_SUMMARY ((gcov_unsigned_t)0xa3000000) |
| 330 | #define GCOV_TAG_SUMMARY_LENGTH \ |
| 331 | (1 + GCOV_COUNTERS_SUMMABLE * (2 + 3 * 2)) |
| 332 | |
| 333 | /* Counters that are collected. */ |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 334 | #define GCOV_COUNTER_ARCS 0 /* Arc transitions. */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 335 | #define GCOV_COUNTERS_SUMMABLE 1 /* Counters which can be |
Martin Roth | cbf2bd7 | 2013-07-09 21:51:14 -0600 | [diff] [blame] | 336 | summed. */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 337 | #define GCOV_FIRST_VALUE_COUNTER 1 /* The first of counters used for value |
| 338 | profiling. They must form a consecutive |
| 339 | interval and their order must match |
| 340 | the order of HIST_TYPEs in |
| 341 | value-prof.h. */ |
| 342 | #define GCOV_COUNTER_V_INTERVAL 1 /* Histogram of value inside an interval. */ |
| 343 | #define GCOV_COUNTER_V_POW2 2 /* Histogram of exact power2 logarithm |
| 344 | of a value. */ |
| 345 | #define GCOV_COUNTER_V_SINGLE 3 /* The most common value of expression. */ |
| 346 | #define GCOV_COUNTER_V_DELTA 4 /* The most common difference between |
| 347 | consecutive values of expression. */ |
| 348 | |
| 349 | #define GCOV_COUNTER_V_INDIR 5 /* The most common indirect address */ |
| 350 | #define GCOV_COUNTER_AVERAGE 6 /* Compute average value passed to the |
| 351 | counter. */ |
| 352 | #define GCOV_COUNTER_IOR 7 /* IOR of the all values passed to |
| 353 | counter. */ |
| 354 | #define GCOV_LAST_VALUE_COUNTER 7 /* The last of counters used for value |
| 355 | profiling. */ |
| 356 | #define GCOV_COUNTERS 8 |
| 357 | |
| 358 | /* Number of counters used for value profiling. */ |
| 359 | #define GCOV_N_VALUE_COUNTERS \ |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 360 | (GCOV_LAST_VALUE_COUNTER - GCOV_FIRST_VALUE_COUNTER + 1) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 361 | |
| 362 | /* A list of human readable names of the counters */ |
| 363 | #define GCOV_COUNTER_NAMES {"arcs", "interval", "pow2", "single", \ |
| 364 | "delta", "indirect_call", "average", "ior"} |
| 365 | |
| 366 | /* Names of merge functions for counters. */ |
| 367 | #define GCOV_MERGE_FUNCTIONS {"__gcov_merge_add", \ |
| 368 | "__gcov_merge_add", \ |
| 369 | "__gcov_merge_add", \ |
| 370 | "__gcov_merge_single", \ |
| 371 | "__gcov_merge_delta", \ |
| 372 | "__gcov_merge_single", \ |
| 373 | "__gcov_merge_add", \ |
| 374 | "__gcov_merge_ior"} |
| 375 | |
| 376 | /* Convert a counter index to a tag. */ |
| 377 | #define GCOV_TAG_FOR_COUNTER(COUNT) \ |
| 378 | (GCOV_TAG_COUNTER_BASE + ((gcov_unsigned_t)(COUNT) << 17)) |
| 379 | /* Convert a tag to a counter. */ |
| 380 | #define GCOV_COUNTER_FOR_TAG(TAG) \ |
Lee Leahy | 75b8599 | 2017-03-08 16:34:12 -0800 | [diff] [blame] | 381 | ((unsigned int)(((TAG) - GCOV_TAG_COUNTER_BASE) >> 17)) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 382 | /* Check whether a tag is a counter tag. */ |
| 383 | #define GCOV_TAG_IS_COUNTER(TAG) \ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 384 | (!((TAG) & 0xFFFF) && GCOV_COUNTER_FOR_TAG(TAG) < GCOV_COUNTERS) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 385 | |
| 386 | /* The tag level mask has 1's in the position of the inner levels, & |
| 387 | the lsb of the current level, and zero on the current and outer |
| 388 | levels. */ |
| 389 | #define GCOV_TAG_MASK(TAG) (((TAG) - 1) ^ (TAG)) |
| 390 | |
| 391 | /* Return nonzero if SUB is an immediate subtag of TAG. */ |
Lee Leahy | 35af5c4 | 2017-03-09 17:35:28 -0800 | [diff] [blame] | 392 | #define GCOV_TAG_IS_SUBTAG(TAG, SUB) \ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 393 | (GCOV_TAG_MASK(TAG) >> 8 == GCOV_TAG_MASK(SUB) \ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 394 | && !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK(TAG))) |
| 395 | |
| 396 | /* Return nonzero if SUB is at a sublevel to TAG. */ |
Lee Leahy | 35af5c4 | 2017-03-09 17:35:28 -0800 | [diff] [blame] | 397 | #define GCOV_TAG_IS_SUBLEVEL(TAG, SUB) \ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 398 | (GCOV_TAG_MASK(TAG) > GCOV_TAG_MASK(SUB)) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 399 | |
| 400 | /* Basic block flags. */ |
| 401 | #define GCOV_BLOCK_UNEXPECTED (1 << 1) |
| 402 | |
| 403 | /* Arc flags. */ |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 404 | #define GCOV_ARC_ON_TREE (1 << 0) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 405 | #define GCOV_ARC_FAKE (1 << 1) |
| 406 | #define GCOV_ARC_FALLTHROUGH (1 << 2) |
| 407 | |
| 408 | /* Structured records. */ |
| 409 | |
| 410 | /* Cumulative counter data. */ |
Lee Leahy | 342f8d6 | 2017-03-10 15:31:56 -0800 | [diff] [blame] | 411 | struct gcov_ctr_summary { |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 412 | gcov_unsigned_t num; /* number of counters. */ |
| 413 | gcov_unsigned_t runs; /* number of program runs */ |
| 414 | gcov_type sum_all; /* sum of all counters accumulated. */ |
| 415 | gcov_type run_max; /* maximum value on a single run. */ |
| 416 | gcov_type sum_max; /* sum of individual run max values. */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 417 | }; |
| 418 | |
| 419 | /* Object & program summary record. */ |
Lee Leahy | 342f8d6 | 2017-03-10 15:31:56 -0800 | [diff] [blame] | 420 | struct gcov_summary { |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 421 | gcov_unsigned_t checksum; /* checksum of program */ |
| 422 | struct gcov_ctr_summary ctrs[GCOV_COUNTERS_SUMMABLE]; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 423 | }; |
| 424 | |
Martin Roth | cbf2bd7 | 2013-07-09 21:51:14 -0600 | [diff] [blame] | 425 | /* Structures embedded in coverage program. The structures generated |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 426 | by write_profile must match these. */ |
| 427 | |
| 428 | #if IN_LIBGCOV |
| 429 | /* Information about counters for a single function. */ |
Lee Leahy | 342f8d6 | 2017-03-10 15:31:56 -0800 | [diff] [blame] | 430 | struct gcov_ctr_info { |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 431 | gcov_unsigned_t num; /* number of counters. */ |
| 432 | gcov_type *values; /* their values. */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 433 | }; |
| 434 | |
| 435 | /* Information about a single function. This uses the trailing array |
| 436 | idiom. The number of counters is determined from the merge pointer |
| 437 | array in gcov_info. The key is used to detect which of a set of |
| 438 | comdat functions was selected -- it points to the gcov_info object |
| 439 | of the object file containing the selected comdat function. */ |
| 440 | |
Lee Leahy | 342f8d6 | 2017-03-10 15:31:56 -0800 | [diff] [blame] | 441 | struct gcov_fn_info { |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 442 | const struct gcov_info *key; /* comdat key */ |
| 443 | gcov_unsigned_t ident; /* unique ident of function */ |
| 444 | gcov_unsigned_t lineno_checksum; /* function lineo_checksum */ |
| 445 | gcov_unsigned_t cfg_checksum; /* function cfg checksum */ |
| 446 | struct gcov_ctr_info ctrs[0]; /* instrumented counters */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 447 | }; |
| 448 | |
| 449 | /* Type of function used to merge counters. */ |
| 450 | typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t); |
| 451 | |
| 452 | /* Information about a single object file. */ |
Lee Leahy | 342f8d6 | 2017-03-10 15:31:56 -0800 | [diff] [blame] | 453 | struct gcov_info { |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 454 | gcov_unsigned_t version; /* expected version number */ |
| 455 | struct gcov_info *next; /* link to next, used by libgcov */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 456 | |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 457 | gcov_unsigned_t stamp; /* uniquifying time stamp */ |
| 458 | const char *filename; /* output file name */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 459 | |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 460 | gcov_merge_fn merge[GCOV_COUNTERS]; /* merge functions (null for |
| 461 | unused) */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 462 | |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 463 | unsigned int n_functions; /* number of functions */ |
| 464 | const struct gcov_fn_info *const *functions; /* pointer to pointers to |
| 465 | function information */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 466 | }; |
| 467 | |
| 468 | /* Register a new object file module. */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 469 | extern void __gcov_init(struct gcov_info *) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 470 | |
| 471 | #ifndef __COREBOOT__ |
| 472 | /* Called before fork, to avoid double counting. */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 473 | extern void __gcov_flush(void) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 474 | #endif |
| 475 | |
| 476 | /* The merge function that just sums the counters. */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 477 | extern void __gcov_merge_add(gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 478 | |
| 479 | /* The merge function to choose the most common value. */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 480 | extern void __gcov_merge_single(gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 481 | |
| 482 | /* The merge function to choose the most common difference between |
| 483 | consecutive values. */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 484 | extern void __gcov_merge_delta(gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 485 | |
| 486 | /* The merge function that just ors the counters together. */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 487 | extern void __gcov_merge_ior(gcov_type *, unsigned int) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 488 | |
| 489 | /* The profiler functions. */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 490 | extern void __gcov_interval_profiler(gcov_type *, gcov_type, int, unsigned int); |
| 491 | extern void __gcov_pow2_profiler(gcov_type *, gcov_type); |
| 492 | extern void __gcov_one_value_profiler(gcov_type *, gcov_type); |
Lee Leahy | 7340217 | 2017-03-10 15:23:24 -0800 | [diff] [blame] | 493 | extern void __gcov_indirect_call_profiler(gcov_type *, gcov_type, void *, |
| 494 | void *); |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 495 | extern void __gcov_average_profiler(gcov_type *, gcov_type); |
| 496 | extern void __gcov_ior_profiler(gcov_type *, gcov_type); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 497 | |
| 498 | #ifndef inhibit_libc |
| 499 | /* The wrappers around some library functions.. */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 500 | extern pid_t __gcov_fork(void) ATTRIBUTE_HIDDEN; |
| 501 | extern int __gcov_execl(const char *, char *, ...) ATTRIBUTE_HIDDEN; |
| 502 | extern int __gcov_execlp(const char *, char *, ...) ATTRIBUTE_HIDDEN; |
| 503 | extern int __gcov_execle(const char *, char *, ...) ATTRIBUTE_HIDDEN; |
| 504 | extern int __gcov_execv(const char *, char *const []) ATTRIBUTE_HIDDEN; |
| 505 | extern int __gcov_execvp(const char *, char *const []) ATTRIBUTE_HIDDEN; |
| 506 | extern int __gcov_execve(const char *, char *const [], char *const []) |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 507 | ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 508 | #endif |
| 509 | |
| 510 | #endif /* IN_LIBGCOV */ |
| 511 | |
| 512 | #if IN_LIBGCOV >= 0 |
| 513 | |
| 514 | /* Optimum number of gcov_unsigned_t's read from or written to disk. */ |
| 515 | #define GCOV_BLOCK_SIZE (1 << 10) |
| 516 | |
| 517 | GCOV_LINKAGE struct gcov_var |
| 518 | { |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 519 | FILE *file; |
| 520 | gcov_position_t start; /* Position of first byte of block */ |
| 521 | unsigned int offset; /* Read/write position within the block. */ |
| 522 | unsigned int length; /* Read limit in the block. */ |
| 523 | unsigned int overread; /* Number of words overread. */ |
| 524 | int error; /* < 0 overflow, > 0 disk error. */ |
| 525 | int mode; /* < 0 writing, > 0 reading */ |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 526 | #if IN_LIBGCOV |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 527 | /* Holds one block plus 4 bytes, thus all coverage reads & writes |
| 528 | * fit within this buffer and we always can transfer GCOV_BLOCK_SIZE |
| 529 | * to and from the disk. libgcov never backtracks and only writes 4 |
| 530 | * or 8 byte objects. |
| 531 | */ |
| 532 | gcov_unsigned_t buffer[GCOV_BLOCK_SIZE + 1]; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 533 | #else |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 534 | int endian; /* Swap endianness. */ |
| 535 | /* Holds a variable length block, as the compiler can write |
| 536 | * strings and needs to backtrack. |
| 537 | */ |
| 538 | size_t alloc; |
| 539 | gcov_unsigned_t *buffer; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 540 | #endif |
| 541 | } gcov_var ATTRIBUTE_HIDDEN; |
| 542 | |
| 543 | /* Functions for reading and writing gcov files. In libgcov you can |
| 544 | open the file for reading then writing. Elsewhere you can open the |
| 545 | file either for reading or for writing. When reading a file you may |
| 546 | use the gcov_read_* functions, gcov_sync, gcov_position, & |
| 547 | gcov_error. When writing a file you may use the gcov_write |
| 548 | functions, gcov_seek & gcov_error. When a file is to be rewritten |
| 549 | you use the functions for reading, then gcov_rewrite then the |
| 550 | functions for writing. Your file may become corrupted if you break |
| 551 | these invariants. */ |
| 552 | #if IN_LIBGCOV |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 553 | GCOV_LINKAGE int gcov_open(const char */*name*/) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 554 | #else |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 555 | GCOV_LINKAGE int gcov_open(const char */*name*/, int /*direction*/); |
| 556 | GCOV_LINKAGE int gcov_magic(gcov_unsigned_t, gcov_unsigned_t); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 557 | #endif |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 558 | GCOV_LINKAGE int gcov_close(void) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 559 | |
| 560 | /* Available everywhere. */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 561 | static gcov_position_t gcov_position(void); |
| 562 | static int gcov_is_error(void); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 563 | |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 564 | GCOV_LINKAGE gcov_unsigned_t gcov_read_unsigned(void) ATTRIBUTE_HIDDEN; |
| 565 | GCOV_LINKAGE gcov_type gcov_read_counter(void) ATTRIBUTE_HIDDEN; |
| 566 | GCOV_LINKAGE void gcov_read_summary(struct gcov_summary *) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 567 | |
| 568 | #if IN_LIBGCOV |
| 569 | /* Available only in libgcov */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 570 | GCOV_LINKAGE void gcov_write_counter(gcov_type) ATTRIBUTE_HIDDEN; |
| 571 | GCOV_LINKAGE void gcov_write_tag_length(gcov_unsigned_t, gcov_unsigned_t) |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 572 | ATTRIBUTE_HIDDEN; |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 573 | GCOV_LINKAGE void gcov_write_summary(gcov_unsigned_t /*tag*/, |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 574 | const struct gcov_summary *) |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 575 | ATTRIBUTE_HIDDEN; |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 576 | static void gcov_rewrite(void); |
| 577 | GCOV_LINKAGE void gcov_seek(gcov_position_t /*position*/) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 578 | #else |
| 579 | /* Available outside libgcov */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 580 | GCOV_LINKAGE const char *gcov_read_string(void); |
| 581 | GCOV_LINKAGE void gcov_sync(gcov_position_t /*base*/, |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 582 | gcov_unsigned_t /*length */); |
| 583 | #endif |
| 584 | |
| 585 | #if !IN_GCOV |
| 586 | /* Available outside gcov */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 587 | GCOV_LINKAGE void gcov_write_unsigned(gcov_unsigned_t) ATTRIBUTE_HIDDEN; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 588 | #endif |
| 589 | |
| 590 | #if !IN_GCOV && !IN_LIBGCOV |
| 591 | /* Available only in compiler */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 592 | GCOV_LINKAGE void gcov_write_string(const char *); |
| 593 | GCOV_LINKAGE gcov_position_t gcov_write_tag(gcov_unsigned_t); |
| 594 | GCOV_LINKAGE void gcov_write_length(gcov_position_t /*position*/); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 595 | #endif |
| 596 | |
| 597 | #if IN_GCOV > 0 |
| 598 | /* Available in gcov */ |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 599 | GCOV_LINKAGE time_t gcov_time(void); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 600 | #endif |
| 601 | |
| 602 | /* Save the current position in the gcov file. */ |
| 603 | |
| 604 | static inline gcov_position_t |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 605 | gcov_position(void) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 606 | { |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 607 | gcc_assert(gcov_var.mode > 0); |
| 608 | return gcov_var.start + gcov_var.offset; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 609 | } |
| 610 | |
| 611 | /* Return nonzero if the error flag is set. */ |
| 612 | |
| 613 | static inline int |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 614 | gcov_is_error(void) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 615 | { |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 616 | return gcov_var.file ? gcov_var.error : 1; |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 617 | } |
| 618 | |
| 619 | #if IN_LIBGCOV |
| 620 | /* Move to beginning of file and initialize for writing. */ |
| 621 | |
| 622 | static inline void |
Lee Leahy | 38768c3 | 2017-03-09 14:07:18 -0800 | [diff] [blame] | 623 | gcov_rewrite(void) |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 624 | { |
Lee Leahy | e20a319 | 2017-03-09 16:21:34 -0800 | [diff] [blame] | 625 | gcc_assert(gcov_var.mode > 0); |
| 626 | gcov_var.mode = -1; |
| 627 | gcov_var.start = 0; |
| 628 | gcov_var.offset = 0; |
| 629 | fseek(gcov_var.file, 0L, SEEK_SET); |
Stefan Reinauer | d37ab45 | 2012-12-18 16:23:28 -0800 | [diff] [blame] | 630 | } |
| 631 | #endif |
| 632 | |
| 633 | #endif /* IN_LIBGCOV >= 0 */ |
| 634 | |
| 635 | #endif /* GCC_GCOV_IO_H */ |