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