Bug Summary

File:build/gcc/vec.h
Warning:line 814, column 10
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name coverage.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/13.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/backward -internal-isystem /usr/lib64/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/home/marxin/BIG/buildbot/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 /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-11-20-133755-20252-1/report-8Lv1Ed.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c

1/* Read and write coverage files, and associated functionality.
2 Copyright (C) 1990-2021 Free Software Foundation, Inc.
3 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
4 based on some ideas from Dain Samples of UC Berkeley.
5 Further mangling by Bob Manson, Cygnus Support.
6 Further mangled by Nathan Sidwell, CodeSourcery
7
8This file is part of GCC.
9
10GCC is free software; you can redistribute it and/or modify it under
11the terms of the GNU General Public License as published by the Free
12Software Foundation; either version 3, or (at your option) any later
13version.
14
15GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16WARRANTY; without even the implied warranty of MERCHANTABILITY or
17FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18for more details.
19
20You should have received a copy of the GNU General Public License
21along with GCC; see the file COPYING3. If not see
22<http://www.gnu.org/licenses/>. */
23
24
25#define GCOV_LINKAGE
26
27#include "config.h"
28#include "system.h"
29#include "coretypes.h"
30#include "backend.h"
31#include "target.h"
32#include "rtl.h"
33#include "tree.h"
34#include "tree-pass.h"
35#include "memmodel.h"
36#include "tm_p.h"
37#include "stringpool.h"
38#include "cgraph.h"
39#include "coverage.h"
40#include "diagnostic-core.h"
41#include "fold-const.h"
42#include "stor-layout.h"
43#include "output.h"
44#include "toplev.h"
45#include "langhooks.h"
46#include "tree-iterator.h"
47#include "context.h"
48#include "pass_manager.h"
49#include "intl.h"
50#include "auto-profile.h"
51#include "profile.h"
52#include "diagnostic.h"
53#include "varasm.h"
54
55#include "gcov-io.c"
56
57struct GTY((chain_next ("%h.next"))) coverage_data
58{
59 struct coverage_data *next; /* next function */
60 unsigned ident; /* function ident */
61 unsigned lineno_checksum; /* function lineno checksum */
62 unsigned cfg_checksum; /* function cfg checksum */
63 tree fn_decl; /* the function decl */
64 tree ctr_vars[GCOV_COUNTERS]; /* counter variables. */
65};
66
67/* Counts information for a function. */
68struct counts_entry : pointer_hash <counts_entry>
69{
70 /* We hash by */
71 unsigned ident;
72 unsigned ctr;
73
74 /* Store */
75 unsigned lineno_checksum;
76 unsigned cfg_checksum;
77 gcov_type *counts;
78 unsigned n_counts;
79
80 /* hash_table support. */
81 static inline hashval_t hash (const counts_entry *);
82 static int equal (const counts_entry *, const counts_entry *);
83 static void remove (counts_entry *);
84};
85
86static GTY(()) struct coverage_data *functions_head = 0;
87static struct coverage_data **functions_tail = &functions_head;
88static unsigned no_coverage = 0;
89
90/* Cumulative counter information for whole program. */
91static unsigned prg_ctr_mask; /* Mask of counter types generated. */
92
93/* Counter information for current function. */
94static unsigned fn_ctr_mask; /* Mask of counters used. */
95static GTY(()) tree fn_v_ctrs[GCOV_COUNTERS]; /* counter variables. */
96static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */
97static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */
98
99/* Coverage info VAR_DECL and function info type nodes. */
100static GTY(()) tree gcov_info_var;
101static GTY(()) tree gcov_fn_info_type;
102static GTY(()) tree gcov_fn_info_ptr_type;
103
104/* Name of the notes (gcno) output file. The "bbg" prefix is for
105 historical reasons, when the notes file contained only the
106 basic block graph notes.
107 If this is NULL we're not writing to the notes file. */
108static char *bbg_file_name;
109
110/* File stamp for notes file. */
111static unsigned bbg_file_stamp;
112
113/* Name of the count data (gcda) file. */
114static char *da_file_name;
115
116/* The names of merge functions for counters. */
117#define STR(str) #str
118#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) STR(__gcov_merge ## FN_TYPE),
119static const char *const ctr_merge_functions[GCOV_COUNTERS] = {
120#include "gcov-counter.def"
121};
122#undef DEF_GCOV_COUNTER
123#undef STR
124
125#define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) NAME,
126static const char *const ctr_names[GCOV_COUNTERS] = {
127#include "gcov-counter.def"
128};
129#undef DEF_GCOV_COUNTER
130
131/* Forward declarations. */
132static tree build_var (tree, tree, int);
133
134/* Return the type node for gcov_type. */
135
136tree
137get_gcov_type (void)
138{
139 scalar_int_mode mode
140 = smallest_int_mode_for_size (targetm.gcov_type_size ());
141 return lang_hooks.types.type_for_mode (mode, false);
142}
143
144/* Return the type node for gcov_unsigned_t. */
145
146static tree
147get_gcov_unsigned_t (void)
148{
149 scalar_int_mode mode = smallest_int_mode_for_size (32);
150 return lang_hooks.types.type_for_mode (mode, true);
151}
152
153inline hashval_t
154counts_entry::hash (const counts_entry *entry)
155{
156 return entry->ident * GCOV_COUNTERS + entry->ctr;
157}
158
159inline int
160counts_entry::equal (const counts_entry *entry1, const counts_entry *entry2)
161{
162 return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
163}
164
165inline void
166counts_entry::remove (counts_entry *entry)
167{
168 free (entry->counts);
169 free (entry);
170}
171
172/* Hash table of count data. */
173static hash_table<counts_entry> *counts_hash;
174
175/* Read in the counts file, if available. */
176
177static void
178read_counts_file (void)
179{
180 gcov_unsigned_t fn_ident = 0;
181 gcov_unsigned_t tag;
182 int is_error = 0;
183 unsigned lineno_checksum = 0;
184 unsigned cfg_checksum = 0;
185
186 if (!gcov_open (da_file_name, 1))
187 return;
188
189 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC((gcov_unsigned_t)0x67636461)))
190 {
191 warning (0, "%qs is not a gcov data file", da_file_name);
192 gcov_close ();
193 return;
194 }
195 else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION((gcov_unsigned_t)0x42323020))
196 {
197 char v[4], e[4];
198
199 GCOV_UNSIGNED2STRING (v, tag)((v)[0] = (char)((tag) >> 24), (v)[1] = (char)((tag) >>
16), (v)[2] = (char)((tag) >> 8), (v)[3] = (char)((tag
) >> 0))
;
200 GCOV_UNSIGNED2STRING (e, GCOV_VERSION)((e)[0] = (char)((((gcov_unsigned_t)0x42323020)) >> 24)
, (e)[1] = (char)((((gcov_unsigned_t)0x42323020)) >> 16
), (e)[2] = (char)((((gcov_unsigned_t)0x42323020)) >> 8
), (e)[3] = (char)((((gcov_unsigned_t)0x42323020)) >> 0
))
;
201
202 warning (0, "%qs is version %q.*s, expected version %q.*s",
203 da_file_name, 4, v, 4, e);
204 gcov_close ();
205 return;
206 }
207
208 /* Read the stamp, used for creating a generation count. */
209 tag = gcov_read_unsigned ();
210 bbg_file_stamp = crc32_unsigned (bbg_file_stamp, tag);
211
212 /* Read checksum. */
213 gcov_read_unsigned ();
214
215 counts_hash = new hash_table<counts_entry> (10);
216 while ((tag = gcov_read_unsigned ()))
217 {
218 gcov_unsigned_t length;
219 gcov_position_t offset;
220
221 length = gcov_read_unsigned ();
222 offset = gcov_position ();
223 if (tag == GCOV_TAG_FUNCTION((gcov_unsigned_t)0x01000000))
224 {
225 if (length)
226 {
227 fn_ident = gcov_read_unsigned ();
228 lineno_checksum = gcov_read_unsigned ();
229 cfg_checksum = gcov_read_unsigned ();
230 }
231 else
232 fn_ident = lineno_checksum = cfg_checksum = 0;
233 }
234 else if (tag == GCOV_TAG_OBJECT_SUMMARY((gcov_unsigned_t)0xa1000000))
235 {
236 profile_info = XCNEW (gcov_summary)((gcov_summary *) xcalloc (1, sizeof (gcov_summary)));
237 profile_info->runs = gcov_read_unsigned ();
238 profile_info->sum_max = gcov_read_unsigned ();
239 }
240 else if (GCOV_TAG_IS_COUNTER (tag)(!((tag) & 0xFFFF) && ((unsigned)(((tag) - ((gcov_unsigned_t
)0x01a10000)) >> 17)) < GCOV_COUNTERS)
&& fn_ident)
241 {
242 counts_entry **slot, *entry, elt;
243 int read_length = (int)length;
244 length = read_length > 0 ? read_length : 0;
245 unsigned n_counts = GCOV_TAG_COUNTER_NUM (abs (read_length))((abs (read_length) / 4) / 2);
246 unsigned ix;
247
248 elt.ident = fn_ident;
249 elt.ctr = GCOV_COUNTER_FOR_TAG (tag)((unsigned)(((tag) - ((gcov_unsigned_t)0x01a10000)) >> 17
))
;
250
251 slot = counts_hash->find_slot (&elt, INSERT);
252 entry = *slot;
253 if (!entry)
254 {
255 *slot = entry = XCNEW (counts_entry)((counts_entry *) xcalloc (1, sizeof (counts_entry)));
256 entry->ident = fn_ident;
257 entry->ctr = elt.ctr;
258 entry->lineno_checksum = lineno_checksum;
259 entry->cfg_checksum = cfg_checksum;
260 entry->counts = XCNEWVEC (gcov_type, n_counts)((gcov_type *) xcalloc ((n_counts), sizeof (gcov_type)));
261 entry->n_counts = n_counts;
262 }
263 else if (entry->lineno_checksum != lineno_checksum
264 || entry->cfg_checksum != cfg_checksum)
265 {
266 error ("profile data for function %u is corrupted", fn_ident);
267 error ("checksum is (%x,%x) instead of (%x,%x)",
268 entry->lineno_checksum, entry->cfg_checksum,
269 lineno_checksum, cfg_checksum);
270 delete counts_hash;
271 counts_hash = NULL__null;
272 break;
273 }
274 if (read_length > 0)
275 for (ix = 0; ix != n_counts; ix++)
276 entry->counts[ix] = gcov_read_counter ();
277 }
278 gcov_sync (offset, length);
279 if ((is_error = gcov_is_error ()))
280 {
281 error (is_error < 0
282 ? G_("%qs has overflowed")"%qs has overflowed"
283 : G_("%qs is corrupted")"%qs is corrupted",
284 da_file_name);
285 delete counts_hash;
286 counts_hash = NULL__null;
287 break;
288 }
289 }
290
291 gcov_close ();
292}
293
294/* Returns the counters for a particular tag. */
295
296gcov_type *
297get_coverage_counts (unsigned counter, unsigned cfg_checksum,
298 unsigned lineno_checksum, unsigned int n_counts)
299{
300 counts_entry *entry, elt;
301
302 /* No hash table, no counts. */
303 if (!counts_hash)
304 {
305 static int warned = 0;
306
307 if (!warned++)
308 {
309 warning (OPT_Wmissing_profile,
310 "%qs profile count data file not found",
311 da_file_name);
312 if (dump_enabled_p ())
313 {
314 dump_user_location_t loc
315 = dump_user_location_t::from_location_t (input_location);
316 dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc,
317 "file %s not found, %s\n", da_file_name,
318 (flag_guess_branch_probglobal_options.x_flag_guess_branch_prob
319 ? "execution counts estimated"
320 : "execution counts assumed to be zero"));
321 }
322 }
323 return NULL__null;
324 }
325 if (param_profile_func_internal_idglobal_options.x_param_profile_func_internal_id)
326 elt.ident = current_function_funcdef_no((cfun + 0)->funcdef_no) + 1;
327 else
328 {
329 gcc_assert (coverage_node_map_initialized_p ())((void)(!(coverage_node_map_initialized_p ()) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 329, __FUNCTION__), 0 : 0))
;
330 elt.ident = cgraph_node::get (current_function_decl)->profile_id;
331 }
332 elt.ctr = counter;
333 entry = counts_hash->find (&elt);
334 if (!entry)
335 {
336 if (counter == GCOV_COUNTER_ARCS)
337 warning_at (DECL_SOURCE_LOCATION (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 337, __FUNCTION__))->decl_minimal.locus)
,
338 OPT_Wmissing_profile,
339 "profile for function %qD not found in profile data",
340 current_function_decl);
341 /* The function was not emitted, or is weak and not chosen in the
342 final executable. Silently fail, because there's nothing we
343 can do about it. */
344 return NULL__null;
345 }
346
347 if (entry->cfg_checksum != cfg_checksum
348 || (counter != GCOV_COUNTER_V_INDIR
349 && counter != GCOV_COUNTER_V_TOPN
350 && entry->n_counts != n_counts))
351 {
352 static int warned = 0;
353 bool warning_printed = false;
354
355 if (entry->n_counts != n_counts)
356 warning_printed =
357 warning_at (DECL_SOURCE_LOCATION (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 357, __FUNCTION__))->decl_minimal.locus)
,
358 OPT_Wcoverage_mismatch,
359 "number of counters in profile data for function %qD "
360 "does not match "
361 "its profile data (counter %qs, expected %i and have %i)",
362 current_function_decl,
363 ctr_names[counter], entry->n_counts, n_counts);
364 else
365 warning_printed =
366 warning_at (DECL_SOURCE_LOCATION (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 366, __FUNCTION__))->decl_minimal.locus)
,
367 OPT_Wcoverage_mismatch,
368 "the control flow of function %qD does not match "
369 "its profile data (counter %qs)", current_function_decl,
370 ctr_names[counter]);
371 if (warning_printed && dump_enabled_p ())
372 {
373 dump_user_location_t loc
374 = dump_user_location_t::from_function_decl (current_function_decl);
375 dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc,
376 "use -Wno-error=coverage-mismatch to tolerate "
377 "the mismatch but performance may drop if the "
378 "function is hot\n");
379
380 if (!seen_error ()
381 && !warned++)
382 {
383 dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc,
384 "coverage mismatch ignored\n");
385 dump_printf (MSG_MISSED_OPTIMIZATION,
386 flag_guess_branch_probglobal_options.x_flag_guess_branch_prob
387 ? G_("execution counts estimated\n")"execution counts estimated\n"
388 : G_("execution counts assumed to be zero\n")"execution counts assumed to be zero\n");
389 if (!flag_guess_branch_probglobal_options.x_flag_guess_branch_prob)
390 dump_printf (MSG_MISSED_OPTIMIZATION,
391 "this can result in poorly optimized code\n");
392 }
393 }
394
395 return NULL__null;
396 }
397 else if (entry->lineno_checksum != lineno_checksum)
398 {
399 warning_at (DECL_SOURCE_LOCATION (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 399, __FUNCTION__))->decl_minimal.locus)
,
400 OPT_Wcoverage_mismatch,
401 "source locations for function %qD have changed,"
402 " the profile data may be out of date",
403 current_function_decl);
404 }
405
406 return entry->counts;
407}
408
409/* Allocate NUM counters of type COUNTER. Returns nonzero if the
410 allocation succeeded. */
411
412int
413coverage_counter_alloc (unsigned counter, unsigned num)
414{
415 if (no_coverage)
416 return 0;
417
418 if (!num)
419 return 1;
420
421 if (!fn_v_ctrs[counter])
422 {
423 tree array_type = build_array_type (get_gcov_type (), NULL_TREE(tree) __null);
424
425 fn_v_ctrs[counter]
426 = build_var (current_function_decl, array_type, counter);
427 }
428
429 fn_b_ctrs[counter] = fn_n_ctrs[counter];
430 fn_n_ctrs[counter] += num;
431
432 fn_ctr_mask |= 1 << counter;
433 return 1;
434}
435
436/* Generate a tree to access COUNTER NO. */
437
438tree
439tree_coverage_counter_ref (unsigned counter, unsigned no)
440{
441 tree gcov_type_node = get_gcov_type ();
442
443 gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter])((void)(!(no < fn_n_ctrs[counter] - fn_b_ctrs[counter]) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 443, __FUNCTION__), 0 : 0))
;
444
445 no += fn_b_ctrs[counter];
446
447 /* "no" here is an array index, scaled to bytes later. */
448 return build4 (ARRAY_REF, gcov_type_node, fn_v_ctrs[counter],
449 build_int_cst (integer_type_nodeinteger_types[itk_int], no), NULL__null, NULL__null);
450}
451
452/* Generate a tree to access the address of COUNTER NO. */
453
454tree
455tree_coverage_counter_addr (unsigned counter, unsigned no)
456{
457 tree gcov_type_node = get_gcov_type ();
458
459 gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter])((void)(!(no < fn_n_ctrs[counter] - fn_b_ctrs[counter]) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 459, __FUNCTION__), 0 : 0))
;
460 no += fn_b_ctrs[counter];
461
462 /* "no" here is an array index, scaled to bytes later. */
463 return build_fold_addr_expr (build4 (ARRAY_REF, gcov_type_node,build_fold_addr_expr_loc (((location_t) 0), (build4 (ARRAY_REF
, gcov_type_node, fn_v_ctrs[counter], build_int_cst (integer_types
[itk_int], no), __null, __null)))
464 fn_v_ctrs[counter],build_fold_addr_expr_loc (((location_t) 0), (build4 (ARRAY_REF
, gcov_type_node, fn_v_ctrs[counter], build_int_cst (integer_types
[itk_int], no), __null, __null)))
465 build_int_cst (integer_type_node, no),build_fold_addr_expr_loc (((location_t) 0), (build4 (ARRAY_REF
, gcov_type_node, fn_v_ctrs[counter], build_int_cst (integer_types
[itk_int], no), __null, __null)))
466 NULL, NULL))build_fold_addr_expr_loc (((location_t) 0), (build4 (ARRAY_REF
, gcov_type_node, fn_v_ctrs[counter], build_int_cst (integer_types
[itk_int], no), __null, __null)))
;
467}
468
469
470/* Generate a checksum for a string. CHKSUM is the current
471 checksum. */
472
473static unsigned
474coverage_checksum_string (unsigned chksum, const char *string)
475{
476 int i;
477 char *dup = NULL__null;
478
479 /* Look for everything that looks if it were produced by
480 get_file_function_name and zero out the second part
481 that may result from flag_random_seed. This is not critical
482 as the checksums are used only for sanity checking. */
483 for (i = 0; string[i]; i++)
484 {
485 int offset = 0;
486 if (startswith (string + i, "_GLOBAL__N_"))
487 offset = 11;
488 if (startswith (string + i, "_GLOBAL__"))
489 offset = 9;
490
491 /* C++ namespaces do have scheme:
492 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
493 since filename might contain extra underscores there seems
494 to be no better chance then walk all possible offsets looking
495 for magicnumber. */
496 if (offset)
497 {
498 for (i = i + offset; string[i]; i++)
499 if (string[i]=='_')
500 {
501 int y;
502
503 for (y = 1; y < 9; y++)
504 if (!(string[i + y] >= '0' && string[i + y] <= '9')
505 && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
506 break;
507 if (y != 9 || string[i + 9] != '_')
508 continue;
509 for (y = 10; y < 18; y++)
510 if (!(string[i + y] >= '0' && string[i + y] <= '9')
511 && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
512 break;
513 if (y != 18)
514 continue;
515 if (!dup)
516 string = dup = xstrdup (string);
517 for (y = 10; y < 18; y++)
518 dup[i + y] = '0';
519 }
520 break;
521 }
522 }
523
524 chksum = crc32_string (chksum, string);
525 free (dup);
526
527 return chksum;
528}
529
530/* Compute checksum for the current function. We generate a CRC32. */
531
532unsigned
533coverage_compute_lineno_checksum (void)
534{
535 expanded_location xloc
536 = expand_location (DECL_SOURCE_LOCATION (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 536, __FUNCTION__))->decl_minimal.locus)
);
537 unsigned chksum = xloc.line;
538
539 if (xloc.file)
540 chksum = coverage_checksum_string (chksum, xloc.file);
541 chksum = coverage_checksum_string
542 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl))((const char *) (tree_check ((decl_assembler_name (current_function_decl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 542, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
);
543
544 return chksum;
545}
546
547/* Compute profile ID. This is better to be unique in whole program. */
548
549unsigned
550coverage_compute_profile_id (struct cgraph_node *n)
551{
552 unsigned chksum;
553
554 /* Externally visible symbols have unique name. */
555 if (TREE_PUBLIC (n->decl)((n->decl)->base.public_flag) || DECL_EXTERNAL (n->decl)((contains_struct_check ((n->decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 555, __FUNCTION__))->decl_common.decl_flag_1)
|| n->unique_name)
556 {
557 chksum = coverage_checksum_string
558 (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl))((const char *) (tree_check ((decl_assembler_name (n->decl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 558, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
);
559 }
560 else
561 {
562 expanded_location xloc
563 = expand_location (DECL_SOURCE_LOCATION (n->decl)((contains_struct_check ((n->decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 563, __FUNCTION__))->decl_minimal.locus)
);
564 bool use_name_only = (param_profile_func_internal_idglobal_options.x_param_profile_func_internal_id == 0);
565
566 chksum = (use_name_only ? 0 : xloc.line);
567 if (xloc.file)
568 chksum = coverage_checksum_string (chksum, xloc.file);
569 chksum = coverage_checksum_string
570 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl))((const char *) (tree_check ((decl_assembler_name (n->decl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 570, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
);
571 if (!use_name_only && first_global_object_name)
572 chksum = coverage_checksum_string
573 (chksum, first_global_object_name);
574 char *base_name = xstrdup (aux_base_nameglobal_options.x_aux_base_name);
575 if (endswith (base_name, ".gk"))
576 base_name[strlen (base_name) - 3] = '\0';
577 chksum = coverage_checksum_string (chksum, base_name);
578 free (base_name);
579 }
580
581 /* Non-negative integers are hopefully small enough to fit in all targets.
582 Gcov file formats wants non-zero function IDs. */
583 chksum = chksum & 0x7fffffff;
584 return chksum + (!chksum);
585}
586
587/* Compute cfg checksum for the function FN given as argument.
588 The checksum is calculated carefully so that
589 source code changes that doesn't affect the control flow graph
590 won't change the checksum.
591 This is to make the profile data useable across source code change.
592 The downside of this is that the compiler may use potentially
593 wrong profile data - that the source code change has non-trivial impact
594 on the validity of profile data (e.g. the reversed condition)
595 but the compiler won't detect the change and use the wrong profile data. */
596
597unsigned
598coverage_compute_cfg_checksum (struct function *fn)
599{
600 basic_block bb;
601 unsigned chksum = n_basic_blocks_for_fn (fn)((fn)->cfg->x_n_basic_blocks);
602
603 FOR_EACH_BB_FN (bb, fn)for (bb = (fn)->cfg->x_entry_block_ptr->next_bb; bb !=
(fn)->cfg->x_exit_block_ptr; bb = bb->next_bb)
604 {
605 edge e;
606 edge_iterator ei;
607 chksum = crc32_byte (chksum, bb->index);
608 FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
609 {
610 chksum = crc32_byte (chksum, e->dest->index);
611 }
612 }
613
614 return chksum;
615}
616
617/* Begin output to the notes file for the current function.
618 Writes the function header. Returns nonzero if data should be output. */
619
620int
621coverage_begin_function (unsigned lineno_checksum, unsigned cfg_checksum)
622{
623 /* We don't need to output .gcno file unless we're under -ftest-coverage
624 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
625 if (no_coverage || !bbg_file_name)
626 return 0;
627
628 expanded_location startloc
629 = expand_location (DECL_SOURCE_LOCATION (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 629, __FUNCTION__))->decl_minimal.locus)
);
630
631 /* Announce function */
632 unsigned long offset = gcov_write_tag (GCOV_TAG_FUNCTION((gcov_unsigned_t)0x01000000));
633 if (param_profile_func_internal_idglobal_options.x_param_profile_func_internal_id)
634 gcov_write_unsigned (current_function_funcdef_no((cfun + 0)->funcdef_no) + 1);
635 else
636 {
637 gcc_assert (coverage_node_map_initialized_p ())((void)(!(coverage_node_map_initialized_p ()) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 637, __FUNCTION__), 0 : 0))
;
638 gcov_write_unsigned (
639 cgraph_node::get (current_function_decl)->profile_id);
640 }
641
642 gcov_write_unsigned (lineno_checksum);
643 gcov_write_unsigned (cfg_checksum);
644 gcov_write_string (IDENTIFIER_POINTER((const char *) (tree_check ((decl_assembler_name (current_function_decl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 645, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
645 (DECL_ASSEMBLER_NAME (current_function_decl))((const char *) (tree_check ((decl_assembler_name (current_function_decl
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 645, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
);
646 gcov_write_unsigned (DECL_ARTIFICIAL (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 646, __FUNCTION__))->decl_common.artificial_flag)
647 && !DECL_FUNCTION_VERSIONED (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 647, __FUNCTION__, (FUNCTION_DECL)))->function_decl.versioned_function
)
648 && !DECL_LAMBDA_FUNCTION_P (current_function_decl)(((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 648, __FUNCTION__, (FUNCTION_DECL)))->function_decl.decl_type
) == LAMBDA_FUNCTION)
);
649 gcov_write_filename (startloc.file);
650 gcov_write_unsigned (startloc.line);
651 gcov_write_unsigned (startloc.column);
652
653 expanded_location endloc = expand_location (cfun(cfun + 0)->function_end_locus);
654
655 /* Function can start in a single file and end in another one. */
656 int end_line
657 = endloc.file == startloc.file ? endloc.line : startloc.line;
658 int end_column
659 = endloc.file == startloc.file ? endloc.column: startloc.column;
660
661 if (startloc.line > end_line)
662 {
663 warning_at (DECL_SOURCE_LOCATION (current_function_decl)((contains_struct_check ((current_function_decl), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 663, __FUNCTION__))->decl_minimal.locus)
,
664 OPT_Wcoverage_invalid_line_number,
665 "function starts on a higher line number than it ends");
666 end_line = startloc.line;
667 end_column = startloc.column;
668 }
669
670 gcov_write_unsigned (end_line);
671 gcov_write_unsigned (end_column);
672 gcov_write_length (offset);
673
674 return !gcov_is_error ();
675}
676
677/* Finish coverage data for the current function. Verify no output
678 error has occurred. Save function coverage counts. */
679
680void
681coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum)
682{
683 unsigned i;
684
685 if (bbg_file_name && gcov_is_error ())
686 {
687 warning (0, "error writing %qs", bbg_file_name);
688 unlink (bbg_file_name);
689 bbg_file_name = NULL__null;
690 }
691
692 if (fn_ctr_mask)
693 {
694 struct coverage_data *item = 0;
695
696 item = ggc_alloc<coverage_data> ();
697
698 if (param_profile_func_internal_idglobal_options.x_param_profile_func_internal_id)
699 item->ident = current_function_funcdef_no((cfun + 0)->funcdef_no) + 1;
700 else
701 {
702 gcc_assert (coverage_node_map_initialized_p ())((void)(!(coverage_node_map_initialized_p ()) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 702, __FUNCTION__), 0 : 0))
;
703 item->ident = cgraph_node::get (cfun(cfun + 0)->decl)->profile_id;
704 }
705
706 item->lineno_checksum = lineno_checksum;
707 item->cfg_checksum = cfg_checksum;
708
709 item->fn_decl = current_function_decl;
710 item->next = 0;
711 *functions_tail = item;
712 functions_tail = &item->next;
713
714 for (i = 0; i != GCOV_COUNTERS; i++)
715 {
716 tree var = fn_v_ctrs[i];
717
718 if (item)
719 item->ctr_vars[i] = var;
720 if (var)
721 {
722 tree array_type = build_index_type (size_int (fn_n_ctrs[i] - 1)size_int_kind (fn_n_ctrs[i] - 1, stk_sizetype));
723 array_type = build_array_type (get_gcov_type (), array_type);
724 TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 724, __FUNCTION__))->typed.type)
= array_type;
725 DECL_SIZE (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 725, __FUNCTION__))->decl_common.size)
= TYPE_SIZE (array_type)((tree_class_check ((array_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 725, __FUNCTION__))->type_common.size)
;
726 DECL_SIZE_UNIT (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 726, __FUNCTION__))->decl_common.size_unit)
= TYPE_SIZE_UNIT (array_type)((tree_class_check ((array_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 726, __FUNCTION__))->type_common.size_unit)
;
727 varpool_node::finalize_decl (var);
728 }
729
730 fn_b_ctrs[i] = fn_n_ctrs[i] = 0;
731 fn_v_ctrs[i] = NULL_TREE(tree) __null;
732 }
733 prg_ctr_mask |= fn_ctr_mask;
734 fn_ctr_mask = 0;
735 }
736}
737
738/* Remove coverage file if opened. */
739
740void
741coverage_remove_note_file (void)
742{
743 if (bbg_file_name)
744 {
745 gcov_close ();
746 unlink (bbg_file_name);
747 }
748}
749
750/* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
751 >= 0 it is a counter array, otherwise it is the function structure. */
752
753static tree
754build_var (tree fn_decl, tree type, int counter)
755{
756 tree var = build_decl (BUILTINS_LOCATION((location_t) 1), VAR_DECL, NULL_TREE(tree) __null, type);
757 const char *fn_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl))((const char *) (tree_check ((decl_assembler_name (fn_decl)),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 757, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
)
;
758 char *buf;
759 size_t fn_name_len, len;
760
761 fn_name = targetm.strip_name_encoding (fn_name);
762 fn_name_len = strlen (fn_name);
763 buf = XALLOCAVEC (char, fn_name_len + 8 + sizeof (int) * 3)((char *) __builtin_alloca(sizeof (char) * (fn_name_len + 8 +
sizeof (int) * 3)))
;
764
765 if (counter < 0)
766 strcpy (buf, "__gcov__");
767 else
768 sprintf (buf, "__gcov%u_", counter);
769 len = strlen (buf);
770 buf[len - 1] = symbol_table::symbol_suffix_separator ();
771 memcpy (buf + len, fn_name, fn_name_len + 1);
772 DECL_NAME (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 772, __FUNCTION__))->decl_minimal.name)
= get_identifier (buf)(__builtin_constant_p (buf) ? get_identifier_with_length ((buf
), strlen (buf)) : get_identifier (buf))
;
773 TREE_STATIC (var)((var)->base.static_flag) = 1;
774 TREE_ADDRESSABLE (var)((var)->base.addressable_flag) = 1;
775 DECL_NONALIASED (var)((tree_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 775, __FUNCTION__, (VAR_DECL)))->base.nothrow_flag)
= 1;
776 SET_DECL_ALIGN (var, TYPE_ALIGN (type))(((contains_struct_check ((var), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 776, __FUNCTION__))->decl_common.align) = ffs_hwi ((((tree_class_check
((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 776, __FUNCTION__))->type_common.align) ? ((unsigned)1) <<
(((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 776, __FUNCTION__))->type_common.align) - 1) : 0)))
;
777
778 return var;
779}
780
781/* Creates the gcov_fn_info RECORD_TYPE. */
782
783static void
784build_fn_info_type (tree type, unsigned counters, tree gcov_info_type)
785{
786 tree ctr_info = lang_hooks.types.make_type (RECORD_TYPE);
787 tree field, fields;
788 tree array_type;
789
790 gcc_assert (counters)((void)(!(counters) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 790, __FUNCTION__), 0 : 0))
;
791
792 /* ctr_info::num */
793 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
794 get_gcov_unsigned_t ());
795 fields = field;
796
797 /* ctr_info::values */
798 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
799 build_pointer_type (get_gcov_type ()));
800 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 800, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 800, __FUNCTION__))->common.chain))
= fields;
801 fields = field;
802
803 finish_builtin_struct (ctr_info, "__gcov_ctr_info", fields, NULL_TREE(tree) __null);
804
805 /* key */
806 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
807 build_pointer_type (build_qualified_type
808 (gcov_info_type, TYPE_QUAL_CONST)));
809 fields = field;
810
811 /* ident */
812 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
813 get_gcov_unsigned_t ());
814 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 814, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 814, __FUNCTION__))->common.chain))
= fields;
815 fields = field;
816
817 /* lineno_checksum */
818 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
819 get_gcov_unsigned_t ());
820 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 820, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 820, __FUNCTION__))->common.chain))
= fields;
821 fields = field;
822
823 /* cfg checksum */
824 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
825 get_gcov_unsigned_t ());
826 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 826, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 826, __FUNCTION__))->common.chain))
= fields;
827 fields = field;
828
829 array_type = build_index_type (size_int (counters - 1)size_int_kind (counters - 1, stk_sizetype));
830 array_type = build_array_type (ctr_info, array_type);
831
832 /* counters */
833 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null, array_type);
834 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 834, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 834, __FUNCTION__))->common.chain))
= fields;
835 fields = field;
836
837 finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE(tree) __null);
838}
839
840/* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
841 the coverage data for the function and TYPE is the gcov_fn_info
842 RECORD_TYPE. KEY is the object file key. */
843
844static tree
845build_fn_info (const struct coverage_data *data, tree type, tree key)
846{
847 tree fields = TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 847, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
;
848 tree ctr_type;
849 unsigned ix;
850 vec<constructor_elt, va_gc> *v1 = NULL__null;
851 vec<constructor_elt, va_gc> *v2 = NULL__null;
852
853 /* key */
854 CONSTRUCTOR_APPEND_ELT (v1, fields,do { constructor_elt _ce___ = {fields, build1 (ADDR_EXPR, ((contains_struct_check
((fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 855, __FUNCTION__))->typed.type), key)}; vec_safe_push (
(v1), _ce___); } while (0)
855 build1 (ADDR_EXPR, TREE_TYPE (fields), key))do { constructor_elt _ce___ = {fields, build1 (ADDR_EXPR, ((contains_struct_check
((fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 855, __FUNCTION__))->typed.type), key)}; vec_safe_push (
(v1), _ce___); } while (0)
;
856 fields = DECL_CHAIN (fields)(((contains_struct_check (((contains_struct_check ((fields), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 856, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 856, __FUNCTION__))->common.chain))
;
857
858 /* ident */
859 CONSTRUCTOR_APPEND_ELT (v1, fields,do { constructor_elt _ce___ = {fields, build_int_cstu (get_gcov_unsigned_t
(), data->ident)}; vec_safe_push ((v1), _ce___); } while (
0)
860 build_int_cstu (get_gcov_unsigned_t (),do { constructor_elt _ce___ = {fields, build_int_cstu (get_gcov_unsigned_t
(), data->ident)}; vec_safe_push ((v1), _ce___); } while (
0)
861 data->ident))do { constructor_elt _ce___ = {fields, build_int_cstu (get_gcov_unsigned_t
(), data->ident)}; vec_safe_push ((v1), _ce___); } while (
0)
;
862 fields = DECL_CHAIN (fields)(((contains_struct_check (((contains_struct_check ((fields), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 862, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 862, __FUNCTION__))->common.chain))
;
863
864 /* lineno_checksum */
865 CONSTRUCTOR_APPEND_ELT (v1, fields,do { constructor_elt _ce___ = {fields, build_int_cstu (get_gcov_unsigned_t
(), data->lineno_checksum)}; vec_safe_push ((v1), _ce___)
; } while (0)
866 build_int_cstu (get_gcov_unsigned_t (),do { constructor_elt _ce___ = {fields, build_int_cstu (get_gcov_unsigned_t
(), data->lineno_checksum)}; vec_safe_push ((v1), _ce___)
; } while (0)
867 data->lineno_checksum))do { constructor_elt _ce___ = {fields, build_int_cstu (get_gcov_unsigned_t
(), data->lineno_checksum)}; vec_safe_push ((v1), _ce___)
; } while (0)
;
868 fields = DECL_CHAIN (fields)(((contains_struct_check (((contains_struct_check ((fields), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 868, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 868, __FUNCTION__))->common.chain))
;
869
870 /* cfg_checksum */
871 CONSTRUCTOR_APPEND_ELT (v1, fields,do { constructor_elt _ce___ = {fields, build_int_cstu (get_gcov_unsigned_t
(), data->cfg_checksum)}; vec_safe_push ((v1), _ce___); }
while (0)
872 build_int_cstu (get_gcov_unsigned_t (),do { constructor_elt _ce___ = {fields, build_int_cstu (get_gcov_unsigned_t
(), data->cfg_checksum)}; vec_safe_push ((v1), _ce___); }
while (0)
873 data->cfg_checksum))do { constructor_elt _ce___ = {fields, build_int_cstu (get_gcov_unsigned_t
(), data->cfg_checksum)}; vec_safe_push ((v1), _ce___); }
while (0)
;
874 fields = DECL_CHAIN (fields)(((contains_struct_check (((contains_struct_check ((fields), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 874, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 874, __FUNCTION__))->common.chain))
;
875
876 /* counters */
877 ctr_type = TREE_TYPE (TREE_TYPE (fields))((contains_struct_check ((((contains_struct_check ((fields), (
TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 877, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 877, __FUNCTION__))->typed.type)
;
878 for (ix = 0; ix != GCOV_COUNTERS; ix++)
879 if (prg_ctr_mask & (1 << ix))
880 {
881 vec<constructor_elt, va_gc> *ctr = NULL__null;
882 tree var = data->ctr_vars[ix];
883 unsigned count = 0;
884
885 if (var)
886 count
887 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var)))((tree_check5 ((((tree_check ((((contains_struct_check ((var)
, (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 887, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 887, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 887, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
)
888 + 1;
889
890 CONSTRUCTOR_APPEND_ELT (ctr, TYPE_FIELDS (ctr_type),do { constructor_elt _ce___ = {((tree_check3 ((ctr_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 890, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values), build_int_cstu (get_gcov_unsigned_t
(), count)}; vec_safe_push ((ctr), _ce___); } while (0)
891 build_int_cstu (get_gcov_unsigned_t (),do { constructor_elt _ce___ = {((tree_check3 ((ctr_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 890, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values), build_int_cstu (get_gcov_unsigned_t
(), count)}; vec_safe_push ((ctr), _ce___); } while (0)
892 count))do { constructor_elt _ce___ = {((tree_check3 ((ctr_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 890, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values), build_int_cstu (get_gcov_unsigned_t
(), count)}; vec_safe_push ((ctr), _ce___); } while (0)
;
893
894 if (var)
895 CONSTRUCTOR_APPEND_ELT (ctr, DECL_CHAIN (TYPE_FIELDS (ctr_type)),do { constructor_elt _ce___ = {(((contains_struct_check (((contains_struct_check
((((tree_check3 ((ctr_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 895, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 895, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 895, __FUNCTION__))->common.chain)), build_fold_addr_expr_loc
(((location_t) 0), (var))}; vec_safe_push ((ctr), _ce___); }
while (0)
896 build_fold_addr_expr (var))do { constructor_elt _ce___ = {(((contains_struct_check (((contains_struct_check
((((tree_check3 ((ctr_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 895, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 895, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 895, __FUNCTION__))->common.chain)), build_fold_addr_expr_loc
(((location_t) 0), (var))}; vec_safe_push ((ctr), _ce___); }
while (0)
;
897
898 CONSTRUCTOR_APPEND_ELT (v2, NULL, build_constructor (ctr_type, ctr))do { constructor_elt _ce___ = {__null, build_constructor (ctr_type
, ctr)}; vec_safe_push ((v2), _ce___); } while (0)
;
899 }
900
901 CONSTRUCTOR_APPEND_ELT (v1, fields,do { constructor_elt _ce___ = {fields, build_constructor (((contains_struct_check
((fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 902, __FUNCTION__))->typed.type), v2)}; vec_safe_push ((
v1), _ce___); } while (0)
902 build_constructor (TREE_TYPE (fields), v2))do { constructor_elt _ce___ = {fields, build_constructor (((contains_struct_check
((fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 902, __FUNCTION__))->typed.type), v2)}; vec_safe_push ((
v1), _ce___); } while (0)
;
903
904 return build_constructor (type, v1);
905}
906
907/* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
908 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
909
910static void
911build_info_type (tree type, tree fn_info_ptr_type)
912{
913 tree field, fields = NULL_TREE(tree) __null;
914 tree merge_fn_type;
915
916 /* Version ident */
917 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
918 get_gcov_unsigned_t ());
919 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 919, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 919, __FUNCTION__))->common.chain))
= fields;
920 fields = field;
921
922 /* next pointer */
923 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
924 build_pointer_type (build_qualified_type
925 (type, TYPE_QUAL_CONST)));
926 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 926, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 926, __FUNCTION__))->common.chain))
= fields;
927 fields = field;
928
929 /* stamp */
930 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
931 get_gcov_unsigned_t ());
932 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 932, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 932, __FUNCTION__))->common.chain))
= fields;
933 fields = field;
934
935 /* Checksum. */
936 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
937 get_gcov_unsigned_t ());
938 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 938, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 938, __FUNCTION__))->common.chain))
= fields;
939 fields = field;
940
941 /* Filename */
942 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
943 build_pointer_type (build_qualified_type
944 (char_type_nodeinteger_types[itk_char], TYPE_QUAL_CONST)));
945 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 945, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 945, __FUNCTION__))->common.chain))
= fields;
946 fields = field;
947
948 /* merge fn array */
949 merge_fn_type
950 = build_function_type_list (void_type_nodeglobal_trees[TI_VOID_TYPE],
951 build_pointer_type (get_gcov_type ()),
952 get_gcov_unsigned_t (), NULL_TREE(tree) __null);
953 merge_fn_type
954 = build_array_type (build_pointer_type (merge_fn_type),
955 build_index_type (size_int (GCOV_COUNTERS - 1)size_int_kind (GCOV_COUNTERS - 1, stk_sizetype)));
956 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
957 merge_fn_type);
958 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 958, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 958, __FUNCTION__))->common.chain))
= fields;
959 fields = field;
960
961 /* n_functions */
962 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
963 get_gcov_unsigned_t ());
964 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 964, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 964, __FUNCTION__))->common.chain))
= fields;
965 fields = field;
966
967 /* function_info pointer pointer */
968 fn_info_ptr_type = build_pointer_type
969 (build_qualified_type (fn_info_ptr_type, TYPE_QUAL_CONST));
970 field = build_decl (BUILTINS_LOCATION((location_t) 1), FIELD_DECL, NULL_TREE(tree) __null,
971 fn_info_ptr_type);
972 DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 972, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 972, __FUNCTION__))->common.chain))
= fields;
973 fields = field;
974
975 finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE(tree) __null);
976}
977
978/* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
979 gcov_info structure type, FN_ARY is the array of pointers to
980 function info objects. */
981
982static tree
983build_info (tree info_type, tree fn_ary, unsigned object_checksum)
984{
985 tree info_fields = TYPE_FIELDS (info_type)((tree_check3 ((info_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 985, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
;
986 tree merge_fn_type, n_funcs;
987 unsigned ix;
988 tree filename_string;
989 int da_file_name_len;
990 vec<constructor_elt, va_gc> *v1 = NULL__null;
10
'v1' initialized to a null pointer value
991 vec<constructor_elt, va_gc> *v2 = NULL__null;
992
993 /* Version ident */
994 CONSTRUCTOR_APPEND_ELT (v1, info_fields,do { constructor_elt _ce___ = {info_fields, build_int_cstu ((
(contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 995, __FUNCTION__))->typed.type), ((gcov_unsigned_t)0x42323020
))}; vec_safe_push ((v1), _ce___); } while (0)
11
Passing value via 1st parameter 'v'
12
Calling 'vec_safe_push<constructor_elt, va_gc>'
995 build_int_cstu (TREE_TYPE (info_fields),do { constructor_elt _ce___ = {info_fields, build_int_cstu ((
(contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 995, __FUNCTION__))->typed.type), ((gcov_unsigned_t)0x42323020
))}; vec_safe_push ((v1), _ce___); } while (0)
996 GCOV_VERSION))do { constructor_elt _ce___ = {info_fields, build_int_cstu ((
(contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 995, __FUNCTION__))->typed.type), ((gcov_unsigned_t)0x42323020
))}; vec_safe_push ((v1), _ce___); } while (0)
;
997 info_fields = DECL_CHAIN (info_fields)(((contains_struct_check (((contains_struct_check ((info_fields
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 997, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 997, __FUNCTION__))->common.chain))
;
998
999 /* next -- NULL */
1000 CONSTRUCTOR_APPEND_ELT (v1, info_fields, null_pointer_node)do { constructor_elt _ce___ = {info_fields, global_trees[TI_NULL_POINTER
]}; vec_safe_push ((v1), _ce___); } while (0)
;
1001 info_fields = DECL_CHAIN (info_fields)(((contains_struct_check (((contains_struct_check ((info_fields
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1001, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1001, __FUNCTION__))->common.chain))
;
1002
1003 /* stamp */
1004 CONSTRUCTOR_APPEND_ELT (v1, info_fields,do { constructor_elt _ce___ = {info_fields, build_int_cstu ((
(contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1005, __FUNCTION__))->typed.type), bbg_file_stamp)}; vec_safe_push
((v1), _ce___); } while (0)
1005 build_int_cstu (TREE_TYPE (info_fields),do { constructor_elt _ce___ = {info_fields, build_int_cstu ((
(contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1005, __FUNCTION__))->typed.type), bbg_file_stamp)}; vec_safe_push
((v1), _ce___); } while (0)
1006 bbg_file_stamp))do { constructor_elt _ce___ = {info_fields, build_int_cstu ((
(contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1005, __FUNCTION__))->typed.type), bbg_file_stamp)}; vec_safe_push
((v1), _ce___); } while (0)
;
1007 info_fields = DECL_CHAIN (info_fields)(((contains_struct_check (((contains_struct_check ((info_fields
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1007, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1007, __FUNCTION__))->common.chain))
;
1008
1009 /* Checksum. */
1010 CONSTRUCTOR_APPEND_ELT (v1, info_fields,do { constructor_elt _ce___ = {info_fields, build_int_cstu ((
(contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1011, __FUNCTION__))->typed.type), object_checksum)}; vec_safe_push
((v1), _ce___); } while (0)
1011 build_int_cstu (TREE_TYPE (info_fields),do { constructor_elt _ce___ = {info_fields, build_int_cstu ((
(contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1011, __FUNCTION__))->typed.type), object_checksum)}; vec_safe_push
((v1), _ce___); } while (0)
1012 object_checksum))do { constructor_elt _ce___ = {info_fields, build_int_cstu ((
(contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1011, __FUNCTION__))->typed.type), object_checksum)}; vec_safe_push
((v1), _ce___); } while (0)
;
1013 info_fields = DECL_CHAIN (info_fields)(((contains_struct_check (((contains_struct_check ((info_fields
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1013, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1013, __FUNCTION__))->common.chain))
;
1014
1015 /* Filename */
1016 da_file_name_len = strlen (da_file_name);
1017 filename_string = build_string (da_file_name_len + 1, da_file_name);
1018 TREE_TYPE (filename_string)((contains_struct_check ((filename_string), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1018, __FUNCTION__))->typed.type)
= build_array_type
1019 (char_type_nodeinteger_types[itk_char], build_index_type (size_int (da_file_name_len)size_int_kind (da_file_name_len, stk_sizetype)));
1020 CONSTRUCTOR_APPEND_ELT (v1, info_fields,do { constructor_elt _ce___ = {info_fields, build1 (ADDR_EXPR
, ((contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1021, __FUNCTION__))->typed.type), filename_string)}; vec_safe_push
((v1), _ce___); } while (0)
1021 build1 (ADDR_EXPR, TREE_TYPE (info_fields),do { constructor_elt _ce___ = {info_fields, build1 (ADDR_EXPR
, ((contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1021, __FUNCTION__))->typed.type), filename_string)}; vec_safe_push
((v1), _ce___); } while (0)
1022 filename_string))do { constructor_elt _ce___ = {info_fields, build1 (ADDR_EXPR
, ((contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1021, __FUNCTION__))->typed.type), filename_string)}; vec_safe_push
((v1), _ce___); } while (0)
;
1023 info_fields = DECL_CHAIN (info_fields)(((contains_struct_check (((contains_struct_check ((info_fields
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1023, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1023, __FUNCTION__))->common.chain))
;
1024
1025 /* merge fn array -- NULL slots indicate unmeasured counters */
1026 merge_fn_type = TREE_TYPE (TREE_TYPE (info_fields))((contains_struct_check ((((contains_struct_check ((info_fields
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1026, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1026, __FUNCTION__))->typed.type)
;
1027 for (ix = 0; ix != GCOV_COUNTERS; ix++)
1028 {
1029 tree ptr = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
1030
1031 if ((1u << ix) & prg_ctr_mask)
1032 {
1033 tree merge_fn = build_decl (BUILTINS_LOCATION((location_t) 1),
1034 FUNCTION_DECL,
1035 get_identifier (ctr_merge_functions[ix])(__builtin_constant_p (ctr_merge_functions[ix]) ? get_identifier_with_length
((ctr_merge_functions[ix]), strlen (ctr_merge_functions[ix])
) : get_identifier (ctr_merge_functions[ix]))
,
1036 TREE_TYPE (merge_fn_type)((contains_struct_check ((merge_fn_type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1036, __FUNCTION__))->typed.type)
);
1037 DECL_EXTERNAL (merge_fn)((contains_struct_check ((merge_fn), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1037, __FUNCTION__))->decl_common.decl_flag_1)
= 1;
1038 TREE_PUBLIC (merge_fn)((merge_fn)->base.public_flag) = 1;
1039 DECL_ARTIFICIAL (merge_fn)((contains_struct_check ((merge_fn), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1039, __FUNCTION__))->decl_common.artificial_flag)
= 1;
1040 TREE_NOTHROW (merge_fn)((merge_fn)->base.nothrow_flag) = 1;
1041 /* Initialize assembler name so we can stream out. */
1042 DECL_ASSEMBLER_NAME (merge_fn)decl_assembler_name (merge_fn);
1043 ptr = build1 (ADDR_EXPR, merge_fn_type, merge_fn);
1044 }
1045 CONSTRUCTOR_APPEND_ELT (v2, NULL, ptr)do { constructor_elt _ce___ = {__null, ptr}; vec_safe_push ((
v2), _ce___); } while (0)
;
1046 }
1047 CONSTRUCTOR_APPEND_ELT (v1, info_fields,do { constructor_elt _ce___ = {info_fields, build_constructor
(((contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1048, __FUNCTION__))->typed.type), v2)}; vec_safe_push (
(v1), _ce___); } while (0)
1048 build_constructor (TREE_TYPE (info_fields), v2))do { constructor_elt _ce___ = {info_fields, build_constructor
(((contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1048, __FUNCTION__))->typed.type), v2)}; vec_safe_push (
(v1), _ce___); } while (0)
;
1049 info_fields = DECL_CHAIN (info_fields)(((contains_struct_check (((contains_struct_check ((info_fields
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1049, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1049, __FUNCTION__))->common.chain))
;
1050
1051 /* n_functions */
1052 n_funcs = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary)))((tree_check5 ((((tree_check ((((contains_struct_check ((fn_ary
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1052, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1052, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1052, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
;
1053 n_funcs = fold_build2 (PLUS_EXPR, TREE_TYPE (info_fields),fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1053, __FUNCTION__))->typed.type), n_funcs, global_trees
[TI_SIZE_ONE] )
1054 n_funcs, size_one_node)fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1053, __FUNCTION__))->typed.type), n_funcs, global_trees
[TI_SIZE_ONE] )
;
1055 CONSTRUCTOR_APPEND_ELT (v1, info_fields, n_funcs)do { constructor_elt _ce___ = {info_fields, n_funcs}; vec_safe_push
((v1), _ce___); } while (0)
;
1056 info_fields = DECL_CHAIN (info_fields)(((contains_struct_check (((contains_struct_check ((info_fields
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1056, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1056, __FUNCTION__))->common.chain))
;
1057
1058 /* functions */
1059 CONSTRUCTOR_APPEND_ELT (v1, info_fields,do { constructor_elt _ce___ = {info_fields, build1 (ADDR_EXPR
, ((contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1060, __FUNCTION__))->typed.type), fn_ary)}; vec_safe_push
((v1), _ce___); } while (0)
1060 build1 (ADDR_EXPR, TREE_TYPE (info_fields), fn_ary))do { constructor_elt _ce___ = {info_fields, build1 (ADDR_EXPR
, ((contains_struct_check ((info_fields), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1060, __FUNCTION__))->typed.type), fn_ary)}; vec_safe_push
((v1), _ce___); } while (0)
;
1061 info_fields = DECL_CHAIN (info_fields)(((contains_struct_check (((contains_struct_check ((info_fields
), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1061, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1061, __FUNCTION__))->common.chain))
;
1062
1063 gcc_assert (!info_fields)((void)(!(!info_fields) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1063, __FUNCTION__), 0 : 0))
;
1064 return build_constructor (info_type, v1);
1065}
1066
1067/* Generate the constructor function to call __gcov_init. */
1068
1069static void
1070build_init_ctor (tree gcov_info_type)
1071{
1072 tree ctor, stmt, init_fn;
1073
1074 /* Build a decl for __gcov_init. */
1075 init_fn = build_pointer_type (gcov_info_type);
1076 init_fn = build_function_type_list (void_type_nodeglobal_trees[TI_VOID_TYPE], init_fn, NULL__null);
1077 init_fn = build_decl (BUILTINS_LOCATION((location_t) 1), FUNCTION_DECL,
1078 get_identifier ("__gcov_init")(__builtin_constant_p ("__gcov_init") ? get_identifier_with_length
(("__gcov_init"), strlen ("__gcov_init")) : get_identifier (
"__gcov_init"))
, init_fn);
1079 TREE_PUBLIC (init_fn)((init_fn)->base.public_flag) = 1;
1080 DECL_EXTERNAL (init_fn)((contains_struct_check ((init_fn), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1080, __FUNCTION__))->decl_common.decl_flag_1)
= 1;
1081 DECL_ASSEMBLER_NAME (init_fn)decl_assembler_name (init_fn);
1082
1083 /* Generate a call to __gcov_init(&gcov_info). */
1084 ctor = NULL__null;
1085 stmt = build_fold_addr_expr (gcov_info_var)build_fold_addr_expr_loc (((location_t) 0), (gcov_info_var));
1086 stmt = build_call_expr (init_fn, 1, stmt);
1087 append_to_statement_list (stmt, &ctor);
1088
1089 /* Generate a constructor to run it. */
1090 int priority = SUPPORTS_INIT_PRIORITY1
1091 ? MAX_RESERVED_INIT_PRIORITY100: DEFAULT_INIT_PRIORITY65535;
1092 cgraph_build_static_cdtor ('I', ctor, priority);
1093}
1094
1095/* Generate the destructor function to call __gcov_exit. */
1096
1097static void
1098build_gcov_exit_decl (void)
1099{
1100 tree init_fn = build_function_type_list (void_type_nodeglobal_trees[TI_VOID_TYPE], NULL__null);
1101 init_fn = build_decl (BUILTINS_LOCATION((location_t) 1), FUNCTION_DECL,
1102 get_identifier ("__gcov_exit")(__builtin_constant_p ("__gcov_exit") ? get_identifier_with_length
(("__gcov_exit"), strlen ("__gcov_exit")) : get_identifier (
"__gcov_exit"))
, init_fn);
1103 TREE_PUBLIC (init_fn)((init_fn)->base.public_flag) = 1;
1104 DECL_EXTERNAL (init_fn)((contains_struct_check ((init_fn), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1104, __FUNCTION__))->decl_common.decl_flag_1)
= 1;
1105 DECL_ASSEMBLER_NAME (init_fn)decl_assembler_name (init_fn);
1106
1107 /* Generate a call to __gcov_exit (). */
1108 tree dtor = NULL__null;
1109 tree stmt = build_call_expr (init_fn, 0);
1110 append_to_statement_list (stmt, &dtor);
1111
1112 /* Generate a destructor to run it. */
1113 int priority = SUPPORTS_INIT_PRIORITY1
1114 ? MAX_RESERVED_INIT_PRIORITY100: DEFAULT_INIT_PRIORITY65535;
1115
1116 cgraph_build_static_cdtor ('D', dtor, priority);
1117}
1118
1119/* Generate the pointer to the gcov_info_var in a dedicated section. */
1120
1121static void
1122build_gcov_info_var_registration (tree gcov_info_type)
1123{
1124 tree var = build_decl (BUILTINS_LOCATION((location_t) 1),
1125 VAR_DECL, NULL_TREE(tree) __null,
1126 build_pointer_type (gcov_info_type));
1127 TREE_STATIC (var)((var)->base.static_flag) = 1;
1128 TREE_READONLY (var)((non_type_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1128, __FUNCTION__))->base.readonly_flag)
= 1;
1129 char name_buf[32];
1130 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 2)do { char *__p; (name_buf)[0] = '*'; (name_buf)[1] = '.'; __p
= stpcpy (&(name_buf)[2], "LPBX"); sprint_ul (__p, (unsigned
long) (2)); } while (0)
;
1131 DECL_NAME (var)((contains_struct_check ((var), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1131, __FUNCTION__))->decl_minimal.name)
= get_identifier (name_buf)(__builtin_constant_p (name_buf) ? get_identifier_with_length
((name_buf), strlen (name_buf)) : get_identifier (name_buf))
;
1132 get_section (profile_info_sectionglobal_options.x_profile_info_section, SECTION_UNNAMED, NULL__null);
1133 set_decl_section_name (var, profile_info_sectionglobal_options.x_profile_info_section);
1134 mark_decl_referenced (var);
1135 DECL_INITIAL (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1135, __FUNCTION__))->decl_common.initial)
= build_fold_addr_expr (gcov_info_var)build_fold_addr_expr_loc (((location_t) 0), (gcov_info_var));
1136 varpool_node::finalize_decl (var);
1137}
1138
1139/* Create the gcov_info types and object. Generate the constructor
1140 function to call __gcov_init. Does not generate the initializer
1141 for the object. Returns TRUE if coverage data is being emitted. */
1142
1143static bool
1144coverage_obj_init (void)
1145{
1146 tree gcov_info_type;
1147 unsigned n_counters = 0;
1148 unsigned ix;
1149 struct coverage_data *fn;
1150 struct coverage_data **fn_prev;
1151 char name_buf[32];
1152
1153 no_coverage = 1; /* Disable any further coverage. */
1154
1155 if (!prg_ctr_mask)
1156 return false;
1157
1158 if (symtab->dump_file)
1159 fprintf (symtab->dump_file, "Using data file %s\n", da_file_name);
1160
1161 /* Prune functions. */
1162 for (fn_prev = &functions_head; (fn = *fn_prev);)
1163 if (DECL_STRUCT_FUNCTION (fn->fn_decl)((tree_check ((fn->fn_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1163, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f)
)
1164 fn_prev = &fn->next;
1165 else
1166 /* The function is not being emitted, remove from list. */
1167 *fn_prev = fn->next;
1168
1169 if (functions_head == NULL__null)
1170 return false;
1171
1172 for (ix = 0; ix != GCOV_COUNTERS; ix++)
1173 if ((1u << ix) & prg_ctr_mask)
1174 n_counters++;
1175
1176 /* Build the info and fn_info types. These are mutually recursive. */
1177 gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1178 gcov_fn_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1179 build_fn_info_type (gcov_fn_info_type, n_counters, gcov_info_type);
1180 gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1181 gcov_fn_info_ptr_type = build_pointer_type
1182 (build_qualified_type (gcov_fn_info_type, TYPE_QUAL_CONST));
1183 build_info_type (gcov_info_type, gcov_fn_info_ptr_type);
1184
1185 /* Build the gcov info var, this is referred to in its own
1186 initializer. */
1187 gcov_info_var = build_decl (BUILTINS_LOCATION((location_t) 1),
1188 VAR_DECL, NULL_TREE(tree) __null, gcov_info_type);
1189 TREE_STATIC (gcov_info_var)((gcov_info_var)->base.static_flag) = 1;
1190 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0)do { char *__p; (name_buf)[0] = '*'; (name_buf)[1] = '.'; __p
= stpcpy (&(name_buf)[2], "LPBX"); sprint_ul (__p, (unsigned
long) (0)); } while (0)
;
1191 DECL_NAME (gcov_info_var)((contains_struct_check ((gcov_info_var), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1191, __FUNCTION__))->decl_minimal.name)
= get_identifier (name_buf)(__builtin_constant_p (name_buf) ? get_identifier_with_length
((name_buf), strlen (name_buf)) : get_identifier (name_buf))
;
1192
1193 if (profile_info_sectionglobal_options.x_profile_info_section)
1194 build_gcov_info_var_registration (gcov_info_type);
1195 else
1196 {
1197 build_init_ctor (gcov_info_type);
1198 build_gcov_exit_decl ();
1199 }
1200
1201 return true;
1202}
1203
1204/* Generate the coverage function info for FN and DATA. Append a
1205 pointer to that object to CTOR and return the appended CTOR. */
1206
1207static vec<constructor_elt, va_gc> *
1208coverage_obj_fn (vec<constructor_elt, va_gc> *ctor, tree fn,
1209 struct coverage_data const *data)
1210{
1211 tree init = build_fn_info (data, gcov_fn_info_type, gcov_info_var);
1212 tree var = build_var (fn, gcov_fn_info_type, -1);
1213
1214 DECL_INITIAL (var)((contains_struct_check ((var), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1214, __FUNCTION__))->decl_common.initial)
= init;
1215 varpool_node::finalize_decl (var);
1216
1217 CONSTRUCTOR_APPEND_ELT (ctor, NULL,do { constructor_elt _ce___ = {__null, build1 (ADDR_EXPR, gcov_fn_info_ptr_type
, var)}; vec_safe_push ((ctor), _ce___); } while (0)
1218 build1 (ADDR_EXPR, gcov_fn_info_ptr_type, var))do { constructor_elt _ce___ = {__null, build1 (ADDR_EXPR, gcov_fn_info_ptr_type
, var)}; vec_safe_push ((ctor), _ce___); } while (0)
;
1219 return ctor;
1220}
1221
1222/* Finalize the coverage data. Generates the array of pointers to
1223 function objects from CTOR. Generate the gcov_info initializer. */
1224
1225static void
1226coverage_obj_finish (vec<constructor_elt, va_gc> *ctor,
1227 unsigned object_checksum)
1228{
1229 unsigned n_functions = vec_safe_length (ctor);
1230 tree fn_info_ary_type = build_array_type
1231 (build_qualified_type (gcov_fn_info_ptr_type, TYPE_QUAL_CONST),
1232 build_index_type (size_int (n_functions - 1)size_int_kind (n_functions - 1, stk_sizetype)));
1233 tree fn_info_ary = build_decl (BUILTINS_LOCATION((location_t) 1), VAR_DECL, NULL_TREE(tree) __null,
1234 fn_info_ary_type);
1235 char name_buf[32];
1236
1237 TREE_STATIC (fn_info_ary)((fn_info_ary)->base.static_flag) = 1;
1238 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 1)do { char *__p; (name_buf)[0] = '*'; (name_buf)[1] = '.'; __p
= stpcpy (&(name_buf)[2], "LPBX"); sprint_ul (__p, (unsigned
long) (1)); } while (0)
;
7
Loop condition is false. Exiting loop
1239 DECL_NAME (fn_info_ary)((contains_struct_check ((fn_info_ary), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1239, __FUNCTION__))->decl_minimal.name)
= get_identifier (name_buf)(__builtin_constant_p (name_buf) ? get_identifier_with_length
((name_buf), strlen (name_buf)) : get_identifier (name_buf))
;
8
'?' condition is false
1240 DECL_INITIAL (fn_info_ary)((contains_struct_check ((fn_info_ary), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1240, __FUNCTION__))->decl_common.initial)
= build_constructor (fn_info_ary_type, ctor);
1241 varpool_node::finalize_decl (fn_info_ary);
1242
1243 DECL_INITIAL (gcov_info_var)((contains_struct_check ((gcov_info_var), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1243, __FUNCTION__))->decl_common.initial)
1244 = build_info (TREE_TYPE (gcov_info_var)((contains_struct_check ((gcov_info_var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/coverage.c"
, 1244, __FUNCTION__))->typed.type)
, fn_info_ary, object_checksum)
;
9
Calling 'build_info'
1245 varpool_node::finalize_decl (gcov_info_var);
1246}
1247
1248/* Perform file-level initialization. Read in data file, generate name
1249 of notes file. */
1250
1251void
1252coverage_init (const char *filename)
1253{
1254 const char *original_filename = filename;
1255 int original_len = strlen (original_filename);
1256#if HAVE_DOS_BASED_FILE_SYSTEM
1257 const char *separator = "\\";
1258#else
1259 const char *separator = "/";
1260#endif
1261 int len = strlen (filename);
1262 int prefix_len = 0;
1263
1264 /* Since coverage_init is invoked very early, before the pass
1265 manager, we need to set up the dumping explicitly. This is
1266 similar to the handling in finish_optimization_passes. */
1267 int profile_pass_num =
1268 g->get_passes ()->get_pass_profile ()->static_pass_number;
1269 g->get_dumps ()->dump_start (profile_pass_num, NULL__null);
1270
1271 if (!IS_ABSOLUTE_PATH (filename)(((((filename)[0]) == '/') || ((((filename)[0]) == '\\') &&
(0))) || ((filename)[0] && ((filename)[1] == ':') &&
(0)))
)
1272 {
1273 /* When a profile_data_prefix is provided, then mangle full path
1274 of filename in order to prevent file path clashing. */
1275 if (profile_data_prefixglobal_options.x_profile_data_prefix)
1276 {
1277 filename = concat (getpwd (), separator, filename, NULL__null);
1278 if (profile_prefix_pathglobal_options.x_profile_prefix_path)
1279 {
1280 if (startswith (filename, profile_prefix_pathglobal_options.x_profile_prefix_path))
1281 {
1282 filename += strlen (profile_prefix_pathglobal_options.x_profile_prefix_path);
1283 while (*filename == *separator)
1284 filename++;
1285 }
1286 else
1287 warning (0, "filename %qs does not start with profile "
1288 "prefix %qs", filename, profile_prefix_pathglobal_options.x_profile_prefix_path);
1289 }
1290 filename = mangle_path (filename);
1291 len = strlen (filename);
1292 }
1293 else
1294 profile_data_prefixglobal_options.x_profile_data_prefix = getpwd ();
1295 }
1296
1297 if (profile_data_prefixglobal_options.x_profile_data_prefix)
1298 prefix_len = strlen (profile_data_prefixglobal_options.x_profile_data_prefix);
1299
1300 /* Name of da file. */
1301 da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX)((char *) xmalloc (sizeof (char) * (len + strlen (".gcda") + prefix_len
+ 2)))
1302 + prefix_len + 2)((char *) xmalloc (sizeof (char) * (len + strlen (".gcda") + prefix_len
+ 2)))
;
1303
1304 if (profile_data_prefixglobal_options.x_profile_data_prefix)
1305 {
1306 memcpy (da_file_name, profile_data_prefixglobal_options.x_profile_data_prefix, prefix_len);
1307 da_file_name[prefix_len++] = *separator;
1308 }
1309 memcpy (da_file_name + prefix_len, filename, len);
1310 strcpy (da_file_name + prefix_len + len, GCOV_DATA_SUFFIX".gcda");
1311
1312 bbg_file_stamp = local_tick;
1313 if (flag_auto_profileglobal_options.x_flag_auto_profile)
1314 read_autofdo_file ();
1315 else if (flag_branch_probabilitiesglobal_options.x_flag_branch_probabilities)
1316 read_counts_file ();
1317
1318 /* Name of bbg file. */
1319 if (flag_test_coverageglobal_options.x_flag_test_coverage && !flag_compare_debugglobal_options.x_flag_compare_debug)
1320 {
1321 if (profile_note_locationglobal_options.x_profile_note_location)
1322 bbg_file_name = xstrdup (profile_note_locationglobal_options.x_profile_note_location);
1323 else
1324 {
1325 bbg_file_name = XNEWVEC (char, original_len + strlen (GCOV_NOTE_SUFFIX) + 1)((char *) xmalloc (sizeof (char) * (original_len + strlen (".gcno"
) + 1)))
;
1326 memcpy (bbg_file_name, original_filename, original_len);
1327 strcpy (bbg_file_name + original_len, GCOV_NOTE_SUFFIX".gcno");
1328 }
1329
1330 if (!gcov_open (bbg_file_name, -1))
1331 {
1332 error ("cannot open %s", bbg_file_name);
1333 bbg_file_name = NULL__null;
1334 }
1335 else
1336 {
1337 gcov_write_unsigned (GCOV_NOTE_MAGIC((gcov_unsigned_t)0x67636e6f));
1338 gcov_write_unsigned (GCOV_VERSION((gcov_unsigned_t)0x42323020));
1339 gcov_write_unsigned (bbg_file_stamp);
1340 /* Use an arbitrary checksum */
1341 gcov_write_unsigned (0);
1342 gcov_write_string (getpwd ());
1343
1344 /* Do not support has_unexecuted_blocks for Ada. */
1345 gcov_write_unsigned (strcmp (lang_hooks.name, "GNU Ada") != 0);
1346 }
1347 }
1348
1349 g->get_dumps ()->dump_finish (profile_pass_num);
1350}
1351
1352/* Performs file-level cleanup. Close notes file, generate coverage
1353 variables and constructor. */
1354
1355void
1356coverage_finish (void)
1357{
1358 if (bbg_file_name && gcov_close ())
1
Assuming 'bbg_file_name' is null
1359 unlink (bbg_file_name);
1360
1361 if (!flag_branch_probabilitiesglobal_options.x_flag_branch_probabilities && flag_test_coverageglobal_options.x_flag_test_coverage
2
Assuming field 'x_flag_branch_probabilities' is not equal to 0
1362 && (!local_tick || local_tick == (unsigned)-1))
1363 /* Only remove the da file, if we're emitting coverage code and
1364 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */
1365 unlink (da_file_name);
1366
1367 /* Global GCDA checksum that aggregates all functions. */
1368 unsigned object_checksum = 0;
1369
1370 if (coverage_obj_init ())
3
Assuming the condition is true
4
Taking true branch
1371 {
1372 vec<constructor_elt, va_gc> *fn_ctor = NULL__null;
1373 struct coverage_data *fn;
1374
1375 for (fn = functions_head; fn; fn = fn->next)
5
Loop condition is false. Execution continues on line 1384
1376 {
1377 fn_ctor = coverage_obj_fn (fn_ctor, fn->fn_decl, fn);
1378
1379 object_checksum = crc32_unsigned (object_checksum, fn->ident);
1380 object_checksum = crc32_unsigned (object_checksum,
1381 fn->lineno_checksum);
1382 object_checksum = crc32_unsigned (object_checksum, fn->cfg_checksum);
1383 }
1384 coverage_obj_finish (fn_ctor, object_checksum);
6
Calling 'coverage_obj_finish'
1385 }
1386
1387 XDELETEVEC (da_file_name)free ((void*) (da_file_name));
1388 da_file_name = NULL__null;
1389}
1390
1391#include "gt-coverage.h"

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h

1/* Vector API for GNU compiler.
2 Copyright (C) 2004-2021 Free Software Foundation, Inc.
3 Contributed by Nathan Sidwell <nathan@codesourcery.com>
4 Re-implemented in C++ by Diego Novillo <dnovillo@google.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22#ifndef GCC_VEC_H
23#define GCC_VEC_H
24
25/* Some gen* file have no ggc support as the header file gtype-desc.h is
26 missing. Provide these definitions in case ggc.h has not been included.
27 This is not a problem because any code that runs before gengtype is built
28 will never need to use GC vectors.*/
29
30extern void ggc_free (void *);
31extern size_t ggc_round_alloc_size (size_t requested_size);
32extern void *ggc_realloc (void *, size_t MEM_STAT_DECL);
33
34/* Templated vector type and associated interfaces.
35
36 The interface functions are typesafe and use inline functions,
37 sometimes backed by out-of-line generic functions. The vectors are
38 designed to interoperate with the GTY machinery.
39
40 There are both 'index' and 'iterate' accessors. The index accessor
41 is implemented by operator[]. The iterator returns a boolean
42 iteration condition and updates the iteration variable passed by
43 reference. Because the iterator will be inlined, the address-of
44 can be optimized away.
45
46 Each operation that increases the number of active elements is
47 available in 'quick' and 'safe' variants. The former presumes that
48 there is sufficient allocated space for the operation to succeed
49 (it dies if there is not). The latter will reallocate the
50 vector, if needed. Reallocation causes an exponential increase in
51 vector size. If you know you will be adding N elements, it would
52 be more efficient to use the reserve operation before adding the
53 elements with the 'quick' operation. This will ensure there are at
54 least as many elements as you ask for, it will exponentially
55 increase if there are too few spare slots. If you want reserve a
56 specific number of slots, but do not want the exponential increase
57 (for instance, you know this is the last allocation), use the
58 reserve_exact operation. You can also create a vector of a
59 specific size from the get go.
60
61 You should prefer the push and pop operations, as they append and
62 remove from the end of the vector. If you need to remove several
63 items in one go, use the truncate operation. The insert and remove
64 operations allow you to change elements in the middle of the
65 vector. There are two remove operations, one which preserves the
66 element ordering 'ordered_remove', and one which does not
67 'unordered_remove'. The latter function copies the end element
68 into the removed slot, rather than invoke a memmove operation. The
69 'lower_bound' function will determine where to place an item in the
70 array using insert that will maintain sorted order.
71
72 Vectors are template types with three arguments: the type of the
73 elements in the vector, the allocation strategy, and the physical
74 layout to use
75
76 Four allocation strategies are supported:
77
78 - Heap: allocation is done using malloc/free. This is the
79 default allocation strategy.
80
81 - GC: allocation is done using ggc_alloc/ggc_free.
82
83 - GC atomic: same as GC with the exception that the elements
84 themselves are assumed to be of an atomic type that does
85 not need to be garbage collected. This means that marking
86 routines do not need to traverse the array marking the
87 individual elements. This increases the performance of
88 GC activities.
89
90 Two physical layouts are supported:
91
92 - Embedded: The vector is structured using the trailing array
93 idiom. The last member of the structure is an array of size
94 1. When the vector is initially allocated, a single memory
95 block is created to hold the vector's control data and the
96 array of elements. These vectors cannot grow without
97 reallocation (see discussion on embeddable vectors below).
98
99 - Space efficient: The vector is structured as a pointer to an
100 embedded vector. This is the default layout. It means that
101 vectors occupy a single word of storage before initial
102 allocation. Vectors are allowed to grow (the internal
103 pointer is reallocated but the main vector instance does not
104 need to relocate).
105
106 The type, allocation and layout are specified when the vector is
107 declared.
108
109 If you need to directly manipulate a vector, then the 'address'
110 accessor will return the address of the start of the vector. Also
111 the 'space' predicate will tell you whether there is spare capacity
112 in the vector. You will not normally need to use these two functions.
113
114 Notes on the different layout strategies
115
116 * Embeddable vectors (vec<T, A, vl_embed>)
117
118 These vectors are suitable to be embedded in other data
119 structures so that they can be pre-allocated in a contiguous
120 memory block.
121
122 Embeddable vectors are implemented using the trailing array
123 idiom, thus they are not resizeable without changing the address
124 of the vector object itself. This means you cannot have
125 variables or fields of embeddable vector type -- always use a
126 pointer to a vector. The one exception is the final field of a
127 structure, which could be a vector type.
128
129 You will have to use the embedded_size & embedded_init calls to
130 create such objects, and they will not be resizeable (so the
131 'safe' allocation variants are not available).
132
133 Properties of embeddable vectors:
134
135 - The whole vector and control data are allocated in a single
136 contiguous block. It uses the trailing-vector idiom, so
137 allocation must reserve enough space for all the elements
138 in the vector plus its control data.
139 - The vector cannot be re-allocated.
140 - The vector cannot grow nor shrink.
141 - No indirections needed for access/manipulation.
142 - It requires 2 words of storage (prior to vector allocation).
143
144
145 * Space efficient vector (vec<T, A, vl_ptr>)
146
147 These vectors can grow dynamically and are allocated together
148 with their control data. They are suited to be included in data
149 structures. Prior to initial allocation, they only take a single
150 word of storage.
151
152 These vectors are implemented as a pointer to embeddable vectors.
153 The semantics allow for this pointer to be NULL to represent
154 empty vectors. This way, empty vectors occupy minimal space in
155 the structure containing them.
156
157 Properties:
158
159 - The whole vector and control data are allocated in a single
160 contiguous block.
161 - The whole vector may be re-allocated.
162 - Vector data may grow and shrink.
163 - Access and manipulation requires a pointer test and
164 indirection.
165 - It requires 1 word of storage (prior to vector allocation).
166
167 An example of their use would be,
168
169 struct my_struct {
170 // A space-efficient vector of tree pointers in GC memory.
171 vec<tree, va_gc, vl_ptr> v;
172 };
173
174 struct my_struct *s;
175
176 if (s->v.length ()) { we have some contents }
177 s->v.safe_push (decl); // append some decl onto the end
178 for (ix = 0; s->v.iterate (ix, &elt); ix++)
179 { do something with elt }
180*/
181
182/* Support function for statistics. */
183extern void dump_vec_loc_statistics (void);
184
185/* Hashtable mapping vec addresses to descriptors. */
186extern htab_t vec_mem_usage_hash;
187
188/* Control data for vectors. This contains the number of allocated
189 and used slots inside a vector. */
190
191struct vec_prefix
192{
193 /* FIXME - These fields should be private, but we need to cater to
194 compilers that have stricter notions of PODness for types. */
195
196 /* Memory allocation support routines in vec.c. */
197 void register_overhead (void *, size_t, size_t CXX_MEM_STAT_INFO);
198 void release_overhead (void *, size_t, size_t, bool CXX_MEM_STAT_INFO);
199 static unsigned calculate_allocation (vec_prefix *, unsigned, bool);
200 static unsigned calculate_allocation_1 (unsigned, unsigned);
201
202 /* Note that vec_prefix should be a base class for vec, but we use
203 offsetof() on vector fields of tree structures (e.g.,
204 tree_binfo::base_binfos), and offsetof only supports base types.
205
206 To compensate, we make vec_prefix a field inside vec and make
207 vec a friend class of vec_prefix so it can access its fields. */
208 template <typename, typename, typename> friend struct vec;
209
210 /* The allocator types also need access to our internals. */
211 friend struct va_gc;
212 friend struct va_gc_atomic;
213 friend struct va_heap;
214
215 unsigned m_alloc : 31;
216 unsigned m_using_auto_storage : 1;
217 unsigned m_num;
218};
219
220/* Calculate the number of slots to reserve a vector, making sure that
221 RESERVE slots are free. If EXACT grow exactly, otherwise grow
222 exponentially. PFX is the control data for the vector. */
223
224inline unsigned
225vec_prefix::calculate_allocation (vec_prefix *pfx, unsigned reserve,
226 bool exact)
227{
228 if (exact)
229 return (pfx ? pfx->m_num : 0) + reserve;
230 else if (!pfx)
231 return MAX (4, reserve)((4) > (reserve) ? (4) : (reserve));
232 return calculate_allocation_1 (pfx->m_alloc, pfx->m_num + reserve);
233}
234
235template<typename, typename, typename> struct vec;
236
237/* Valid vector layouts
238
239 vl_embed - Embeddable vector that uses the trailing array idiom.
240 vl_ptr - Space efficient vector that uses a pointer to an
241 embeddable vector. */
242struct vl_embed { };
243struct vl_ptr { };
244
245
246/* Types of supported allocations
247
248 va_heap - Allocation uses malloc/free.
249 va_gc - Allocation uses ggc_alloc.
250 va_gc_atomic - Same as GC, but individual elements of the array
251 do not need to be marked during collection. */
252
253/* Allocator type for heap vectors. */
254struct va_heap
255{
256 /* Heap vectors are frequently regular instances, so use the vl_ptr
257 layout for them. */
258 typedef vl_ptr default_layout;
259
260 template<typename T>
261 static void reserve (vec<T, va_heap, vl_embed> *&, unsigned, bool
262 CXX_MEM_STAT_INFO);
263
264 template<typename T>
265 static void release (vec<T, va_heap, vl_embed> *&);
266};
267
268
269/* Allocator for heap memory. Ensure there are at least RESERVE free
270 slots in V. If EXACT is true, grow exactly, else grow
271 exponentially. As a special case, if the vector had not been
272 allocated and RESERVE is 0, no vector will be created. */
273
274template<typename T>
275inline void
276va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact
277 MEM_STAT_DECL)
278{
279 size_t elt_size = sizeof (T);
280 unsigned alloc
281 = vec_prefix::calculate_allocation (v ? &v->m_vecpfx : 0, reserve, exact);
282 gcc_checking_assert (alloc)((void)(!(alloc) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 282, __FUNCTION__), 0 : 0))
;
283
284 if (GATHER_STATISTICS0 && v)
285 v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
286 v->allocated (), false);
287
288 size_t size = vec<T, va_heap, vl_embed>::embedded_size (alloc);
289 unsigned nelem = v ? v->length () : 0;
290 v = static_cast <vec<T, va_heap, vl_embed> *> (xrealloc (v, size));
291 v->embedded_init (alloc, nelem);
292
293 if (GATHER_STATISTICS0)
294 v->m_vecpfx.register_overhead (v, alloc, elt_size PASS_MEM_STAT);
295}
296
297
298#if GCC_VERSION(4 * 1000 + 2) >= 4007
299#pragma GCC diagnostic push
300#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
301#endif
302
303/* Free the heap space allocated for vector V. */
304
305template<typename T>
306void
307va_heap::release (vec<T, va_heap, vl_embed> *&v)
308{
309 size_t elt_size = sizeof (T);
310 if (v == NULL__null)
311 return;
312
313 if (GATHER_STATISTICS0)
314 v->m_vecpfx.release_overhead (v, elt_size * v->allocated (),
315 v->allocated (), true);
316 ::free (v);
317 v = NULL__null;
318}
319
320#if GCC_VERSION(4 * 1000 + 2) >= 4007
321#pragma GCC diagnostic pop
322#endif
323
324/* Allocator type for GC vectors. Notice that we need the structure
325 declaration even if GC is not enabled. */
326
327struct va_gc
328{
329 /* Use vl_embed as the default layout for GC vectors. Due to GTY
330 limitations, GC vectors must always be pointers, so it is more
331 efficient to use a pointer to the vl_embed layout, rather than
332 using a pointer to a pointer as would be the case with vl_ptr. */
333 typedef vl_embed default_layout;
334
335 template<typename T, typename A>
336 static void reserve (vec<T, A, vl_embed> *&, unsigned, bool
337 CXX_MEM_STAT_INFO);
338
339 template<typename T, typename A>
340 static void release (vec<T, A, vl_embed> *&v);
341};
342
343
344/* Free GC memory used by V and reset V to NULL. */
345
346template<typename T, typename A>
347inline void
348va_gc::release (vec<T, A, vl_embed> *&v)
349{
350 if (v)
351 ::ggc_free (v);
352 v = NULL__null;
353}
354
355
356/* Allocator for GC memory. Ensure there are at least RESERVE free
357 slots in V. If EXACT is true, grow exactly, else grow
358 exponentially. As a special case, if the vector had not been
359 allocated and RESERVE is 0, no vector will be created. */
360
361template<typename T, typename A>
362void
363va_gc::reserve (vec<T, A, vl_embed> *&v, unsigned reserve, bool exact
364 MEM_STAT_DECL)
365{
366 unsigned alloc
367 = vec_prefix::calculate_allocation (v
16.1
'v' is null
16.1
'v' is null
? &v->m_vecpfx : 0, reserve, exact);
17
'?' condition is false
368 if (!alloc)
18
Assuming 'alloc' is 0
19
Taking true branch
369 {
370 ::ggc_free (v);
371 v = NULL__null;
20
Null pointer value stored to 'v1'
372 return;
373 }
374
375 /* Calculate the amount of space we want. */
376 size_t size = vec<T, A, vl_embed>::embedded_size (alloc);
377
378 /* Ask the allocator how much space it will really give us. */
379 size = ::ggc_round_alloc_size (size);
380
381 /* Adjust the number of slots accordingly. */
382 size_t vec_offset = sizeof (vec_prefix);
383 size_t elt_size = sizeof (T);
384 alloc = (size - vec_offset) / elt_size;
385
386 /* And finally, recalculate the amount of space we ask for. */
387 size = vec_offset + alloc * elt_size;
388
389 unsigned nelem = v ? v->length () : 0;
390 v = static_cast <vec<T, A, vl_embed> *> (::ggc_realloc (v, size
391 PASS_MEM_STAT));
392 v->embedded_init (alloc, nelem);
393}
394
395
396/* Allocator type for GC vectors. This is for vectors of types
397 atomics w.r.t. collection, so allocation and deallocation is
398 completely inherited from va_gc. */
399struct va_gc_atomic : va_gc
400{
401};
402
403
404/* Generic vector template. Default values for A and L indicate the
405 most commonly used strategies.
406
407 FIXME - Ideally, they would all be vl_ptr to encourage using regular
408 instances for vectors, but the existing GTY machinery is limited
409 in that it can only deal with GC objects that are pointers
410 themselves.
411
412 This means that vector operations that need to deal with
413 potentially NULL pointers, must be provided as free
414 functions (see the vec_safe_* functions above). */
415template<typename T,
416 typename A = va_heap,
417 typename L = typename A::default_layout>
418struct GTY((user)) vec
419{
420};
421
422/* Allow C++11 range-based 'for' to work directly on vec<T>*. */
423template<typename T, typename A, typename L>
424T* begin (vec<T,A,L> *v) { return v ? v->begin () : nullptr; }
425template<typename T, typename A, typename L>
426T* end (vec<T,A,L> *v) { return v ? v->end () : nullptr; }
427template<typename T, typename A, typename L>
428const T* begin (const vec<T,A,L> *v) { return v ? v->begin () : nullptr; }
429template<typename T, typename A, typename L>
430const T* end (const vec<T,A,L> *v) { return v ? v->end () : nullptr; }
431
432/* Generic vec<> debug helpers.
433
434 These need to be instantiated for each vec<TYPE> used throughout
435 the compiler like this:
436
437 DEFINE_DEBUG_VEC (TYPE)
438
439 The reason we have a debug_helper() is because GDB can't
440 disambiguate a plain call to debug(some_vec), and it must be called
441 like debug<TYPE>(some_vec). */
442
443template<typename T>
444void
445debug_helper (vec<T> &ref)
446{
447 unsigned i;
448 for (i = 0; i < ref.length (); ++i)
449 {
450 fprintf (stderrstderr, "[%d] = ", i);
451 debug_slim (ref[i]);
452 fputc ('\n', stderrstderr);
453 }
454}
455
456/* We need a separate va_gc variant here because default template
457 argument for functions cannot be used in c++-98. Once this
458 restriction is removed, those variant should be folded with the
459 above debug_helper. */
460
461template<typename T>
462void
463debug_helper (vec<T, va_gc> &ref)
464{
465 unsigned i;
466 for (i = 0; i < ref.length (); ++i)
467 {
468 fprintf (stderrstderr, "[%d] = ", i);
469 debug_slim (ref[i]);
470 fputc ('\n', stderrstderr);
471 }
472}
473
474/* Macro to define debug(vec<T>) and debug(vec<T, va_gc>) helper
475 functions for a type T. */
476
477#define DEFINE_DEBUG_VEC(T)template void debug_helper (vec<T> &); template void
debug_helper (vec<T, va_gc> &); __attribute__ ((__used__
)) void debug (vec<T> &ref) { debug_helper <T>
(ref); } __attribute__ ((__used__)) void debug (vec<T>
*ptr) { if (ptr) debug (*ptr); else fprintf (stderr, "<nil>\n"
); } __attribute__ ((__used__)) void debug (vec<T, va_gc>
&ref) { debug_helper <T> (ref); } __attribute__ ((
__used__)) void debug (vec<T, va_gc> *ptr) { if (ptr) debug
(*ptr); else fprintf (stderr, "<nil>\n"); }
\
478 template void debug_helper (vec<T> &); \
479 template void debug_helper (vec<T, va_gc> &); \
480 /* Define the vec<T> debug functions. */ \
481 DEBUG_FUNCTION__attribute__ ((__used__)) void \
482 debug (vec<T> &ref) \
483 { \
484 debug_helper <T> (ref); \
485 } \
486 DEBUG_FUNCTION__attribute__ ((__used__)) void \
487 debug (vec<T> *ptr) \
488 { \
489 if (ptr) \
490 debug (*ptr); \
491 else \
492 fprintf (stderrstderr, "<nil>\n"); \
493 } \
494 /* Define the vec<T, va_gc> debug functions. */ \
495 DEBUG_FUNCTION__attribute__ ((__used__)) void \
496 debug (vec<T, va_gc> &ref) \
497 { \
498 debug_helper <T> (ref); \
499 } \
500 DEBUG_FUNCTION__attribute__ ((__used__)) void \
501 debug (vec<T, va_gc> *ptr) \
502 { \
503 if (ptr) \
504 debug (*ptr); \
505 else \
506 fprintf (stderrstderr, "<nil>\n"); \
507 }
508
509/* Default-construct N elements in DST. */
510
511template <typename T>
512inline void
513vec_default_construct (T *dst, unsigned n)
514{
515#ifdef BROKEN_VALUE_INITIALIZATION
516 /* Versions of GCC before 4.4 sometimes leave certain objects
517 uninitialized when value initialized, though if the type has
518 user defined default ctor, that ctor is invoked. As a workaround
519 perform clearing first and then the value initialization, which
520 fixes the case when value initialization doesn't initialize due to
521 the bugs and should initialize to all zeros, but still allows
522 vectors for types with user defined default ctor that initializes
523 some or all elements to non-zero. If T has no user defined
524 default ctor and some non-static data members have user defined
525 default ctors that initialize to non-zero the workaround will
526 still not work properly; in that case we just need to provide
527 user defined default ctor. */
528 memset (dst, '\0', sizeof (T) * n);
529#endif
530 for ( ; n; ++dst, --n)
531 ::new (static_cast<void*>(dst)) T ();
532}
533
534/* Copy-construct N elements in DST from *SRC. */
535
536template <typename T>
537inline void
538vec_copy_construct (T *dst, const T *src, unsigned n)
539{
540 for ( ; n; ++dst, ++src, --n)
541 ::new (static_cast<void*>(dst)) T (*src);
542}
543
544/* Type to provide zero-initialized values for vec<T, A, L>. This is
545 used to provide nil initializers for vec instances. Since vec must
546 be a trivially copyable type that can be copied by memcpy and zeroed
547 out by memset, it must have defaulted default and copy ctor and copy
548 assignment. To initialize a vec either use value initialization
549 (e.g., vec() or vec v{ };) or assign it the value vNULL. This isn't
550 needed for file-scope and function-local static vectors, which are
551 zero-initialized by default. */
552struct vnull { };
553constexpr vnull vNULL{ };
554
555
556/* Embeddable vector. These vectors are suitable to be embedded
557 in other data structures so that they can be pre-allocated in a
558 contiguous memory block.
559
560 Embeddable vectors are implemented using the trailing array idiom,
561 thus they are not resizeable without changing the address of the
562 vector object itself. This means you cannot have variables or
563 fields of embeddable vector type -- always use a pointer to a
564 vector. The one exception is the final field of a structure, which
565 could be a vector type.
566
567 You will have to use the embedded_size & embedded_init calls to
568 create such objects, and they will not be resizeable (so the 'safe'
569 allocation variants are not available).
570
571 Properties:
572
573 - The whole vector and control data are allocated in a single
574 contiguous block. It uses the trailing-vector idiom, so
575 allocation must reserve enough space for all the elements
576 in the vector plus its control data.
577 - The vector cannot be re-allocated.
578 - The vector cannot grow nor shrink.
579 - No indirections needed for access/manipulation.
580 - It requires 2 words of storage (prior to vector allocation). */
581
582template<typename T, typename A>
583struct GTY((user)) vec<T, A, vl_embed>
584{
585public:
586 unsigned allocated (void) const { return m_vecpfx.m_alloc; }
587 unsigned length (void) const { return m_vecpfx.m_num; }
588 bool is_empty (void) const { return m_vecpfx.m_num == 0; }
589 T *address (void) { return m_vecdata; }
590 const T *address (void) const { return m_vecdata; }
591 T *begin () { return address (); }
592 const T *begin () const { return address (); }
593 T *end () { return address () + length (); }
594 const T *end () const { return address () + length (); }
595 const T &operator[] (unsigned) const;
596 T &operator[] (unsigned);
597 T &last (void);
598 bool space (unsigned) const;
599 bool iterate (unsigned, T *) const;
600 bool iterate (unsigned, T **) const;
601 vec *copy (ALONE_CXX_MEM_STAT_INFO) const;
602 void splice (const vec &);
603 void splice (const vec *src);
604 T *quick_push (const T &);
605 T &pop (void);
606 void truncate (unsigned);
607 void quick_insert (unsigned, const T &);
608 void ordered_remove (unsigned);
609 void unordered_remove (unsigned);
610 void block_remove (unsigned, unsigned);
611 void qsort (int (*) (const void *, const void *))qsort (int (*) (const void *, const void *));
612 void sort (int (*) (const void *, const void *, void *), void *);
613 void stablesort (int (*) (const void *, const void *, void *), void *);
614 T *bsearch (const void *key, int (*compar)(const void *, const void *));
615 T *bsearch (const void *key,
616 int (*compar)(const void *, const void *, void *), void *);
617 unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
618 bool contains (const T &search) const;
619 static size_t embedded_size (unsigned);
620 void embedded_init (unsigned, unsigned = 0, unsigned = 0);
621 void quick_grow (unsigned len);
622 void quick_grow_cleared (unsigned len);
623
624 /* vec class can access our internal data and functions. */
625 template <typename, typename, typename> friend struct vec;
626
627 /* The allocator types also need access to our internals. */
628 friend struct va_gc;
629 friend struct va_gc_atomic;
630 friend struct va_heap;
631
632 /* FIXME - These fields should be private, but we need to cater to
633 compilers that have stricter notions of PODness for types. */
634 vec_prefix m_vecpfx;
635 T m_vecdata[1];
636};
637
638
639/* Convenience wrapper functions to use when dealing with pointers to
640 embedded vectors. Some functionality for these vectors must be
641 provided via free functions for these reasons:
642
643 1- The pointer may be NULL (e.g., before initial allocation).
644
645 2- When the vector needs to grow, it must be reallocated, so
646 the pointer will change its value.
647
648 Because of limitations with the current GC machinery, all vectors
649 in GC memory *must* be pointers. */
650
651
652/* If V contains no room for NELEMS elements, return false. Otherwise,
653 return true. */
654template<typename T, typename A>
655inline bool
656vec_safe_space (const vec<T, A, vl_embed> *v, unsigned nelems)
657{
658 return v ? v->space (nelems) : nelems == 0;
659}
660
661
662/* If V is NULL, return 0. Otherwise, return V->length(). */
663template<typename T, typename A>
664inline unsigned
665vec_safe_length (const vec<T, A, vl_embed> *v)
666{
667 return v ? v->length () : 0;
668}
669
670
671/* If V is NULL, return NULL. Otherwise, return V->address(). */
672template<typename T, typename A>
673inline T *
674vec_safe_address (vec<T, A, vl_embed> *v)
675{
676 return v ? v->address () : NULL__null;
677}
678
679
680/* If V is NULL, return true. Otherwise, return V->is_empty(). */
681template<typename T, typename A>
682inline bool
683vec_safe_is_empty (vec<T, A, vl_embed> *v)
684{
685 return v ? v->is_empty () : true;
686}
687
688/* If V does not have space for NELEMS elements, call
689 V->reserve(NELEMS, EXACT). */
690template<typename T, typename A>
691inline bool
692vec_safe_reserve (vec<T, A, vl_embed> *&v, unsigned nelems, bool exact = false
693 CXX_MEM_STAT_INFO)
694{
695 bool extend = nelems
13.1
'nelems' is 1
13.1
'nelems' is 1
? !vec_safe_space (v, nelems) : false;
14
'?' condition is true
696 if (extend
14.1
'extend' is true
14.1
'extend' is true
)
15
Taking true branch
697 A::reserve (v, nelems, exact PASS_MEM_STAT);
16
Calling 'va_gc::reserve'
21
Returning from 'va_gc::reserve'
698 return extend;
699}
700
701template<typename T, typename A>
702inline bool
703vec_safe_reserve_exact (vec<T, A, vl_embed> *&v, unsigned nelems
704 CXX_MEM_STAT_INFO)
705{
706 return vec_safe_reserve (v, nelems, true PASS_MEM_STAT);
707}
708
709
710/* Allocate GC memory for V with space for NELEMS slots. If NELEMS
711 is 0, V is initialized to NULL. */
712
713template<typename T, typename A>
714inline void
715vec_alloc (vec<T, A, vl_embed> *&v, unsigned nelems CXX_MEM_STAT_INFO)
716{
717 v = NULL__null;
718 vec_safe_reserve (v, nelems, false PASS_MEM_STAT);
719}
720
721
722/* Free the GC memory allocated by vector V and set it to NULL. */
723
724template<typename T, typename A>
725inline void
726vec_free (vec<T, A, vl_embed> *&v)
727{
728 A::release (v);
729}
730
731
732/* Grow V to length LEN. Allocate it, if necessary. */
733template<typename T, typename A>
734inline void
735vec_safe_grow (vec<T, A, vl_embed> *&v, unsigned len,
736 bool exact = false CXX_MEM_STAT_INFO)
737{
738 unsigned oldlen = vec_safe_length (v);
739 gcc_checking_assert (len >= oldlen)((void)(!(len >= oldlen) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 739, __FUNCTION__), 0 : 0))
;
740 vec_safe_reserve (v, len - oldlen, exact PASS_MEM_STAT);
741 v->quick_grow (len);
742}
743
744
745/* If V is NULL, allocate it. Call V->safe_grow_cleared(LEN). */
746template<typename T, typename A>
747inline void
748vec_safe_grow_cleared (vec<T, A, vl_embed> *&v, unsigned len,
749 bool exact = false CXX_MEM_STAT_INFO)
750{
751 unsigned oldlen = vec_safe_length (v);
752 vec_safe_grow (v, len, exact PASS_MEM_STAT);
753 vec_default_construct (v->address () + oldlen, len - oldlen);
754}
755
756
757/* Assume V is not NULL. */
758
759template<typename T>
760inline void
761vec_safe_grow_cleared (vec<T, va_heap, vl_ptr> *&v,
762 unsigned len, bool exact = false CXX_MEM_STAT_INFO)
763{
764 v->safe_grow_cleared (len, exact PASS_MEM_STAT);
765}
766
767/* If V does not have space for NELEMS elements, call
768 V->reserve(NELEMS, EXACT). */
769
770template<typename T>
771inline bool
772vec_safe_reserve (vec<T, va_heap, vl_ptr> *&v, unsigned nelems, bool exact = false
773 CXX_MEM_STAT_INFO)
774{
775 return v->reserve (nelems, exact);
776}
777
778
779/* If V is NULL return false, otherwise return V->iterate(IX, PTR). */
780template<typename T, typename A>
781inline bool
782vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T **ptr)
783{
784 if (v)
785 return v->iterate (ix, ptr);
786 else
787 {
788 *ptr = 0;
789 return false;
790 }
791}
792
793template<typename T, typename A>
794inline bool
795vec_safe_iterate (const vec<T, A, vl_embed> *v, unsigned ix, T *ptr)
796{
797 if (v)
798 return v->iterate (ix, ptr);
799 else
800 {
801 *ptr = 0;
802 return false;
803 }
804}
805
806
807/* If V has no room for one more element, reallocate it. Then call
808 V->quick_push(OBJ). */
809template<typename T, typename A>
810inline T *
811vec_safe_push (vec<T, A, vl_embed> *&v, const T &obj CXX_MEM_STAT_INFO)
812{
813 vec_safe_reserve (v, 1, false PASS_MEM_STAT);
13
Calling 'vec_safe_reserve<constructor_elt, va_gc>'
22
Returning from 'vec_safe_reserve<constructor_elt, va_gc>'
814 return v->quick_push (obj);
23
Called C++ object pointer is null
815}
816
817
818/* if V has no room for one more element, reallocate it. Then call
819 V->quick_insert(IX, OBJ). */
820template<typename T, typename A>
821inline void
822vec_safe_insert (vec<T, A, vl_embed> *&v, unsigned ix, const T &obj
823 CXX_MEM_STAT_INFO)
824{
825 vec_safe_reserve (v, 1, false PASS_MEM_STAT);
826 v->quick_insert (ix, obj);
827}
828
829
830/* If V is NULL, do nothing. Otherwise, call V->truncate(SIZE). */
831template<typename T, typename A>
832inline void
833vec_safe_truncate (vec<T, A, vl_embed> *v, unsigned size)
834{
835 if (v)
836 v->truncate (size);
837}
838
839
840/* If SRC is not NULL, return a pointer to a copy of it. */
841template<typename T, typename A>
842inline vec<T, A, vl_embed> *
843vec_safe_copy (vec<T, A, vl_embed> *src CXX_MEM_STAT_INFO)
844{
845 return src ? src->copy (ALONE_PASS_MEM_STAT) : NULL__null;
846}
847
848/* Copy the elements from SRC to the end of DST as if by memcpy.
849 Reallocate DST, if necessary. */
850template<typename T, typename A>
851inline void
852vec_safe_splice (vec<T, A, vl_embed> *&dst, const vec<T, A, vl_embed> *src
853 CXX_MEM_STAT_INFO)
854{
855 unsigned src_len = vec_safe_length (src);
856 if (src_len)
857 {
858 vec_safe_reserve_exact (dst, vec_safe_length (dst) + src_len
859 PASS_MEM_STAT);
860 dst->splice (*src);
861 }
862}
863
864/* Return true if SEARCH is an element of V. Note that this is O(N) in the
865 size of the vector and so should be used with care. */
866
867template<typename T, typename A>
868inline bool
869vec_safe_contains (vec<T, A, vl_embed> *v, const T &search)
870{
871 return v ? v->contains (search) : false;
872}
873
874/* Index into vector. Return the IX'th element. IX must be in the
875 domain of the vector. */
876
877template<typename T, typename A>
878inline const T &
879vec<T, A, vl_embed>::operator[] (unsigned ix) const
880{
881 gcc_checking_assert (ix < m_vecpfx.m_num)((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 881, __FUNCTION__), 0 : 0))
;
882 return m_vecdata[ix];
883}
884
885template<typename T, typename A>
886inline T &
887vec<T, A, vl_embed>::operator[] (unsigned ix)
888{
889 gcc_checking_assert (ix < m_vecpfx.m_num)((void)(!(ix < m_vecpfx.m_num) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 889, __FUNCTION__), 0 : 0))
;
890 return m_vecdata[ix];
891}
892
893
894/* Get the final element of the vector, which must not be empty. */
895
896template<typename T, typename A>
897inline T &
898vec<T, A, vl_embed>::last (void)
899{
900 gcc_checking_assert (m_vecpfx.m_num > 0)((void)(!(m_vecpfx.m_num > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 900, __FUNCTION__), 0 : 0))
;
901 return (*this)[m_vecpfx.m_num - 1];
902}
903
904
905/* If this vector has space for NELEMS additional entries, return
906 true. You usually only need to use this if you are doing your
907 own vector reallocation, for instance on an embedded vector. This
908 returns true in exactly the same circumstances that vec::reserve
909 will. */
910
911template<typename T, typename A>
912inline bool
913vec<T, A, vl_embed>::space (unsigned nelems) const
914{
915 return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems;
916}
917
918
919/* Return iteration condition and update PTR to point to the IX'th
920 element of this vector. Use this to iterate over the elements of a
921 vector as follows,
922
923 for (ix = 0; vec<T, A>::iterate (v, ix, &ptr); ix++)
924 continue; */
925
926template<typename T, typename A>
927inline bool
928vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const
929{
930 if (ix < m_vecpfx.m_num)
931 {
932 *ptr = m_vecdata[ix];
933 return true;
934 }
935 else
936 {
937 *ptr = 0;
938 return false;
939 }
940}
941
942
943/* Return iteration condition and update *PTR to point to the
944 IX'th element of this vector. Use this to iterate over the
945 elements of a vector as follows,
946
947 for (ix = 0; v->iterate (ix, &ptr); ix++)
948 continue;
949
950 This variant is for vectors of objects. */
951
952template<typename T, typename A>
953inline bool
954vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const
955{
956 if (ix < m_vecpfx.m_num)
957 {
958 *ptr = CONST_CAST (T *, &m_vecdata[ix])(const_cast<T *> ((&m_vecdata[ix])));
959 return true;
960 }
961 else
962 {
963 *ptr = 0;
964 return false;
965 }
966}
967
968
969/* Return a pointer to a copy of this vector. */
970
971template<typename T, typename A>
972inline vec<T, A, vl_embed> *
973vec<T, A, vl_embed>::copy (ALONE_MEM_STAT_DECLvoid) const
974{
975 vec<T, A, vl_embed> *new_vec = NULL__null;
976 unsigned len = length ();
977 if (len)
978 {
979 vec_alloc (new_vec, len PASS_MEM_STAT);
980 new_vec->embedded_init (len, len);
981 vec_copy_construct (new_vec->address (), m_vecdata, len);
982 }
983 return new_vec;
984}
985
986
987/* Copy the elements from SRC to the end of this vector as if by memcpy.
988 The vector must have sufficient headroom available. */
989
990template<typename T, typename A>
991inline void
992vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> &src)
993{
994 unsigned len = src.length ();
995 if (len)
996 {
997 gcc_checking_assert (space (len))((void)(!(space (len)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 997, __FUNCTION__), 0 : 0))
;
998 vec_copy_construct (end (), src.address (), len);
999 m_vecpfx.m_num += len;
1000 }
1001}
1002
1003template<typename T, typename A>
1004inline void
1005vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> *src)
1006{
1007 if (src)
1008 splice (*src);
1009}
1010
1011
1012/* Push OBJ (a new element) onto the end of the vector. There must be
1013 sufficient space in the vector. Return a pointer to the slot
1014 where OBJ was inserted. */
1015
1016template<typename T, typename A>
1017inline T *
1018vec<T, A, vl_embed>::quick_push (const T &obj)
1019{
1020 gcc_checking_assert (space (1))((void)(!(space (1)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1020, __FUNCTION__), 0 : 0))
;
1021 T *slot = &m_vecdata[m_vecpfx.m_num++];
1022 *slot = obj;
1023 return slot;
1024}
1025
1026
1027/* Pop and return the last element off the end of the vector. */
1028
1029template<typename T, typename A>
1030inline T &
1031vec<T, A, vl_embed>::pop (void)
1032{
1033 gcc_checking_assert (length () > 0)((void)(!(length () > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1033, __FUNCTION__), 0 : 0))
;
1034 return m_vecdata[--m_vecpfx.m_num];
1035}
1036
1037
1038/* Set the length of the vector to SIZE. The new length must be less
1039 than or equal to the current length. This is an O(1) operation. */
1040
1041template<typename T, typename A>
1042inline void
1043vec<T, A, vl_embed>::truncate (unsigned size)
1044{
1045 gcc_checking_assert (length () >= size)((void)(!(length () >= size) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1045, __FUNCTION__), 0 : 0))
;
1046 m_vecpfx.m_num = size;
1047}
1048
1049
1050/* Insert an element, OBJ, at the IXth position of this vector. There
1051 must be sufficient space. */
1052
1053template<typename T, typename A>
1054inline void
1055vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj)
1056{
1057 gcc_checking_assert (length () < allocated ())((void)(!(length () < allocated ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1057, __FUNCTION__), 0 : 0))
;
1058 gcc_checking_assert (ix <= length ())((void)(!(ix <= length ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1058, __FUNCTION__), 0 : 0))
;
1059 T *slot = &m_vecdata[ix];
1060 memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T));
1061 *slot = obj;
1062}
1063
1064
1065/* Remove an element from the IXth position of this vector. Ordering of
1066 remaining elements is preserved. This is an O(N) operation due to
1067 memmove. */
1068
1069template<typename T, typename A>
1070inline void
1071vec<T, A, vl_embed>::ordered_remove (unsigned ix)
1072{
1073 gcc_checking_assert (ix < length ())((void)(!(ix < length ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1073, __FUNCTION__), 0 : 0))
;
1074 T *slot = &m_vecdata[ix];
1075 memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T));
1076}
1077
1078
1079/* Remove elements in [START, END) from VEC for which COND holds. Ordering of
1080 remaining elements is preserved. This is an O(N) operation. */
1081
1082#define VEC_ORDERED_REMOVE_IF_FROM_TO(vec, read_index, write_index, \{ ((void)(!((end) <= (vec).length ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1083, __FUNCTION__), 0 : 0)); for (read_index = write_index
= (start); read_index < (end); ++read_index) { elem_ptr =
&(vec)[read_index]; bool remove_p = (cond); if (remove_p
) continue; if (read_index != write_index) (vec)[write_index]
= (vec)[read_index]; write_index++; } if (read_index - write_index
> 0) (vec).block_remove (write_index, read_index - write_index
); }
1083 elem_ptr, start, end, cond){ ((void)(!((end) <= (vec).length ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1083, __FUNCTION__), 0 : 0)); for (read_index = write_index
= (start); read_index < (end); ++read_index) { elem_ptr =
&(vec)[read_index]; bool remove_p = (cond); if (remove_p
) continue; if (read_index != write_index) (vec)[write_index]
= (vec)[read_index]; write_index++; } if (read_index - write_index
> 0) (vec).block_remove (write_index, read_index - write_index
); }
\
1084 { \
1085 gcc_assert ((end) <= (vec).length ())((void)(!((end) <= (vec).length ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1085, __FUNCTION__), 0 : 0))
; \
1086 for (read_index = write_index = (start); read_index < (end); \
1087 ++read_index) \
1088 { \
1089 elem_ptr = &(vec)[read_index]; \
1090 bool remove_p = (cond); \
1091 if (remove_p) \
1092 continue; \
1093 \
1094 if (read_index != write_index) \
1095 (vec)[write_index] = (vec)[read_index]; \
1096 \
1097 write_index++; \
1098 } \
1099 \
1100 if (read_index - write_index > 0) \
1101 (vec).block_remove (write_index, read_index - write_index); \
1102 }
1103
1104
1105/* Remove elements from VEC for which COND holds. Ordering of remaining
1106 elements is preserved. This is an O(N) operation. */
1107
1108#define VEC_ORDERED_REMOVE_IF(vec, read_index, write_index, elem_ptr, \{ ((void)(!(((vec).length ()) <= ((vec)).length ()) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1109, __FUNCTION__), 0 : 0)); for (read_index = write_index
= (0); read_index < ((vec).length ()); ++read_index) { elem_ptr
= &((vec))[read_index]; bool remove_p = ((cond)); if (remove_p
) continue; if (read_index != write_index) ((vec))[write_index
] = ((vec))[read_index]; write_index++; } if (read_index - write_index
> 0) ((vec)).block_remove (write_index, read_index - write_index
); }
1109 cond){ ((void)(!(((vec).length ()) <= ((vec)).length ()) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1109, __FUNCTION__), 0 : 0)); for (read_index = write_index
= (0); read_index < ((vec).length ()); ++read_index) { elem_ptr
= &((vec))[read_index]; bool remove_p = ((cond)); if (remove_p
) continue; if (read_index != write_index) ((vec))[write_index
] = ((vec))[read_index]; write_index++; } if (read_index - write_index
> 0) ((vec)).block_remove (write_index, read_index - write_index
); }
\
1110 VEC_ORDERED_REMOVE_IF_FROM_TO ((vec), read_index, write_index, \{ ((void)(!(((vec).length ()) <= ((vec)).length ()) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1111, __FUNCTION__), 0 : 0)); for (read_index = write_index
= (0); read_index < ((vec).length ()); ++read_index) { elem_ptr
= &((vec))[read_index]; bool remove_p = ((cond)); if (remove_p
) continue; if (read_index != write_index) ((vec))[write_index
] = ((vec))[read_index]; write_index++; } if (read_index - write_index
> 0) ((vec)).block_remove (write_index, read_index - write_index
); }
1111 elem_ptr, 0, (vec).length (), (cond)){ ((void)(!(((vec).length ()) <= ((vec)).length ()) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1111, __FUNCTION__), 0 : 0)); for (read_index = write_index
= (0); read_index < ((vec).length ()); ++read_index) { elem_ptr
= &((vec))[read_index]; bool remove_p = ((cond)); if (remove_p
) continue; if (read_index != write_index) ((vec))[write_index
] = ((vec))[read_index]; write_index++; } if (read_index - write_index
> 0) ((vec)).block_remove (write_index, read_index - write_index
); }
1112
1113/* Remove an element from the IXth position of this vector. Ordering of
1114 remaining elements is destroyed. This is an O(1) operation. */
1115
1116template<typename T, typename A>
1117inline void
1118vec<T, A, vl_embed>::unordered_remove (unsigned ix)
1119{
1120 gcc_checking_assert (ix < length ())((void)(!(ix < length ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1120, __FUNCTION__), 0 : 0))
;
1121 m_vecdata[ix] = m_vecdata[--m_vecpfx.m_num];
1122}
1123
1124
1125/* Remove LEN elements starting at the IXth. Ordering is retained.
1126 This is an O(N) operation due to memmove. */
1127
1128template<typename T, typename A>
1129inline void
1130vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len)
1131{
1132 gcc_checking_assert (ix + len <= length ())((void)(!(ix + len <= length ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1132, __FUNCTION__), 0 : 0))
;
1133 T *slot = &m_vecdata[ix];
1134 m_vecpfx.m_num -= len;
1135 memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T));
1136}
1137
1138
1139/* Sort the contents of this vector with qsort. CMP is the comparison
1140 function to pass to qsort. */
1141
1142template<typename T, typename A>
1143inline void
1144vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *))qsort (int (*cmp) (const void *, const void *))
1145{
1146 if (length () > 1)
1147 gcc_qsort (address (), length (), sizeof (T), cmp);
1148}
1149
1150/* Sort the contents of this vector with qsort. CMP is the comparison
1151 function to pass to qsort. */
1152
1153template<typename T, typename A>
1154inline void
1155vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *),
1156 void *data)
1157{
1158 if (length () > 1)
1159 gcc_sort_r (address (), length (), sizeof (T), cmp, data);
1160}
1161
1162/* Sort the contents of this vector with gcc_stablesort_r. CMP is the
1163 comparison function to pass to qsort. */
1164
1165template<typename T, typename A>
1166inline void
1167vec<T, A, vl_embed>::stablesort (int (*cmp) (const void *, const void *,
1168 void *), void *data)
1169{
1170 if (length () > 1)
1171 gcc_stablesort_r (address (), length (), sizeof (T), cmp, data);
1172}
1173
1174/* Search the contents of the sorted vector with a binary search.
1175 CMP is the comparison function to pass to bsearch. */
1176
1177template<typename T, typename A>
1178inline T *
1179vec<T, A, vl_embed>::bsearch (const void *key,
1180 int (*compar) (const void *, const void *))
1181{
1182 const void *base = this->address ();
1183 size_t nmemb = this->length ();
1184 size_t size = sizeof (T);
1185 /* The following is a copy of glibc stdlib-bsearch.h. */
1186 size_t l, u, idx;
1187 const void *p;
1188 int comparison;
1189
1190 l = 0;
1191 u = nmemb;
1192 while (l < u)
1193 {
1194 idx = (l + u) / 2;
1195 p = (const void *) (((const char *) base) + (idx * size));
1196 comparison = (*compar) (key, p);
1197 if (comparison < 0)
1198 u = idx;
1199 else if (comparison > 0)
1200 l = idx + 1;
1201 else
1202 return (T *)const_cast<void *>(p);
1203 }
1204
1205 return NULL__null;
1206}
1207
1208/* Search the contents of the sorted vector with a binary search.
1209 CMP is the comparison function to pass to bsearch. */
1210
1211template<typename T, typename A>
1212inline T *
1213vec<T, A, vl_embed>::bsearch (const void *key,
1214 int (*compar) (const void *, const void *,
1215 void *), void *data)
1216{
1217 const void *base = this->address ();
1218 size_t nmemb = this->length ();
1219 size_t size = sizeof (T);
1220 /* The following is a copy of glibc stdlib-bsearch.h. */
1221 size_t l, u, idx;
1222 const void *p;
1223 int comparison;
1224
1225 l = 0;
1226 u = nmemb;
1227 while (l < u)
1228 {
1229 idx = (l + u) / 2;
1230 p = (const void *) (((const char *) base) + (idx * size));
1231 comparison = (*compar) (key, p, data);
1232 if (comparison < 0)
1233 u = idx;
1234 else if (comparison > 0)
1235 l = idx + 1;
1236 else
1237 return (T *)const_cast<void *>(p);
1238 }
1239
1240 return NULL__null;
1241}
1242
1243/* Return true if SEARCH is an element of V. Note that this is O(N) in the
1244 size of the vector and so should be used with care. */
1245
1246template<typename T, typename A>
1247inline bool
1248vec<T, A, vl_embed>::contains (const T &search) const
1249{
1250 unsigned int len = length ();
1251 for (unsigned int i = 0; i < len; i++)
1252 if ((*this)[i] == search)
1253 return true;
1254
1255 return false;
1256}
1257
1258/* Find and return the first position in which OBJ could be inserted
1259 without changing the ordering of this vector. LESSTHAN is a
1260 function that returns true if the first argument is strictly less
1261 than the second. */
1262
1263template<typename T, typename A>
1264unsigned
1265vec<T, A, vl_embed>::lower_bound (T obj, bool (*lessthan)(const T &, const T &))
1266 const
1267{
1268 unsigned int len = length ();
1269 unsigned int half, middle;
1270 unsigned int first = 0;
1271 while (len > 0)
1272 {
1273 half = len / 2;
1274 middle = first;
1275 middle += half;
1276 T middle_elem = (*this)[middle];
1277 if (lessthan (middle_elem, obj))
1278 {
1279 first = middle;
1280 ++first;
1281 len = len - half - 1;
1282 }
1283 else
1284 len = half;
1285 }
1286 return first;
1287}
1288
1289
1290/* Return the number of bytes needed to embed an instance of an
1291 embeddable vec inside another data structure.
1292
1293 Use these methods to determine the required size and initialization
1294 of a vector V of type T embedded within another structure (as the
1295 final member):
1296
1297 size_t vec<T, A, vl_embed>::embedded_size (unsigned alloc);
1298 void v->embedded_init (unsigned alloc, unsigned num);
1299
1300 These allow the caller to perform the memory allocation. */
1301
1302template<typename T, typename A>
1303inline size_t
1304vec<T, A, vl_embed>::embedded_size (unsigned alloc)
1305{
1306 struct alignas (T) U { char data[sizeof (T)]; };
1307 typedef vec<U, A, vl_embed> vec_embedded;
1308 typedef typename std::conditional<std::is_standard_layout<T>::value,
1309 vec, vec_embedded>::type vec_stdlayout;
1310 static_assert (sizeof (vec_stdlayout) == sizeof (vec), "");
1311 static_assert (alignof (vec_stdlayout) == alignof (vec), "");
1312 return offsetof (vec_stdlayout, m_vecdata)__builtin_offsetof(vec_stdlayout, m_vecdata) + alloc * sizeof (T);
1313}
1314
1315
1316/* Initialize the vector to contain room for ALLOC elements and
1317 NUM active elements. */
1318
1319template<typename T, typename A>
1320inline void
1321vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut)
1322{
1323 m_vecpfx.m_alloc = alloc;
1324 m_vecpfx.m_using_auto_storage = aut;
1325 m_vecpfx.m_num = num;
1326}
1327
1328
1329/* Grow the vector to a specific length. LEN must be as long or longer than
1330 the current length. The new elements are uninitialized. */
1331
1332template<typename T, typename A>
1333inline void
1334vec<T, A, vl_embed>::quick_grow (unsigned len)
1335{
1336 gcc_checking_assert (length () <= len && len <= m_vecpfx.m_alloc)((void)(!(length () <= len && len <= m_vecpfx.m_alloc
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1336, __FUNCTION__), 0 : 0))
;
1337 m_vecpfx.m_num = len;
1338}
1339
1340
1341/* Grow the vector to a specific length. LEN must be as long or longer than
1342 the current length. The new elements are initialized to zero. */
1343
1344template<typename T, typename A>
1345inline void
1346vec<T, A, vl_embed>::quick_grow_cleared (unsigned len)
1347{
1348 unsigned oldlen = length ();
1349 size_t growby = len - oldlen;
1350 quick_grow (len);
1351 if (growby != 0)
1352 vec_default_construct (address () + oldlen, growby);
1353}
1354
1355/* Garbage collection support for vec<T, A, vl_embed>. */
1356
1357template<typename T>
1358void
1359gt_ggc_mx (vec<T, va_gc> *v)
1360{
1361 extern void gt_ggc_mx (T &);
1362 for (unsigned i = 0; i < v->length (); i++)
1363 gt_ggc_mx ((*v)[i]);
1364}
1365
1366template<typename T>
1367void
1368gt_ggc_mx (vec<T, va_gc_atomic, vl_embed> *v ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1369{
1370 /* Nothing to do. Vectors of atomic types wrt GC do not need to
1371 be traversed. */
1372}
1373
1374
1375/* PCH support for vec<T, A, vl_embed>. */
1376
1377template<typename T, typename A>
1378void
1379gt_pch_nx (vec<T, A, vl_embed> *v)
1380{
1381 extern void gt_pch_nx (T &);
1382 for (unsigned i = 0; i < v->length (); i++)
1383 gt_pch_nx ((*v)[i]);
1384}
1385
1386template<typename T, typename A>
1387void
1388gt_pch_nx (vec<T *, A, vl_embed> *v, gt_pointer_operator op, void *cookie)
1389{
1390 for (unsigned i = 0; i < v->length (); i++)
1391 op (&((*v)[i]), cookie);
1392}
1393
1394template<typename T, typename A>
1395void
1396gt_pch_nx (vec<T, A, vl_embed> *v, gt_pointer_operator op, void *cookie)
1397{
1398 extern void gt_pch_nx (T *, gt_pointer_operator, void *);
1399 for (unsigned i = 0; i < v->length (); i++)
1400 gt_pch_nx (&((*v)[i]), op, cookie);
1401}
1402
1403
1404/* Space efficient vector. These vectors can grow dynamically and are
1405 allocated together with their control data. They are suited to be
1406 included in data structures. Prior to initial allocation, they
1407 only take a single word of storage.
1408
1409 These vectors are implemented as a pointer to an embeddable vector.
1410 The semantics allow for this pointer to be NULL to represent empty
1411 vectors. This way, empty vectors occupy minimal space in the
1412 structure containing them.
1413
1414 Properties:
1415
1416 - The whole vector and control data are allocated in a single
1417 contiguous block.
1418 - The whole vector may be re-allocated.
1419 - Vector data may grow and shrink.
1420 - Access and manipulation requires a pointer test and
1421 indirection.
1422 - It requires 1 word of storage (prior to vector allocation).
1423
1424
1425 Limitations:
1426
1427 These vectors must be PODs because they are stored in unions.
1428 (http://en.wikipedia.org/wiki/Plain_old_data_structures).
1429 As long as we use C++03, we cannot have constructors nor
1430 destructors in classes that are stored in unions. */
1431
1432template<typename T, size_t N = 0>
1433class auto_vec;
1434
1435template<typename T>
1436struct vec<T, va_heap, vl_ptr>
1437{
1438public:
1439 /* Default ctors to ensure triviality. Use value-initialization
1440 (e.g., vec() or vec v{ };) or vNULL to create a zero-initialized
1441 instance. */
1442 vec () = default;
1443 vec (const vec &) = default;
1444 /* Initialization from the generic vNULL. */
1445 vec (vnull): m_vec () { }
1446 /* Same as default ctor: vec storage must be released manually. */
1447 ~vec () = default;
1448
1449 /* Defaulted same as copy ctor. */
1450 vec& operator= (const vec &) = default;
1451
1452 /* Prevent implicit conversion from auto_vec. Use auto_vec::to_vec()
1453 instead. */
1454 template <size_t N>
1455 vec (auto_vec<T, N> &) = delete;
1456
1457 template <size_t N>
1458 void operator= (auto_vec<T, N> &) = delete;
1459
1460 /* Memory allocation and deallocation for the embedded vector.
1461 Needed because we cannot have proper ctors/dtors defined. */
1462 void create (unsigned nelems CXX_MEM_STAT_INFO);
1463 void release (void);
1464
1465 /* Vector operations. */
1466 bool exists (void) const
1467 { return m_vec != NULL__null; }
1468
1469 bool is_empty (void) const
1470 { return m_vec ? m_vec->is_empty () : true; }
1471
1472 unsigned length (void) const
1473 { return m_vec ? m_vec->length () : 0; }
1474
1475 T *address (void)
1476 { return m_vec ? m_vec->m_vecdata : NULL__null; }
1477
1478 const T *address (void) const
1479 { return m_vec ? m_vec->m_vecdata : NULL__null; }
1480
1481 T *begin () { return address (); }
1482 const T *begin () const { return address (); }
1483 T *end () { return begin () + length (); }
1484 const T *end () const { return begin () + length (); }
1485 const T &operator[] (unsigned ix) const
1486 { return (*m_vec)[ix]; }
1487
1488 bool operator!=(const vec &other) const
1489 { return !(*this == other); }
1490
1491 bool operator==(const vec &other) const
1492 { return address () == other.address (); }
1493
1494 T &operator[] (unsigned ix)
1495 { return (*m_vec)[ix]; }
1496
1497 T &last (void)
1498 { return m_vec->last (); }
1499
1500 bool space (int nelems) const
1501 { return m_vec ? m_vec->space (nelems) : nelems == 0; }
1502
1503 bool iterate (unsigned ix, T *p) const;
1504 bool iterate (unsigned ix, T **p) const;
1505 vec copy (ALONE_CXX_MEM_STAT_INFO) const;
1506 bool reserve (unsigned, bool = false CXX_MEM_STAT_INFO);
1507 bool reserve_exact (unsigned CXX_MEM_STAT_INFO);
1508 void splice (const vec &);
1509 void safe_splice (const vec & CXX_MEM_STAT_INFO);
1510 T *quick_push (const T &);
1511 T *safe_push (const T &CXX_MEM_STAT_INFO);
1512 T &pop (void);
1513 void truncate (unsigned);
1514 void safe_grow (unsigned, bool = false CXX_MEM_STAT_INFO);
1515 void safe_grow_cleared (unsigned, bool = false CXX_MEM_STAT_INFO);
1516 void quick_grow (unsigned);
1517 void quick_grow_cleared (unsigned);
1518 void quick_insert (unsigned, const T &);
1519 void safe_insert (unsigned, const T & CXX_MEM_STAT_INFO);
1520 void ordered_remove (unsigned);
1521 void unordered_remove (unsigned);
1522 void block_remove (unsigned, unsigned);
1523 void qsort (int (*) (const void *, const void *))qsort (int (*) (const void *, const void *));
1524 void sort (int (*) (const void *, const void *, void *), void *);
1525 void stablesort (int (*) (const void *, const void *, void *), void *);
1526 T *bsearch (const void *key, int (*compar)(const void *, const void *));
1527 T *bsearch (const void *key,
1528 int (*compar)(const void *, const void *, void *), void *);
1529 unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
1530 bool contains (const T &search) const;
1531 void reverse (void);
1532
1533 bool using_auto_storage () const;
1534
1535 /* FIXME - This field should be private, but we need to cater to
1536 compilers that have stricter notions of PODness for types. */
1537 vec<T, va_heap, vl_embed> *m_vec;
1538};
1539
1540
1541/* auto_vec is a subclass of vec that automatically manages creating and
1542 releasing the internal vector. If N is non zero then it has N elements of
1543 internal storage. The default is no internal storage, and you probably only
1544 want to ask for internal storage for vectors on the stack because if the
1545 size of the vector is larger than the internal storage that space is wasted.
1546 */
1547template<typename T, size_t N /* = 0 */>
1548class auto_vec : public vec<T, va_heap>
1549{
1550public:
1551 auto_vec ()
1552 {
1553 m_auto.embedded_init (MAX (N, 2)((N) > (2) ? (N) : (2)), 0, 1);
1554 this->m_vec = &m_auto;
1555 }
1556
1557 auto_vec (size_t s CXX_MEM_STAT_INFO)
1558 {
1559 if (s > N)
1560 {
1561 this->create (s PASS_MEM_STAT);
1562 return;
1563 }
1564
1565 m_auto.embedded_init (MAX (N, 2)((N) > (2) ? (N) : (2)), 0, 1);
1566 this->m_vec = &m_auto;
1567 }
1568
1569 ~auto_vec ()
1570 {
1571 this->release ();
1572 }
1573
1574 /* Explicitly convert to the base class. There is no conversion
1575 from a const auto_vec because a copy of the returned vec can
1576 be used to modify *THIS.
1577 This is a legacy function not to be used in new code. */
1578 vec<T, va_heap> to_vec_legacy () {
1579 return *static_cast<vec<T, va_heap> *>(this);
1580 }
1581
1582private:
1583 vec<T, va_heap, vl_embed> m_auto;
1584 T m_data[MAX (N - 1, 1)((N - 1) > (1) ? (N - 1) : (1))];
1585};
1586
1587/* auto_vec is a sub class of vec whose storage is released when it is
1588 destroyed. */
1589template<typename T>
1590class auto_vec<T, 0> : public vec<T, va_heap>
1591{
1592public:
1593 auto_vec () { this->m_vec = NULL__null; }
1594 auto_vec (size_t n CXX_MEM_STAT_INFO) { this->create (n PASS_MEM_STAT); }
1595 ~auto_vec () { this->release (); }
1596
1597 auto_vec (vec<T, va_heap>&& r)
1598 {
1599 gcc_assert (!r.using_auto_storage ())((void)(!(!r.using_auto_storage ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1599, __FUNCTION__), 0 : 0))
;
1600 this->m_vec = r.m_vec;
1601 r.m_vec = NULL__null;
1602 }
1603
1604 auto_vec (auto_vec<T> &&r)
1605 {
1606 gcc_assert (!r.using_auto_storage ())((void)(!(!r.using_auto_storage ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1606, __FUNCTION__), 0 : 0))
;
1607 this->m_vec = r.m_vec;
1608 r.m_vec = NULL__null;
1609 }
1610
1611 auto_vec& operator= (vec<T, va_heap>&& r)
1612 {
1613 if (this == &r)
1614 return *this;
1615
1616 gcc_assert (!r.using_auto_storage ())((void)(!(!r.using_auto_storage ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1616, __FUNCTION__), 0 : 0))
;
1617 this->release ();
1618 this->m_vec = r.m_vec;
1619 r.m_vec = NULL__null;
1620 return *this;
1621 }
1622
1623 auto_vec& operator= (auto_vec<T> &&r)
1624 {
1625 if (this == &r)
1626 return *this;
1627
1628 gcc_assert (!r.using_auto_storage ())((void)(!(!r.using_auto_storage ()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1628, __FUNCTION__), 0 : 0))
;
1629 this->release ();
1630 this->m_vec = r.m_vec;
1631 r.m_vec = NULL__null;
1632 return *this;
1633 }
1634
1635 /* Explicitly convert to the base class. There is no conversion
1636 from a const auto_vec because a copy of the returned vec can
1637 be used to modify *THIS.
1638 This is a legacy function not to be used in new code. */
1639 vec<T, va_heap> to_vec_legacy () {
1640 return *static_cast<vec<T, va_heap> *>(this);
1641 }
1642
1643 // You probably don't want to copy a vector, so these are deleted to prevent
1644 // unintentional use. If you really need a copy of the vectors contents you
1645 // can use copy ().
1646 auto_vec(const auto_vec &) = delete;
1647 auto_vec &operator= (const auto_vec &) = delete;
1648};
1649
1650
1651/* Allocate heap memory for pointer V and create the internal vector
1652 with space for NELEMS elements. If NELEMS is 0, the internal
1653 vector is initialized to empty. */
1654
1655template<typename T>
1656inline void
1657vec_alloc (vec<T> *&v, unsigned nelems CXX_MEM_STAT_INFO)
1658{
1659 v = new vec<T>;
1660 v->create (nelems PASS_MEM_STAT);
1661}
1662
1663
1664/* A subclass of auto_vec <char *> that frees all of its elements on
1665 deletion. */
1666
1667class auto_string_vec : public auto_vec <char *>
1668{
1669 public:
1670 ~auto_string_vec ();
1671};
1672
1673/* A subclass of auto_vec <T *> that deletes all of its elements on
1674 destruction.
1675
1676 This is a crude way for a vec to "own" the objects it points to
1677 and clean up automatically.
1678
1679 For example, no attempt is made to delete elements when an item
1680 within the vec is overwritten.
1681
1682 We can't rely on gnu::unique_ptr within a container,
1683 since we can't rely on move semantics in C++98. */
1684
1685template <typename T>
1686class auto_delete_vec : public auto_vec <T *>
1687{
1688 public:
1689 auto_delete_vec () {}
1690 auto_delete_vec (size_t s) : auto_vec <T *> (s) {}
1691
1692 ~auto_delete_vec ();
1693
1694private:
1695 DISABLE_COPY_AND_ASSIGN(auto_delete_vec)auto_delete_vec (const auto_delete_vec&) = delete; void operator
= (const auto_delete_vec &) = delete
;
1696};
1697
1698/* Conditionally allocate heap memory for VEC and its internal vector. */
1699
1700template<typename T>
1701inline void
1702vec_check_alloc (vec<T, va_heap> *&vec, unsigned nelems CXX_MEM_STAT_INFO)
1703{
1704 if (!vec)
1705 vec_alloc (vec, nelems PASS_MEM_STAT);
1706}
1707
1708
1709/* Free the heap memory allocated by vector V and set it to NULL. */
1710
1711template<typename T>
1712inline void
1713vec_free (vec<T> *&v)
1714{
1715 if (v == NULL__null)
1716 return;
1717
1718 v->release ();
1719 delete v;
1720 v = NULL__null;
1721}
1722
1723
1724/* Return iteration condition and update PTR to point to the IX'th
1725 element of this vector. Use this to iterate over the elements of a
1726 vector as follows,
1727
1728 for (ix = 0; v.iterate (ix, &ptr); ix++)
1729 continue; */
1730
1731template<typename T>
1732inline bool
1733vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T *ptr) const
1734{
1735 if (m_vec)
1736 return m_vec->iterate (ix, ptr);
1737 else
1738 {
1739 *ptr = 0;
1740 return false;
1741 }
1742}
1743
1744
1745/* Return iteration condition and update *PTR to point to the
1746 IX'th element of this vector. Use this to iterate over the
1747 elements of a vector as follows,
1748
1749 for (ix = 0; v->iterate (ix, &ptr); ix++)
1750 continue;
1751
1752 This variant is for vectors of objects. */
1753
1754template<typename T>
1755inline bool
1756vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T **ptr) const
1757{
1758 if (m_vec)
1759 return m_vec->iterate (ix, ptr);
1760 else
1761 {
1762 *ptr = 0;
1763 return false;
1764 }
1765}
1766
1767
1768/* Convenience macro for forward iteration. */
1769#define FOR_EACH_VEC_ELT(V, I, P)for (I = 0; (V).iterate ((I), &(P)); ++(I)) \
1770 for (I = 0; (V).iterate ((I), &(P)); ++(I))
1771
1772#define FOR_EACH_VEC_SAFE_ELT(V, I, P)for (I = 0; vec_safe_iterate ((V), (I), &(P)); ++(I)) \
1773 for (I = 0; vec_safe_iterate ((V), (I), &(P)); ++(I))
1774
1775/* Likewise, but start from FROM rather than 0. */
1776#define FOR_EACH_VEC_ELT_FROM(V, I, P, FROM)for (I = (FROM); (V).iterate ((I), &(P)); ++(I)) \
1777 for (I = (FROM); (V).iterate ((I), &(P)); ++(I))
1778
1779/* Convenience macro for reverse iteration. */
1780#define FOR_EACH_VEC_ELT_REVERSE(V, I, P)for (I = (V).length () - 1; (V).iterate ((I), &(P)); (I)--
)
\
1781 for (I = (V).length () - 1; \
1782 (V).iterate ((I), &(P)); \
1783 (I)--)
1784
1785#define FOR_EACH_VEC_SAFE_ELT_REVERSE(V, I, P)for (I = vec_safe_length (V) - 1; vec_safe_iterate ((V), (I),
&(P)); (I)--)
\
1786 for (I = vec_safe_length (V) - 1; \
1787 vec_safe_iterate ((V), (I), &(P)); \
1788 (I)--)
1789
1790/* auto_string_vec's dtor, freeing all contained strings, automatically
1791 chaining up to ~auto_vec <char *>, which frees the internal buffer. */
1792
1793inline
1794auto_string_vec::~auto_string_vec ()
1795{
1796 int i;
1797 char *str;
1798 FOR_EACH_VEC_ELT (*this, i, str)for (i = 0; (*this).iterate ((i), &(str)); ++(i))
1799 free (str);
1800}
1801
1802/* auto_delete_vec's dtor, deleting all contained items, automatically
1803 chaining up to ~auto_vec <T*>, which frees the internal buffer. */
1804
1805template <typename T>
1806inline
1807auto_delete_vec<T>::~auto_delete_vec ()
1808{
1809 int i;
1810 T *item;
1811 FOR_EACH_VEC_ELT (*this, i, item)for (i = 0; (*this).iterate ((i), &(item)); ++(i))
1812 delete item;
1813}
1814
1815
1816/* Return a copy of this vector. */
1817
1818template<typename T>
1819inline vec<T, va_heap, vl_ptr>
1820vec<T, va_heap, vl_ptr>::copy (ALONE_MEM_STAT_DECLvoid) const
1821{
1822 vec<T, va_heap, vl_ptr> new_vec{ };
1823 if (length ())
1824 new_vec.m_vec = m_vec->copy (ALONE_PASS_MEM_STAT);
1825 return new_vec;
1826}
1827
1828
1829/* Ensure that the vector has at least RESERVE slots available (if
1830 EXACT is false), or exactly RESERVE slots available (if EXACT is
1831 true).
1832
1833 This may create additional headroom if EXACT is false.
1834
1835 Note that this can cause the embedded vector to be reallocated.
1836 Returns true iff reallocation actually occurred. */
1837
1838template<typename T>
1839inline bool
1840vec<T, va_heap, vl_ptr>::reserve (unsigned nelems, bool exact MEM_STAT_DECL)
1841{
1842 if (space (nelems))
1843 return false;
1844
1845 /* For now play a game with va_heap::reserve to hide our auto storage if any,
1846 this is necessary because it doesn't have enough information to know the
1847 embedded vector is in auto storage, and so should not be freed. */
1848 vec<T, va_heap, vl_embed> *oldvec = m_vec;
1849 unsigned int oldsize = 0;
1850 bool handle_auto_vec = m_vec && using_auto_storage ();
1851 if (handle_auto_vec)
1852 {
1853 m_vec = NULL__null;
1854 oldsize = oldvec->length ();
1855 nelems += oldsize;
1856 }
1857
1858 va_heap::reserve (m_vec, nelems, exact PASS_MEM_STAT);
1859 if (handle_auto_vec)
1860 {
1861 vec_copy_construct (m_vec->address (), oldvec->address (), oldsize);
1862 m_vec->m_vecpfx.m_num = oldsize;
1863 }
1864
1865 return true;
1866}
1867
1868
1869/* Ensure that this vector has exactly NELEMS slots available. This
1870 will not create additional headroom. Note this can cause the
1871 embedded vector to be reallocated. Returns true iff reallocation
1872 actually occurred. */
1873
1874template<typename T>
1875inline bool
1876vec<T, va_heap, vl_ptr>::reserve_exact (unsigned nelems MEM_STAT_DECL)
1877{
1878 return reserve (nelems, true PASS_MEM_STAT);
1879}
1880
1881
1882/* Create the internal vector and reserve NELEMS for it. This is
1883 exactly like vec::reserve, but the internal vector is
1884 unconditionally allocated from scratch. The old one, if it
1885 existed, is lost. */
1886
1887template<typename T>
1888inline void
1889vec<T, va_heap, vl_ptr>::create (unsigned nelems MEM_STAT_DECL)
1890{
1891 m_vec = NULL__null;
1892 if (nelems > 0)
1893 reserve_exact (nelems PASS_MEM_STAT);
1894}
1895
1896
1897/* Free the memory occupied by the embedded vector. */
1898
1899template<typename T>
1900inline void
1901vec<T, va_heap, vl_ptr>::release (void)
1902{
1903 if (!m_vec)
1904 return;
1905
1906 if (using_auto_storage ())
1907 {
1908 m_vec->m_vecpfx.m_num = 0;
1909 return;
1910 }
1911
1912 va_heap::release (m_vec);
1913}
1914
1915/* Copy the elements from SRC to the end of this vector as if by memcpy.
1916 SRC and this vector must be allocated with the same memory
1917 allocation mechanism. This vector is assumed to have sufficient
1918 headroom available. */
1919
1920template<typename T>
1921inline void
1922vec<T, va_heap, vl_ptr>::splice (const vec<T, va_heap, vl_ptr> &src)
1923{
1924 if (src.length ())
1925 m_vec->splice (*(src.m_vec));
1926}
1927
1928
1929/* Copy the elements in SRC to the end of this vector as if by memcpy.
1930 SRC and this vector must be allocated with the same mechanism.
1931 If there is not enough headroom in this vector, it will be reallocated
1932 as needed. */
1933
1934template<typename T>
1935inline void
1936vec<T, va_heap, vl_ptr>::safe_splice (const vec<T, va_heap, vl_ptr> &src
1937 MEM_STAT_DECL)
1938{
1939 if (src.length ())
1940 {
1941 reserve_exact (src.length ());
1942 splice (src);
1943 }
1944}
1945
1946
1947/* Push OBJ (a new element) onto the end of the vector. There must be
1948 sufficient space in the vector. Return a pointer to the slot
1949 where OBJ was inserted. */
1950
1951template<typename T>
1952inline T *
1953vec<T, va_heap, vl_ptr>::quick_push (const T &obj)
1954{
1955 return m_vec->quick_push (obj);
1956}
1957
1958
1959/* Push a new element OBJ onto the end of this vector. Reallocates
1960 the embedded vector, if needed. Return a pointer to the slot where
1961 OBJ was inserted. */
1962
1963template<typename T>
1964inline T *
1965vec<T, va_heap, vl_ptr>::safe_push (const T &obj MEM_STAT_DECL)
1966{
1967 reserve (1, false PASS_MEM_STAT);
1968 return quick_push (obj);
1969}
1970
1971
1972/* Pop and return the last element off the end of the vector. */
1973
1974template<typename T>
1975inline T &
1976vec<T, va_heap, vl_ptr>::pop (void)
1977{
1978 return m_vec->pop ();
1979}
1980
1981
1982/* Set the length of the vector to LEN. The new length must be less
1983 than or equal to the current length. This is an O(1) operation. */
1984
1985template<typename T>
1986inline void
1987vec<T, va_heap, vl_ptr>::truncate (unsigned size)
1988{
1989 if (m_vec)
1990 m_vec->truncate (size);
1991 else
1992 gcc_checking_assert (size == 0)((void)(!(size == 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 1992, __FUNCTION__), 0 : 0))
;
1993}
1994
1995
1996/* Grow the vector to a specific length. LEN must be as long or
1997 longer than the current length. The new elements are
1998 uninitialized. Reallocate the internal vector, if needed. */
1999
2000template<typename T>
2001inline void
2002vec<T, va_heap, vl_ptr>::safe_grow (unsigned len, bool exact MEM_STAT_DECL)
2003{
2004 unsigned oldlen = length ();
2005 gcc_checking_assert (oldlen <= len)((void)(!(oldlen <= len) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2005, __FUNCTION__), 0 : 0))
;
2006 reserve (len - oldlen, exact PASS_MEM_STAT);
2007 if (m_vec)
2008 m_vec->quick_grow (len);
2009 else
2010 gcc_checking_assert (len == 0)((void)(!(len == 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2010, __FUNCTION__), 0 : 0))
;
2011}
2012
2013
2014/* Grow the embedded vector to a specific length. LEN must be as
2015 long or longer than the current length. The new elements are
2016 initialized to zero. Reallocate the internal vector, if needed. */
2017
2018template<typename T>
2019inline void
2020vec<T, va_heap, vl_ptr>::safe_grow_cleared (unsigned len, bool exact
2021 MEM_STAT_DECL)
2022{
2023 unsigned oldlen = length ();
2024 size_t growby = len - oldlen;
2025 safe_grow (len, exact PASS_MEM_STAT);
2026 if (growby != 0)
2027 vec_default_construct (address () + oldlen, growby);
2028}
2029
2030
2031/* Same as vec::safe_grow but without reallocation of the internal vector.
2032 If the vector cannot be extended, a runtime assertion will be triggered. */
2033
2034template<typename T>
2035inline void
2036vec<T, va_heap, vl_ptr>::quick_grow (unsigned len)
2037{
2038 gcc_checking_assert (m_vec)((void)(!(m_vec) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2038, __FUNCTION__), 0 : 0))
;
2039 m_vec->quick_grow (len);
2040}
2041
2042
2043/* Same as vec::quick_grow_cleared but without reallocation of the
2044 internal vector. If the vector cannot be extended, a runtime
2045 assertion will be triggered. */
2046
2047template<typename T>
2048inline void
2049vec<T, va_heap, vl_ptr>::quick_grow_cleared (unsigned len)
2050{
2051 gcc_checking_assert (m_vec)((void)(!(m_vec) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2051, __FUNCTION__), 0 : 0))
;
2052 m_vec->quick_grow_cleared (len);
2053}
2054
2055
2056/* Insert an element, OBJ, at the IXth position of this vector. There
2057 must be sufficient space. */
2058
2059template<typename T>
2060inline void
2061vec<T, va_heap, vl_ptr>::quick_insert (unsigned ix, const T &obj)
2062{
2063 m_vec->quick_insert (ix, obj);
2064}
2065
2066
2067/* Insert an element, OBJ, at the IXth position of the vector.
2068 Reallocate the embedded vector, if necessary. */
2069
2070template<typename T>
2071inline void
2072vec<T, va_heap, vl_ptr>::safe_insert (unsigned ix, const T &obj MEM_STAT_DECL)
2073{
2074 reserve (1, false PASS_MEM_STAT);
2075 quick_insert (ix, obj);
2076}
2077
2078
2079/* Remove an element from the IXth position of this vector. Ordering of
2080 remaining elements is preserved. This is an O(N) operation due to
2081 a memmove. */
2082
2083template<typename T>
2084inline void
2085vec<T, va_heap, vl_ptr>::ordered_remove (unsigned ix)
2086{
2087 m_vec->ordered_remove (ix);
2088}
2089
2090
2091/* Remove an element from the IXth position of this vector. Ordering
2092 of remaining elements is destroyed. This is an O(1) operation. */
2093
2094template<typename T>
2095inline void
2096vec<T, va_heap, vl_ptr>::unordered_remove (unsigned ix)
2097{
2098 m_vec->unordered_remove (ix);
2099}
2100
2101
2102/* Remove LEN elements starting at the IXth. Ordering is retained.
2103 This is an O(N) operation due to memmove. */
2104
2105template<typename T>
2106inline void
2107vec<T, va_heap, vl_ptr>::block_remove (unsigned ix, unsigned len)
2108{
2109 m_vec->block_remove (ix, len);
2110}
2111
2112
2113/* Sort the contents of this vector with qsort. CMP is the comparison
2114 function to pass to qsort. */
2115
2116template<typename T>
2117inline void
2118vec<T, va_heap, vl_ptr>::qsort (int (*cmp) (const void *, const void *))qsort (int (*cmp) (const void *, const void *))
2119{
2120 if (m_vec)
2121 m_vec->qsort (cmp)qsort (cmp);
2122}
2123
2124/* Sort the contents of this vector with qsort. CMP is the comparison
2125 function to pass to qsort. */
2126
2127template<typename T>
2128inline void
2129vec<T, va_heap, vl_ptr>::sort (int (*cmp) (const void *, const void *,
2130 void *), void *data)
2131{
2132 if (m_vec)
2133 m_vec->sort (cmp, data);
2134}
2135
2136/* Sort the contents of this vector with gcc_stablesort_r. CMP is the
2137 comparison function to pass to qsort. */
2138
2139template<typename T>
2140inline void
2141vec<T, va_heap, vl_ptr>::stablesort (int (*cmp) (const void *, const void *,
2142 void *), void *data)
2143{
2144 if (m_vec)
2145 m_vec->stablesort (cmp, data);
2146}
2147
2148/* Search the contents of the sorted vector with a binary search.
2149 CMP is the comparison function to pass to bsearch. */
2150
2151template<typename T>
2152inline T *
2153vec<T, va_heap, vl_ptr>::bsearch (const void *key,
2154 int (*cmp) (const void *, const void *))
2155{
2156 if (m_vec)
2157 return m_vec->bsearch (key, cmp);
2158 return NULL__null;
2159}
2160
2161/* Search the contents of the sorted vector with a binary search.
2162 CMP is the comparison function to pass to bsearch. */
2163
2164template<typename T>
2165inline T *
2166vec<T, va_heap, vl_ptr>::bsearch (const void *key,
2167 int (*cmp) (const void *, const void *,
2168 void *), void *data)
2169{
2170 if (m_vec)
2171 return m_vec->bsearch (key, cmp, data);
2172 return NULL__null;
2173}
2174
2175
2176/* Find and return the first position in which OBJ could be inserted
2177 without changing the ordering of this vector. LESSTHAN is a
2178 function that returns true if the first argument is strictly less
2179 than the second. */
2180
2181template<typename T>
2182inline unsigned
2183vec<T, va_heap, vl_ptr>::lower_bound (T obj,
2184 bool (*lessthan)(const T &, const T &))
2185 const
2186{
2187 return m_vec ? m_vec->lower_bound (obj, lessthan) : 0;
2188}
2189
2190/* Return true if SEARCH is an element of V. Note that this is O(N) in the
2191 size of the vector and so should be used with care. */
2192
2193template<typename T>
2194inline bool
2195vec<T, va_heap, vl_ptr>::contains (const T &search) const
2196{
2197 return m_vec ? m_vec->contains (search) : false;
2198}
2199
2200/* Reverse content of the vector. */
2201
2202template<typename T>
2203inline void
2204vec<T, va_heap, vl_ptr>::reverse (void)
2205{
2206 unsigned l = length ();
2207 T *ptr = address ();
2208
2209 for (unsigned i = 0; i < l / 2; i++)
2210 std::swap (ptr[i], ptr[l - i - 1]);
2211}
2212
2213template<typename T>
2214inline bool
2215vec<T, va_heap, vl_ptr>::using_auto_storage () const
2216{
2217 return m_vec ? m_vec->m_vecpfx.m_using_auto_storage : false;
2218}
2219
2220/* Release VEC and call release of all element vectors. */
2221
2222template<typename T>
2223inline void
2224release_vec_vec (vec<vec<T> > &vec)
2225{
2226 for (unsigned i = 0; i < vec.length (); i++)
2227 vec[i].release ();
2228
2229 vec.release ();
2230}
2231
2232// Provide a subset of the std::span functionality. (We can't use std::span
2233// itself because it's a C++20 feature.)
2234//
2235// In addition, provide an invalid value that is distinct from all valid
2236// sequences (including the empty sequence). This can be used to return
2237// failure without having to use std::optional.
2238//
2239// There is no operator bool because it would be ambiguous whether it is
2240// testing for a valid value or an empty sequence.
2241template<typename T>
2242class array_slice
2243{
2244 template<typename OtherT> friend class array_slice;
2245
2246public:
2247 using value_type = T;
2248 using iterator = T *;
2249 using const_iterator = const T *;
2250
2251 array_slice () : m_base (nullptr), m_size (0) {}
2252
2253 template<typename OtherT>
2254 array_slice (array_slice<OtherT> other)
2255 : m_base (other.m_base), m_size (other.m_size) {}
2256
2257 array_slice (iterator base, unsigned int size)
2258 : m_base (base), m_size (size) {}
2259
2260 template<size_t N>
2261 array_slice (T (&array)[N]) : m_base (array), m_size (N) {}
2262
2263 template<typename OtherT>
2264 array_slice (const vec<OtherT> &v)
2265 : m_base (v.address ()), m_size (v.length ()) {}
2266
2267 iterator begin () { return m_base; }
2268 iterator end () { return m_base + m_size; }
2269
2270 const_iterator begin () const { return m_base; }
2271 const_iterator end () const { return m_base + m_size; }
2272
2273 value_type &front ();
2274 value_type &back ();
2275 value_type &operator[] (unsigned int i);
2276
2277 const value_type &front () const;
2278 const value_type &back () const;
2279 const value_type &operator[] (unsigned int i) const;
2280
2281 size_t size () const { return m_size; }
2282 size_t size_bytes () const { return m_size * sizeof (T); }
2283 bool empty () const { return m_size == 0; }
2284
2285 // An invalid array_slice that represents a failed operation. This is
2286 // distinct from an empty slice, which is a valid result in some contexts.
2287 static array_slice invalid () { return { nullptr, ~0U }; }
2288
2289 // True if the array is valid, false if it is an array like INVALID.
2290 bool is_valid () const { return m_base || m_size == 0; }
2291
2292private:
2293 iterator m_base;
2294 unsigned int m_size;
2295};
2296
2297template<typename T>
2298inline typename array_slice<T>::value_type &
2299array_slice<T>::front ()
2300{
2301 gcc_checking_assert (m_size)((void)(!(m_size) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2301, __FUNCTION__), 0 : 0))
;
2302 return m_base[0];
2303}
2304
2305template<typename T>
2306inline const typename array_slice<T>::value_type &
2307array_slice<T>::front () const
2308{
2309 gcc_checking_assert (m_size)((void)(!(m_size) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2309, __FUNCTION__), 0 : 0))
;
2310 return m_base[0];
2311}
2312
2313template<typename T>
2314inline typename array_slice<T>::value_type &
2315array_slice<T>::back ()
2316{
2317 gcc_checking_assert (m_size)((void)(!(m_size) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2317, __FUNCTION__), 0 : 0))
;
2318 return m_base[m_size - 1];
2319}
2320
2321template<typename T>
2322inline const typename array_slice<T>::value_type &
2323array_slice<T>::back () const
2324{
2325 gcc_checking_assert (m_size)((void)(!(m_size) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2325, __FUNCTION__), 0 : 0))
;
2326 return m_base[m_size - 1];
2327}
2328
2329template<typename T>
2330inline typename array_slice<T>::value_type &
2331array_slice<T>::operator[] (unsigned int i)
2332{
2333 gcc_checking_assert (i < m_size)((void)(!(i < m_size) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2333, __FUNCTION__), 0 : 0))
;
2334 return m_base[i];
2335}
2336
2337template<typename T>
2338inline const typename array_slice<T>::value_type &
2339array_slice<T>::operator[] (unsigned int i) const
2340{
2341 gcc_checking_assert (i < m_size)((void)(!(i < m_size) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h"
, 2341, __FUNCTION__), 0 : 0))
;
2342 return m_base[i];
2343}
2344
2345template<typename T>
2346array_slice<T>
2347make_array_slice (T *base, unsigned int size)
2348{
2349 return array_slice<T> (base, size);
2350}
2351
2352#if (GCC_VERSION(4 * 1000 + 2) >= 3000)
2353# pragma GCC poison m_vec m_vecpfx m_vecdata
2354#endif
2355
2356#endif // GCC_VEC_H