Dan Albert | 287553d | 2017-02-16 10:47:51 -0800 | [diff] [blame] | 1 | /* File format for coverage information |
| 2 | Copyright (C) 1996-2014 Free Software Foundation, Inc. |
| 3 | Contributed by Bob Manson <manson@cygnus.com>. |
| 4 | Completely remangled by Nathan Sidwell <nathan@codesourcery.com>. |
| 5 | |
| 6 | This file is part of GCC. |
| 7 | |
| 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 |
| 11 | version. |
| 12 | |
| 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 |
| 16 | for more details. |
| 17 | |
| 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. |
| 21 | |
| 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/>. */ |
| 26 | |
| 27 | |
| 28 | /* Coverage information is held in two files. A notes file, which is |
| 29 | generated by the compiler, and a data file, which is generated by |
| 30 | the program under test. Both files use a similar structure. We do |
| 31 | not attempt to make these files backwards compatible with previous |
| 32 | versions, as you only need coverage information when developing a |
| 33 | program. We do hold version information, so that mismatches can be |
| 34 | detected, and we use a format that allows tools to skip information |
| 35 | they do not understand or are not interested in. |
| 36 | |
| 37 | Numbers are recorded in the 32 bit unsigned binary form of the |
| 38 | endianness of the machine generating the file. 64 bit numbers are |
| 39 | stored as two 32 bit numbers, the low part first. Strings are |
| 40 | padded with 1 to 4 NUL bytes, to bring the length up to a multiple |
| 41 | of 4. The number of 4 bytes is stored, followed by the padded |
| 42 | string. Zero length and NULL strings are simply stored as a length |
| 43 | of zero (they have no trailing NUL or padding). |
| 44 | |
| 45 | int32: byte3 byte2 byte1 byte0 | byte0 byte1 byte2 byte3 |
| 46 | int64: int32:low int32:high |
| 47 | string: int32:0 | int32:length char* char:0 padding |
| 48 | padding: | char:0 | char:0 char:0 | char:0 char:0 char:0 |
| 49 | item: int32 | int64 | string |
| 50 | |
| 51 | The basic format of the files is |
| 52 | |
| 53 | file : int32:magic int32:version int32:stamp record* |
| 54 | |
| 55 | The magic ident is different for the notes and the data files. The |
| 56 | magic ident is used to determine the endianness of the file, when |
| 57 | reading. The version is the same for both files and is derived |
| 58 | from gcc's version number. The stamp value is used to synchronize |
| 59 | note and data files and to synchronize merging within a data |
| 60 | file. It need not be an absolute time stamp, merely a ticker that |
| 61 | increments fast enough and cycles slow enough to distinguish |
| 62 | different compile/run/compile cycles. |
| 63 | |
| 64 | Although the ident and version are formally 32 bit numbers, they |
| 65 | are derived from 4 character ASCII strings. The version number |
| 66 | consists of the single character major version number, a two |
| 67 | character minor version number (leading zero for versions less than |
| 68 | 10), and a single character indicating the status of the release. |
| 69 | That will be 'e' experimental, 'p' prerelease and 'r' for release. |
| 70 | Because, by good fortune, these are in alphabetical order, string |
| 71 | collating can be used to compare version strings. Be aware that |
| 72 | the 'e' designation will (naturally) be unstable and might be |
| 73 | incompatible with itself. For gcc 3.4 experimental, it would be |
| 74 | '304e' (0x33303465). When the major version reaches 10, the |
| 75 | letters A-Z will be used. Assuming minor increments releases every |
| 76 | 6 months, we have to make a major increment every 50 years. |
| 77 | Assuming major increments releases every 5 years, we're ok for the |
| 78 | next 155 years -- good enough for me. |
| 79 | |
| 80 | A record has a tag, length and variable amount of data. |
| 81 | |
| 82 | record: header data |
| 83 | header: int32:tag int32:length |
| 84 | data: item* |
| 85 | |
| 86 | Records are not nested, but there is a record hierarchy. Tag |
| 87 | numbers reflect this hierarchy. Tags are unique across note and |
| 88 | data files. Some record types have a varying amount of data. The |
| 89 | LENGTH is the number of 4bytes that follow and is usually used to |
| 90 | determine how much data. The tag value is split into 4 8-bit |
| 91 | fields, one for each of four possible levels. The most significant |
| 92 | is allocated first. Unused levels are zero. Active levels are |
| 93 | odd-valued, so that the LSB of the level is one. A sub-level |
| 94 | incorporates the values of its superlevels. This formatting allows |
| 95 | you to determine the tag hierarchy, without understanding the tags |
| 96 | themselves, and is similar to the standard section numbering used |
| 97 | in technical documents. Level values [1..3f] are used for common |
| 98 | tags, values [41..9f] for the notes file and [a1..ff] for the data |
| 99 | file. |
| 100 | |
| 101 | The notes file contains the following records |
| 102 | note: unit function-graph* |
| 103 | unit: header int32:checksum string:source |
| 104 | function-graph: announce_function basic_blocks {arcs | lines}* |
| 105 | announce_function: header int32:ident |
| 106 | int32:lineno_checksum int32:cfg_checksum |
| 107 | string:name string:source int32:lineno |
| 108 | basic_block: header int32:flags* |
| 109 | arcs: header int32:block_no arc* |
| 110 | arc: int32:dest_block int32:flags |
| 111 | lines: header int32:block_no line* |
| 112 | int32:0 string:NULL |
| 113 | line: int32:line_no | int32:0 string:filename |
| 114 | |
| 115 | The BASIC_BLOCK record holds per-bb flags. The number of blocks |
| 116 | can be inferred from its data length. There is one ARCS record per |
| 117 | basic block. The number of arcs from a bb is implicit from the |
| 118 | data length. It enumerates the destination bb and per-arc flags. |
| 119 | There is one LINES record per basic block, it enumerates the source |
| 120 | lines which belong to that basic block. Source file names are |
| 121 | introduced by a line number of 0, following lines are from the new |
| 122 | source file. The initial source file for the function is NULL, but |
| 123 | the current source file should be remembered from one LINES record |
| 124 | to the next. The end of a block is indicated by an empty filename |
| 125 | - this does not reset the current source file. Note there is no |
| 126 | ordering of the ARCS and LINES records: they may be in any order, |
| 127 | interleaved in any manner. The current filename follows the order |
| 128 | the LINES records are stored in the file, *not* the ordering of the |
| 129 | blocks they are for. |
| 130 | |
| 131 | The data file contains the following records. |
| 132 | data: {unit summary:program* build_info zero_fixup function-data*}* |
| 133 | unit: header int32:checksum |
| 134 | function-data: announce_function present counts |
| 135 | announce_function: header int32:ident |
| 136 | int32:lineno_checksum int32:cfg_checksum |
| 137 | present: header int32:present |
| 138 | counts: header int64:count* |
| 139 | summary: int32:checksum {count-summary}GCOV_COUNTERS_SUMMABLE |
| 140 | count-summary: int32:num int32:runs int64:sum |
| 141 | int64:max int64:sum_max histogram |
| 142 | histogram: {int32:bitvector}8 histogram-buckets* |
| 143 | histogram-buckets: int32:num int64:min int64:sum |
| 144 | build_info: string:info* |
| 145 | zero_fixup: int32:num int32:bitvector* |
| 146 | |
| 147 | The ANNOUNCE_FUNCTION record is the same as that in the note file, |
| 148 | but without the source location. The COUNTS gives the |
| 149 | counter values for instrumented features. The about the whole |
| 150 | program. The checksum is used for whole program summaries, and |
| 151 | disambiguates different programs which include the same |
| 152 | instrumented object file. There may be several program summaries, |
| 153 | each with a unique checksum. The object summary's checksum is |
| 154 | zero. Note that the data file might contain information from |
| 155 | several runs concatenated, or the data might be merged. |
| 156 | |
| 157 | BUILD_INFO record contains a list of strings that is used |
| 158 | to include in the data file information about the profile generate |
| 159 | build. For example, it can be used to include source revision |
| 160 | information that is useful in diagnosing profile mis-matches. |
| 161 | |
| 162 | ZERO_FIXUP record contains a count of functions in the gcda file |
| 163 | and an array of bitvectors indexed by the function index's in the |
| 164 | function-data section. Each bit flags whether the function was a |
| 165 | COMDAT that had all-zero profiles that was fixed up by dyn-ipa |
| 166 | using profiles from functions with matching checksums in other modules. |
| 167 | |
| 168 | This file is included by both the compiler, gcov tools and the |
| 169 | runtime support library libgcov. IN_LIBGCOV and IN_GCOV are used to |
| 170 | distinguish which case is which. If IN_LIBGCOV is nonzero, |
| 171 | libgcov is being built. If IN_GCOV is nonzero, the gcov tools are |
| 172 | being built. Otherwise the compiler is being built. IN_GCOV may be |
| 173 | positive or negative. If positive, we are compiling a tool that |
| 174 | requires additional functions (see the code for knowledge of what |
| 175 | those functions are). */ |
| 176 | |
| 177 | #ifndef GCC_GCOV_IO_H |
| 178 | #define GCC_GCOV_IO_H |
| 179 | |
| 180 | #ifndef __KERNEL__ |
| 181 | # define _GCOV_FILE FILE |
| 182 | # define _GCOV_fclose fclose |
| 183 | # define _GCOV_ftell ftell |
| 184 | # define _GCOV_fseek fseek |
| 185 | # define _GCOV_ftruncate ftruncate |
| 186 | # define _GCOV_fread fread |
| 187 | # define _GCOV_fwrite fwrite |
| 188 | # define _GCOV_fread fread |
| 189 | # define _GCOV_fileno fileno |
| 190 | # define _GCOV_fopen fopen |
| 191 | #endif |
| 192 | |
| 193 | #ifndef IN_LIBGCOV |
| 194 | /* About the host */ |
| 195 | |
| 196 | typedef unsigned gcov_unsigned_t; |
| 197 | typedef unsigned gcov_position_t; |
| 198 | |
| 199 | #if LONG_LONG_TYPE_SIZE > 32 |
| 200 | #define GCOV_TYPE_ATOMIC_FETCH_ADD_FN __atomic_fetch_add_8 |
| 201 | #define GCOV_TYPE_ATOMIC_FETCH_ADD BUILT_IN_ATOMIC_FETCH_ADD_8 |
| 202 | #else |
| 203 | #define GCOV_TYPE_ATOMIC_FETCH_ADD_FN __atomic_fetch_add_4 |
| 204 | #define GCOV_TYPE_ATOMIC_FETCH_ADD BUILT_IN_ATOMIC_FETCH_ADD_4 |
| 205 | #endif |
| 206 | #define PROFILE_GEN_EDGE_ATOMIC (flag_profile_gen_atomic == 1 || \ |
| 207 | flag_profile_gen_atomic == 3) |
| 208 | #define PROFILE_GEN_VALUE_ATOMIC (flag_profile_gen_atomic == 2 || \ |
| 209 | flag_profile_gen_atomic == 3) |
| 210 | |
| 211 | /* gcov_type is typedef'd elsewhere for the compiler */ |
| 212 | #if IN_GCOV |
| 213 | #define GCOV_LINKAGE static |
| 214 | typedef HOST_WIDEST_INT gcov_type; |
| 215 | typedef unsigned HOST_WIDEST_INT gcov_type_unsigned; |
| 216 | #if IN_GCOV > 0 |
| 217 | #include <sys/types.h> |
| 218 | #endif |
| 219 | |
| 220 | #define FUNC_ID_WIDTH HOST_BITS_PER_WIDE_INT/2 |
| 221 | #define FUNC_ID_MASK ((1L << FUNC_ID_WIDTH) - 1) |
| 222 | #define EXTRACT_MODULE_ID_FROM_GLOBAL_ID(gid) (unsigned)(((gid) >> FUNC_ID_WIDTH) & FUNC_ID_MASK) |
| 223 | #define EXTRACT_FUNC_ID_FROM_GLOBAL_ID(gid) (unsigned)((gid) & FUNC_ID_MASK) |
| 224 | #define FUNC_GLOBAL_ID(m,f) ((((HOST_WIDE_INT) (m)) << FUNC_ID_WIDTH) | (f) |
| 225 | |
| 226 | #else /*!IN_GCOV */ |
| 227 | #define GCOV_TYPE_SIZE (LONG_LONG_TYPE_SIZE > 32 ? 64 : 32) |
| 228 | #endif |
| 229 | |
| 230 | #if defined (HOST_HAS_F_SETLKW) |
| 231 | #define GCOV_LOCKED 1 |
| 232 | #else |
| 233 | #define GCOV_LOCKED 0 |
| 234 | #endif |
| 235 | |
| 236 | #define ATTRIBUTE_HIDDEN |
| 237 | |
| 238 | #endif /* !IN_LIBGOCV */ |
| 239 | |
| 240 | #ifndef GCOV_LINKAGE |
| 241 | #define GCOV_LINKAGE extern |
| 242 | #endif |
| 243 | |
| 244 | /* File suffixes. */ |
| 245 | #define GCOV_DATA_SUFFIX ".gcda" |
| 246 | #define GCOV_NOTE_SUFFIX ".gcno" |
| 247 | |
| 248 | /* File magic. Must not be palindromes. */ |
| 249 | #define GCOV_DATA_MAGIC ((gcov_unsigned_t)0x67636461) /* "gcda" */ |
| 250 | #define GCOV_NOTE_MAGIC ((gcov_unsigned_t)0x67636e6f) /* "gcno" */ |
| 251 | |
| 252 | /* gcov-iov.h is automatically generated by the makefile from |
| 253 | version.c, it looks like |
| 254 | #define GCOV_VERSION ((gcov_unsigned_t)0x89abcdef) |
| 255 | */ |
| 256 | #include "gcov-iov.h" |
| 257 | |
| 258 | /* Convert a magic or version number to a 4 character string. */ |
| 259 | #define GCOV_UNSIGNED2STRING(ARRAY,VALUE) \ |
| 260 | ((ARRAY)[0] = (char)((VALUE) >> 24), \ |
| 261 | (ARRAY)[1] = (char)((VALUE) >> 16), \ |
| 262 | (ARRAY)[2] = (char)((VALUE) >> 8), \ |
| 263 | (ARRAY)[3] = (char)((VALUE) >> 0)) |
| 264 | |
| 265 | /* The record tags. Values [1..3f] are for tags which may be in either |
| 266 | file. Values [41..9f] for those in the note file and [a1..ff] for |
| 267 | the data file. The tag value zero is used as an explicit end of |
| 268 | file marker -- it is not required to be present. */ |
| 269 | |
| 270 | #define GCOV_TAG_FUNCTION ((gcov_unsigned_t)0x01000000) |
| 271 | #define GCOV_TAG_FUNCTION_LENGTH (3) |
| 272 | #define GCOV_TAG_BLOCKS ((gcov_unsigned_t)0x01410000) |
| 273 | #define GCOV_TAG_BLOCKS_LENGTH(NUM) (NUM) |
| 274 | #define GCOV_TAG_BLOCKS_NUM(LENGTH) (LENGTH) |
| 275 | #define GCOV_TAG_ARCS ((gcov_unsigned_t)0x01430000) |
| 276 | #define GCOV_TAG_ARCS_LENGTH(NUM) (1 + (NUM) * 2) |
| 277 | #define GCOV_TAG_ARCS_NUM(LENGTH) (((LENGTH) - 1) / 2) |
| 278 | #define GCOV_TAG_LINES ((gcov_unsigned_t)0x01450000) |
| 279 | #define GCOV_TAG_COUNTER_BASE ((gcov_unsigned_t)0x01a10000) |
| 280 | #define GCOV_TAG_COUNTER_LENGTH(NUM) ((NUM) * 2) |
| 281 | #define GCOV_TAG_COUNTER_NUM(LENGTH) ((LENGTH) / 2) |
| 282 | #define GCOV_TAG_OBJECT_SUMMARY ((gcov_unsigned_t)0xa1000000) /* Obsolete */ |
| 283 | #define GCOV_TAG_PROGRAM_SUMMARY ((gcov_unsigned_t)0xa3000000) |
| 284 | #define GCOV_TAG_COMDAT_ZERO_FIXUP ((gcov_unsigned_t)0xa9000000) |
| 285 | /* Ceiling divide by 32 bit word size, plus one word to hold NUM. */ |
| 286 | #define GCOV_TAG_COMDAT_ZERO_FIXUP_LENGTH(NUM) (1 + (NUM + 31) / 32) |
| 287 | #define GCOV_TAG_SUMMARY_LENGTH(NUM) \ |
| 288 | (1 + GCOV_COUNTERS_SUMMABLE * (10 + 3 * 2) + (NUM) * 5) |
| 289 | #define GCOV_TAG_BUILD_INFO ((gcov_unsigned_t)0xa7000000) |
| 290 | #define GCOV_TAG_MODULE_INFO ((gcov_unsigned_t)0xab000000) |
| 291 | #define GCOV_TAG_AFDO_FILE_NAMES ((gcov_unsigned_t)0xaa000000) |
| 292 | #define GCOV_TAG_AFDO_FUNCTION ((gcov_unsigned_t)0xac000000) |
| 293 | #define GCOV_TAG_AFDO_MODULE_GROUPING ((gcov_unsigned_t)0xae000000) |
| 294 | #define GCOV_TAG_AFDO_WORKING_SET ((gcov_unsigned_t)0xaf000000) |
| 295 | |
| 296 | /* Counters that are collected. */ |
| 297 | #define DEF_GCOV_COUNTER(COUNTER, NAME, MERGE_FN) COUNTER, |
| 298 | enum { |
| 299 | #include "gcov-counter.def" |
| 300 | GCOV_COUNTERS |
| 301 | }; |
| 302 | #undef DEF_GCOV_COUNTER |
| 303 | |
| 304 | /* Counters which can be summaried. */ |
| 305 | #define GCOV_COUNTERS_SUMMABLE (GCOV_COUNTER_ARCS + 1) |
| 306 | |
| 307 | /* The first of counters used for value profiling. They must form a |
| 308 | consecutive interval and their order must match the order of |
| 309 | HIST_TYPEs in value-prof.h. */ |
| 310 | #define GCOV_FIRST_VALUE_COUNTER GCOV_COUNTERS_SUMMABLE |
| 311 | |
| 312 | /* The last of counters used for value profiling. */ |
| 313 | #define GCOV_LAST_VALUE_COUNTER (GCOV_COUNTERS - 2) |
| 314 | |
| 315 | /* Number of counters used for value profiling. */ |
| 316 | #define GCOV_N_VALUE_COUNTERS \ |
| 317 | (GCOV_LAST_VALUE_COUNTER - GCOV_FIRST_VALUE_COUNTER + 1) |
| 318 | |
| 319 | #define GCOV_ICALL_TOPN_VAL 2 /* Track two hottest callees */ |
| 320 | #define GCOV_ICALL_TOPN_NCOUNTS 9 /* The number of counter entries per icall callsite */ |
| 321 | |
| 322 | /* Convert a counter index to a tag. */ |
| 323 | #define GCOV_TAG_FOR_COUNTER(COUNT) \ |
| 324 | (GCOV_TAG_COUNTER_BASE + ((gcov_unsigned_t)(COUNT) << 17)) |
| 325 | /* Convert a tag to a counter. */ |
| 326 | #define GCOV_COUNTER_FOR_TAG(TAG) \ |
| 327 | ((unsigned)(((TAG) - GCOV_TAG_COUNTER_BASE) >> 17)) |
| 328 | /* Check whether a tag is a counter tag. */ |
| 329 | #define GCOV_TAG_IS_COUNTER(TAG) \ |
| 330 | (!((TAG) & 0xFFFF) && GCOV_COUNTER_FOR_TAG (TAG) < GCOV_COUNTERS) |
| 331 | |
| 332 | /* The tag level mask has 1's in the position of the inner levels, & |
| 333 | the lsb of the current level, and zero on the current and outer |
| 334 | levels. */ |
| 335 | #define GCOV_TAG_MASK(TAG) (((TAG) - 1) ^ (TAG)) |
| 336 | |
| 337 | /* Return nonzero if SUB is an immediate subtag of TAG. */ |
| 338 | #define GCOV_TAG_IS_SUBTAG(TAG,SUB) \ |
| 339 | (GCOV_TAG_MASK (TAG) >> 8 == GCOV_TAG_MASK (SUB) \ |
| 340 | && !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK (TAG))) |
| 341 | |
| 342 | /* Return nonzero if SUB is at a sublevel to TAG. */ |
| 343 | #define GCOV_TAG_IS_SUBLEVEL(TAG,SUB) \ |
| 344 | (GCOV_TAG_MASK (TAG) > GCOV_TAG_MASK (SUB)) |
| 345 | |
| 346 | /* Basic block flags. */ |
| 347 | #define GCOV_BLOCK_UNEXPECTED (1 << 1) |
| 348 | |
| 349 | /* Arc flags. */ |
| 350 | #define GCOV_ARC_ON_TREE (1 << 0) |
| 351 | #define GCOV_ARC_FAKE (1 << 1) |
| 352 | #define GCOV_ARC_FALLTHROUGH (1 << 2) |
| 353 | |
| 354 | /* Structured records. */ |
| 355 | |
| 356 | /* Structure used for each bucket of the log2 histogram of counter values. */ |
| 357 | typedef struct |
| 358 | { |
| 359 | /* Number of counters whose profile count falls within the bucket. */ |
| 360 | gcov_unsigned_t num_counters; |
| 361 | /* Smallest profile count included in this bucket. */ |
| 362 | gcov_type min_value; |
| 363 | /* Cumulative value of the profile counts in this bucket. */ |
| 364 | gcov_type cum_value; |
| 365 | } gcov_bucket_type; |
| 366 | |
| 367 | /* For a log2 scale histogram with each range split into 4 |
| 368 | linear sub-ranges, there will be at most 64 (max gcov_type bit size) - 1 log2 |
| 369 | ranges since the lowest 2 log2 values share the lowest 4 linear |
| 370 | sub-range (values 0 - 3). This is 252 total entries (63*4). */ |
| 371 | |
| 372 | #define GCOV_HISTOGRAM_SIZE 252 |
| 373 | |
| 374 | /* How many unsigned ints are required to hold a bit vector of non-zero |
| 375 | histogram entries when the histogram is written to the gcov file. |
| 376 | This is essentially a ceiling divide by 32 bits. */ |
| 377 | #define GCOV_HISTOGRAM_BITVECTOR_SIZE (GCOV_HISTOGRAM_SIZE + 31) / 32 |
| 378 | |
| 379 | /* Cumulative counter data. */ |
| 380 | struct gcov_ctr_summary |
| 381 | { |
| 382 | gcov_unsigned_t num; /* number of counters. */ |
| 383 | gcov_unsigned_t runs; /* number of program runs */ |
| 384 | gcov_type sum_all; /* sum of all counters accumulated. */ |
| 385 | gcov_type run_max; /* maximum value on a single run. */ |
| 386 | gcov_type sum_max; /* sum of individual run max values. */ |
| 387 | gcov_bucket_type histogram[GCOV_HISTOGRAM_SIZE]; /* histogram of |
| 388 | counter values. */ |
| 389 | }; |
| 390 | |
| 391 | /* Object & program summary record. */ |
| 392 | struct gcov_summary |
| 393 | { |
| 394 | gcov_unsigned_t checksum; /* checksum of program */ |
| 395 | struct gcov_ctr_summary ctrs[GCOV_COUNTERS_SUMMABLE]; |
| 396 | }; |
| 397 | |
| 398 | #define GCOV_MODULE_UNKNOWN_LANG 0 |
| 399 | #define GCOV_MODULE_C_LANG 1 |
| 400 | #define GCOV_MODULE_CPP_LANG 2 |
| 401 | #define GCOV_MODULE_FORT_LANG 3 |
| 402 | |
| 403 | #define GCOV_MODULE_ASM_STMTS (1 << 16) |
| 404 | #define GCOV_MODULE_LANG_MASK 0xffff |
| 405 | |
| 406 | /* Source module info. The data structure is used in |
| 407 | both runtime and profile-use phase. Make sure to allocate |
| 408 | enough space for the variable length member. */ |
| 409 | struct gcov_module_info |
| 410 | { |
| 411 | gcov_unsigned_t ident; |
| 412 | gcov_unsigned_t is_primary; /* this is overloaded to mean two things: |
| 413 | (1) means FDO/LIPO in instrumented binary. |
| 414 | (2) means IS_PRIMARY in persistent file or |
| 415 | memory copy used in profile-use. */ |
| 416 | gcov_unsigned_t flags; /* bit 0: is_exported, |
| 417 | bit 1: need to include all the auxiliary |
| 418 | modules in use compilation. */ |
| 419 | gcov_unsigned_t lang; /* lower 16 bits encode the language, and the upper |
| 420 | 16 bits enocde other attributes, such as whether |
| 421 | any assembler is present in the source, etc. */ |
| 422 | gcov_unsigned_t ggc_memory; /* memory needed for parsing in kb */ |
| 423 | char *da_filename; |
| 424 | char *source_filename; |
| 425 | gcov_unsigned_t num_quote_paths; |
| 426 | gcov_unsigned_t num_bracket_paths; |
| 427 | gcov_unsigned_t num_system_paths; |
| 428 | gcov_unsigned_t num_cpp_defines; |
| 429 | gcov_unsigned_t num_cpp_includes; |
| 430 | gcov_unsigned_t num_cl_args; |
| 431 | char *string_array[1]; |
| 432 | }; |
| 433 | |
| 434 | extern struct gcov_module_info **module_infos; |
| 435 | extern unsigned primary_module_id; |
| 436 | #define SET_MODULE_INCLUDE_ALL_AUX(modu) ((modu->flags |= 0x2)) |
| 437 | #define MODULE_INCLUDE_ALL_AUX_FLAG(modu) ((modu->flags & 0x2)) |
| 438 | #define SET_MODULE_EXPORTED(modu) ((modu->flags |= 0x1)) |
| 439 | #define MODULE_EXPORTED_FLAG(modu) ((modu->flags & 0x1)) |
| 440 | #define PRIMARY_MODULE_EXPORTED \ |
| 441 | (MODULE_EXPORTED_FLAG (module_infos[0]) \ |
| 442 | && !((module_infos[0]->lang & GCOV_MODULE_ASM_STMTS) \ |
| 443 | && flag_ripa_disallow_asm_modules)) |
| 444 | |
| 445 | #if !defined(inhibit_libc) |
| 446 | |
| 447 | /* Functions for reading and writing gcov files. In libgcov you can |
| 448 | open the file for reading then writing. Elsewhere you can open the |
| 449 | file either for reading or for writing. When reading a file you may |
| 450 | use the gcov_read_* functions, gcov_sync, gcov_position, & |
| 451 | gcov_error. When writing a file you may use the gcov_write |
| 452 | functions, gcov_seek & gcov_error. When a file is to be rewritten |
| 453 | you use the functions for reading, then gcov_rewrite then the |
| 454 | functions for writing. Your file may become corrupted if you break |
| 455 | these invariants. */ |
| 456 | |
| 457 | #if !IN_LIBGCOV |
| 458 | GCOV_LINKAGE int gcov_open (const char */*name*/, int /*direction*/); |
| 459 | GCOV_LINKAGE int gcov_magic (gcov_unsigned_t, gcov_unsigned_t); |
| 460 | #endif |
| 461 | |
| 462 | /* Available everywhere. */ |
| 463 | GCOV_LINKAGE int gcov_close (void) ATTRIBUTE_HIDDEN; |
| 464 | GCOV_LINKAGE gcov_unsigned_t gcov_read_unsigned (void) ATTRIBUTE_HIDDEN; |
| 465 | GCOV_LINKAGE gcov_type gcov_read_counter (void) ATTRIBUTE_HIDDEN; |
| 466 | GCOV_LINKAGE void gcov_read_summary (struct gcov_summary *) ATTRIBUTE_HIDDEN; |
| 467 | GCOV_LINKAGE int *gcov_read_comdat_zero_fixup (gcov_unsigned_t, |
| 468 | gcov_unsigned_t *) |
| 469 | ATTRIBUTE_HIDDEN; |
| 470 | GCOV_LINKAGE char **gcov_read_build_info (gcov_unsigned_t, gcov_unsigned_t *) |
| 471 | ATTRIBUTE_HIDDEN; |
| 472 | GCOV_LINKAGE const char *gcov_read_string (void); |
| 473 | GCOV_LINKAGE void gcov_sync (gcov_position_t /*base*/, |
| 474 | gcov_unsigned_t /*length */); |
| 475 | GCOV_LINKAGE gcov_unsigned_t gcov_read_string_array (char **, gcov_unsigned_t) |
| 476 | ATTRIBUTE_HIDDEN; |
| 477 | |
| 478 | |
| 479 | #if !IN_LIBGCOV && IN_GCOV != 1 |
| 480 | GCOV_LINKAGE void gcov_read_module_info (struct gcov_module_info *mod_info, |
| 481 | gcov_unsigned_t len) ATTRIBUTE_HIDDEN; |
| 482 | #endif |
| 483 | |
| 484 | #if !IN_GCOV |
| 485 | /* Available outside gcov */ |
| 486 | GCOV_LINKAGE void gcov_write_unsigned (gcov_unsigned_t) ATTRIBUTE_HIDDEN; |
| 487 | GCOV_LINKAGE gcov_unsigned_t gcov_compute_string_array_len (char **, |
| 488 | gcov_unsigned_t) |
| 489 | ATTRIBUTE_HIDDEN; |
| 490 | GCOV_LINKAGE void gcov_write_string_array (char **, gcov_unsigned_t) |
| 491 | ATTRIBUTE_HIDDEN; |
| 492 | #endif |
| 493 | |
| 494 | #if !IN_GCOV && !IN_LIBGCOV |
| 495 | /* Available only in compiler */ |
| 496 | GCOV_LINKAGE unsigned gcov_histo_index (gcov_type value); |
| 497 | GCOV_LINKAGE void gcov_write_string (const char *); |
| 498 | GCOV_LINKAGE gcov_position_t gcov_write_tag (gcov_unsigned_t); |
| 499 | GCOV_LINKAGE void gcov_write_length (gcov_position_t /*position*/); |
| 500 | #endif |
| 501 | |
| 502 | #if IN_GCOV <= 0 && !IN_LIBGCOV |
| 503 | /* Available in gcov-dump and the compiler. */ |
| 504 | |
| 505 | /* Number of data points in the working set summary array. Using 128 |
| 506 | provides information for at least every 1% increment of the total |
| 507 | profile size. The last entry is hardwired to 99.9% of the total. */ |
| 508 | #define NUM_GCOV_WORKING_SETS 128 |
| 509 | |
| 510 | /* Working set size statistics for a given percentage of the entire |
| 511 | profile (sum_all from the counter summary). */ |
| 512 | typedef struct gcov_working_set_info |
| 513 | { |
| 514 | /* Number of hot counters included in this working set. */ |
| 515 | unsigned num_counters; |
| 516 | /* Smallest counter included in this working set. */ |
| 517 | gcov_type min_counter; |
| 518 | } gcov_working_set_t; |
| 519 | |
| 520 | GCOV_LINKAGE void compute_working_sets (const struct gcov_ctr_summary *summary, |
| 521 | gcov_working_set_t *gcov_working_sets); |
| 522 | #endif |
| 523 | |
| 524 | #if IN_GCOV > 0 |
| 525 | /* Available in gcov */ |
| 526 | GCOV_LINKAGE time_t gcov_time (void); |
| 527 | #endif |
| 528 | |
| 529 | #endif /* !inhibit_libc */ |
| 530 | |
| 531 | #endif /* GCC_GCOV_IO_H */ |