1 | /* Header file for libgcov-*.c. |
2 | Copyright (C) 1996-2023 Free Software Foundation, Inc. |
3 | |
4 | This file is part of GCC. |
5 | |
6 | GCC is free software; you can redistribute it and/or modify it under |
7 | the terms of the GNU General Public License as published by the Free |
8 | Software Foundation; either version 3, or (at your option) any later |
9 | version. |
10 | |
11 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
12 | WARRANTY; without even the implied warranty of MERCHANTABILITY or |
13 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
14 | for more details. |
15 | |
16 | Under Section 7 of GPL version 3, you are granted additional |
17 | permissions described in the GCC Runtime Library Exception, version |
18 | 3.1, as published by the Free Software Foundation. |
19 | |
20 | You should have received a copy of the GNU General Public License and |
21 | a copy of the GCC Runtime Library Exception along with this program; |
22 | see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
23 | <http://www.gnu.org/licenses/>. */ |
24 | |
25 | #ifndef GCC_LIBGCOV_H |
26 | #define GCC_LIBGCOV_H |
27 | |
28 | /* work around the poisoned malloc/calloc in system.h. */ |
29 | #ifndef xmalloc |
30 | #define xmalloc malloc |
31 | #endif |
32 | #ifndef xcalloc |
33 | #define xcalloc calloc |
34 | #endif |
35 | |
36 | #ifndef IN_GCOV_TOOL |
37 | /* About the target. */ |
38 | /* This path will be used by libgcov runtime. */ |
39 | |
40 | #include "tconfig.h" |
41 | #include "auto-target.h" |
42 | #include "tsystem.h" |
43 | #include "coretypes.h" |
44 | #include "tm.h" |
45 | #include "libgcc_tm.h" |
46 | #include "gcov.h" |
47 | |
48 | #if HAVE_SYS_MMAN_H |
49 | #include <sys/mman.h> |
50 | #endif |
51 | |
52 | #if __CHAR_BIT__ == 8 |
53 | typedef unsigned gcov_unsigned_t __attribute__ ((mode (SI))); |
54 | typedef unsigned gcov_position_t __attribute__ ((mode (SI))); |
55 | #if __LIBGCC_GCOV_TYPE_SIZE > 32 |
56 | typedef signed gcov_type __attribute__ ((mode (DI))); |
57 | typedef unsigned gcov_type_unsigned __attribute__ ((mode (DI))); |
58 | #else |
59 | typedef signed gcov_type __attribute__ ((mode (SI))); |
60 | typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI))); |
61 | #endif |
62 | #else |
63 | #if __CHAR_BIT__ == 16 |
64 | typedef unsigned gcov_unsigned_t __attribute__ ((mode (HI))); |
65 | typedef unsigned gcov_position_t __attribute__ ((mode (HI))); |
66 | #if __LIBGCC_GCOV_TYPE_SIZE > 32 |
67 | typedef signed gcov_type __attribute__ ((mode (SI))); |
68 | typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI))); |
69 | #else |
70 | typedef signed gcov_type __attribute__ ((mode (HI))); |
71 | typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI))); |
72 | #endif |
73 | #else |
74 | typedef unsigned gcov_unsigned_t __attribute__ ((mode (QI))); |
75 | typedef unsigned gcov_position_t __attribute__ ((mode (QI))); |
76 | #if __LIBGCC_GCOV_TYPE_SIZE > 32 |
77 | typedef signed gcov_type __attribute__ ((mode (HI))); |
78 | typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI))); |
79 | #else |
80 | typedef signed gcov_type __attribute__ ((mode (QI))); |
81 | typedef unsigned gcov_type_unsigned __attribute__ ((mode (QI))); |
82 | #endif |
83 | #endif |
84 | #endif |
85 | |
86 | #if defined (TARGET_POSIX_IO) |
87 | #define GCOV_LOCKED 1 |
88 | #else |
89 | #define GCOV_LOCKED 0 |
90 | #endif |
91 | |
92 | #if defined (__MSVCRT__) |
93 | #define GCOV_LOCKED_WITH_LOCKING 1 |
94 | #else |
95 | #define GCOV_LOCKED_WITH_LOCKING 0 |
96 | #endif |
97 | |
98 | #ifndef GCOV_SUPPORTS_ATOMIC |
99 | /* Detect whether target can support atomic update of profilers. */ |
100 | #if __SIZEOF_LONG_LONG__ == 4 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 |
101 | #define GCOV_SUPPORTS_ATOMIC 1 |
102 | #else |
103 | #if __SIZEOF_LONG_LONG__ == 8 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 |
104 | #define GCOV_SUPPORTS_ATOMIC 1 |
105 | #else |
106 | #define GCOV_SUPPORTS_ATOMIC 0 |
107 | #endif |
108 | #endif |
109 | #endif |
110 | |
111 | /* In libgcov we need these functions to be extern, so prefix them with |
112 | __gcov. In libgcov they must also be hidden so that the instance in |
113 | the executable is not also used in a DSO. */ |
114 | #define gcov_var __gcov_var |
115 | #define gcov_open __gcov_open |
116 | #define gcov_close __gcov_close |
117 | #define gcov_position __gcov_position |
118 | #define gcov_rewrite __gcov_rewrite |
119 | #define gcov_is_error __gcov_is_error |
120 | #define gcov_write_unsigned __gcov_write_unsigned |
121 | #define gcov_write_object_summary __gcov_write_object_summary |
122 | #define gcov_read_unsigned __gcov_read_unsigned |
123 | #define gcov_read_counter __gcov_read_counter |
124 | #define gcov_read_summary __gcov_read_summary |
125 | |
126 | #else /* IN_GCOV_TOOL */ |
127 | /* About the host. */ |
128 | /* This path will be compiled for the host and linked into |
129 | gcov-tool binary. */ |
130 | |
131 | #include "config.h" |
132 | #include "system.h" |
133 | #include "coretypes.h" |
134 | #include "tm.h" |
135 | |
136 | typedef unsigned gcov_unsigned_t; |
137 | typedef unsigned gcov_position_t; |
138 | /* gcov_type is typedef'd elsewhere for the compiler */ |
139 | |
140 | #if defined (HOST_HAS_F_SETLKW) |
141 | #define GCOV_LOCKED 1 |
142 | #else |
143 | #define GCOV_LOCKED 0 |
144 | #endif |
145 | |
146 | #if defined (HOST_HAS_LK_LOCK) |
147 | #define GCOV_LOCKED_WITH_LOCKING 1 |
148 | #else |
149 | #define GCOV_LOCKED_WITH_LOCKING 0 |
150 | #endif |
151 | |
152 | /* Some Macros specific to gcov-tool. */ |
153 | |
154 | #define L_gcov 1 |
155 | #define L_gcov_merge_add 1 |
156 | #define L_gcov_merge_topn 1 |
157 | #define L_gcov_merge_ior 1 |
158 | #define L_gcov_merge_time_profile 1 |
159 | |
160 | extern gcov_type gcov_read_counter_mem (); |
161 | extern unsigned gcov_get_merge_weight (); |
162 | extern struct gcov_info *gcov_list; |
163 | |
164 | #endif /* !IN_GCOV_TOOL */ |
165 | |
166 | #if defined(inhibit_libc) |
167 | #define IN_LIBGCOV (-1) |
168 | #else |
169 | #define IN_LIBGCOV 1 |
170 | #if defined(L_gcov) |
171 | #define GCOV_LINKAGE /* nothing */ |
172 | #endif |
173 | #endif |
174 | |
175 | /* Poison these, so they don't accidentally slip in. */ |
176 | #pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length |
177 | #pragma GCC poison gcov_time |
178 | |
179 | #ifdef HAVE_GAS_HIDDEN |
180 | #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden"))) |
181 | #else |
182 | #define ATTRIBUTE_HIDDEN |
183 | #endif |
184 | |
185 | #if HAVE_SYS_MMAN_H |
186 | #ifndef MAP_FAILED |
187 | #define MAP_FAILED ((void *)-1) |
188 | #endif |
189 | |
190 | #if !defined (MAP_ANONYMOUS) && defined (MAP_ANON) |
191 | #define MAP_ANONYMOUS MAP_ANON |
192 | #endif |
193 | #endif |
194 | |
195 | #include "gcov-io.h" |
196 | |
197 | /* Structures embedded in coveraged program. The structures generated |
198 | by write_profile must match these. */ |
199 | |
200 | /* Information about counters for a single function. */ |
201 | struct gcov_ctr_info |
202 | { |
203 | gcov_unsigned_t num; /* number of counters. */ |
204 | gcov_type *values; /* their values. */ |
205 | }; |
206 | |
207 | /* Information about a single function. This uses the trailing array |
208 | idiom. The number of counters is determined from the merge pointer |
209 | array in gcov_info. The key is used to detect which of a set of |
210 | comdat functions was selected -- it points to the gcov_info object |
211 | of the object file containing the selected comdat function. */ |
212 | |
213 | struct gcov_fn_info |
214 | { |
215 | const struct gcov_info *key; /* comdat key */ |
216 | gcov_unsigned_t ident; /* unique ident of function */ |
217 | gcov_unsigned_t lineno_checksum; /* function lineo_checksum */ |
218 | gcov_unsigned_t cfg_checksum; /* function cfg checksum */ |
219 | struct gcov_ctr_info ctrs[1]; /* instrumented counters */ |
220 | }; |
221 | |
222 | /* Type of function used to merge counters. */ |
223 | typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t); |
224 | |
225 | /* Information about a single object file. */ |
226 | struct gcov_info |
227 | { |
228 | gcov_unsigned_t version; /* expected version number */ |
229 | struct gcov_info *next; /* link to next, used by libgcov */ |
230 | |
231 | gcov_unsigned_t stamp; /* uniquifying time stamp */ |
232 | gcov_unsigned_t checksum; /* unique object checksum */ |
233 | const char *filename; /* output file name */ |
234 | |
235 | gcov_merge_fn merge[GCOV_COUNTERS]; /* merge functions (null for |
236 | unused) */ |
237 | |
238 | gcov_unsigned_t n_functions; /* number of functions */ |
239 | |
240 | #ifndef IN_GCOV_TOOL |
241 | const struct gcov_fn_info *const *functions; /* pointer to pointers |
242 | to function information */ |
243 | #else |
244 | struct gcov_fn_info **functions; |
245 | struct gcov_summary summary; |
246 | #endif /* !IN_GCOV_TOOL */ |
247 | }; |
248 | |
249 | /* Root of a program/shared-object state */ |
250 | struct gcov_root |
251 | { |
252 | struct gcov_info *list; |
253 | unsigned dumped : 1; /* counts have been dumped. */ |
254 | unsigned run_counted : 1; /* run has been accounted for. */ |
255 | struct gcov_root *next; |
256 | struct gcov_root *prev; |
257 | }; |
258 | |
259 | extern struct gcov_root __gcov_root ATTRIBUTE_HIDDEN; |
260 | |
261 | struct gcov_master |
262 | { |
263 | gcov_unsigned_t version; |
264 | struct gcov_root *root; |
265 | }; |
266 | |
267 | struct indirect_call_tuple |
268 | { |
269 | /* Callee function. */ |
270 | void *callee; |
271 | |
272 | /* Pointer to counters. */ |
273 | gcov_type *counters; |
274 | }; |
275 | |
276 | /* Exactly one of these will be active in the process. */ |
277 | extern struct gcov_master __gcov_master; |
278 | extern struct gcov_kvp *__gcov_kvp_dynamic_pool; |
279 | extern unsigned __gcov_kvp_dynamic_pool_index; |
280 | extern unsigned __gcov_kvp_dynamic_pool_size; |
281 | |
282 | /* Dump a set of gcov objects. */ |
283 | extern void __gcov_dump_one (struct gcov_root *) ATTRIBUTE_HIDDEN; |
284 | |
285 | /* Register a new object file module. */ |
286 | extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN; |
287 | |
288 | /* GCOV exit function registered via a static destructor. */ |
289 | extern void __gcov_exit (void) ATTRIBUTE_HIDDEN; |
290 | |
291 | /* Function to reset all counters to 0. Both externally visible (and |
292 | overridable) and internal version. */ |
293 | extern void __gcov_reset_int (void) ATTRIBUTE_HIDDEN; |
294 | |
295 | /* User function to enable early write of profile information so far. */ |
296 | extern void __gcov_dump_int (void) ATTRIBUTE_HIDDEN; |
297 | |
298 | /* Lock critical section for __gcov_dump and __gcov_reset functions. */ |
299 | extern void __gcov_lock (void) ATTRIBUTE_HIDDEN; |
300 | |
301 | /* Unlock critical section for __gcov_dump and __gcov_reset functions. */ |
302 | extern void __gcov_unlock (void) ATTRIBUTE_HIDDEN; |
303 | |
304 | /* The merge function that just sums the counters. */ |
305 | extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; |
306 | |
307 | /* The merge function to select the minimum valid counter value. */ |
308 | extern void __gcov_merge_time_profile (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; |
309 | |
310 | /* The merge function to choose the most common N values. */ |
311 | extern void __gcov_merge_topn (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; |
312 | |
313 | /* The merge function that just ors the counters together. */ |
314 | extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; |
315 | |
316 | /* The profiler functions. */ |
317 | extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned); |
318 | extern void __gcov_interval_profiler_atomic (gcov_type *, gcov_type, int, |
319 | unsigned); |
320 | extern void __gcov_pow2_profiler (gcov_type *, gcov_type); |
321 | extern void __gcov_pow2_profiler_atomic (gcov_type *, gcov_type); |
322 | extern void __gcov_topn_values_profiler (gcov_type *, gcov_type); |
323 | extern void __gcov_topn_values_profiler_atomic (gcov_type *, gcov_type); |
324 | extern void __gcov_indirect_call_profiler_v4 (gcov_type, void *); |
325 | extern void __gcov_indirect_call_profiler_v4_atomic (gcov_type, void *); |
326 | extern void __gcov_time_profiler (gcov_type *); |
327 | extern void __gcov_time_profiler_atomic (gcov_type *); |
328 | extern void __gcov_average_profiler (gcov_type *, gcov_type); |
329 | extern void __gcov_average_profiler_atomic (gcov_type *, gcov_type); |
330 | extern void __gcov_ior_profiler (gcov_type *, gcov_type); |
331 | extern void __gcov_ior_profiler_atomic (gcov_type *, gcov_type); |
332 | |
333 | #ifndef inhibit_libc |
334 | /* The wrappers around some library functions.. */ |
335 | extern pid_t __gcov_fork (void) ATTRIBUTE_HIDDEN; |
336 | extern int __gcov_execl (const char *, char *, ...) ATTRIBUTE_HIDDEN; |
337 | extern int __gcov_execlp (const char *, char *, ...) ATTRIBUTE_HIDDEN; |
338 | extern int __gcov_execle (const char *, char *, ...) ATTRIBUTE_HIDDEN; |
339 | extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN; |
340 | extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN; |
341 | extern int __gcov_execve (const char *, char *const [], char *const []) |
342 | ATTRIBUTE_HIDDEN; |
343 | |
344 | /* Functions that only available in libgcov. */ |
345 | GCOV_LINKAGE void gcov_write_object_summary (const struct gcov_summary *) |
346 | ATTRIBUTE_HIDDEN; |
347 | GCOV_LINKAGE void gcov_rewrite (void) ATTRIBUTE_HIDDEN; |
348 | |
349 | /* "Counts" stored in gcda files can be a real counter value, or |
350 | an target address. When differentiate these two types because |
351 | when manipulating counts, we should only change real counter values, |
352 | rather target addresses. */ |
353 | |
354 | static inline gcov_type |
355 | gcov_get_counter (void) |
356 | { |
357 | #ifndef IN_GCOV_TOOL |
358 | /* This version is for reading count values in libgcov runtime: |
359 | we read from gcda files. */ |
360 | |
361 | return gcov_read_counter (); |
362 | #else |
363 | /* This version is for gcov-tool. We read the value from memory and |
364 | multiply it by the merge weight. */ |
365 | |
366 | return gcov_read_counter_mem () * gcov_get_merge_weight (); |
367 | #endif |
368 | } |
369 | |
370 | /* Similar function as gcov_get_counter(), but do not scale |
371 | when read value is equal to IGNORE_SCALING. */ |
372 | |
373 | static inline gcov_type |
374 | gcov_get_counter_ignore_scaling (gcov_type ignore_scaling ATTRIBUTE_UNUSED) |
375 | { |
376 | #ifndef IN_GCOV_TOOL |
377 | /* This version is for reading count values in libgcov runtime: |
378 | we read from gcda files. */ |
379 | |
380 | return gcov_read_counter (); |
381 | #else |
382 | /* This version is for gcov-tool. We read the value from memory and |
383 | multiply it by the merge weight. */ |
384 | |
385 | gcov_type v = gcov_read_counter_mem (); |
386 | if (v != ignore_scaling) |
387 | v *= gcov_get_merge_weight (); |
388 | |
389 | return v; |
390 | #endif |
391 | } |
392 | |
393 | /* Similar function as gcov_get_counter(), but handles target address |
394 | counters. */ |
395 | |
396 | static inline gcov_type |
397 | gcov_get_counter_target (void) |
398 | { |
399 | #ifndef IN_GCOV_TOOL |
400 | /* This version is for reading count target values in libgcov runtime: |
401 | we read from gcda files. */ |
402 | |
403 | return gcov_read_counter (); |
404 | #else |
405 | /* This version is for gcov-tool. We read the value from memory and we do NOT |
406 | multiply it by the merge weight. */ |
407 | |
408 | return gcov_read_counter_mem (); |
409 | #endif |
410 | } |
411 | |
412 | /* Add VALUE to *COUNTER and make it with atomic operation |
413 | if USE_ATOMIC is true. */ |
414 | |
415 | static inline void |
416 | gcov_counter_add (gcov_type *counter, gcov_type value, |
417 | int use_atomic ATTRIBUTE_UNUSED) |
418 | { |
419 | #if GCOV_SUPPORTS_ATOMIC |
420 | if (use_atomic) |
421 | __atomic_fetch_add (counter, value, __ATOMIC_RELAXED); |
422 | else |
423 | #endif |
424 | *counter += value; |
425 | } |
426 | |
427 | #if HAVE_SYS_MMAN_H |
428 | |
429 | /* Allocate LENGTH with mmap function. */ |
430 | |
431 | static inline void * |
432 | malloc_mmap (size_t length) |
433 | { |
434 | return mmap (NULL, len: length, PROT_READ | PROT_WRITE, |
435 | MAP_PRIVATE | MAP_ANONYMOUS, fd: -1, offset: 0); |
436 | } |
437 | |
438 | #endif |
439 | |
440 | /* Allocate gcov_kvp from statically pre-allocated pool, |
441 | or use heap otherwise. */ |
442 | |
443 | static inline struct gcov_kvp * |
444 | allocate_gcov_kvp (void) |
445 | { |
446 | #define MMAP_CHUNK_SIZE (128 * 1024) |
447 | struct gcov_kvp *new_node = NULL; |
448 | unsigned kvp_sizeof = sizeof(struct gcov_kvp); |
449 | |
450 | /* Try mmaped pool if available. */ |
451 | #if !defined(IN_GCOV_TOOL) && !defined(L_gcov_merge_topn) && HAVE_SYS_MMAN_H |
452 | if (__gcov_kvp_dynamic_pool == NULL |
453 | || __gcov_kvp_dynamic_pool_index >= __gcov_kvp_dynamic_pool_size) |
454 | { |
455 | void *ptr = malloc_mmap (MMAP_CHUNK_SIZE); |
456 | if (ptr != MAP_FAILED) |
457 | { |
458 | __gcov_kvp_dynamic_pool = ptr; |
459 | __gcov_kvp_dynamic_pool_size = MMAP_CHUNK_SIZE / kvp_sizeof; |
460 | __gcov_kvp_dynamic_pool_index = 0; |
461 | } |
462 | } |
463 | |
464 | if (__gcov_kvp_dynamic_pool != NULL) |
465 | { |
466 | unsigned index; |
467 | #if GCOV_SUPPORTS_ATOMIC |
468 | index |
469 | = __atomic_fetch_add (&__gcov_kvp_dynamic_pool_index, 1, |
470 | __ATOMIC_RELAXED); |
471 | #else |
472 | index = __gcov_kvp_dynamic_pool_index++; |
473 | #endif |
474 | if (index < __gcov_kvp_dynamic_pool_size) |
475 | new_node = __gcov_kvp_dynamic_pool + index; |
476 | } |
477 | #endif |
478 | |
479 | /* Fallback to malloc. */ |
480 | if (new_node == NULL) |
481 | new_node = (struct gcov_kvp *)xcalloc (1, kvp_sizeof); |
482 | |
483 | return new_node; |
484 | } |
485 | |
486 | /* Add key value pair VALUE:COUNT to a top N COUNTERS. When INCREMENT_TOTAL |
487 | is true, add COUNT to total of the TOP counter. If USE_ATOMIC is true, |
488 | do it in atomic way. Return true when the counter is full, otherwise |
489 | return false. */ |
490 | |
491 | static inline unsigned |
492 | gcov_topn_add_value (gcov_type *counters, gcov_type value, gcov_type count, |
493 | int use_atomic, int increment_total) |
494 | { |
495 | if (increment_total) |
496 | { |
497 | /* In the multi-threaded mode, we can have an already merged profile |
498 | with a negative total value. In that case, we should bail out. */ |
499 | if (counters[0] < 0) |
500 | return 0; |
501 | gcov_counter_add (counter: &counters[0], value: 1, use_atomic); |
502 | } |
503 | |
504 | struct gcov_kvp *prev_node = NULL; |
505 | struct gcov_kvp *minimal_node = NULL; |
506 | struct gcov_kvp *current_node = (struct gcov_kvp *)(intptr_t)counters[2]; |
507 | |
508 | while (current_node) |
509 | { |
510 | if (current_node->value == value) |
511 | { |
512 | gcov_counter_add (counter: ¤t_node->count, value: count, use_atomic); |
513 | return 0; |
514 | } |
515 | |
516 | if (minimal_node == NULL |
517 | || current_node->count < minimal_node->count) |
518 | minimal_node = current_node; |
519 | |
520 | prev_node = current_node; |
521 | current_node = current_node->next; |
522 | } |
523 | |
524 | if (counters[1] == GCOV_TOPN_MAXIMUM_TRACKED_VALUES) |
525 | { |
526 | if (--minimal_node->count < count) |
527 | { |
528 | minimal_node->value = value; |
529 | minimal_node->count = count; |
530 | } |
531 | |
532 | return 1; |
533 | } |
534 | else |
535 | { |
536 | struct gcov_kvp *new_node = allocate_gcov_kvp (); |
537 | if (new_node == NULL) |
538 | return 0; |
539 | |
540 | new_node->value = value; |
541 | new_node->count = count; |
542 | |
543 | int success = 0; |
544 | if (!counters[2]) |
545 | { |
546 | #if GCOV_SUPPORTS_ATOMIC |
547 | if (use_atomic) |
548 | { |
549 | struct gcov_kvp **ptr = (struct gcov_kvp **)(intptr_t)&counters[2]; |
550 | success = !__sync_val_compare_and_swap (ptr, 0, new_node); |
551 | } |
552 | else |
553 | #endif |
554 | { |
555 | counters[2] = (intptr_t)new_node; |
556 | success = 1; |
557 | } |
558 | } |
559 | else if (prev_node && !prev_node->next) |
560 | { |
561 | #if GCOV_SUPPORTS_ATOMIC |
562 | if (use_atomic) |
563 | success = !__sync_val_compare_and_swap (&prev_node->next, 0, |
564 | new_node); |
565 | else |
566 | #endif |
567 | { |
568 | prev_node->next = new_node; |
569 | success = 1; |
570 | } |
571 | } |
572 | |
573 | /* Increment number of nodes. */ |
574 | if (success) |
575 | gcov_counter_add (counter: &counters[1], value: 1, use_atomic); |
576 | } |
577 | |
578 | return 0; |
579 | } |
580 | |
581 | #endif /* !inhibit_libc */ |
582 | |
583 | #endif /* GCC_LIBGCOV_H */ |
584 | |