Bug Summary

File:build/gcc/../libgcc/libgcov.h
Warning:line 574, column 11
Potential leak of memory pointed to by 'new_node'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name libgcov-merge.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -D IN_GCOV_TOOL=1 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -Wno-error -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-6NqHQX.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libgcc/libgcov-merge.c

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libgcc/libgcov-merge.c

→
1/* Routines required for instrumenting a program. */
2/* Compile this one with gcc. */
3/* Copyright (C) 1989-2023 Free Software Foundation, Inc.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17Under Section 7 of GPL version 3, you are granted additional
18permissions described in the GCC Runtime Library Exception, version
193.1, as published by the Free Software Foundation.
20
21You should have received a copy of the GNU General Public License and
22a copy of the GCC Runtime Library Exception along with this program;
23see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24<http://www.gnu.org/licenses/>. */
25
26#include "libgcov.h"
27
28#if defined(inhibit_libc)
29/* If libc and its header files are not available, provide dummy functions. */
30
31#ifdef L_gcov_merge_add1
32void __gcov_merge_add (gcov_type *counters __attribute__ ((unused)),
33 unsigned n_counters __attribute__ ((unused))) {}
34#endif
35
36#ifdef L_gcov_merge_topn1
37void __gcov_merge_topn (gcov_type *counters __attribute__ ((unused)),
38 unsigned n_counters __attribute__ ((unused))) {}
39#endif
40
41#else
42
43#ifdef L_gcov_merge_add1
44/* The profile merging function that just adds the counters. It is given
45 an array COUNTERS of N_COUNTERS old counters and it reads the same number
46 of counters from the gcov file. */
47void
48__gcov_merge_add (gcov_type *counters, unsigned n_counters)
49{
50 for (; n_counters; counters++, n_counters--)
51 *counters += gcov_get_counter ();
52}
53#endif /* L_gcov_merge_add */
54
55#ifdef L_gcov_merge_ior1
56/* The profile merging function that just adds the counters. It is given
57 an array COUNTERS of N_COUNTERS old counters and it reads the same number
58 of counters from the gcov file. */
59void
60__gcov_merge_ior (gcov_type *counters, unsigned n_counters)
61{
62 for (; n_counters; counters++, n_counters--)
63 *counters |= gcov_get_counter_target ();
64}
65#endif
66
67#ifdef L_gcov_merge_time_profile1
68/* Time profiles are merged so that minimum from all valid (greater than zero)
69 is stored. There could be a fork that creates new counters. To have
70 the profile stable, we chosen to pick the smallest function visit time. */
71void
72__gcov_merge_time_profile (gcov_type *counters, unsigned n_counters)
73{
74 unsigned int i;
75 gcov_type value;
76
77 for (i = 0; i < n_counters; i++)
78 {
79 value = gcov_get_counter_target ();
80
81 if (value && (!counters[i] || value < counters[i]))
82 counters[i] = value;
83 }
84}
85#endif /* L_gcov_merge_time_profile */
86
87#ifdef L_gcov_merge_topn1
88
89/* The profile merging function for choosing the most common value.
90 It is given an array COUNTERS of N_COUNTERS old counters and it
91 reads the same number of counters from the gcov file. The counters
92 are split into pairs where the members of the tuple have
93 meanings:
94
95 -- the stored candidate on the most common value of the measured entity
96 -- counter
97
98 We use -TOTAL for situation when merging dropped some values.
99 The information is used for -fprofile-reproducible flag.
100 */
101
102void
103__gcov_merge_topn (gcov_type *counters, unsigned n_counters)
104{
105 gcc_assert (!(n_counters % GCOV_TOPN_MEM_COUNTERS))((void)(!(!(n_counters % 3)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libgcc/libgcov-merge.c"
, 105, __FUNCTION__), 0 : 0));
1
Assuming the condition is true
→
2
←
'?' condition is false
→
106
107 for (unsigned i = 0; i < (n_counters / GCOV_TOPN_MEM_COUNTERS3); i++)
3
←
Assuming the condition is true
→
4
←
Loop condition is true. Entering loop body
→
108 {
109 /* First value is number of total executions of the profiler. */
110 gcov_type all = gcov_get_counter_ignore_scaling (-1);
111 gcov_type n = gcov_get_counter_ignore_scaling (-1);
112
113 unsigned full = all < 0;
114 gcov_type *total = &counters[GCOV_TOPN_MEM_COUNTERS3 * i];
115 *total += full
4.1
'full' is 1
4.1
'full' is 1
 ? -all : all;
5
←
'?' condition is true
→
116
117 for (unsigned j = 0; j < n; j++)
6
←
Assuming 'j' is < 'n'
→
7
←
Loop condition is true. Entering loop body
→
118 {
119 gcov_type value = gcov_get_counter_target ();
120 gcov_type count = gcov_get_counter_ignore_scaling (-1);
121
122 // TODO: we should use atomic here
123 full |= gcov_topn_add_value (counters + GCOV_TOPN_MEM_COUNTERS3 * i,
8
←
Calling 'gcov_topn_add_value'
→
124 value, count, 0, 0);
125 }
126
127 if (full)
128 *total = -(*total);
129 }
130}
131#endif /* L_gcov_merge_topn */
132
133#endif /* inhibit_libc */
←

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libgcc/libgcov.h

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 xmallocmalloc
30#define xmallocmalloc malloc
31#endif
32#ifndef xcalloccalloc
33#define xcalloccalloc calloc
34#endif
35
36#ifndef IN_GCOV_TOOL1
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_H1
49#include <sys/mman.h>
50#endif
51
52#if __CHAR_BIT__8 == 8
53typedef unsigned gcov_unsigned_t __attribute__ ((mode (SI)));
54typedef unsigned gcov_position_t __attribute__ ((mode (SI)));
55#if __LIBGCC_GCOV_TYPE_SIZE > 32
56typedef signed gcov_type __attribute__ ((mode (DI)));
57typedef unsigned gcov_type_unsigned __attribute__ ((mode (DI)));
58#else
59typedef signed gcov_type __attribute__ ((mode (SI)));
60typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI)));
61#endif
62#else
63#if __CHAR_BIT__8 == 16
64typedef unsigned gcov_unsigned_t __attribute__ ((mode (HI)));
65typedef unsigned gcov_position_t __attribute__ ((mode (HI)));
66#if __LIBGCC_GCOV_TYPE_SIZE > 32
67typedef signed gcov_type __attribute__ ((mode (SI)));
68typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI)));
69#else
70typedef signed gcov_type __attribute__ ((mode (HI)));
71typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI)));
72#endif
73#else
74typedef unsigned gcov_unsigned_t __attribute__ ((mode (QI)));
75typedef unsigned gcov_position_t __attribute__ ((mode (QI)));
76#if __LIBGCC_GCOV_TYPE_SIZE > 32
77typedef signed gcov_type __attribute__ ((mode (HI)));
78typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI)));
79#else
80typedef signed gcov_type __attribute__ ((mode (QI)));
81typedef unsigned gcov_type_unsigned __attribute__ ((mode (QI)));
82#endif
83#endif
84#endif
85
86#if defined (TARGET_POSIX_IO)
87#define GCOV_LOCKED1 1
88#else
89#define GCOV_LOCKED1 0
90#endif
91
92#if defined (__MSVCRT__)
93#define GCOV_LOCKED_WITH_LOCKING0 1
94#else
95#define GCOV_LOCKED_WITH_LOCKING0 0
96#endif
97
98#ifndef GCOV_SUPPORTS_ATOMIC
99/* Detect whether target can support atomic update of profilers. */
100#if __SIZEOF_LONG_LONG__8 == 4 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_41
101#define GCOV_SUPPORTS_ATOMIC 1
102#else
103#if __SIZEOF_LONG_LONG__8 == 8 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_81
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
136typedef unsigned gcov_unsigned_t;
137typedef unsigned gcov_position_t;
138/* gcov_type is typedef'd elsewhere for the compiler */
139
140#if defined (HOST_HAS_F_SETLKW1)
141#define GCOV_LOCKED1 1
142#else
143#define GCOV_LOCKED1 0
144#endif
145
146#if defined (HOST_HAS_LK_LOCK)
147#define GCOV_LOCKED_WITH_LOCKING0 1
148#else
149#define GCOV_LOCKED_WITH_LOCKING0 0
150#endif
151
152/* Some Macros specific to gcov-tool. */
153
154#define L_gcov1 1
155#define L_gcov_merge_add1 1
156#define L_gcov_merge_topn1 1
157#define L_gcov_merge_ior1 1
158#define L_gcov_merge_time_profile1 1
159
160extern gcov_type gcov_read_counter_mem ();
161extern unsigned gcov_get_merge_weight ();
162extern struct gcov_info *gcov_list;
163
164#endif /* !IN_GCOV_TOOL */
165
166#if defined(inhibit_libc)
167#define IN_LIBGCOV1 (-1)
168#else
169#define IN_LIBGCOV1 1
170#if defined(L_gcov1)
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_HIDDEN1
180#define ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden"))) __attribute__ ((__visibility__ ("hidden")))
181#else
182#define ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")))
183#endif
184
185#if HAVE_SYS_MMAN_H1
186#ifndef MAP_FAILED((void *) -1)
187#define MAP_FAILED((void *) -1) ((void *)-1)
188#endif
189
190#if !defined (MAP_ANONYMOUS0x20) && defined (MAP_ANON0x20)
191#define MAP_ANONYMOUS0x20 MAP_ANON0x20
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. */
201struct 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
213struct 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. */
223typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t);
224
225/* Information about a single object file. */
226struct 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_TOOL1
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 */
250struct 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
259extern struct gcov_root __gcov_root ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
260
261struct gcov_master
262{
263 gcov_unsigned_t version;
264 struct gcov_root *root;
265};
266
267struct 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. */
277extern struct gcov_master __gcov_master;
278extern struct gcov_kvp *__gcov_kvp_dynamic_pool;
279extern unsigned __gcov_kvp_dynamic_pool_index;
280extern unsigned __gcov_kvp_dynamic_pool_size;
281
282/* Dump a set of gcov objects. */
283extern void __gcov_dump_one (struct gcov_root *) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
284
285/* Register a new object file module. */
286extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
287
288/* GCOV exit function registered via a static destructor. */
289extern void __gcov_exit (void) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
290
291/* Function to reset all counters to 0. Both externally visible (and
292 overridable) and internal version. */
293extern void __gcov_reset_int (void) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
294
295/* User function to enable early write of profile information so far. */
296extern void __gcov_dump_int (void) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
297
298/* Lock critical section for __gcov_dump and __gcov_reset functions. */
299extern void __gcov_lock (void) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
300
301/* Unlock critical section for __gcov_dump and __gcov_reset functions. */
302extern void __gcov_unlock (void) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
303
304/* The merge function that just sums the counters. */
305extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
306
307/* The merge function to select the minimum valid counter value. */
308extern void __gcov_merge_time_profile (gcov_type *, unsigned) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
309
310/* The merge function to choose the most common N values. */
311extern void __gcov_merge_topn (gcov_type *, unsigned) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
312
313/* The merge function that just ors the counters together. */
314extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
315
316/* The profiler functions. */
317extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned);
318extern void __gcov_interval_profiler_atomic (gcov_type *, gcov_type, int,
319 unsigned);
320extern void __gcov_pow2_profiler (gcov_type *, gcov_type);
321extern void __gcov_pow2_profiler_atomic (gcov_type *, gcov_type);
322extern void __gcov_topn_values_profiler (gcov_type *, gcov_type);
323extern void __gcov_topn_values_profiler_atomic (gcov_type *, gcov_type);
324extern void __gcov_indirect_call_profiler_v4 (gcov_type, void *);
325extern void __gcov_indirect_call_profiler_v4_atomic (gcov_type, void *);
326extern void __gcov_time_profiler (gcov_type *);
327extern void __gcov_time_profiler_atomic (gcov_type *);
328extern void __gcov_average_profiler (gcov_type *, gcov_type);
329extern void __gcov_average_profiler_atomic (gcov_type *, gcov_type);
330extern void __gcov_ior_profiler (gcov_type *, gcov_type);
331extern void __gcov_ior_profiler_atomic (gcov_type *, gcov_type);
332
333#ifndef inhibit_libc
334/* The wrappers around some library functions.. */
335extern pid_t __gcov_fork (void) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
336extern int __gcov_execl (const char *, char *, ...) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
337extern int __gcov_execlp (const char *, char *, ...) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
338extern int __gcov_execle (const char *, char *, ...) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
339extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
340extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
341extern int __gcov_execve (const char *, char *const [], char *const [])
342 ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
343
344/* Functions that only available in libgcov. */
345GCOV_LINKAGE void gcov_write_object_summary (const struct gcov_summary *)
346 ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("hidden")));
347GCOV_LINKAGE void gcov_rewrite (void) ATTRIBUTE_HIDDEN__attribute__ ((__visibility__ ("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
354static inline gcov_type
355gcov_get_counter (void)
356{
357#ifndef IN_GCOV_TOOL1
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
373static inline gcov_type
374gcov_get_counter_ignore_scaling (gcov_type ignore_scaling ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
375{
376#ifndef IN_GCOV_TOOL1
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
396static inline gcov_type
397gcov_get_counter_target (void)
398{
399#ifndef IN_GCOV_TOOL1
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
415static inline void
416gcov_counter_add (gcov_type *counter, gcov_type value,
417 int use_atomic ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
418{
419#if GCOV_SUPPORTS_ATOMIC
420 if (use_atomic)
421 __atomic_fetch_add (counter, value, __ATOMIC_RELAXED0);
422 else
423#endif
424 *counter += value;
425}
426
427#if HAVE_SYS_MMAN_H1
428
429/* Allocate LENGTH with mmap function. */
430
431static inline void *
432malloc_mmap (size_t length)
433{
434 return mmap (NULLnullptr, length, PROT_READ0x1 | PROT_WRITE0x2,
435 MAP_PRIVATE0x02 | MAP_ANONYMOUS0x20, -1, 0);
436}
437
438#endif
439
440/* Allocate gcov_kvp from statically pre-allocated pool,
441 or use heap otherwise. */
442
443static inline struct gcov_kvp *
444allocate_gcov_kvp (void)
445{
446#define MMAP_CHUNK_SIZE(128 * 1024) (128 * 1024)
447 struct gcov_kvp *new_node = NULLnullptr;
448 unsigned kvp_sizeof = sizeof(struct gcov_kvp);
449
450 /* Try mmaped pool if available. */
451#if !defined(IN_GCOV_TOOL1) && !defined(L_gcov_merge_topn1) && HAVE_SYS_MMAN_H1
452 if (__gcov_kvp_dynamic_pool == NULLnullptr
453 || __gcov_kvp_dynamic_pool_index >= __gcov_kvp_dynamic_pool_size)
454 {
455 void *ptr = malloc_mmap (MMAP_CHUNK_SIZE(128 * 1024));
456 if (ptr != MAP_FAILED((void *) -1))
457 {
458 __gcov_kvp_dynamic_pool = ptr;
459 __gcov_kvp_dynamic_pool_size = MMAP_CHUNK_SIZE(128 * 1024) / kvp_sizeof;
460 __gcov_kvp_dynamic_pool_index = 0;
461 }
462 }
463
464 if (__gcov_kvp_dynamic_pool != NULLnullptr)
465 {
466 unsigned index;
467#if GCOV_SUPPORTS_ATOMIC
468 index
469 = __atomic_fetch_add (&__gcov_kvp_dynamic_pool_index, 1,
470 __ATOMIC_RELAXED0);
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 == NULLnullptr)
14
←
Taking true branch
→
481 new_node = (struct gcov_kvp *)xcalloccalloc (1, kvp_sizeof);
15
←
Memory is allocated
→
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
491static inline unsigned
492gcov_topn_add_value (gcov_type *counters, gcov_type value, gcov_type count,
493 int use_atomic, int increment_total)
494{
495 if (increment_total
8.1
'increment_total' is 0
8.1
'increment_total' is 0
)
9
←
Taking false branch
→
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 (&counters[0], 1, use_atomic);
502 }
503
504 struct gcov_kvp *prev_node = NULLnullptr;
505 struct gcov_kvp *minimal_node = NULLnullptr;
506 struct gcov_kvp *current_node = (struct gcov_kvp *)(intptr_t)counters[2];
507
508 while (current_node)
10
←
Loop condition is false. Execution continues on line 524
→
509 {
510 if (current_node->value == value)
511 {
512 gcov_counter_add (&current_node->count, count, use_atomic);
513 return 0;
514 }
515
516 if (minimal_node == NULLnullptr
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_VALUES32)
11
←
Assuming the condition is false
→
12
←
Taking false branch
→
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 ();
13
←
Calling 'allocate_gcov_kvp'
→
16
←
Returned allocated memory
→
537 if (new_node == NULLnullptr)
17
←
Assuming the condition is false
→
18
←
Taking false branch
→
538 return 0;
539
540 new_node->value = value;
541 new_node->count = count;
542
543 int success = 0;
544 if (!counters[2])
19
←
Assuming the condition is false
→
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
19.1
'prev_node' is null
19.1
'prev_node' is null
 && !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)
20
←
Potential leak of memory pointed to by 'new_node'
575 gcov_counter_add (&counters[1], 1, use_atomic);
576 }
577
578 return 0;
579}
580
581#endif /* !inhibit_libc */
582
583#endif /* GCC_LIBGCOV_H */