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 alias.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-Zdemr5.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c

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

1/* Alias analysis for GNU C
2 Copyright (C) 1997-2021 Free Software Foundation, Inc.
3 Contributed by John Carr (jfc@mit.edu).
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "backend.h"
25#include "target.h"
26#include "rtl.h"
27#include "tree.h"
28#include "gimple.h"
29#include "df.h"
30#include "memmodel.h"
31#include "tm_p.h"
32#include "gimple-ssa.h"
33#include "emit-rtl.h"
34#include "alias.h"
35#include "fold-const.h"
36#include "varasm.h"
37#include "cselib.h"
38#include "langhooks.h"
39#include "cfganal.h"
40#include "rtl-iter.h"
41#include "cgraph.h"
42#include "ipa-utils.h"
43
44/* The aliasing API provided here solves related but different problems:
45
46 Say there exists (in c)
47
48 struct X {
49 struct Y y1;
50 struct Z z2;
51 } x1, *px1, *px2;
52
53 struct Y y2, *py;
54 struct Z z2, *pz;
55
56
57 py = &x1.y1;
58 px2 = &x1;
59
60 Consider the four questions:
61
62 Can a store to x1 interfere with px2->y1?
63 Can a store to x1 interfere with px2->z2?
64 Can a store to x1 change the value pointed to by with py?
65 Can a store to x1 change the value pointed to by with pz?
66
67 The answer to these questions can be yes, yes, yes, and maybe.
68
69 The first two questions can be answered with a simple examination
70 of the type system. If structure X contains a field of type Y then
71 a store through a pointer to an X can overwrite any field that is
72 contained (recursively) in an X (unless we know that px1 != px2).
73
74 The last two questions can be solved in the same way as the first
75 two questions but this is too conservative. The observation is
76 that in some cases we can know which (if any) fields are addressed
77 and if those addresses are used in bad ways. This analysis may be
78 language specific. In C, arbitrary operations may be applied to
79 pointers. However, there is some indication that this may be too
80 conservative for some C++ types.
81
82 The pass ipa-type-escape does this analysis for the types whose
83 instances do not escape across the compilation boundary.
84
85 Historically in GCC, these two problems were combined and a single
86 data structure that was used to represent the solution to these
87 problems. We now have two similar but different data structures,
88 The data structure to solve the last two questions is similar to
89 the first, but does not contain the fields whose address are never
90 taken. For types that do escape the compilation unit, the data
91 structures will have identical information.
92*/
93
94/* The alias sets assigned to MEMs assist the back-end in determining
95 which MEMs can alias which other MEMs. In general, two MEMs in
96 different alias sets cannot alias each other, with one important
97 exception. Consider something like:
98
99 struct S { int i; double d; };
100
101 a store to an `S' can alias something of either type `int' or type
102 `double'. (However, a store to an `int' cannot alias a `double'
103 and vice versa.) We indicate this via a tree structure that looks
104 like:
105 struct S
106 / \
107 / \
108 |/_ _\|
109 int double
110
111 (The arrows are directed and point downwards.)
112 In this situation we say the alias set for `struct S' is the
113 `superset' and that those for `int' and `double' are `subsets'.
114
115 To see whether two alias sets can point to the same memory, we must
116 see if either alias set is a subset of the other. We need not trace
117 past immediate descendants, however, since we propagate all
118 grandchildren up one level.
119
120 Alias set zero is implicitly a superset of all other alias sets.
121 However, this is no actual entry for alias set zero. It is an
122 error to attempt to explicitly construct a subset of zero. */
123
124struct alias_set_hash : int_hash <int, INT_MIN(-2147483647 -1), INT_MIN(-2147483647 -1) + 1> {};
125
126struct GTY(()) alias_set_entry {
127 /* The alias set number, as stored in MEM_ALIAS_SET. */
128 alias_set_type alias_set;
129
130 /* Nonzero if would have a child of zero: this effectively makes this
131 alias set the same as alias set zero. */
132 bool has_zero_child;
133 /* Nonzero if alias set corresponds to pointer type itself (i.e. not to
134 aggregate contaiing pointer.
135 This is used for a special case where we need an universal pointer type
136 compatible with all other pointer types. */
137 bool is_pointer;
138 /* Nonzero if is_pointer or if one of childs have has_pointer set. */
139 bool has_pointer;
140
141 /* The children of the alias set. These are not just the immediate
142 children, but, in fact, all descendants. So, if we have:
143
144 struct T { struct S s; float f; }
145
146 continuing our example above, the children here will be all of
147 `int', `double', `float', and `struct S'. */
148 hash_map<alias_set_hash, int> *children;
149};
150
151static int rtx_equal_for_memref_p (const_rtx, const_rtx);
152static void record_set (rtx, const_rtx, void *);
153static int base_alias_check (rtx, rtx, rtx, rtx, machine_mode,
154 machine_mode);
155static rtx find_base_value (rtx);
156static int mems_in_disjoint_alias_sets_p (const_rtx, const_rtx);
157static alias_set_entry *get_alias_set_entry (alias_set_type);
158static tree decl_for_component_ref (tree);
159static int write_dependence_p (const_rtx,
160 const_rtx, machine_mode, rtx,
161 bool, bool, bool);
162static int compare_base_symbol_refs (const_rtx, const_rtx,
163 HOST_WIDE_INTlong * = NULLnullptr);
164
165static void memory_modified_1 (rtx, const_rtx, void *);
166
167/* Query statistics for the different low-level disambiguators.
168 A high-level query may trigger multiple of them. */
169
170static struct {
171 unsigned long long num_alias_zero;
172 unsigned long long num_same_alias_set;
173 unsigned long long num_same_objects;
174 unsigned long long num_volatile;
175 unsigned long long num_dag;
176 unsigned long long num_universal;
177 unsigned long long num_disambiguated;
178} alias_stats;
179
180
181/* Set up all info needed to perform alias analysis on memory references. */
182
183/* Returns the size in bytes of the mode of X. */
184#define SIZE_FOR_MODE(X)(GET_MODE_SIZE (((machine_mode) (X)->mode))) (GET_MODE_SIZE (GET_MODE (X)((machine_mode) (X)->mode)))
185
186/* Cap the number of passes we make over the insns propagating alias
187 information through set chains.
188 ??? 10 is a completely arbitrary choice. This should be based on the
189 maximum loop depth in the CFG, but we do not have this information
190 available (even if current_loops _is_ available). */
191#define MAX_ALIAS_LOOP_PASSES10 10
192
193/* reg_base_value[N] gives an address to which register N is related.
194 If all sets after the first add or subtract to the current value
195 or otherwise modify it so it does not point to a different top level
196 object, reg_base_value[N] is equal to the address part of the source
197 of the first set.
198
199 A base address can be an ADDRESS, SYMBOL_REF, or LABEL_REF. ADDRESS
200 expressions represent three types of base:
201
202 1. incoming arguments. There is just one ADDRESS to represent all
203 arguments, since we do not know at this level whether accesses
204 based on different arguments can alias. The ADDRESS has id 0.
205
206 2. stack_pointer_rtx, frame_pointer_rtx, hard_frame_pointer_rtx
207 (if distinct from frame_pointer_rtx) and arg_pointer_rtx.
208 Each of these rtxes has a separate ADDRESS associated with it,
209 each with a negative id.
210
211 GCC is (and is required to be) precise in which register it
212 chooses to access a particular region of stack. We can therefore
213 assume that accesses based on one of these rtxes do not alias
214 accesses based on another of these rtxes.
215
216 3. bases that are derived from malloc()ed memory (REG_NOALIAS).
217 Each such piece of memory has a separate ADDRESS associated
218 with it, each with an id greater than 0.
219
220 Accesses based on one ADDRESS do not alias accesses based on other
221 ADDRESSes. Accesses based on ADDRESSes in groups (2) and (3) do not
222 alias globals either; the ADDRESSes have Pmode to indicate this.
223 The ADDRESS in group (1) _may_ alias globals; it has VOIDmode to
224 indicate this. */
225
226static GTY(()) vec<rtx, va_gc> *reg_base_value;
227static rtx *new_reg_base_value;
228
229/* The single VOIDmode ADDRESS that represents all argument bases.
230 It has id 0. */
231static GTY(()) rtx arg_base_value;
232
233/* Used to allocate unique ids to each REG_NOALIAS ADDRESS. */
234static int unique_id;
235
236/* We preserve the copy of old array around to avoid amount of garbage
237 produced. About 8% of garbage produced were attributed to this
238 array. */
239static GTY((deletable)) vec<rtx, va_gc> *old_reg_base_value;
240
241/* Values of XINT (address, 0) of Pmode ADDRESS rtxes for special
242 registers. */
243#define UNIQUE_BASE_VALUE_SP-1 -1
244#define UNIQUE_BASE_VALUE_ARGP-2 -2
245#define UNIQUE_BASE_VALUE_FP-3 -3
246#define UNIQUE_BASE_VALUE_HFP-4 -4
247
248#define static_reg_base_value(this_target_rtl->x_static_reg_base_value) \
249 (this_target_rtl->x_static_reg_base_value)
250
251#define REG_BASE_VALUE(X)((rhs_regno(X)) < vec_safe_length (reg_base_value) ? (*reg_base_value
)[(rhs_regno(X))] : 0)
\
252 (REGNO (X)(rhs_regno(X)) < vec_safe_length (reg_base_value) \
253 ? (*reg_base_value)[REGNO (X)(rhs_regno(X))] : 0)
254
255/* Vector indexed by N giving the initial (unchanging) value known for
256 pseudo-register N. This vector is initialized in init_alias_analysis,
257 and does not change until end_alias_analysis is called. */
258static GTY(()) vec<rtx, va_gc> *reg_known_value;
259
260/* Vector recording for each reg_known_value whether it is due to a
261 REG_EQUIV note. Future passes (viz., reload) may replace the
262 pseudo with the equivalent expression and so we account for the
263 dependences that would be introduced if that happens.
264
265 The REG_EQUIV notes created in assign_parms may mention the arg
266 pointer, and there are explicit insns in the RTL that modify the
267 arg pointer. Thus we must ensure that such insns don't get
268 scheduled across each other because that would invalidate the
269 REG_EQUIV notes. One could argue that the REG_EQUIV notes are
270 wrong, but solving the problem in the scheduler will likely give
271 better code, so we do it here. */
272static sbitmap reg_known_equiv_p;
273
274/* True when scanning insns from the start of the rtl to the
275 NOTE_INSN_FUNCTION_BEG note. */
276static bool copying_arguments;
277
278
279/* The splay-tree used to store the various alias set entries. */
280static GTY (()) vec<alias_set_entry *, va_gc> *alias_sets;
281
282/* Build a decomposed reference object for querying the alias-oracle
283 from the MEM rtx and store it in *REF.
284 Returns false if MEM is not suitable for the alias-oracle. */
285
286static bool
287ao_ref_from_mem (ao_ref *ref, const_rtx mem)
288{
289 tree expr = MEM_EXPR (mem)(get_mem_attrs (mem)->expr);
290 tree base;
291
292 if (!expr)
293 return false;
294
295 ao_ref_init (ref, expr);
296
297 /* Get the base of the reference and see if we have to reject or
298 adjust it. */
299 base = ao_ref_base (ref);
300 if (base == NULL_TREE(tree) nullptr)
301 return false;
302
303 /* The tree oracle doesn't like bases that are neither decls
304 nor indirect references of SSA names. */
305 if (!(DECL_P (base)(tree_code_type[(int) (((enum tree_code) (base)->base.code
))] == tcc_declaration)
306 || (TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF
307 && TREE_CODE (TREE_OPERAND (base, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((base), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 307, __FUNCTION__))))))->base.code)
== SSA_NAME)
308 || (TREE_CODE (base)((enum tree_code) (base)->base.code) == TARGET_MEM_REF
309 && TREE_CODE (TMR_BASE (base))((enum tree_code) (((*((const_cast<tree*> (tree_operand_check
(((tree_check ((base), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 309, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 309, __FUNCTION__)))))))->base.code)
== SSA_NAME)))
310 return false;
311
312 ref->ref_alias_set = MEM_ALIAS_SET (mem)(get_mem_attrs (mem)->alias);
313
314 /* If MEM_OFFSET or MEM_SIZE are unknown what we got from MEM_EXPR
315 is conservative, so trust it. */
316 if (!MEM_OFFSET_KNOWN_P (mem)(get_mem_attrs (mem)->offset_known_p)
317 || !MEM_SIZE_KNOWN_P (mem)(get_mem_attrs (mem)->size_known_p))
318 return true;
319
320 /* If MEM_OFFSET/MEM_SIZE get us outside of ref->offset/ref->max_size
321 drop ref->ref. */
322 if (maybe_lt (MEM_OFFSET (mem)(get_mem_attrs (mem)->offset), 0)
323 || (ref->max_size_known_p ()
324 && maybe_gt ((MEM_OFFSET (mem) + MEM_SIZE (mem)) * BITS_PER_UNIT,maybe_lt (ref->max_size, ((get_mem_attrs (mem)->offset)
+ (get_mem_attrs (mem)->size)) * (8))
325 ref->max_size)maybe_lt (ref->max_size, ((get_mem_attrs (mem)->offset)
+ (get_mem_attrs (mem)->size)) * (8))
))
326 ref->ref = NULL_TREE(tree) nullptr;
327
328 /* Refine size and offset we got from analyzing MEM_EXPR by using
329 MEM_SIZE and MEM_OFFSET. */
330
331 ref->offset += MEM_OFFSET (mem)(get_mem_attrs (mem)->offset) * BITS_PER_UNIT(8);
332 ref->size = MEM_SIZE (mem)(get_mem_attrs (mem)->size) * BITS_PER_UNIT(8);
333
334 /* The MEM may extend into adjacent fields, so adjust max_size if
335 necessary. */
336 if (ref->max_size_known_p ())
337 ref->max_size = upper_bound (ref->max_size, ref->size);
338
339 /* If MEM_OFFSET and MEM_SIZE might get us outside of the base object of
340 the MEM_EXPR punt. This happens for STRICT_ALIGNMENT targets a lot. */
341 if (MEM_EXPR (mem)(get_mem_attrs (mem)->expr) != get_spill_slot_decl (false)
342 && (maybe_lt (ref->offset, 0)
343 || (DECL_P (ref->base)(tree_code_type[(int) (((enum tree_code) (ref->base)->base
.code))] == tcc_declaration)
344 && (DECL_SIZE (ref->base)((contains_struct_check ((ref->base), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 344, __FUNCTION__))->decl_common.size)
== NULL_TREE(tree) nullptr
345 || !poly_int_tree_p (DECL_SIZE (ref->base)((contains_struct_check ((ref->base), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 345, __FUNCTION__))->decl_common.size)
)
346 || maybe_lt (wi::to_poly_offset (DECL_SIZE (ref->base)((contains_struct_check ((ref->base), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 346, __FUNCTION__))->decl_common.size)
),
347 ref->offset + ref->size)))))
348 return false;
349
350 return true;
351}
352
353/* Query the alias-oracle on whether the two memory rtx X and MEM may
354 alias. If TBAA_P is set also apply TBAA. Returns true if the
355 two rtxen may alias, false otherwise. */
356
357static bool
358rtx_refs_may_alias_p (const_rtx x, const_rtx mem, bool tbaa_p)
359{
360 ao_ref ref1, ref2;
361
362 if (!ao_ref_from_mem (&ref1, x)
363 || !ao_ref_from_mem (&ref2, mem))
364 return true;
365
366 return refs_may_alias_p_1 (&ref1, &ref2,
367 tbaa_p
368 && MEM_ALIAS_SET (x)(get_mem_attrs (x)->alias) != 0
369 && MEM_ALIAS_SET (mem)(get_mem_attrs (mem)->alias) != 0);
370}
371
372/* Return true if the ref EARLIER behaves the same as LATER with respect
373 to TBAA for every memory reference that might follow LATER. */
374
375bool
376refs_same_for_tbaa_p (tree earlier, tree later)
377{
378 ao_ref earlier_ref, later_ref;
379 ao_ref_init (&earlier_ref, earlier);
380 ao_ref_init (&later_ref, later);
381 alias_set_type earlier_set = ao_ref_alias_set (&earlier_ref);
382 alias_set_type later_set = ao_ref_alias_set (&later_ref);
383 if (!(earlier_set == later_set
384 || alias_set_subset_of (later_set, earlier_set)))
385 return false;
386 alias_set_type later_base_set = ao_ref_base_alias_set (&later_ref);
387 alias_set_type earlier_base_set = ao_ref_base_alias_set (&earlier_ref);
388 return (earlier_base_set == later_base_set
389 || alias_set_subset_of (later_base_set, earlier_base_set));
390}
391
392/* Returns a pointer to the alias set entry for ALIAS_SET, if there is
393 such an entry, or NULL otherwise. */
394
395static inline alias_set_entry *
396get_alias_set_entry (alias_set_type alias_set)
397{
398 return (*alias_sets)[alias_set];
399}
400
401/* Returns nonzero if the alias sets for MEM1 and MEM2 are such that
402 the two MEMs cannot alias each other. */
403
404static inline int
405mems_in_disjoint_alias_sets_p (const_rtx mem1, const_rtx mem2)
406{
407 return (flag_strict_aliasingglobal_options.x_flag_strict_aliasing
408 && ! alias_sets_conflict_p (MEM_ALIAS_SET (mem1)(get_mem_attrs (mem1)->alias),
409 MEM_ALIAS_SET (mem2)(get_mem_attrs (mem2)->alias)));
410}
411
412/* Return true if the first alias set is a subset of the second. */
413
414bool
415alias_set_subset_of (alias_set_type set1, alias_set_type set2)
416{
417 alias_set_entry *ase2;
418
419 /* Disable TBAA oracle with !flag_strict_aliasing. */
420 if (!flag_strict_aliasingglobal_options.x_flag_strict_aliasing)
421 return true;
422
423 /* Everything is a subset of the "aliases everything" set. */
424 if (set2 == 0)
425 return true;
426
427 /* Check if set1 is a subset of set2. */
428 ase2 = get_alias_set_entry (set2);
429 if (ase2 != 0
430 && (ase2->has_zero_child
431 || (ase2->children && ase2->children->get (set1))))
432 return true;
433
434 /* As a special case we consider alias set of "void *" to be both subset
435 and superset of every alias set of a pointer. This extra symmetry does
436 not matter for alias_sets_conflict_p but it makes aliasing_component_refs_p
437 to return true on the following testcase:
438
439 void *ptr;
440 char **ptr2=(char **)&ptr;
441 *ptr2 = ...
442
443 Additionally if a set contains universal pointer, we consider every pointer
444 to be a subset of it, but we do not represent this explicitely - doing so
445 would require us to update transitive closure each time we introduce new
446 pointer type. This makes aliasing_component_refs_p to return true
447 on the following testcase:
448
449 struct a {void *ptr;}
450 char **ptr = (char **)&a.ptr;
451 ptr = ...
452
453 This makes void * truly universal pointer type. See pointer handling in
454 get_alias_set for more details. */
455 if (ase2 && ase2->has_pointer)
456 {
457 alias_set_entry *ase1 = get_alias_set_entry (set1);
458
459 if (ase1 && ase1->is_pointer)
460 {
461 alias_set_type voidptr_set = TYPE_ALIAS_SET (ptr_type_node)((tree_class_check ((global_trees[TI_PTR_TYPE]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 461, __FUNCTION__))->type_common.alias_set)
;
462 /* If one is ptr_type_node and other is pointer, then we consider
463 them subset of each other. */
464 if (set1 == voidptr_set || set2 == voidptr_set)
465 return true;
466 /* If SET2 contains universal pointer's alias set, then we consdier
467 every (non-universal) pointer. */
468 if (ase2->children && set1 != voidptr_set
469 && ase2->children->get (voidptr_set))
470 return true;
471 }
472 }
473 return false;
474}
475
476/* Return 1 if the two specified alias sets may conflict. */
477
478int
479alias_sets_conflict_p (alias_set_type set1, alias_set_type set2)
480{
481 alias_set_entry *ase1;
482 alias_set_entry *ase2;
483
484 /* The easy case. */
485 if (alias_sets_must_conflict_p (set1, set2))
486 return 1;
487
488 /* See if the first alias set is a subset of the second. */
489 ase1 = get_alias_set_entry (set1);
490 if (ase1 != 0
491 && ase1->children && ase1->children->get (set2))
492 {
493 ++alias_stats.num_dag;
494 return 1;
495 }
496
497 /* Now do the same, but with the alias sets reversed. */
498 ase2 = get_alias_set_entry (set2);
499 if (ase2 != 0
500 && ase2->children && ase2->children->get (set1))
501 {
502 ++alias_stats.num_dag;
503 return 1;
504 }
505
506 /* We want void * to be compatible with any other pointer without
507 really dropping it to alias set 0. Doing so would make it
508 compatible with all non-pointer types too.
509
510 This is not strictly necessary by the C/C++ language
511 standards, but avoids common type punning mistakes. In
512 addition to that, we need the existence of such universal
513 pointer to implement Fortran's C_PTR type (which is defined as
514 type compatible with all C pointers). */
515 if (ase1 && ase2 && ase1->has_pointer && ase2->has_pointer)
516 {
517 alias_set_type voidptr_set = TYPE_ALIAS_SET (ptr_type_node)((tree_class_check ((global_trees[TI_PTR_TYPE]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 517, __FUNCTION__))->type_common.alias_set)
;
518
519 /* If one of the sets corresponds to universal pointer,
520 we consider it to conflict with anything that is
521 or contains pointer. */
522 if (set1 == voidptr_set || set2 == voidptr_set)
523 {
524 ++alias_stats.num_universal;
525 return true;
526 }
527 /* If one of sets is (non-universal) pointer and the other
528 contains universal pointer, we also get conflict. */
529 if (ase1->is_pointer && set2 != voidptr_set
530 && ase2->children && ase2->children->get (voidptr_set))
531 {
532 ++alias_stats.num_universal;
533 return true;
534 }
535 if (ase2->is_pointer && set1 != voidptr_set
536 && ase1->children && ase1->children->get (voidptr_set))
537 {
538 ++alias_stats.num_universal;
539 return true;
540 }
541 }
542
543 ++alias_stats.num_disambiguated;
544
545 /* The two alias sets are distinct and neither one is the
546 child of the other. Therefore, they cannot conflict. */
547 return 0;
548}
549
550/* Return 1 if the two specified alias sets will always conflict. */
551
552int
553alias_sets_must_conflict_p (alias_set_type set1, alias_set_type set2)
554{
555 /* Disable TBAA oracle with !flag_strict_aliasing. */
556 if (!flag_strict_aliasingglobal_options.x_flag_strict_aliasing)
557 return 1;
558 if (set1 == 0 || set2 == 0)
559 {
560 ++alias_stats.num_alias_zero;
561 return 1;
562 }
563 if (set1 == set2)
564 {
565 ++alias_stats.num_same_alias_set;
566 return 1;
567 }
568
569 return 0;
570}
571
572/* Return 1 if any MEM object of type T1 will always conflict (using the
573 dependency routines in this file) with any MEM object of type T2.
574 This is used when allocating temporary storage. If T1 and/or T2 are
575 NULL_TREE, it means we know nothing about the storage. */
576
577int
578objects_must_conflict_p (tree t1, tree t2)
579{
580 alias_set_type set1, set2;
581
582 /* If neither has a type specified, we don't know if they'll conflict
583 because we may be using them to store objects of various types, for
584 example the argument and local variables areas of inlined functions. */
585 if (t1 == 0 && t2 == 0)
586 return 0;
587
588 /* If they are the same type, they must conflict. */
589 if (t1 == t2)
590 {
591 ++alias_stats.num_same_objects;
592 return 1;
593 }
594 /* Likewise if both are volatile. */
595 if (t1 != 0 && TYPE_VOLATILE (t1)((tree_class_check ((t1), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 595, __FUNCTION__))->base.volatile_flag)
&& t2 != 0 && TYPE_VOLATILE (t2)((tree_class_check ((t2), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 595, __FUNCTION__))->base.volatile_flag)
)
596 {
597 ++alias_stats.num_volatile;
598 return 1;
599 }
600
601 set1 = t1 ? get_alias_set (t1) : 0;
602 set2 = t2 ? get_alias_set (t2) : 0;
603
604 /* We can't use alias_sets_conflict_p because we must make sure
605 that every subtype of t1 will conflict with every subtype of
606 t2 for which a pair of subobjects of these respective subtypes
607 overlaps on the stack. */
608 return alias_sets_must_conflict_p (set1, set2);
609}
610
611/* Return true if T is an end of the access path which can be used
612 by type based alias oracle. */
613
614bool
615ends_tbaa_access_path_p (const_tree t)
616{
617 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
618 {
619 case COMPONENT_REF:
620 if (DECL_NONADDRESSABLE_P (TREE_OPERAND (t, 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
((t), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 620, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 620, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_2
)
)
621 return true;
622 /* Permit type-punning when accessing a union, provided the access
623 is directly through the union. For example, this code does not
624 permit taking the address of a union member and then storing
625 through it. Even the type-punning allowed here is a GCC
626 extension, albeit a common and useful one; the C standard says
627 that such accesses have implementation-defined behavior. */
628 else if (TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))((enum tree_code) (((contains_struct_check (((*((const_cast<
tree*> (tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 628, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 628, __FUNCTION__))->typed.type))->base.code)
== UNION_TYPE)
629 return true;
630 break;
631
632 case ARRAY_REF:
633 case ARRAY_RANGE_REF:
634 if (TYPE_NONALIASED_COMPONENT (TREE_TYPE (TREE_OPERAND (t, 0)))((tree_check ((((contains_struct_check (((*((const_cast<tree
*> (tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 634, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 634, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 634, __FUNCTION__, (ARRAY_TYPE)))->type_common.transparent_aggr_flag
)
)
635 return true;
636 break;
637
638 case REALPART_EXPR:
639 case IMAGPART_EXPR:
640 break;
641
642 case BIT_FIELD_REF:
643 case VIEW_CONVERT_EXPR:
644 /* Bitfields and casts are never addressable. */
645 return true;
646 break;
647
648 default:
649 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 649, __FUNCTION__))
;
650 }
651 return false;
652}
653
654/* Return the outermost parent of component present in the chain of
655 component references handled by get_inner_reference in T with the
656 following property:
657 - the component is non-addressable
658 or NULL_TREE if no such parent exists. In the former cases, the alias
659 set of this parent is the alias set that must be used for T itself. */
660
661tree
662component_uses_parent_alias_set_from (const_tree t)
663{
664 const_tree found = NULL_TREE(tree) nullptr;
665
666 while (handled_component_p (t))
667 {
668 if (ends_tbaa_access_path_p (t))
669 found = t;
670
671 t = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 671, __FUNCTION__)))))
;
672 }
673
674 if (found)
675 return TREE_OPERAND (found, 0)(*((const_cast<tree*> (tree_operand_check ((found), (0)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 675, __FUNCTION__)))))
;
676
677 return NULL_TREE(tree) nullptr;
678}
679
680
681/* Return whether the pointer-type T effective for aliasing may
682 access everything and thus the reference has to be assigned
683 alias-set zero. */
684
685static bool
686ref_all_alias_ptr_type_p (const_tree t)
687{
688 return (TREE_CODE (TREE_TYPE (t))((enum tree_code) (((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 688, __FUNCTION__))->typed.type))->base.code)
== VOID_TYPE
689 || TYPE_REF_CAN_ALIAS_ALL (t)((tree_check2 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 689, __FUNCTION__, (POINTER_TYPE), (REFERENCE_TYPE)))->base
.static_flag)
);
690}
691
692/* Return the alias set for the memory pointed to by T, which may be
693 either a type or an expression. Return -1 if there is nothing
694 special about dereferencing T. */
695
696static alias_set_type
697get_deref_alias_set_1 (tree t)
698{
699 /* All we care about is the type. */
700 if (! TYPE_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_type)
)
701 t = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 701, __FUNCTION__))->typed.type)
;
702
703 /* If we have an INDIRECT_REF via a void pointer, we don't
704 know anything about what that might alias. Likewise if the
705 pointer is marked that way. */
706 if (ref_all_alias_ptr_type_p (t))
707 return 0;
708
709 return -1;
710}
711
712/* Return the alias set for the memory pointed to by T, which may be
713 either a type or an expression. */
714
715alias_set_type
716get_deref_alias_set (tree t)
717{
718 /* If we're not doing any alias analysis, just assume everything
719 aliases everything else. */
720 if (!flag_strict_aliasingglobal_options.x_flag_strict_aliasing)
721 return 0;
722
723 alias_set_type set = get_deref_alias_set_1 (t);
724
725 /* Fall back to the alias-set of the pointed-to type. */
726 if (set == -1)
727 {
728 if (! TYPE_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_type)
)
729 t = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 729, __FUNCTION__))->typed.type)
;
730 set = get_alias_set (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 730, __FUNCTION__))->typed.type)
);
731 }
732
733 return set;
734}
735
736/* Return the pointer-type relevant for TBAA purposes from the
737 memory reference tree *T or NULL_TREE in which case *T is
738 adjusted to point to the outermost component reference that
739 can be used for assigning an alias set. */
740
741tree
742reference_alias_ptr_type_1 (tree *t)
743{
744 tree inner;
745
746 /* Get the base object of the reference. */
747 inner = *t;
748 while (handled_component_p (inner))
749 {
750 /* If there is a VIEW_CONVERT_EXPR in the chain we cannot use
751 the type of any component references that wrap it to
752 determine the alias-set. */
753 if (TREE_CODE (inner)((enum tree_code) (inner)->base.code) == VIEW_CONVERT_EXPR)
754 *t = TREE_OPERAND (inner, 0)(*((const_cast<tree*> (tree_operand_check ((inner), (0)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 754, __FUNCTION__)))))
;
755 inner = TREE_OPERAND (inner, 0)(*((const_cast<tree*> (tree_operand_check ((inner), (0)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 755, __FUNCTION__)))))
;
756 }
757
758 /* Handle pointer dereferences here, they can override the
759 alias-set. */
760 if (INDIRECT_REF_P (inner)(((enum tree_code) (inner)->base.code) == INDIRECT_REF)
761 && ref_all_alias_ptr_type_p (TREE_TYPE (TREE_OPERAND (inner, 0))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((inner), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 761, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 761, __FUNCTION__))->typed.type)
))
762 return TREE_TYPE (TREE_OPERAND (inner, 0))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((inner), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 762, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 762, __FUNCTION__))->typed.type)
;
763 else if (TREE_CODE (inner)((enum tree_code) (inner)->base.code) == TARGET_MEM_REF)
764 return TREE_TYPE (TMR_OFFSET (inner))((contains_struct_check ((((*((const_cast<tree*> (tree_operand_check
(((tree_check ((inner), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 764, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 764, __FUNCTION__))))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 764, __FUNCTION__))->typed.type)
;
765 else if (TREE_CODE (inner)((enum tree_code) (inner)->base.code) == MEM_REF
766 && ref_all_alias_ptr_type_p (TREE_TYPE (TREE_OPERAND (inner, 1))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((inner), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 766, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 766, __FUNCTION__))->typed.type)
))
767 return TREE_TYPE (TREE_OPERAND (inner, 1))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((inner), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 767, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 767, __FUNCTION__))->typed.type)
;
768
769 /* If the innermost reference is a MEM_REF that has a
770 conversion embedded treat it like a VIEW_CONVERT_EXPR above,
771 using the memory access type for determining the alias-set. */
772 if (TREE_CODE (inner)((enum tree_code) (inner)->base.code) == MEM_REF
773 && (TYPE_MAIN_VARIANT (TREE_TYPE (inner))((tree_class_check ((((contains_struct_check ((inner), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 773, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 773, __FUNCTION__))->type_common.main_variant)
774 != TYPE_MAIN_VARIANT((tree_class_check ((((contains_struct_check ((((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((inner), (
1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 775, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 775, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 775, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 775, __FUNCTION__))->type_common.main_variant)
775 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (inner, 1))))((tree_class_check ((((contains_struct_check ((((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((inner), (
1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 775, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 775, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 775, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 775, __FUNCTION__))->type_common.main_variant)
))
776 return TREE_TYPE (TREE_OPERAND (inner, 1))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((inner), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 776, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 776, __FUNCTION__))->typed.type)
;
777
778 /* Otherwise, pick up the outermost object that we could have
779 a pointer to. */
780 tree tem = component_uses_parent_alias_set_from (*t);
781 if (tem)
782 *t = tem;
783
784 return NULL_TREE(tree) nullptr;
785}
786
787/* Return the pointer-type relevant for TBAA purposes from the
788 gimple memory reference tree T. This is the type to be used for
789 the offset operand of MEM_REF or TARGET_MEM_REF replacements of T
790 and guarantees that get_alias_set will return the same alias
791 set for T and the replacement. */
792
793tree
794reference_alias_ptr_type (tree t)
795{
796 /* If the frontend assigns this alias-set zero, preserve that. */
797 if (lang_hooks.get_alias_set (t) == 0)
798 return ptr_type_nodeglobal_trees[TI_PTR_TYPE];
799
800 tree ptype = reference_alias_ptr_type_1 (&t);
801 /* If there is a given pointer type for aliasing purposes, return it. */
802 if (ptype != NULL_TREE(tree) nullptr)
803 return ptype;
804
805 /* Otherwise build one from the outermost component reference we
806 may use. */
807 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == MEM_REF
808 || TREE_CODE (t)((enum tree_code) (t)->base.code) == TARGET_MEM_REF)
809 return TREE_TYPE (TREE_OPERAND (t, 1))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
((t), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 809, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 809, __FUNCTION__))->typed.type)
;
810 else
811 return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (t))((tree_class_check ((((contains_struct_check ((t), (TS_TYPED)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 811, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 811, __FUNCTION__))->type_common.main_variant)
);
812}
813
814/* Return whether the pointer-types T1 and T2 used to determine
815 two alias sets of two references will yield the same answer
816 from get_deref_alias_set. */
817
818bool
819alias_ptr_types_compatible_p (tree t1, tree t2)
820{
821 if (TYPE_MAIN_VARIANT (t1)((tree_class_check ((t1), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 821, __FUNCTION__))->type_common.main_variant)
== TYPE_MAIN_VARIANT (t2)((tree_class_check ((t2), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 821, __FUNCTION__))->type_common.main_variant)
)
822 return true;
823
824 if (ref_all_alias_ptr_type_p (t1)
825 || ref_all_alias_ptr_type_p (t2))
826 return false;
827
828 /* This function originally abstracts from simply comparing
829 get_deref_alias_set so that we are sure this still computes
830 the same result after LTO type merging is applied.
831 When in LTO type merging is done we can actually do this compare.
832 */
833 if (in_lto_pglobal_options.x_in_lto_p)
834 return get_deref_alias_set (t1) == get_deref_alias_set (t2);
835 else
836 return (TYPE_MAIN_VARIANT (TREE_TYPE (t1))((tree_class_check ((((contains_struct_check ((t1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 836, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 836, __FUNCTION__))->type_common.main_variant)
837 == TYPE_MAIN_VARIANT (TREE_TYPE (t2))((tree_class_check ((((contains_struct_check ((t2), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 837, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 837, __FUNCTION__))->type_common.main_variant)
);
838}
839
840/* Create emptry alias set entry. */
841
842alias_set_entry *
843init_alias_set_entry (alias_set_type set)
844{
845 alias_set_entry *ase = ggc_alloc<alias_set_entry> ();
846 ase->alias_set = set;
847 ase->children = NULLnullptr;
848 ase->has_zero_child = false;
849 ase->is_pointer = false;
850 ase->has_pointer = false;
851 gcc_checking_assert (!get_alias_set_entry (set))((void)(!(!get_alias_set_entry (set)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 851, __FUNCTION__), 0 : 0))
;
852 (*alias_sets)[set] = ase;
853 return ase;
854}
855
856/* Return the alias set for T, which may be either a type or an
857 expression. Call language-specific routine for help, if needed. */
858
859alias_set_type
860get_alias_set (tree t)
861{
862 alias_set_type set;
863
864 /* We cannot give up with -fno-strict-aliasing because we need to build
865 proper type representations for possible functions which are built with
866 -fstrict-aliasing. */
867
868 /* return 0 if this or its type is an error. */
869 if (t == error_mark_nodeglobal_trees[TI_ERROR_MARK]
870 || (! TYPE_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_type)
871 && (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 871, __FUNCTION__))->typed.type)
== 0 || TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 871, __FUNCTION__))->typed.type)
== error_mark_nodeglobal_trees[TI_ERROR_MARK])))
872 return 0;
873
874 /* We can be passed either an expression or a type. This and the
875 language-specific routine may make mutually-recursive calls to each other
876 to figure out what to do. At each juncture, we see if this is a tree
877 that the language may need to handle specially. First handle things that
878 aren't types. */
879 if (! TYPE_P (t)(tree_code_type[(int) (((enum tree_code) (t)->base.code))]
== tcc_type)
)
880 {
881 /* Give the language a chance to do something with this tree
882 before we look at it. */
883 STRIP_NOPS (t)(t) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((t)))))
;
884 set = lang_hooks.get_alias_set (t);
885 if (set != -1)
886 return set;
887
888 /* Get the alias pointer-type to use or the outermost object
889 that we could have a pointer to. */
890 tree ptype = reference_alias_ptr_type_1 (&t);
891 if (ptype != NULLnullptr)
892 return get_deref_alias_set (ptype);
893
894 /* If we've already determined the alias set for a decl, just return
895 it. This is necessary for C++ anonymous unions, whose component
896 variables don't look like union members (boo!). */
897 if (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL)
898 && DECL_RTL_SET_P (t)(((tree_contains_struct[(((enum tree_code) (t)->base.code)
)][(TS_DECL_WRTL)])) && (contains_struct_check ((t), (
TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 898, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
&& MEM_P (DECL_RTL (t))(((enum rtx_code) (((contains_struct_check ((t), (TS_DECL_WRTL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 898, __FUNCTION__))->decl_with_rtl.rtl ? (t)->decl_with_rtl
.rtl : (make_decl_rtl (t), (t)->decl_with_rtl.rtl)))->code
) == MEM)
)
899 return MEM_ALIAS_SET (DECL_RTL (t))(get_mem_attrs (((contains_struct_check ((t), (TS_DECL_WRTL),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 899, __FUNCTION__))->decl_with_rtl.rtl ? (t)->decl_with_rtl
.rtl : (make_decl_rtl (t), (t)->decl_with_rtl.rtl)))->alias
)
;
900
901 /* Now all we care about is the type. */
902 t = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 902, __FUNCTION__))->typed.type)
;
903 }
904
905 /* Variant qualifiers don't affect the alias set, so get the main
906 variant. */
907 t = TYPE_MAIN_VARIANT (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 907, __FUNCTION__))->type_common.main_variant)
;
908
909 if (AGGREGATE_TYPE_P (t)(((enum tree_code) (t)->base.code) == ARRAY_TYPE || (((enum
tree_code) (t)->base.code) == RECORD_TYPE || ((enum tree_code
) (t)->base.code) == UNION_TYPE || ((enum tree_code) (t)->
base.code) == QUAL_UNION_TYPE))
910 && TYPE_TYPELESS_STORAGE (t)((tree_check4 ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 910, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
), (ARRAY_TYPE)))->type_common.typeless_storage)
)
911 return 0;
912
913 /* Always use the canonical type as well. If this is a type that
914 requires structural comparisons to identify compatible types
915 use alias set zero. */
916 if (TYPE_STRUCTURAL_EQUALITY_P (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 916, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
)
917 {
918 /* Allow the language to specify another alias set for this
919 type. */
920 set = lang_hooks.get_alias_set (t);
921 if (set != -1)
922 return set;
923 /* Handle structure type equality for pointer types, arrays and vectors.
924 This is easy to do, because the code below ignores canonical types on
925 these anyway. This is important for LTO, where TYPE_CANONICAL for
926 pointers cannot be meaningfully computed by the frontend. */
927 if (canonical_type_used_p (t))
928 {
929 /* In LTO we set canonical types for all types where it makes
930 sense to do so. Double check we did not miss some type. */
931 gcc_checking_assert (!in_lto_p || !type_with_alias_set_p (t))((void)(!(!global_options.x_in_lto_p || !type_with_alias_set_p
(t)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 931, __FUNCTION__), 0 : 0))
;
932 return 0;
933 }
934 }
935 else
936 {
937 t = TYPE_CANONICAL (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 937, __FUNCTION__))->type_common.canonical)
;
938 gcc_checking_assert (!TYPE_STRUCTURAL_EQUALITY_P (t))((void)(!(!(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 938, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 938, __FUNCTION__), 0 : 0))
;
939 }
940
941 /* If this is a type with a known alias set, return it. */
942 gcc_checking_assert (t == TYPE_MAIN_VARIANT (t))((void)(!(t == ((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 942, __FUNCTION__))->type_common.main_variant)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 942, __FUNCTION__), 0 : 0))
;
943 if (TYPE_ALIAS_SET_KNOWN_P (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 943, __FUNCTION__))->type_common.alias_set != -1)
)
944 return TYPE_ALIAS_SET (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 944, __FUNCTION__))->type_common.alias_set)
;
945
946 /* We don't want to set TYPE_ALIAS_SET for incomplete types. */
947 if (!COMPLETE_TYPE_P (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 947, __FUNCTION__))->type_common.size) != (tree) nullptr
)
)
948 {
949 /* For arrays with unknown size the conservative answer is the
950 alias set of the element type. */
951 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == ARRAY_TYPE)
952 return get_alias_set (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 952, __FUNCTION__))->typed.type)
);
953
954 /* But return zero as a conservative answer for incomplete types. */
955 return 0;
956 }
957
958 /* See if the language has special handling for this type. */
959 set = lang_hooks.get_alias_set (t);
960 if (set != -1)
961 return set;
962
963 /* There are no objects of FUNCTION_TYPE, so there's no point in
964 using up an alias set for them. (There are, of course, pointers
965 and references to functions, but that's different.) */
966 else if (TREE_CODE (t)((enum tree_code) (t)->base.code) == FUNCTION_TYPE || TREE_CODE (t)((enum tree_code) (t)->base.code) == METHOD_TYPE)
967 set = 0;
968
969 /* Unless the language specifies otherwise, let vector types alias
970 their components. This avoids some nasty type punning issues in
971 normal usage. And indeed lets vectors be treated more like an
972 array slice. */
973 else if (TREE_CODE (t)((enum tree_code) (t)->base.code) == VECTOR_TYPE)
974 set = get_alias_set (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 974, __FUNCTION__))->typed.type)
);
975
976 /* Unless the language specifies otherwise, treat array types the
977 same as their components. This avoids the asymmetry we get
978 through recording the components. Consider accessing a
979 character(kind=1) through a reference to a character(kind=1)[1:1].
980 Or consider if we want to assign integer(kind=4)[0:D.1387] and
981 integer(kind=4)[4] the same alias set or not.
982 Just be pragmatic here and make sure the array and its element
983 type get the same alias set assigned. */
984 else if (TREE_CODE (t)((enum tree_code) (t)->base.code) == ARRAY_TYPE
985 && (!TYPE_NONALIASED_COMPONENT (t)((tree_check ((t), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 985, __FUNCTION__, (ARRAY_TYPE)))->type_common.transparent_aggr_flag
)
986 || TYPE_STRUCTURAL_EQUALITY_P (t)(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 986, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
))
987 set = get_alias_set (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 987, __FUNCTION__))->typed.type)
);
988
989 /* From the former common C and C++ langhook implementation:
990
991 Unfortunately, there is no canonical form of a pointer type.
992 In particular, if we have `typedef int I', then `int *', and
993 `I *' are different types. So, we have to pick a canonical
994 representative. We do this below.
995
996 Technically, this approach is actually more conservative that
997 it needs to be. In particular, `const int *' and `int *'
998 should be in different alias sets, according to the C and C++
999 standard, since their types are not the same, and so,
1000 technically, an `int **' and `const int **' cannot point at
1001 the same thing.
1002
1003 But, the standard is wrong. In particular, this code is
1004 legal C++:
1005
1006 int *ip;
1007 int **ipp = &ip;
1008 const int* const* cipp = ipp;
1009 And, it doesn't make sense for that to be legal unless you
1010 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
1011 the pointed-to types. This issue has been reported to the
1012 C++ committee.
1013
1014 For this reason go to canonical type of the unqalified pointer type.
1015 Until GCC 6 this code set all pointers sets to have alias set of
1016 ptr_type_node but that is a bad idea, because it prevents disabiguations
1017 in between pointers. For Firefox this accounts about 20% of all
1018 disambiguations in the program. */
1019 else if (POINTER_TYPE_P (t)(((enum tree_code) (t)->base.code) == POINTER_TYPE || ((enum
tree_code) (t)->base.code) == REFERENCE_TYPE)
&& t != ptr_type_nodeglobal_trees[TI_PTR_TYPE])
1020 {
1021 tree p;
1022 auto_vec <bool, 8> reference;
1023
1024 /* Unnest all pointers and references.
1025 We also want to make pointer to array/vector equivalent to pointer to
1026 its element (see the reasoning above). Skip all those types, too. */
1027 for (p = t; POINTER_TYPE_P (p)(((enum tree_code) (p)->base.code) == POINTER_TYPE || ((enum
tree_code) (p)->base.code) == REFERENCE_TYPE)
1028 || (TREE_CODE (p)((enum tree_code) (p)->base.code) == ARRAY_TYPE
1029 && (!TYPE_NONALIASED_COMPONENT (p)((tree_check ((p), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1029, __FUNCTION__, (ARRAY_TYPE)))->type_common.transparent_aggr_flag
)
1030 || !COMPLETE_TYPE_P (p)(((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1030, __FUNCTION__))->type_common.size) != (tree) nullptr
)
1031 || TYPE_STRUCTURAL_EQUALITY_P (p)(((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1031, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
))
1032 || TREE_CODE (p)((enum tree_code) (p)->base.code) == VECTOR_TYPE;
1033 p = TREE_TYPE (p)((contains_struct_check ((p), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1033, __FUNCTION__))->typed.type)
)
1034 {
1035 /* Ada supports recursive pointers. Instead of doing recursion
1036 check, just give up once the preallocated space of 8 elements
1037 is up. In this case just punt to void * alias set. */
1038 if (reference.length () == 8)
1039 {
1040 p = ptr_type_nodeglobal_trees[TI_PTR_TYPE];
1041 break;
1042 }
1043 if (TREE_CODE (p)((enum tree_code) (p)->base.code) == REFERENCE_TYPE)
1044 /* In LTO we want languages that use references to be compatible
1045 with languages that use pointers. */
1046 reference.safe_push (true && !in_lto_pglobal_options.x_in_lto_p);
1047 if (TREE_CODE (p)((enum tree_code) (p)->base.code) == POINTER_TYPE)
1048 reference.safe_push (false);
1049 }
1050 p = TYPE_MAIN_VARIANT (p)((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1050, __FUNCTION__))->type_common.main_variant)
;
1051
1052 /* In LTO for C++ programs we can turn incomplete types to complete
1053 using ODR name lookup. */
1054 if (in_lto_pglobal_options.x_in_lto_p && TYPE_STRUCTURAL_EQUALITY_P (p)(((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1054, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
&& odr_type_p (p))
1055 {
1056 p = prevailing_odr_type (p);
1057 gcc_checking_assert (TYPE_MAIN_VARIANT (p) == p)((void)(!(((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1057, __FUNCTION__))->type_common.main_variant) == p) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1057, __FUNCTION__), 0 : 0))
;
1058 }
1059
1060 /* Make void * compatible with char * and also void **.
1061 Programs are commonly violating TBAA by this.
1062
1063 We also make void * to conflict with every pointer
1064 (see record_component_aliases) and thus it is safe it to use it for
1065 pointers to types with TYPE_STRUCTURAL_EQUALITY_P. */
1066 if (TREE_CODE (p)((enum tree_code) (p)->base.code) == VOID_TYPE || TYPE_STRUCTURAL_EQUALITY_P (p)(((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1066, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)
)
1067 set = get_alias_set (ptr_type_nodeglobal_trees[TI_PTR_TYPE]);
1068 else
1069 {
1070 /* Rebuild pointer type starting from canonical types using
1071 unqualified pointers and references only. This way all such
1072 pointers will have the same alias set and will conflict with
1073 each other.
1074
1075 Most of time we already have pointers or references of a given type.
1076 If not we build new one just to be sure that if someone later
1077 (probably only middle-end can, as we should assign all alias
1078 classes only after finishing translation unit) builds the pointer
1079 type, the canonical type will match. */
1080 p = TYPE_CANONICAL (p)((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1080, __FUNCTION__))->type_common.canonical)
;
1081 while (!reference.is_empty ())
1082 {
1083 if (reference.pop ())
1084 p = build_reference_type (p);
1085 else
1086 p = build_pointer_type (p);
1087 gcc_checking_assert (p == TYPE_MAIN_VARIANT (p))((void)(!(p == ((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1087, __FUNCTION__))->type_common.main_variant)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1087, __FUNCTION__), 0 : 0))
;
1088 /* build_pointer_type should always return the canonical type.
1089 For LTO TYPE_CANOINCAL may be NULL, because we do not compute
1090 them. Be sure that frontends do not glob canonical types of
1091 pointers in unexpected way and that p == TYPE_CANONICAL (p)
1092 in all other cases. */
1093 gcc_checking_assert (!TYPE_CANONICAL (p)((void)(!(!((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1093, __FUNCTION__))->type_common.canonical) || p == ((tree_class_check
((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1094, __FUNCTION__))->type_common.canonical)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1094, __FUNCTION__), 0 : 0))
1094 || p == TYPE_CANONICAL (p))((void)(!(!((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1093, __FUNCTION__))->type_common.canonical) || p == ((tree_class_check
((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1094, __FUNCTION__))->type_common.canonical)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1094, __FUNCTION__), 0 : 0))
;
1095 }
1096
1097 /* Assign the alias set to both p and t.
1098 We cannot call get_alias_set (p) here as that would trigger
1099 infinite recursion when p == t. In other cases it would just
1100 trigger unnecesary legwork of rebuilding the pointer again. */
1101 gcc_checking_assert (p == TYPE_MAIN_VARIANT (p))((void)(!(p == ((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1101, __FUNCTION__))->type_common.main_variant)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1101, __FUNCTION__), 0 : 0))
;
1102 if (TYPE_ALIAS_SET_KNOWN_P (p)((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1102, __FUNCTION__))->type_common.alias_set != -1)
)
1103 set = TYPE_ALIAS_SET (p)((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1103, __FUNCTION__))->type_common.alias_set)
;
1104 else
1105 {
1106 set = new_alias_set ();
1107 TYPE_ALIAS_SET (p)((tree_class_check ((p), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1107, __FUNCTION__))->type_common.alias_set)
= set;
1108 }
1109 }
1110 }
1111 /* Alias set of ptr_type_node is special and serve as universal pointer which
1112 is TBAA compatible with every other pointer type. Be sure we have the
1113 alias set built even for LTO which otherwise keeps all TYPE_CANONICAL
1114 of pointer types NULL. */
1115 else if (t == ptr_type_nodeglobal_trees[TI_PTR_TYPE])
1116 set = new_alias_set ();
1117
1118 /* Otherwise make a new alias set for this type. */
1119 else
1120 {
1121 /* Each canonical type gets its own alias set, so canonical types
1122 shouldn't form a tree. It doesn't really matter for types
1123 we handle specially above, so only check it where it possibly
1124 would result in a bogus alias set. */
1125 gcc_checking_assert (TYPE_CANONICAL (t) == t)((void)(!(((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1125, __FUNCTION__))->type_common.canonical) == t) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1125, __FUNCTION__), 0 : 0))
;
1126
1127 set = new_alias_set ();
1128 }
1129
1130 TYPE_ALIAS_SET (t)((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1130, __FUNCTION__))->type_common.alias_set)
= set;
1131
1132 /* If this is an aggregate type or a complex type, we must record any
1133 component aliasing information. */
1134 if (AGGREGATE_TYPE_P (t)(((enum tree_code) (t)->base.code) == ARRAY_TYPE || (((enum
tree_code) (t)->base.code) == RECORD_TYPE || ((enum tree_code
) (t)->base.code) == UNION_TYPE || ((enum tree_code) (t)->
base.code) == QUAL_UNION_TYPE))
|| TREE_CODE (t)((enum tree_code) (t)->base.code) == COMPLEX_TYPE)
1135 record_component_aliases (t);
1136
1137 /* We treat pointer types specially in alias_set_subset_of. */
1138 if (POINTER_TYPE_P (t)(((enum tree_code) (t)->base.code) == POINTER_TYPE || ((enum
tree_code) (t)->base.code) == REFERENCE_TYPE)
&& set)
1139 {
1140 alias_set_entry *ase = get_alias_set_entry (set);
1141 if (!ase)
1142 ase = init_alias_set_entry (set);
1143 ase->is_pointer = true;
1144 ase->has_pointer = true;
1145 }
1146
1147 return set;
1148}
1149
1150/* Return a brand-new alias set. */
1151
1152alias_set_type
1153new_alias_set (void)
1154{
1155 if (alias_sets == 0)
4
Assuming 'alias_sets' is not equal to null
5
Taking false branch
1156 vec_safe_push (alias_sets, (alias_set_entry *) NULLnullptr);
1157 vec_safe_push (alias_sets, (alias_set_entry *) NULLnullptr);
6
Passing value via 1st parameter 'v'
7
Calling 'vec_safe_push<alias_set_entry *, va_gc>'
1158 return alias_sets->length () - 1;
1159}
1160
1161/* Indicate that things in SUBSET can alias things in SUPERSET, but that
1162 not everything that aliases SUPERSET also aliases SUBSET. For example,
1163 in C, a store to an `int' can alias a load of a structure containing an
1164 `int', and vice versa. But it can't alias a load of a 'double' member
1165 of the same structure. Here, the structure would be the SUPERSET and
1166 `int' the SUBSET. This relationship is also described in the comment at
1167 the beginning of this file.
1168
1169 This function should be called only once per SUPERSET/SUBSET pair.
1170
1171 It is illegal for SUPERSET to be zero; everything is implicitly a
1172 subset of alias set zero. */
1173
1174void
1175record_alias_subset (alias_set_type superset, alias_set_type subset)
1176{
1177 alias_set_entry *superset_entry;
1178 alias_set_entry *subset_entry;
1179
1180 /* It is possible in complex type situations for both sets to be the same,
1181 in which case we can ignore this operation. */
1182 if (superset == subset)
1183 return;
1184
1185 gcc_assert (superset)((void)(!(superset) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1185, __FUNCTION__), 0 : 0))
;
1186
1187 superset_entry = get_alias_set_entry (superset);
1188 if (superset_entry == 0)
1189 {
1190 /* Create an entry for the SUPERSET, so that we have a place to
1191 attach the SUBSET. */
1192 superset_entry = init_alias_set_entry (superset);
1193 }
1194
1195 if (subset == 0)
1196 superset_entry->has_zero_child = 1;
1197 else
1198 {
1199 if (!superset_entry->children)
1200 superset_entry->children
1201 = hash_map<alias_set_hash, int>::create_ggc (64);
1202
1203 /* Enter the SUBSET itself as a child of the SUPERSET. If it was
1204 already there we're done. */
1205 if (superset_entry->children->put (subset, 0))
1206 return;
1207
1208 subset_entry = get_alias_set_entry (subset);
1209 /* If there is an entry for the subset, enter all of its children
1210 (if they are not already present) as children of the SUPERSET. */
1211 if (subset_entry)
1212 {
1213 if (subset_entry->has_zero_child)
1214 superset_entry->has_zero_child = true;
1215 if (subset_entry->has_pointer)
1216 superset_entry->has_pointer = true;
1217
1218 if (subset_entry->children)
1219 {
1220 hash_map<alias_set_hash, int>::iterator iter
1221 = subset_entry->children->begin ();
1222 for (; iter != subset_entry->children->end (); ++iter)
1223 superset_entry->children->put ((*iter).first, (*iter).second);
1224 }
1225 }
1226 }
1227}
1228
1229/* Record that component types of TYPE, if any, are part of SUPERSET for
1230 aliasing purposes. For record types, we only record component types
1231 for fields that are not marked non-addressable. For array types, we
1232 only record the component type if it is not marked non-aliased. */
1233
1234void
1235record_component_aliases (tree type, alias_set_type superset)
1236{
1237 tree field;
1238
1239 if (superset == 0)
1240 return;
1241
1242 switch (TREE_CODE (type)((enum tree_code) (type)->base.code))
1243 {
1244 case RECORD_TYPE:
1245 case UNION_TYPE:
1246 case QUAL_UNION_TYPE:
1247 {
1248 /* LTO non-ODR type merging does not make any difference between
1249 component pointer types. We may have
1250
1251 struct foo {int *a;};
1252
1253 as TYPE_CANONICAL of
1254
1255 struct bar {float *a;};
1256
1257 Because accesses to int * and float * do not alias, we would get
1258 false negative when accessing the same memory location by
1259 float ** and bar *. We thus record the canonical type as:
1260
1261 struct {void *a;};
1262
1263 void * is special cased and works as a universal pointer type.
1264 Accesses to it conflicts with accesses to any other pointer
1265 type. */
1266 bool void_pointers = in_lto_pglobal_options.x_in_lto_p
1267 && (!odr_type_p (type)
1268 || !odr_based_tbaa_p (type));
1269 for (field = TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1269, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
; field != 0; field = 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/alias.c"
, 1269, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1269, __FUNCTION__))->common.chain))
)
1270 if (TREE_CODE (field)((enum tree_code) (field)->base.code) == FIELD_DECL && !DECL_NONADDRESSABLE_P (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1270, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_2
)
)
1271 {
1272 tree t = TREE_TYPE (field)((contains_struct_check ((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1272, __FUNCTION__))->typed.type)
;
1273 if (void_pointers)
1274 {
1275 /* VECTOR_TYPE and ARRAY_TYPE share the alias set with their
1276 element type and that type has to be normalized to void *,
1277 too, in the case it is a pointer. */
1278 while (!canonical_type_used_p (t) && !POINTER_TYPE_P (t)(((enum tree_code) (t)->base.code) == POINTER_TYPE || ((enum
tree_code) (t)->base.code) == REFERENCE_TYPE)
)
1279 {
1280 gcc_checking_assert (TYPE_STRUCTURAL_EQUALITY_P (t))((void)(!((((tree_class_check ((t), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1280, __FUNCTION__))->type_common.canonical) == (tree) nullptr
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1280, __FUNCTION__), 0 : 0))
;
1281 t = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1281, __FUNCTION__))->typed.type)
;
1282 }
1283 if (POINTER_TYPE_P (t)(((enum tree_code) (t)->base.code) == POINTER_TYPE || ((enum
tree_code) (t)->base.code) == REFERENCE_TYPE)
)
1284 t = ptr_type_nodeglobal_trees[TI_PTR_TYPE];
1285 else if (flag_checkingglobal_options.x_flag_checking)
1286 gcc_checking_assert (get_alias_set (t)((void)(!(get_alias_set (t) == get_alias_set (((contains_struct_check
((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1287, __FUNCTION__))->typed.type))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1287, __FUNCTION__), 0 : 0))
1287 == get_alias_set (TREE_TYPE (field)))((void)(!(get_alias_set (t) == get_alias_set (((contains_struct_check
((field), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1287, __FUNCTION__))->typed.type))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1287, __FUNCTION__), 0 : 0))
;
1288 }
1289
1290 alias_set_type set = get_alias_set (t);
1291 record_alias_subset (superset, set);
1292 /* If the field has alias-set zero make sure to still record
1293 any componets of it. This makes sure that for
1294 struct A {
1295 struct B {
1296 int i;
1297 char c[4];
1298 } b;
1299 };
1300 in C++ even though 'B' has alias-set zero because
1301 TYPE_TYPELESS_STORAGE is set, 'A' has the alias-set of
1302 'int' as subset. */
1303 if (set == 0)
1304 record_component_aliases (t, superset);
1305 }
1306 }
1307 break;
1308
1309 case COMPLEX_TYPE:
1310 record_alias_subset (superset, get_alias_set (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1310, __FUNCTION__))->typed.type)
));
1311 break;
1312
1313 /* VECTOR_TYPE and ARRAY_TYPE share the alias set with their
1314 element type. */
1315
1316 default:
1317 break;
1318 }
1319}
1320
1321/* Record that component types of TYPE, if any, are part of that type for
1322 aliasing purposes. For record types, we only record component types
1323 for fields that are not marked non-addressable. For array types, we
1324 only record the component type if it is not marked non-aliased. */
1325
1326void
1327record_component_aliases (tree type)
1328{
1329 alias_set_type superset = get_alias_set (type);
1330 record_component_aliases (type, superset);
1331}
1332
1333
1334/* Allocate an alias set for use in storing and reading from the varargs
1335 spill area. */
1336
1337static GTY(()) alias_set_type varargs_set = -1;
1338
1339alias_set_type
1340get_varargs_alias_set (void)
1341{
1342#if 1
1343 /* We now lower VA_ARG_EXPR, and there's currently no way to attach the
1344 varargs alias set to an INDIRECT_REF (FIXME!), so we can't
1345 consistently use the varargs alias set for loads from the varargs
1346 area. So don't use it anywhere. */
1347 return 0;
1348#else
1349 if (varargs_set == -1)
1350 varargs_set = new_alias_set ();
1351
1352 return varargs_set;
1353#endif
1354}
1355
1356/* Likewise, but used for the fixed portions of the frame, e.g., register
1357 save areas. */
1358
1359static GTY(()) alias_set_type frame_set = -1;
1360
1361alias_set_type
1362get_frame_alias_set (void)
1363{
1364 if (frame_set == -1)
1
Assuming the condition is true
2
Taking true branch
1365 frame_set = new_alias_set ();
3
Calling 'new_alias_set'
1366
1367 return frame_set;
1368}
1369
1370/* Create a new, unique base with id ID. */
1371
1372static rtx
1373unique_base_value (HOST_WIDE_INTlong id)
1374{
1375 return gen_rtx_ADDRESS (Pmode, id)gen_rtx_fmt_i_stat ((ADDRESS), (((global_options.x_ix86_pmode
== PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
))), ((id)) )
;
1376}
1377
1378/* Return true if accesses based on any other base value cannot alias
1379 those based on X. */
1380
1381static bool
1382unique_base_value_p (rtx x)
1383{
1384 return GET_CODE (x)((enum rtx_code) (x)->code) == ADDRESS && GET_MODE (x)((machine_mode) (x)->mode) == Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
;
1385}
1386
1387/* Return true if X is known to be a base value. */
1388
1389static bool
1390known_base_value_p (rtx x)
1391{
1392 switch (GET_CODE (x)((enum rtx_code) (x)->code))
1393 {
1394 case LABEL_REF:
1395 case SYMBOL_REF:
1396 return true;
1397
1398 case ADDRESS:
1399 /* Arguments may or may not be bases; we don't know for sure. */
1400 return GET_MODE (x)((machine_mode) (x)->mode) != VOIDmode((void) 0, E_VOIDmode);
1401
1402 default:
1403 return false;
1404 }
1405}
1406
1407/* Inside SRC, the source of a SET, find a base address. */
1408
1409static rtx
1410find_base_value (rtx src)
1411{
1412 unsigned int regno;
1413 scalar_int_mode int_mode;
1414
1415#if defined (FIND_BASE_TERM)
1416 /* Try machine-dependent ways to find the base term. */
1417 src = FIND_BASE_TERM (src)ix86_find_base_term (src);
1418#endif
1419
1420 switch (GET_CODE (src)((enum rtx_code) (src)->code))
1421 {
1422 case SYMBOL_REF:
1423 case LABEL_REF:
1424 return src;
1425
1426 case REG:
1427 regno = REGNO (src)(rhs_regno(src));
1428 /* At the start of a function, argument registers have known base
1429 values which may be lost later. Returning an ADDRESS
1430 expression here allows optimization based on argument values
1431 even when the argument registers are used for other purposes. */
1432 if (regno < FIRST_PSEUDO_REGISTER76 && copying_arguments)
1433 return new_reg_base_value[regno];
1434
1435 /* If a pseudo has a known base value, return it. Do not do this
1436 for non-fixed hard regs since it can result in a circular
1437 dependency chain for registers which have values at function entry.
1438
1439 The test above is not sufficient because the scheduler may move
1440 a copy out of an arg reg past the NOTE_INSN_FUNCTION_BEGIN. */
1441 if ((regno >= FIRST_PSEUDO_REGISTER76 || fixed_regs(this_target_hard_regs->x_fixed_regs)[regno])
1442 && regno < vec_safe_length (reg_base_value))
1443 {
1444 /* If we're inside init_alias_analysis, use new_reg_base_value
1445 to reduce the number of relaxation iterations. */
1446 if (new_reg_base_value && new_reg_base_value[regno]
1447 && DF_REG_DEF_COUNT (regno)(df->def_regs[(regno)]->n_refs) == 1)
1448 return new_reg_base_value[regno];
1449
1450 if ((*reg_base_value)[regno])
1451 return (*reg_base_value)[regno];
1452 }
1453
1454 return 0;
1455
1456 case MEM:
1457 /* Check for an argument passed in memory. Only record in the
1458 copying-arguments block; it is too hard to track changes
1459 otherwise. */
1460 if (copying_arguments
1461 && (XEXP (src, 0)(((src)->u.fld[0]).rt_rtx) == arg_pointer_rtx((this_target_rtl->x_global_rtl)[GR_ARG_POINTER])
1462 || (GET_CODE (XEXP (src, 0))((enum rtx_code) ((((src)->u.fld[0]).rt_rtx))->code) == PLUS
1463 && XEXP (XEXP (src, 0), 0)((((((src)->u.fld[0]).rt_rtx))->u.fld[0]).rt_rtx) == arg_pointer_rtx((this_target_rtl->x_global_rtl)[GR_ARG_POINTER]))))
1464 return arg_base_value;
1465 return 0;
1466
1467 case CONST:
1468 src = XEXP (src, 0)(((src)->u.fld[0]).rt_rtx);
1469 if (GET_CODE (src)((enum rtx_code) (src)->code) != PLUS && GET_CODE (src)((enum rtx_code) (src)->code) != MINUS)
1470 break;
1471
1472 /* fall through */
1473
1474 case PLUS:
1475 case MINUS:
1476 {
1477 rtx temp, src_0 = XEXP (src, 0)(((src)->u.fld[0]).rt_rtx), src_1 = XEXP (src, 1)(((src)->u.fld[1]).rt_rtx);
1478
1479 /* If either operand is a REG that is a known pointer, then it
1480 is the base. */
1481 if (REG_P (src_0)(((enum rtx_code) (src_0)->code) == REG) && REG_POINTER (src_0)(__extension__ ({ __typeof ((src_0)) const _rtx = ((src_0)); if
(((enum rtx_code) (_rtx)->code) != REG) rtl_check_failed_flag
("REG_POINTER", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1481, __FUNCTION__); _rtx; })->frame_related)
)
1482 return find_base_value (src_0);
1483 if (REG_P (src_1)(((enum rtx_code) (src_1)->code) == REG) && REG_POINTER (src_1)(__extension__ ({ __typeof ((src_1)) const _rtx = ((src_1)); if
(((enum rtx_code) (_rtx)->code) != REG) rtl_check_failed_flag
("REG_POINTER", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1483, __FUNCTION__); _rtx; })->frame_related)
)
1484 return find_base_value (src_1);
1485
1486 /* If either operand is a REG, then see if we already have
1487 a known value for it. */
1488 if (REG_P (src_0)(((enum rtx_code) (src_0)->code) == REG))
1489 {
1490 temp = find_base_value (src_0);
1491 if (temp != 0)
1492 src_0 = temp;
1493 }
1494
1495 if (REG_P (src_1)(((enum rtx_code) (src_1)->code) == REG))
1496 {
1497 temp = find_base_value (src_1);
1498 if (temp!= 0)
1499 src_1 = temp;
1500 }
1501
1502 /* If either base is named object or a special address
1503 (like an argument or stack reference), then use it for the
1504 base term. */
1505 if (src_0 != 0 && known_base_value_p (src_0))
1506 return src_0;
1507
1508 if (src_1 != 0 && known_base_value_p (src_1))
1509 return src_1;
1510
1511 /* Guess which operand is the base address:
1512 If either operand is a symbol, then it is the base. If
1513 either operand is a CONST_INT, then the other is the base. */
1514 if (CONST_INT_P (src_1)(((enum rtx_code) (src_1)->code) == CONST_INT) || CONSTANT_P (src_0)((rtx_class[(int) (((enum rtx_code) (src_0)->code))]) == RTX_CONST_OBJ
)
)
1515 return find_base_value (src_0);
1516 else if (CONST_INT_P (src_0)(((enum rtx_code) (src_0)->code) == CONST_INT) || CONSTANT_P (src_1)((rtx_class[(int) (((enum rtx_code) (src_1)->code))]) == RTX_CONST_OBJ
)
)
1517 return find_base_value (src_1);
1518
1519 return 0;
1520 }
1521
1522 case LO_SUM:
1523 /* The standard form is (lo_sum reg sym) so look only at the
1524 second operand. */
1525 return find_base_value (XEXP (src, 1)(((src)->u.fld[1]).rt_rtx));
1526
1527 case AND:
1528 /* Look through aligning ANDs. And AND with zero or one with
1529 the LSB set isn't one (see for example PR92462). */
1530 if (CONST_INT_P (XEXP (src, 1))(((enum rtx_code) ((((src)->u.fld[1]).rt_rtx))->code) ==
CONST_INT)
1531 && INTVAL (XEXP (src, 1))(((((src)->u.fld[1]).rt_rtx))->u.hwint[0]) != 0
1532 && (INTVAL (XEXP (src, 1))(((((src)->u.fld[1]).rt_rtx))->u.hwint[0]) & 1) == 0)
1533 return find_base_value (XEXP (src, 0)(((src)->u.fld[0]).rt_rtx));
1534 return 0;
1535
1536 case TRUNCATE:
1537 /* As we do not know which address space the pointer is referring to, we can
1538 handle this only if the target does not support different pointer or
1539 address modes depending on the address space. */
1540 if (!target_default_pointer_address_modes_p ())
1541 break;
1542 if (!is_a <scalar_int_mode> (GET_MODE (src)((machine_mode) (src)->mode), &int_mode)
1543 || GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
))
1544 break;
1545 /* Fall through. */
1546 case HIGH:
1547 case PRE_INC:
1548 case PRE_DEC:
1549 case POST_INC:
1550 case POST_DEC:
1551 case PRE_MODIFY:
1552 case POST_MODIFY:
1553 return find_base_value (XEXP (src, 0)(((src)->u.fld[0]).rt_rtx));
1554
1555 case ZERO_EXTEND:
1556 case SIGN_EXTEND: /* used for NT/Alpha pointers */
1557 /* As we do not know which address space the pointer is referring to, we can
1558 handle this only if the target does not support different pointer or
1559 address modes depending on the address space. */
1560 if (!target_default_pointer_address_modes_p ())
1561 break;
1562
1563 {
1564 rtx temp = find_base_value (XEXP (src, 0)(((src)->u.fld[0]).rt_rtx));
1565
1566 if (temp != 0 && CONSTANT_P (temp)((rtx_class[(int) (((enum rtx_code) (temp)->code))]) == RTX_CONST_OBJ
)
)
1567 temp = convert_memory_address (Pmode, temp)convert_memory_address_addr_space (((global_options.x_ix86_pmode
== PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
)), (temp), 0)
;
1568
1569 return temp;
1570 }
1571
1572 default:
1573 break;
1574 }
1575
1576 return 0;
1577}
1578
1579/* Called from init_alias_analysis indirectly through note_stores,
1580 or directly if DEST is a register with a REG_NOALIAS note attached.
1581 SET is null in the latter case. */
1582
1583/* While scanning insns to find base values, reg_seen[N] is nonzero if
1584 register N has been set in this function. */
1585static sbitmap reg_seen;
1586
1587static void
1588record_set (rtx dest, const_rtx set, void *data ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
1589{
1590 unsigned regno;
1591 rtx src;
1592 int n;
1593
1594 if (!REG_P (dest)(((enum rtx_code) (dest)->code) == REG))
1595 return;
1596
1597 regno = REGNO (dest)(rhs_regno(dest));
1598
1599 gcc_checking_assert (regno < reg_base_value->length ())((void)(!(regno < reg_base_value->length ()) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1599, __FUNCTION__), 0 : 0))
;
1600
1601 n = REG_NREGS (dest)((&(dest)->u.reg)->nregs);
1602 if (n != 1)
1603 {
1604 while (--n >= 0)
1605 {
1606 bitmap_set_bit (reg_seen, regno + n);
1607 new_reg_base_value[regno + n] = 0;
1608 }
1609 return;
1610 }
1611
1612 if (set)
1613 {
1614 /* A CLOBBER wipes out any old value but does not prevent a previously
1615 unset register from acquiring a base address (i.e. reg_seen is not
1616 set). */
1617 if (GET_CODE (set)((enum rtx_code) (set)->code) == CLOBBER)
1618 {
1619 new_reg_base_value[regno] = 0;
1620 return;
1621 }
1622
1623 src = SET_SRC (set)(((set)->u.fld[1]).rt_rtx);
1624 }
1625 else
1626 {
1627 /* There's a REG_NOALIAS note against DEST. */
1628 if (bitmap_bit_p (reg_seen, regno))
1629 {
1630 new_reg_base_value[regno] = 0;
1631 return;
1632 }
1633 bitmap_set_bit (reg_seen, regno);
1634 new_reg_base_value[regno] = unique_base_value (unique_id++);
1635 return;
1636 }
1637
1638 /* If this is not the first set of REGNO, see whether the new value
1639 is related to the old one. There are two cases of interest:
1640
1641 (1) The register might be assigned an entirely new value
1642 that has the same base term as the original set.
1643
1644 (2) The set might be a simple self-modification that
1645 cannot change REGNO's base value.
1646
1647 If neither case holds, reject the original base value as invalid.
1648 Note that the following situation is not detected:
1649
1650 extern int x, y; int *p = &x; p += (&y-&x);
1651
1652 ANSI C does not allow computing the difference of addresses
1653 of distinct top level objects. */
1654 if (new_reg_base_value[regno] != 0
1655 && find_base_value (src) != new_reg_base_value[regno])
1656 switch (GET_CODE (src)((enum rtx_code) (src)->code))
1657 {
1658 case LO_SUM:
1659 case MINUS:
1660 if (XEXP (src, 0)(((src)->u.fld[0]).rt_rtx) != dest && XEXP (src, 1)(((src)->u.fld[1]).rt_rtx) != dest)
1661 new_reg_base_value[regno] = 0;
1662 break;
1663 case PLUS:
1664 /* If the value we add in the PLUS is also a valid base value,
1665 this might be the actual base value, and the original value
1666 an index. */
1667 {
1668 rtx other = NULL_RTX(rtx) 0;
1669
1670 if (XEXP (src, 0)(((src)->u.fld[0]).rt_rtx) == dest)
1671 other = XEXP (src, 1)(((src)->u.fld[1]).rt_rtx);
1672 else if (XEXP (src, 1)(((src)->u.fld[1]).rt_rtx) == dest)
1673 other = XEXP (src, 0)(((src)->u.fld[0]).rt_rtx);
1674
1675 if (! other || find_base_value (other))
1676 new_reg_base_value[regno] = 0;
1677 break;
1678 }
1679 case AND:
1680 if (XEXP (src, 0)(((src)->u.fld[0]).rt_rtx) != dest || !CONST_INT_P (XEXP (src, 1))(((enum rtx_code) ((((src)->u.fld[1]).rt_rtx))->code) ==
CONST_INT)
)
1681 new_reg_base_value[regno] = 0;
1682 break;
1683 default:
1684 new_reg_base_value[regno] = 0;
1685 break;
1686 }
1687 /* If this is the first set of a register, record the value. */
1688 else if ((regno >= FIRST_PSEUDO_REGISTER76 || ! fixed_regs(this_target_hard_regs->x_fixed_regs)[regno])
1689 && ! bitmap_bit_p (reg_seen, regno) && new_reg_base_value[regno] == 0)
1690 new_reg_base_value[regno] = find_base_value (src);
1691
1692 bitmap_set_bit (reg_seen, regno);
1693}
1694
1695/* Return REG_BASE_VALUE for REGNO. Selective scheduler uses this to avoid
1696 using hard registers with non-null REG_BASE_VALUE for renaming. */
1697rtx
1698get_reg_base_value (unsigned int regno)
1699{
1700 return (*reg_base_value)[regno];
1701}
1702
1703/* If a value is known for REGNO, return it. */
1704
1705rtx
1706get_reg_known_value (unsigned int regno)
1707{
1708 if (regno >= FIRST_PSEUDO_REGISTER76)
1709 {
1710 regno -= FIRST_PSEUDO_REGISTER76;
1711 if (regno < vec_safe_length (reg_known_value))
1712 return (*reg_known_value)[regno];
1713 }
1714 return NULLnullptr;
1715}
1716
1717/* Set it. */
1718
1719static void
1720set_reg_known_value (unsigned int regno, rtx val)
1721{
1722 if (regno >= FIRST_PSEUDO_REGISTER76)
1723 {
1724 regno -= FIRST_PSEUDO_REGISTER76;
1725 if (regno < vec_safe_length (reg_known_value))
1726 (*reg_known_value)[regno] = val;
1727 }
1728}
1729
1730/* Similarly for reg_known_equiv_p. */
1731
1732bool
1733get_reg_known_equiv_p (unsigned int regno)
1734{
1735 if (regno >= FIRST_PSEUDO_REGISTER76)
1736 {
1737 regno -= FIRST_PSEUDO_REGISTER76;
1738 if (regno < vec_safe_length (reg_known_value))
1739 return bitmap_bit_p (reg_known_equiv_p, regno);
1740 }
1741 return false;
1742}
1743
1744static void
1745set_reg_known_equiv_p (unsigned int regno, bool val)
1746{
1747 if (regno >= FIRST_PSEUDO_REGISTER76)
1748 {
1749 regno -= FIRST_PSEUDO_REGISTER76;
1750 if (regno < vec_safe_length (reg_known_value))
1751 {
1752 if (val)
1753 bitmap_set_bit (reg_known_equiv_p, regno);
1754 else
1755 bitmap_clear_bit (reg_known_equiv_p, regno);
1756 }
1757 }
1758}
1759
1760
1761/* Returns a canonical version of X, from the point of view alias
1762 analysis. (For example, if X is a MEM whose address is a register,
1763 and the register has a known value (say a SYMBOL_REF), then a MEM
1764 whose address is the SYMBOL_REF is returned.) */
1765
1766rtx
1767canon_rtx (rtx x)
1768{
1769 /* Recursively look for equivalences. */
1770 if (REG_P (x)(((enum rtx_code) (x)->code) == REG) && REGNO (x)(rhs_regno(x)) >= FIRST_PSEUDO_REGISTER76)
1771 {
1772 rtx t = get_reg_known_value (REGNO (x)(rhs_regno(x)));
1773 if (t == x)
1774 return x;
1775 if (t)
1776 return canon_rtx (t);
1777 }
1778
1779 if (GET_CODE (x)((enum rtx_code) (x)->code) == PLUS)
1780 {
1781 rtx x0 = canon_rtx (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx));
1782 rtx x1 = canon_rtx (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx));
1783
1784 if (x0 != XEXP (x, 0)(((x)->u.fld[0]).rt_rtx) || x1 != XEXP (x, 1)(((x)->u.fld[1]).rt_rtx))
1785 return simplify_gen_binary (PLUS, GET_MODE (x)((machine_mode) (x)->mode), x0, x1);
1786 }
1787
1788 /* This gives us much better alias analysis when called from
1789 the loop optimizer. Note we want to leave the original
1790 MEM alone, but need to return the canonicalized MEM with
1791 all the flags with their original values. */
1792 else if (MEM_P (x)(((enum rtx_code) (x)->code) == MEM))
1793 x = replace_equiv_address_nv (x, canon_rtx (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx)));
1794
1795 return x;
1796}
1797
1798/* Return 1 if X and Y are identical-looking rtx's.
1799 Expect that X and Y has been already canonicalized.
1800
1801 We use the data in reg_known_value above to see if two registers with
1802 different numbers are, in fact, equivalent. */
1803
1804static int
1805rtx_equal_for_memref_p (const_rtx x, const_rtx y)
1806{
1807 int i;
1808 int j;
1809 enum rtx_code code;
1810 const char *fmt;
1811
1812 if (x == 0 && y == 0)
1813 return 1;
1814 if (x == 0 || y == 0)
1815 return 0;
1816
1817 if (x == y)
1818 return 1;
1819
1820 code = GET_CODE (x)((enum rtx_code) (x)->code);
1821 /* Rtx's of different codes cannot be equal. */
1822 if (code != GET_CODE (y)((enum rtx_code) (y)->code))
1823 return 0;
1824
1825 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
1826 (REG:SI x) and (REG:HI x) are NOT equivalent. */
1827
1828 if (GET_MODE (x)((machine_mode) (x)->mode) != GET_MODE (y)((machine_mode) (y)->mode))
1829 return 0;
1830
1831 /* Some RTL can be compared without a recursive examination. */
1832 switch (code)
1833 {
1834 case REG:
1835 return REGNO (x)(rhs_regno(x)) == REGNO (y)(rhs_regno(y));
1836
1837 case LABEL_REF:
1838 return label_ref_label (x) == label_ref_label (y);
1839
1840 case SYMBOL_REF:
1841 {
1842 HOST_WIDE_INTlong distance = 0;
1843 return (compare_base_symbol_refs (x, y, &distance) == 1
1844 && distance == 0);
1845 }
1846
1847 case ENTRY_VALUE:
1848 /* This is magic, don't go through canonicalization et al. */
1849 return rtx_equal_p (ENTRY_VALUE_EXP (x)(((x)->u.fld[0]).rt_rtx), ENTRY_VALUE_EXP (y)(((y)->u.fld[0]).rt_rtx));
1850
1851 case VALUE:
1852 CASE_CONST_UNIQUEcase CONST_INT: case CONST_WIDE_INT: case CONST_POLY_INT: case
CONST_DOUBLE: case CONST_FIXED
:
1853 /* Pointer equality guarantees equality for these nodes. */
1854 return 0;
1855
1856 default:
1857 break;
1858 }
1859
1860 /* canon_rtx knows how to handle plus. No need to canonicalize. */
1861 if (code == PLUS)
1862 return ((rtx_equal_for_memref_p (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), XEXP (y, 0)(((y)->u.fld[0]).rt_rtx))
1863 && rtx_equal_for_memref_p (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx), XEXP (y, 1)(((y)->u.fld[1]).rt_rtx)))
1864 || (rtx_equal_for_memref_p (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), XEXP (y, 1)(((y)->u.fld[1]).rt_rtx))
1865 && rtx_equal_for_memref_p (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx), XEXP (y, 0)(((y)->u.fld[0]).rt_rtx))));
1866 /* For commutative operations, the RTX match if the operand match in any
1867 order. Also handle the simple binary and unary cases without a loop. */
1868 if (COMMUTATIVE_P (x)(((rtx_class[(int) (((enum rtx_code) (x)->code))]) & (
~2)) == (RTX_COMM_COMPARE & (~2)))
)
1869 {
1870 rtx xop0 = canon_rtx (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx));
1871 rtx yop0 = canon_rtx (XEXP (y, 0)(((y)->u.fld[0]).rt_rtx));
1872 rtx yop1 = canon_rtx (XEXP (y, 1)(((y)->u.fld[1]).rt_rtx));
1873
1874 return ((rtx_equal_for_memref_p (xop0, yop0)
1875 && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx)), yop1))
1876 || (rtx_equal_for_memref_p (xop0, yop1)
1877 && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx)), yop0)));
1878 }
1879 else if (NON_COMMUTATIVE_P (x)(((rtx_class[(int) (((enum rtx_code) (x)->code))]) & (
~2)) == (RTX_COMPARE & (~2)))
)
1880 {
1881 return (rtx_equal_for_memref_p (canon_rtx (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx)),
1882 canon_rtx (XEXP (y, 0)(((y)->u.fld[0]).rt_rtx)))
1883 && rtx_equal_for_memref_p (canon_rtx (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx)),
1884 canon_rtx (XEXP (y, 1)(((y)->u.fld[1]).rt_rtx))));
1885 }
1886 else if (UNARY_P (x)((rtx_class[(int) (((enum rtx_code) (x)->code))]) == RTX_UNARY
)
)
1887 return rtx_equal_for_memref_p (canon_rtx (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx)),
1888 canon_rtx (XEXP (y, 0)(((y)->u.fld[0]).rt_rtx)));
1889
1890 /* Compare the elements. If any pair of corresponding elements
1891 fail to match, return 0 for the whole things.
1892
1893 Limit cases to types which actually appear in addresses. */
1894
1895 fmt = GET_RTX_FORMAT (code)(rtx_format[(int) (code)]);
1896 for (i = GET_RTX_LENGTH (code)(rtx_length[(int) (code)]) - 1; i >= 0; i--)
1897 {
1898 switch (fmt[i])
1899 {
1900 case 'i':
1901 if (XINT (x, i)(((x)->u.fld[i]).rt_int) != XINT (y, i)(((y)->u.fld[i]).rt_int))
1902 return 0;
1903 break;
1904
1905 case 'p':
1906 if (maybe_ne (SUBREG_BYTE (x)(((x)->u.fld[1]).rt_subreg), SUBREG_BYTE (y)(((y)->u.fld[1]).rt_subreg)))
1907 return 0;
1908 break;
1909
1910 case 'E':
1911 /* Two vectors must have the same length. */
1912 if (XVECLEN (x, i)(((((x)->u.fld[i]).rt_rtvec))->num_elem) != XVECLEN (y, i)(((((y)->u.fld[i]).rt_rtvec))->num_elem))
1913 return 0;
1914
1915 /* And the corresponding elements must match. */
1916 for (j = 0; j < XVECLEN (x, i)(((((x)->u.fld[i]).rt_rtvec))->num_elem); j++)
1917 if (rtx_equal_for_memref_p (canon_rtx (XVECEXP (x, i, j)(((((x)->u.fld[i]).rt_rtvec))->elem[j])),
1918 canon_rtx (XVECEXP (y, i, j)(((((y)->u.fld[i]).rt_rtvec))->elem[j]))) == 0)
1919 return 0;
1920 break;
1921
1922 case 'e':
1923 if (rtx_equal_for_memref_p (canon_rtx (XEXP (x, i)(((x)->u.fld[i]).rt_rtx)),
1924 canon_rtx (XEXP (y, i)(((y)->u.fld[i]).rt_rtx))) == 0)
1925 return 0;
1926 break;
1927
1928 /* This can happen for asm operands. */
1929 case 's':
1930 if (strcmp (XSTR (x, i)(((x)->u.fld[i]).rt_str), XSTR (y, i)(((y)->u.fld[i]).rt_str)))
1931 return 0;
1932 break;
1933
1934 /* This can happen for an asm which clobbers memory. */
1935 case '0':
1936 break;
1937
1938 /* It is believed that rtx's at this level will never
1939 contain anything but integers and other rtx's,
1940 except for within LABEL_REFs and SYMBOL_REFs. */
1941 default:
1942 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 1942, __FUNCTION__))
;
1943 }
1944 }
1945 return 1;
1946}
1947
1948static rtx
1949find_base_term (rtx x, vec<std::pair<cselib_val *,
1950 struct elt_loc_list *> > &visited_vals)
1951{
1952 cselib_val *val;
1953 struct elt_loc_list *l, *f;
1954 rtx ret;
1955 scalar_int_mode int_mode;
1956
1957#if defined (FIND_BASE_TERM)
1958 /* Try machine-dependent ways to find the base term. */
1959 x = FIND_BASE_TERM (x)ix86_find_base_term (x);
1960#endif
1961
1962 switch (GET_CODE (x)((enum rtx_code) (x)->code))
1963 {
1964 case REG:
1965 return REG_BASE_VALUE (x)((rhs_regno(x)) < vec_safe_length (reg_base_value) ? (*reg_base_value
)[(rhs_regno(x))] : 0)
;
1966
1967 case TRUNCATE:
1968 /* As we do not know which address space the pointer is referring to, we can
1969 handle this only if the target does not support different pointer or
1970 address modes depending on the address space. */
1971 if (!target_default_pointer_address_modes_p ())
1972 return 0;
1973 if (!is_a <scalar_int_mode> (GET_MODE (x)((machine_mode) (x)->mode), &int_mode)
1974 || GET_MODE_PRECISION (int_mode) < GET_MODE_PRECISION (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
))
1975 return 0;
1976 /* Fall through. */
1977 case HIGH:
1978 case PRE_INC:
1979 case PRE_DEC:
1980 case POST_INC:
1981 case POST_DEC:
1982 case PRE_MODIFY:
1983 case POST_MODIFY:
1984 return find_base_term (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), visited_vals);
1985
1986 case ZERO_EXTEND:
1987 case SIGN_EXTEND: /* Used for Alpha/NT pointers */
1988 /* As we do not know which address space the pointer is referring to, we can
1989 handle this only if the target does not support different pointer or
1990 address modes depending on the address space. */
1991 if (!target_default_pointer_address_modes_p ())
1992 return 0;
1993
1994 {
1995 rtx temp = find_base_term (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), visited_vals);
1996
1997 if (temp != 0 && CONSTANT_P (temp)((rtx_class[(int) (((enum rtx_code) (temp)->code))]) == RTX_CONST_OBJ
)
)
1998 temp = convert_memory_address (Pmode, temp)convert_memory_address_addr_space (((global_options.x_ix86_pmode
== PMODE_DI ? (scalar_int_mode ((scalar_int_mode::from_int) E_DImode
)) : (scalar_int_mode ((scalar_int_mode::from_int) E_SImode))
)), (temp), 0)
;
1999
2000 return temp;
2001 }
2002
2003 case VALUE:
2004 val = CSELIB_VAL_PTR (x)(((x)->u.fld[0]).rt_cselib);
2005 ret = NULL_RTX(rtx) 0;
2006
2007 if (!val)
2008 return ret;
2009
2010 if (cselib_sp_based_value_p (val))
2011 return static_reg_base_value(this_target_rtl->x_static_reg_base_value)[STACK_POINTER_REGNUM7];
2012
2013 if (visited_vals.length () > (unsigned) param_max_find_base_term_valuesglobal_options.x_param_max_find_base_term_values)
2014 return ret;
2015
2016 f = val->locs;
2017 /* Reset val->locs to avoid infinite recursion. */
2018 if (f)
2019 visited_vals.safe_push (std::make_pair (val, f));
2020 val->locs = NULLnullptr;
2021
2022 for (l = f; l; l = l->next)
2023 if (GET_CODE (l->loc)((enum rtx_code) (l->loc)->code) == VALUE
2024 && CSELIB_VAL_PTR (l->loc)(((l->loc)->u.fld[0]).rt_cselib)->locs
2025 && !CSELIB_VAL_PTR (l->loc)(((l->loc)->u.fld[0]).rt_cselib)->locs->next
2026 && CSELIB_VAL_PTR (l->loc)(((l->loc)->u.fld[0]).rt_cselib)->locs->loc == x)
2027 continue;
2028 else if ((ret = find_base_term (l->loc, visited_vals)) != 0)
2029 break;
2030
2031 return ret;
2032
2033 case LO_SUM:
2034 /* The standard form is (lo_sum reg sym) so look only at the
2035 second operand. */
2036 return find_base_term (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx), visited_vals);
2037
2038 case CONST:
2039 x = XEXP (x, 0)(((x)->u.fld[0]).rt_rtx);
2040 if (GET_CODE (x)((enum rtx_code) (x)->code) != PLUS && GET_CODE (x)((enum rtx_code) (x)->code) != MINUS)
2041 return 0;
2042 /* Fall through. */
2043 case PLUS:
2044 case MINUS:
2045 {
2046 rtx tmp1 = XEXP (x, 0)(((x)->u.fld[0]).rt_rtx);
2047 rtx tmp2 = XEXP (x, 1)(((x)->u.fld[1]).rt_rtx);
2048
2049 /* This is a little bit tricky since we have to determine which of
2050 the two operands represents the real base address. Otherwise this
2051 routine may return the index register instead of the base register.
2052
2053 That may cause us to believe no aliasing was possible, when in
2054 fact aliasing is possible.
2055
2056 We use a few simple tests to guess the base register. Additional
2057 tests can certainly be added. For example, if one of the operands
2058 is a shift or multiply, then it must be the index register and the
2059 other operand is the base register. */
2060
2061 if (tmp1 == pic_offset_table_rtx(this_target_rtl->x_pic_offset_table_rtx) && CONSTANT_P (tmp2)((rtx_class[(int) (((enum rtx_code) (tmp2)->code))]) == RTX_CONST_OBJ
)
)
2062 return find_base_term (tmp2, visited_vals);
2063
2064 /* If either operand is known to be a pointer, then prefer it
2065 to determine the base term. */
2066 if (REG_P (tmp1)(((enum rtx_code) (tmp1)->code) == REG) && REG_POINTER (tmp1)(__extension__ ({ __typeof ((tmp1)) const _rtx = ((tmp1)); if
(((enum rtx_code) (_rtx)->code) != REG) rtl_check_failed_flag
("REG_POINTER", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2066, __FUNCTION__); _rtx; })->frame_related)
)
2067 ;
2068 else if (REG_P (tmp2)(((enum rtx_code) (tmp2)->code) == REG) && REG_POINTER (tmp2)(__extension__ ({ __typeof ((tmp2)) const _rtx = ((tmp2)); if
(((enum rtx_code) (_rtx)->code) != REG) rtl_check_failed_flag
("REG_POINTER", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2068, __FUNCTION__); _rtx; })->frame_related)
)
2069 std::swap (tmp1, tmp2);
2070 /* If second argument is constant which has base term, prefer it
2071 over variable tmp1. See PR64025. */
2072 else if (CONSTANT_P (tmp2)((rtx_class[(int) (((enum rtx_code) (tmp2)->code))]) == RTX_CONST_OBJ
)
&& !CONST_INT_P (tmp2)(((enum rtx_code) (tmp2)->code) == CONST_INT))
2073 std::swap (tmp1, tmp2);
2074
2075 /* Go ahead and find the base term for both operands. If either base
2076 term is from a pointer or is a named object or a special address
2077 (like an argument or stack reference), then use it for the
2078 base term. */
2079 rtx base = find_base_term (tmp1, visited_vals);
2080 if (base != NULL_RTX(rtx) 0
2081 && ((REG_P (tmp1)(((enum rtx_code) (tmp1)->code) == REG) && REG_POINTER (tmp1)(__extension__ ({ __typeof ((tmp1)) const _rtx = ((tmp1)); if
(((enum rtx_code) (_rtx)->code) != REG) rtl_check_failed_flag
("REG_POINTER", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2081, __FUNCTION__); _rtx; })->frame_related)
)
2082 || known_base_value_p (base)))
2083 return base;
2084 base = find_base_term (tmp2, visited_vals);
2085 if (base != NULL_RTX(rtx) 0
2086 && ((REG_P (tmp2)(((enum rtx_code) (tmp2)->code) == REG) && REG_POINTER (tmp2)(__extension__ ({ __typeof ((tmp2)) const _rtx = ((tmp2)); if
(((enum rtx_code) (_rtx)->code) != REG) rtl_check_failed_flag
("REG_POINTER", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2086, __FUNCTION__); _rtx; })->frame_related)
)
2087 || known_base_value_p (base)))
2088 return base;
2089
2090 /* We could not determine which of the two operands was the
2091 base register and which was the index. So we can determine
2092 nothing from the base alias check. */
2093 return 0;
2094 }
2095
2096 case AND:
2097 /* Look through aligning ANDs. And AND with zero or one with
2098 the LSB set isn't one (see for example PR92462). */
2099 if (CONST_INT_P (XEXP (x, 1))(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) == CONST_INT
)
2100 && INTVAL (XEXP (x, 1))(((((x)->u.fld[1]).rt_rtx))->u.hwint[0]) != 0
2101 && (INTVAL (XEXP (x, 1))(((((x)->u.fld[1]).rt_rtx))->u.hwint[0]) & 1) == 0)
2102 return find_base_term (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), visited_vals);
2103 return 0;
2104
2105 case SYMBOL_REF:
2106 case LABEL_REF:
2107 return x;
2108
2109 default:
2110 return 0;
2111 }
2112}
2113
2114/* Wrapper around the worker above which removes locs from visited VALUEs
2115 to avoid visiting them multiple times. We unwind that changes here. */
2116
2117static rtx
2118find_base_term (rtx x)
2119{
2120 auto_vec<std::pair<cselib_val *, struct elt_loc_list *>, 32> visited_vals;
2121 rtx res = find_base_term (x, visited_vals);
2122 for (unsigned i = 0; i < visited_vals.length (); ++i)
2123 visited_vals[i].first->locs = visited_vals[i].second;
2124 return res;
2125}
2126
2127/* Return true if accesses to address X may alias accesses based
2128 on the stack pointer. */
2129
2130bool
2131may_be_sp_based_p (rtx x)
2132{
2133 rtx base = find_base_term (x);
2134 return !base || base == static_reg_base_value(this_target_rtl->x_static_reg_base_value)[STACK_POINTER_REGNUM7];
2135}
2136
2137/* BASE1 and BASE2 are decls. Return 1 if they refer to same object, 0
2138 if they refer to different objects and -1 if we cannot decide. */
2139
2140int
2141compare_base_decls (tree base1, tree base2)
2142{
2143 int ret;
2144 gcc_checking_assert (DECL_P (base1) && DECL_P (base2))((void)(!((tree_code_type[(int) (((enum tree_code) (base1)->
base.code))] == tcc_declaration) && (tree_code_type[(
int) (((enum tree_code) (base2)->base.code))] == tcc_declaration
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2144, __FUNCTION__), 0 : 0))
;
2145 if (base1 == base2)
2146 return 1;
2147
2148 /* If we have two register decls with register specification we
2149 cannot decide unless their assembler names are the same. */
2150 if (VAR_P (base1)(((enum tree_code) (base1)->base.code) == VAR_DECL)
2151 && VAR_P (base2)(((enum tree_code) (base2)->base.code) == VAR_DECL)
2152 && DECL_HARD_REGISTER (base1)((tree_check ((base1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2152, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
)
2153 && DECL_HARD_REGISTER (base2)((tree_check ((base2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2153, __FUNCTION__, (VAR_DECL)))->decl_with_vis.hard_register
)
2154 && DECL_ASSEMBLER_NAME_SET_P (base1)(((contains_struct_check ((base1), (TS_DECL_WITH_VIS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2154, __FUNCTION__))->decl_with_vis.assembler_name) != (
tree) nullptr)
2155 && DECL_ASSEMBLER_NAME_SET_P (base2)(((contains_struct_check ((base2), (TS_DECL_WITH_VIS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2155, __FUNCTION__))->decl_with_vis.assembler_name) != (
tree) nullptr)
)
2156 {
2157 if (DECL_ASSEMBLER_NAME_RAW (base1)((contains_struct_check ((base1), (TS_DECL_WITH_VIS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2157, __FUNCTION__))->decl_with_vis.assembler_name)
== DECL_ASSEMBLER_NAME_RAW (base2)((contains_struct_check ((base2), (TS_DECL_WITH_VIS), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2157, __FUNCTION__))->decl_with_vis.assembler_name)
)
2158 return 1;
2159 return -1;
2160 }
2161
2162 /* Declarations of non-automatic variables may have aliases. All other
2163 decls are unique. */
2164 if (!decl_in_symtab_p (base1)
2165 || !decl_in_symtab_p (base2))
2166 return 0;
2167
2168 /* Don't cause symbols to be inserted by the act of checking. */
2169 symtab_node *node1 = symtab_node::get (base1);
2170 if (!node1)
2171 return 0;
2172 symtab_node *node2 = symtab_node::get (base2);
2173 if (!node2)
2174 return 0;
2175
2176 ret = node1->equal_address_to (node2, true);
2177 return ret;
2178}
2179
2180/* Compare SYMBOL_REFs X_BASE and Y_BASE.
2181
2182 - Return 1 if Y_BASE - X_BASE is constant, adding that constant
2183 to *DISTANCE if DISTANCE is nonnull.
2184
2185 - Return 0 if no accesses based on X_BASE can alias Y_BASE.
2186
2187 - Return -1 if one of the two results applies, but we can't tell
2188 which at compile time. Update DISTANCE in the same way as
2189 for a return value of 1, for the case in which that holds. */
2190
2191static int
2192compare_base_symbol_refs (const_rtx x_base, const_rtx y_base,
2193 HOST_WIDE_INTlong *distance)
2194{
2195 tree x_decl = SYMBOL_REF_DECL (x_base)((__extension__ ({ __typeof ((x_base)) const _rtx = ((x_base)
); if (((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("CONSTANT_POOL_ADDRESS_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2195, __FUNCTION__); _rtx; })->unchanging) ? nullptr : (
(((x_base))->u.fld[1]).rt_tree))
;
2196 tree y_decl = SYMBOL_REF_DECL (y_base)((__extension__ ({ __typeof ((y_base)) const _rtx = ((y_base)
); if (((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("CONSTANT_POOL_ADDRESS_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2196, __FUNCTION__); _rtx; })->unchanging) ? nullptr : (
(((y_base))->u.fld[1]).rt_tree))
;
2197 bool binds_def = true;
2198
2199 if (XSTR (x_base, 0)(((x_base)->u.fld[0]).rt_str) == XSTR (y_base, 0)(((y_base)->u.fld[0]).rt_str))
2200 return 1;
2201 if (x_decl && y_decl)
2202 return compare_base_decls (x_decl, y_decl);
2203 if (x_decl || y_decl)
2204 {
2205 if (!x_decl)
2206 {
2207 std::swap (x_decl, y_decl);
2208 std::swap (x_base, y_base);
2209 }
2210 /* We handle specially only section anchors. Other symbols are
2211 either equal (via aliasing) or refer to different objects. */
2212 if (!SYMBOL_REF_HAS_BLOCK_INFO_P (y_base)(((__extension__ ({ __typeof ((y_base)) const _rtx = ((y_base
)); if (((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("SYMBOL_REF_FLAGS", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2212, __FUNCTION__); _rtx; }) ->u2.symbol_ref_flags) &
(1 << 7)) != 0)
)
2213 return -1;
2214 /* Anchors contains static VAR_DECLs and CONST_DECLs. We are safe
2215 to ignore CONST_DECLs because they are readonly. */
2216 if (!VAR_P (x_decl)(((enum tree_code) (x_decl)->base.code) == VAR_DECL)
2217 || (!TREE_STATIC (x_decl)((x_decl)->base.static_flag) && !TREE_PUBLIC (x_decl)((x_decl)->base.public_flag)))
2218 return 0;
2219
2220 symtab_node *x_node = symtab_node::get_create (x_decl)
2221 ->ultimate_alias_target ();
2222 /* External variable cannot be in section anchor. */
2223 if (!x_node->definition)
2224 return 0;
2225 x_base = XEXP (DECL_RTL (x_node->decl), 0)(((((contains_struct_check ((x_node->decl), (TS_DECL_WRTL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2225, __FUNCTION__))->decl_with_rtl.rtl ? (x_node->decl
)->decl_with_rtl.rtl : (make_decl_rtl (x_node->decl), (
x_node->decl)->decl_with_rtl.rtl)))->u.fld[0]).rt_rtx
)
;
2226 /* If not in anchor, we can disambiguate. */
2227 if (!SYMBOL_REF_HAS_BLOCK_INFO_P (x_base)(((__extension__ ({ __typeof ((x_base)) const _rtx = ((x_base
)); if (((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("SYMBOL_REF_FLAGS", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2227, __FUNCTION__); _rtx; }) ->u2.symbol_ref_flags) &
(1 << 7)) != 0)
)
2228 return 0;
2229
2230 /* We have an alias of anchored variable. If it can be interposed;
2231 we must assume it may or may not alias its anchor. */
2232 binds_def = decl_binds_to_current_def_p (x_decl);
2233 }
2234 /* If we have variable in section anchor, we can compare by offset. */
2235 if (SYMBOL_REF_HAS_BLOCK_INFO_P (x_base)(((__extension__ ({ __typeof ((x_base)) const _rtx = ((x_base
)); if (((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("SYMBOL_REF_FLAGS", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2235, __FUNCTION__); _rtx; }) ->u2.symbol_ref_flags) &
(1 << 7)) != 0)
2236 && SYMBOL_REF_HAS_BLOCK_INFO_P (y_base)(((__extension__ ({ __typeof ((y_base)) const _rtx = ((y_base
)); if (((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("SYMBOL_REF_FLAGS", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2236, __FUNCTION__); _rtx; }) ->u2.symbol_ref_flags) &
(1 << 7)) != 0)
)
2237 {
2238 if (SYMBOL_REF_BLOCK (x_base)((&(x_base)->u.block_sym)->block) != SYMBOL_REF_BLOCK (y_base)((&(y_base)->u.block_sym)->block))
2239 return 0;
2240 if (distance)
2241 *distance += (SYMBOL_REF_BLOCK_OFFSET (y_base)((&(y_base)->u.block_sym)->offset)
2242 - SYMBOL_REF_BLOCK_OFFSET (x_base)((&(x_base)->u.block_sym)->offset));
2243 return binds_def ? 1 : -1;
2244 }
2245 /* Either the symbols are equal (via aliasing) or they refer to
2246 different objects. */
2247 return -1;
2248}
2249
2250/* Return 0 if the addresses X and Y are known to point to different
2251 objects, 1 if they might be pointers to the same object. */
2252
2253static int
2254base_alias_check (rtx x, rtx x_base, rtx y, rtx y_base,
2255 machine_mode x_mode, machine_mode y_mode)
2256{
2257 /* If the address itself has no known base see if a known equivalent
2258 value has one. If either address still has no known base, nothing
2259 is known about aliasing. */
2260 if (x_base == 0)
2261 {
2262 rtx x_c;
2263
2264 if (! flag_expensive_optimizationsglobal_options.x_flag_expensive_optimizations || (x_c = canon_rtx (x)) == x)
2265 return 1;
2266
2267 x_base = find_base_term (x_c);
2268 if (x_base == 0)
2269 return 1;
2270 }
2271
2272 if (y_base == 0)
2273 {
2274 rtx y_c;
2275 if (! flag_expensive_optimizationsglobal_options.x_flag_expensive_optimizations || (y_c = canon_rtx (y)) == y)
2276 return 1;
2277
2278 y_base = find_base_term (y_c);
2279 if (y_base == 0)
2280 return 1;
2281 }
2282
2283 /* If the base addresses are equal nothing is known about aliasing. */
2284 if (rtx_equal_p (x_base, y_base))
2285 return 1;
2286
2287 /* The base addresses are different expressions. If they are not accessed
2288 via AND, there is no conflict. We can bring knowledge of object
2289 alignment into play here. For example, on alpha, "char a, b;" can
2290 alias one another, though "char a; long b;" cannot. AND addresses may
2291 implicitly alias surrounding objects; i.e. unaligned access in DImode
2292 via AND address can alias all surrounding object types except those
2293 with aligment 8 or higher. */
2294 if (GET_CODE (x)((enum rtx_code) (x)->code) == AND && GET_CODE (y)((enum rtx_code) (y)->code) == AND)
2295 return 1;
2296 if (GET_CODE (x)((enum rtx_code) (x)->code) == AND
2297 && (!CONST_INT_P (XEXP (x, 1))(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) == CONST_INT
)
2298 || (int) GET_MODE_UNIT_SIZE (y_mode)mode_to_unit_size (y_mode) < -INTVAL (XEXP (x, 1))(((((x)->u.fld[1]).rt_rtx))->u.hwint[0])))
2299 return 1;
2300 if (GET_CODE (y)((enum rtx_code) (y)->code) == AND
2301 && (!CONST_INT_P (XEXP (y, 1))(((enum rtx_code) ((((y)->u.fld[1]).rt_rtx))->code) == CONST_INT
)
2302 || (int) GET_MODE_UNIT_SIZE (x_mode)mode_to_unit_size (x_mode) < -INTVAL (XEXP (y, 1))(((((y)->u.fld[1]).rt_rtx))->u.hwint[0])))
2303 return 1;
2304
2305 /* Differing symbols not accessed via AND never alias. */
2306 if (GET_CODE (x_base)((enum rtx_code) (x_base)->code) == SYMBOL_REF && GET_CODE (y_base)((enum rtx_code) (y_base)->code) == SYMBOL_REF)
2307 return compare_base_symbol_refs (x_base, y_base) != 0;
2308
2309 if (GET_CODE (x_base)((enum rtx_code) (x_base)->code) != ADDRESS && GET_CODE (y_base)((enum rtx_code) (y_base)->code) != ADDRESS)
2310 return 0;
2311
2312 if (unique_base_value_p (x_base) || unique_base_value_p (y_base))
2313 return 0;
2314
2315 return 1;
2316}
2317
2318/* Return TRUE if EXPR refers to a VALUE whose uid is greater than
2319 (or equal to) that of V. */
2320
2321static bool
2322refs_newer_value_p (const_rtx expr, rtx v)
2323{
2324 int minuid = CSELIB_VAL_PTR (v)(((v)->u.fld[0]).rt_cselib)->uid;
2325 subrtx_iterator::array_type array;
2326 FOR_EACH_SUBRTX (iter, array, expr, NONCONST)for (subrtx_iterator iter (array, expr, rtx_nonconst_subrtx_bounds
); !iter.at_end (); iter.next ())
2327 if (GET_CODE (*iter)((enum rtx_code) (*iter)->code) == VALUE && CSELIB_VAL_PTR (*iter)(((*iter)->u.fld[0]).rt_cselib)->uid >= minuid)
2328 return true;
2329 return false;
2330}
2331
2332/* Convert the address X into something we can use. This is done by returning
2333 it unchanged unless it is a VALUE or VALUE +/- constant; for VALUE
2334 we call cselib to get a more useful rtx. */
2335
2336rtx
2337get_addr (rtx x)
2338{
2339 cselib_val *v;
2340 struct elt_loc_list *l;
2341
2342 if (GET_CODE (x)((enum rtx_code) (x)->code) != VALUE)
2343 {
2344 if ((GET_CODE (x)((enum rtx_code) (x)->code) == PLUS || GET_CODE (x)((enum rtx_code) (x)->code) == MINUS)
2345 && GET_CODE (XEXP (x, 0))((enum rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == VALUE
2346 && CONST_SCALAR_INT_P (XEXP (x, 1))((((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) ==
CONST_INT) || (((enum rtx_code) ((((x)->u.fld[1]).rt_rtx)
)->code) == CONST_WIDE_INT))
)
2347 {
2348 rtx op0 = get_addr (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx));
2349 if (op0 != XEXP (x, 0)(((x)->u.fld[0]).rt_rtx))
2350 {
2351 poly_int64 c;
2352 if (GET_CODE (x)((enum rtx_code) (x)->code) == PLUS
2353 && poly_int_rtx_p (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx), &c))
2354 return plus_constant (GET_MODE (x)((machine_mode) (x)->mode), op0, c);
2355 return simplify_gen_binary (GET_CODE (x)((enum rtx_code) (x)->code), GET_MODE (x)((machine_mode) (x)->mode),
2356 op0, XEXP (x, 1)(((x)->u.fld[1]).rt_rtx));
2357 }
2358 }
2359 return x;
2360 }
2361 v = CSELIB_VAL_PTR (x)(((x)->u.fld[0]).rt_cselib);
2362 if (v)
2363 {
2364 bool have_equivs = cselib_have_permanent_equivalences ();
2365 if (have_equivs)
2366 v = canonical_cselib_val (v);
2367 for (l = v->locs; l; l = l->next)
2368 if (CONSTANT_P (l->loc)((rtx_class[(int) (((enum rtx_code) (l->loc)->code))]) ==
RTX_CONST_OBJ)
)
2369 return l->loc;
2370 for (l = v->locs; l; l = l->next)
2371 if (!REG_P (l->loc)(((enum rtx_code) (l->loc)->code) == REG) && !MEM_P (l->loc)(((enum rtx_code) (l->loc)->code) == MEM)
2372 /* Avoid infinite recursion when potentially dealing with
2373 var-tracking artificial equivalences, by skipping the
2374 equivalences themselves, and not choosing expressions
2375 that refer to newer VALUEs. */
2376 && (!have_equivs
2377 || (GET_CODE (l->loc)((enum rtx_code) (l->loc)->code) != VALUE
2378 && !refs_newer_value_p (l->loc, x))))
2379 return l->loc;
2380 if (have_equivs)
2381 {
2382 for (l = v->locs; l; l = l->next)
2383 if (REG_P (l->loc)(((enum rtx_code) (l->loc)->code) == REG)
2384 || (GET_CODE (l->loc)((enum rtx_code) (l->loc)->code) != VALUE
2385 && !refs_newer_value_p (l->loc, x)))
2386 return l->loc;
2387 /* Return the canonical value. */
2388 return v->val_rtx;
2389 }
2390 if (v->locs)
2391 return v->locs->loc;
2392 }
2393 return x;
2394}
2395
2396/* Return the address of the (N_REFS + 1)th memory reference to ADDR
2397 where SIZE is the size in bytes of the memory reference. If ADDR
2398 is not modified by the memory reference then ADDR is returned. */
2399
2400static rtx
2401addr_side_effect_eval (rtx addr, poly_int64 size, int n_refs)
2402{
2403 poly_int64 offset = 0;
2404
2405 switch (GET_CODE (addr)((enum rtx_code) (addr)->code))
2406 {
2407 case PRE_INC:
2408 offset = (n_refs + 1) * size;
2409 break;
2410 case PRE_DEC:
2411 offset = -(n_refs + 1) * size;
2412 break;
2413 case POST_INC:
2414 offset = n_refs * size;
2415 break;
2416 case POST_DEC:
2417 offset = -n_refs * size;
2418 break;
2419
2420 default:
2421 return addr;
2422 }
2423
2424 addr = plus_constant (GET_MODE (addr)((machine_mode) (addr)->mode), XEXP (addr, 0)(((addr)->u.fld[0]).rt_rtx), offset);
2425 addr = canon_rtx (addr);
2426
2427 return addr;
2428}
2429
2430/* Return TRUE if an object X sized at XSIZE bytes and another object
2431 Y sized at YSIZE bytes, starting C bytes after X, may overlap. If
2432 any of the sizes is zero, assume an overlap, otherwise use the
2433 absolute value of the sizes as the actual sizes. */
2434
2435static inline bool
2436offset_overlap_p (poly_int64 c, poly_int64 xsize, poly_int64 ysize)
2437{
2438 if (known_eq (xsize, 0)(!maybe_ne (xsize, 0)) || known_eq (ysize, 0)(!maybe_ne (ysize, 0)))
2439 return true;
2440
2441 if (maybe_ge (c, 0)maybe_le (0, c))
2442 return maybe_gt (maybe_lt (xsize, 0) ? -xsize : xsize, c)maybe_lt (c, maybe_lt (xsize, 0) ? -xsize : xsize);
2443 else
2444 return maybe_gt (maybe_lt (ysize, 0) ? -ysize : ysize, -c)maybe_lt (-c, maybe_lt (ysize, 0) ? -ysize : ysize);
2445}
2446
2447/* Return one if X and Y (memory addresses) reference the
2448 same location in memory or if the references overlap.
2449 Return zero if they do not overlap, else return
2450 minus one in which case they still might reference the same location.
2451
2452 C is an offset accumulator. When
2453 C is nonzero, we are testing aliases between X and Y + C.
2454 XSIZE is the size in bytes of the X reference,
2455 similarly YSIZE is the size in bytes for Y.
2456 Expect that canon_rtx has been already called for X and Y.
2457
2458 If XSIZE or YSIZE is zero, we do not know the amount of memory being
2459 referenced (the reference was BLKmode), so make the most pessimistic
2460 assumptions.
2461
2462 If XSIZE or YSIZE is negative, we may access memory outside the object
2463 being referenced as a side effect. This can happen when using AND to
2464 align memory references, as is done on the Alpha.
2465
2466 Nice to notice that varying addresses cannot conflict with fp if no
2467 local variables had their addresses taken, but that's too hard now.
2468
2469 ??? Contrary to the tree alias oracle this does not return
2470 one for X + non-constant and Y + non-constant when X and Y are equal.
2471 If that is fixed the TBAA hack for union type-punning can be removed. */
2472
2473static int
2474memrefs_conflict_p (poly_int64 xsize, rtx x, poly_int64 ysize, rtx y,
2475 poly_int64 c)
2476{
2477 if (GET_CODE (x)((enum rtx_code) (x)->code) == VALUE)
2478 {
2479 if (REG_P (y)(((enum rtx_code) (y)->code) == REG))
2480 {
2481 struct elt_loc_list *l = NULLnullptr;
2482 if (CSELIB_VAL_PTR (x)(((x)->u.fld[0]).rt_cselib))
2483 for (l = canonical_cselib_val (CSELIB_VAL_PTR (x)(((x)->u.fld[0]).rt_cselib))->locs;
2484 l; l = l->next)
2485 if (REG_P (l->loc)(((enum rtx_code) (l->loc)->code) == REG) && rtx_equal_for_memref_p (l->loc, y))
2486 break;
2487 if (l)
2488 x = y;
2489 else
2490 x = get_addr (x);
2491 }
2492 /* Don't call get_addr if y is the same VALUE. */
2493 else if (x != y)
2494 x = get_addr (x);
2495 }
2496 if (GET_CODE (y)((enum rtx_code) (y)->code) == VALUE)
2497 {
2498 if (REG_P (x)(((enum rtx_code) (x)->code) == REG))
2499 {
2500 struct elt_loc_list *l = NULLnullptr;
2501 if (CSELIB_VAL_PTR (y)(((y)->u.fld[0]).rt_cselib))
2502 for (l = canonical_cselib_val (CSELIB_VAL_PTR (y)(((y)->u.fld[0]).rt_cselib))->locs;
2503 l; l = l->next)
2504 if (REG_P (l->loc)(((enum rtx_code) (l->loc)->code) == REG) && rtx_equal_for_memref_p (l->loc, x))
2505 break;
2506 if (l)
2507 y = x;
2508 else
2509 y = get_addr (y);
2510 }
2511 /* Don't call get_addr if x is the same VALUE. */
2512 else if (y != x)
2513 y = get_addr (y);
2514 }
2515 if (GET_CODE (x)((enum rtx_code) (x)->code) == HIGH)
2516 x = XEXP (x, 0)(((x)->u.fld[0]).rt_rtx);
2517 else if (GET_CODE (x)((enum rtx_code) (x)->code) == LO_SUM)
2518 x = XEXP (x, 1)(((x)->u.fld[1]).rt_rtx);
2519 else
2520 x = addr_side_effect_eval (x, maybe_lt (xsize, 0) ? -xsize : xsize, 0);
2521 if (GET_CODE (y)((enum rtx_code) (y)->code) == HIGH)
2522 y = XEXP (y, 0)(((y)->u.fld[0]).rt_rtx);
2523 else if (GET_CODE (y)((enum rtx_code) (y)->code) == LO_SUM)
2524 y = XEXP (y, 1)(((y)->u.fld[1]).rt_rtx);
2525 else
2526 y = addr_side_effect_eval (y, maybe_lt (ysize, 0) ? -ysize : ysize, 0);
2527
2528 if (GET_CODE (x)((enum rtx_code) (x)->code) == SYMBOL_REF && GET_CODE (y)((enum rtx_code) (y)->code) == SYMBOL_REF)
2529 {
2530 HOST_WIDE_INTlong distance = 0;
2531 int cmp = compare_base_symbol_refs (x, y, &distance);
2532
2533 /* If both decls are the same, decide by offsets. */
2534 if (cmp == 1)
2535 return offset_overlap_p (c + distance, xsize, ysize);
2536 /* Assume a potential overlap for symbolic addresses that went
2537 through alignment adjustments (i.e., that have negative
2538 sizes), because we can't know how far they are from each
2539 other. */
2540 if (maybe_lt (xsize, 0) || maybe_lt (ysize, 0))
2541 return -1;
2542 /* If decls are different or we know by offsets that there is no overlap,
2543 we win. */
2544 if (!cmp || !offset_overlap_p (c + distance, xsize, ysize))
2545 return 0;
2546 /* Decls may or may not be different and offsets overlap....*/
2547 return -1;
2548 }
2549 else if (rtx_equal_for_memref_p (x, y))
2550 {
2551 return offset_overlap_p (c, xsize, ysize);
2552 }
2553
2554 /* This code used to check for conflicts involving stack references and
2555 globals but the base address alias code now handles these cases. */
2556
2557 if (GET_CODE (x)((enum rtx_code) (x)->code) == PLUS)
2558 {
2559 /* The fact that X is canonicalized means that this
2560 PLUS rtx is canonicalized. */
2561 rtx x0 = XEXP (x, 0)(((x)->u.fld[0]).rt_rtx);
2562 rtx x1 = XEXP (x, 1)(((x)->u.fld[1]).rt_rtx);
2563
2564 /* However, VALUEs might end up in different positions even in
2565 canonical PLUSes. Comparing their addresses is enough. */
2566 if (x0 == y)
2567 return memrefs_conflict_p (xsize, x1, ysize, const0_rtx(const_int_rtx[64]), c);
2568 else if (x1 == y)
2569 return memrefs_conflict_p (xsize, x0, ysize, const0_rtx(const_int_rtx[64]), c);
2570
2571 poly_int64 cx1, cy1;
2572 if (GET_CODE (y)((enum rtx_code) (y)->code) == PLUS)
2573 {
2574 /* The fact that Y is canonicalized means that this
2575 PLUS rtx is canonicalized. */
2576 rtx y0 = XEXP (y, 0)(((y)->u.fld[0]).rt_rtx);
2577 rtx y1 = XEXP (y, 1)(((y)->u.fld[1]).rt_rtx);
2578
2579 if (x0 == y1)
2580 return memrefs_conflict_p (xsize, x1, ysize, y0, c);
2581 if (x1 == y0)
2582 return memrefs_conflict_p (xsize, x0, ysize, y1, c);
2583
2584 if (rtx_equal_for_memref_p (x1, y1))
2585 return memrefs_conflict_p (xsize, x0, ysize, y0, c);
2586 if (rtx_equal_for_memref_p (x0, y0))
2587 return memrefs_conflict_p (xsize, x1, ysize, y1, c);
2588 if (poly_int_rtx_p (x1, &cx1))
2589 {
2590 if (poly_int_rtx_p (y1, &cy1))
2591 return memrefs_conflict_p (xsize, x0, ysize, y0,
2592 c - cx1 + cy1);
2593 else
2594 return memrefs_conflict_p (xsize, x0, ysize, y, c - cx1);
2595 }
2596 else if (poly_int_rtx_p (y1, &cy1))
2597 return memrefs_conflict_p (xsize, x, ysize, y0, c + cy1);
2598
2599 return -1;
2600 }
2601 else if (poly_int_rtx_p (x1, &cx1))
2602 return memrefs_conflict_p (xsize, x0, ysize, y, c - cx1);
2603 }
2604 else if (GET_CODE (y)((enum rtx_code) (y)->code) == PLUS)
2605 {
2606 /* The fact that Y is canonicalized means that this
2607 PLUS rtx is canonicalized. */
2608 rtx y0 = XEXP (y, 0)(((y)->u.fld[0]).rt_rtx);
2609 rtx y1 = XEXP (y, 1)(((y)->u.fld[1]).rt_rtx);
2610
2611 if (x == y0)
2612 return memrefs_conflict_p (xsize, const0_rtx(const_int_rtx[64]), ysize, y1, c);
2613 if (x == y1)
2614 return memrefs_conflict_p (xsize, const0_rtx(const_int_rtx[64]), ysize, y0, c);
2615
2616 poly_int64 cy1;
2617 if (poly_int_rtx_p (y1, &cy1))
2618 return memrefs_conflict_p (xsize, x, ysize, y0, c + cy1);
2619 else
2620 return -1;
2621 }
2622
2623 if (GET_CODE (x)((enum rtx_code) (x)->code) == GET_CODE (y)((enum rtx_code) (y)->code))
2624 switch (GET_CODE (x)((enum rtx_code) (x)->code))
2625 {
2626 case MULT:
2627 {
2628 /* Handle cases where we expect the second operands to be the
2629 same, and check only whether the first operand would conflict
2630 or not. */
2631 rtx x0, y0;
2632 rtx x1 = canon_rtx (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx));
2633 rtx y1 = canon_rtx (XEXP (y, 1)(((y)->u.fld[1]).rt_rtx));
2634 if (! rtx_equal_for_memref_p (x1, y1))
2635 return -1;
2636 x0 = canon_rtx (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx));
2637 y0 = canon_rtx (XEXP (y, 0)(((y)->u.fld[0]).rt_rtx));
2638 if (rtx_equal_for_memref_p (x0, y0))
2639 return offset_overlap_p (c, xsize, ysize);
2640
2641 /* Can't properly adjust our sizes. */
2642 poly_int64 c1;
2643 if (!poly_int_rtx_p (x1, &c1)
2644 || !can_div_trunc_p (xsize, c1, &xsize)
2645 || !can_div_trunc_p (ysize, c1, &ysize)
2646 || !can_div_trunc_p (c, c1, &c))
2647 return -1;
2648 return memrefs_conflict_p (xsize, x0, ysize, y0, c);
2649 }
2650
2651 default:
2652 break;
2653 }
2654
2655 /* Deal with alignment ANDs by adjusting offset and size so as to
2656 cover the maximum range, without taking any previously known
2657 alignment into account. Make a size negative after such an
2658 adjustments, so that, if we end up with e.g. two SYMBOL_REFs, we
2659 assume a potential overlap, because they may end up in contiguous
2660 memory locations and the stricter-alignment access may span over
2661 part of both. */
2662 if (GET_CODE (x)((enum rtx_code) (x)->code) == AND && CONST_INT_P (XEXP (x, 1))(((enum rtx_code) ((((x)->u.fld[1]).rt_rtx))->code) == CONST_INT
)
)
2663 {
2664 HOST_WIDE_INTlong sc = INTVAL (XEXP (x, 1))(((((x)->u.fld[1]).rt_rtx))->u.hwint[0]);
2665 unsigned HOST_WIDE_INTlong uc = sc;
2666 if (sc < 0 && pow2_or_zerop (-uc))
2667 {
2668 if (maybe_gt (xsize, 0)maybe_lt (0, xsize))
2669 xsize = -xsize;
2670 if (maybe_ne (xsize, 0))
2671 xsize += sc + 1;
2672 c -= sc + 1;
2673 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx)),
2674 ysize, y, c);
2675 }
2676 }
2677 if (GET_CODE (y)((enum rtx_code) (y)->code) == AND && CONST_INT_P (XEXP (y, 1))(((enum rtx_code) ((((y)->u.fld[1]).rt_rtx))->code) == CONST_INT
)
)
2678 {
2679 HOST_WIDE_INTlong sc = INTVAL (XEXP (y, 1))(((((y)->u.fld[1]).rt_rtx))->u.hwint[0]);
2680 unsigned HOST_WIDE_INTlong uc = sc;
2681 if (sc < 0 && pow2_or_zerop (-uc))
2682 {
2683 if (maybe_gt (ysize, 0)maybe_lt (0, ysize))
2684 ysize = -ysize;
2685 if (maybe_ne (ysize, 0))
2686 ysize += sc + 1;
2687 c += sc + 1;
2688 return memrefs_conflict_p (xsize, x,
2689 ysize, canon_rtx (XEXP (y, 0)(((y)->u.fld[0]).rt_rtx)), c);
2690 }
2691 }
2692
2693 if (CONSTANT_P (x)((rtx_class[(int) (((enum rtx_code) (x)->code))]) == RTX_CONST_OBJ
)
)
2694 {
2695 poly_int64 cx, cy;
2696 if (poly_int_rtx_p (x, &cx) && poly_int_rtx_p (y, &cy))
2697 {
2698 c += cy - cx;
2699 return offset_overlap_p (c, xsize, ysize);
2700 }
2701
2702 if (GET_CODE (x)((enum rtx_code) (x)->code) == CONST)
2703 {
2704 if (GET_CODE (y)((enum rtx_code) (y)->code) == CONST)
2705 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx)),
2706 ysize, canon_rtx (XEXP (y, 0)(((y)->u.fld[0]).rt_rtx)), c);
2707 else
2708 return memrefs_conflict_p (xsize, canon_rtx (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx)),
2709 ysize, y, c);
2710 }
2711 if (GET_CODE (y)((enum rtx_code) (y)->code) == CONST)
2712 return memrefs_conflict_p (xsize, x, ysize,
2713 canon_rtx (XEXP (y, 0)(((y)->u.fld[0]).rt_rtx)), c);
2714
2715 /* Assume a potential overlap for symbolic addresses that went
2716 through alignment adjustments (i.e., that have negative
2717 sizes), because we can't know how far they are from each
2718 other. */
2719 if (CONSTANT_P (y)((rtx_class[(int) (((enum rtx_code) (y)->code))]) == RTX_CONST_OBJ
)
)
2720 return (maybe_lt (xsize, 0)
2721 || maybe_lt (ysize, 0)
2722 || offset_overlap_p (c, xsize, ysize));
2723
2724 return -1;
2725 }
2726
2727 return -1;
2728}
2729
2730/* Functions to compute memory dependencies.
2731
2732 Since we process the insns in execution order, we can build tables
2733 to keep track of what registers are fixed (and not aliased), what registers
2734 are varying in known ways, and what registers are varying in unknown
2735 ways.
2736
2737 If both memory references are volatile, then there must always be a
2738 dependence between the two references, since their order cannot be
2739 changed. A volatile and non-volatile reference can be interchanged
2740 though.
2741
2742 We also must allow AND addresses, because they may generate accesses
2743 outside the object being referenced. This is used to generate aligned
2744 addresses from unaligned addresses, for instance, the alpha
2745 storeqi_unaligned pattern. */
2746
2747/* Read dependence: X is read after read in MEM takes place. There can
2748 only be a dependence here if both reads are volatile, or if either is
2749 an explicit barrier. */
2750
2751int
2752read_dependence (const_rtx mem, const_rtx x)
2753{
2754 if (MEM_VOLATILE_P (x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2754, __FUNCTION__); _rtx; })->volatil)
&& MEM_VOLATILE_P (mem)(__extension__ ({ __typeof ((mem)) const _rtx = ((mem)); if (
((enum rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2754, __FUNCTION__); _rtx; })->volatil)
)
2755 return true;
2756 if (MEM_ALIAS_SET (x)(get_mem_attrs (x)->alias) == ALIAS_SET_MEMORY_BARRIER((alias_set_type) -1)
2757 || MEM_ALIAS_SET (mem)(get_mem_attrs (mem)->alias) == ALIAS_SET_MEMORY_BARRIER((alias_set_type) -1))
2758 return true;
2759 return false;
2760}
2761
2762/* Look at the bottom of the COMPONENT_REF list for a DECL, and return it. */
2763
2764static tree
2765decl_for_component_ref (tree x)
2766{
2767 do
2768 {
2769 x = TREE_OPERAND (x, 0)(*((const_cast<tree*> (tree_operand_check ((x), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2769, __FUNCTION__)))))
;
2770 }
2771 while (x && TREE_CODE (x)((enum tree_code) (x)->base.code) == COMPONENT_REF);
2772
2773 return x && DECL_P (x)(tree_code_type[(int) (((enum tree_code) (x)->base.code))]
== tcc_declaration)
? x : NULL_TREE(tree) nullptr;
2774}
2775
2776/* Walk up the COMPONENT_REF list in X and adjust *OFFSET to compensate
2777 for the offset of the field reference. *KNOWN_P says whether the
2778 offset is known. */
2779
2780static void
2781adjust_offset_for_component_ref (tree x, bool *known_p,
2782 poly_int64 *offset)
2783{
2784 if (!*known_p)
2785 return;
2786 do
2787 {
2788 tree xoffset = component_ref_field_offset (x);
2789 tree field = TREE_OPERAND (x, 1)(*((const_cast<tree*> (tree_operand_check ((x), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2789, __FUNCTION__)))))
;
2790 if (!poly_int_tree_p (xoffset))
2791 {
2792 *known_p = false;
2793 return;
2794 }
2795
2796 poly_offset_int woffset
2797 = (wi::to_poly_offset (xoffset)
2798 + (wi::to_offset (DECL_FIELD_BIT_OFFSET (field)((tree_check ((field), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2798, __FUNCTION__, (FIELD_DECL)))->field_decl.bit_offset
)
)
2799 >> LOG2_BITS_PER_UNIT3)
2800 + *offset);
2801 if (!woffset.to_shwi (offset))
2802 {
2803 *known_p = false;
2804 return;
2805 }
2806
2807 x = TREE_OPERAND (x, 0)(*((const_cast<tree*> (tree_operand_check ((x), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2807, __FUNCTION__)))))
;
2808 }
2809 while (x && TREE_CODE (x)((enum tree_code) (x)->base.code) == COMPONENT_REF);
2810}
2811
2812/* Return nonzero if we can determine the exprs corresponding to memrefs
2813 X and Y and they do not overlap.
2814 If LOOP_VARIANT is set, skip offset-based disambiguation */
2815
2816int
2817nonoverlapping_memrefs_p (const_rtx x, const_rtx y, bool loop_invariant)
2818{
2819 tree exprx = MEM_EXPR (x)(get_mem_attrs (x)->expr), expry = MEM_EXPR (y)(get_mem_attrs (y)->expr);
2820 rtx rtlx, rtly;
2821 rtx basex, basey;
2822 bool moffsetx_known_p, moffsety_known_p;
2823 poly_int64 moffsetx = 0, moffsety = 0;
2824 poly_int64 offsetx = 0, offsety = 0, sizex, sizey;
2825
2826 /* Unless both have exprs, we can't tell anything. */
2827 if (exprx == 0 || expry == 0)
2828 return 0;
2829
2830 /* For spill-slot accesses make sure we have valid offsets. */
2831 if ((exprx == get_spill_slot_decl (false)
2832 && ! MEM_OFFSET_KNOWN_P (x)(get_mem_attrs (x)->offset_known_p))
2833 || (expry == get_spill_slot_decl (false)
2834 && ! MEM_OFFSET_KNOWN_P (y)(get_mem_attrs (y)->offset_known_p)))
2835 return 0;
2836
2837 /* If the field reference test failed, look at the DECLs involved. */
2838 moffsetx_known_p = MEM_OFFSET_KNOWN_P (x)(get_mem_attrs (x)->offset_known_p);
2839 if (moffsetx_known_p)
2840 moffsetx = MEM_OFFSET (x)(get_mem_attrs (x)->offset);
2841 if (TREE_CODE (exprx)((enum tree_code) (exprx)->base.code) == COMPONENT_REF)
2842 {
2843 tree t = decl_for_component_ref (exprx);
2844 if (! t)
2845 return 0;
2846 adjust_offset_for_component_ref (exprx, &moffsetx_known_p, &moffsetx);
2847 exprx = t;
2848 }
2849
2850 moffsety_known_p = MEM_OFFSET_KNOWN_P (y)(get_mem_attrs (y)->offset_known_p);
2851 if (moffsety_known_p)
2852 moffsety = MEM_OFFSET (y)(get_mem_attrs (y)->offset);
2853 if (TREE_CODE (expry)((enum tree_code) (expry)->base.code) == COMPONENT_REF)
2854 {
2855 tree t = decl_for_component_ref (expry);
2856 if (! t)
2857 return 0;
2858 adjust_offset_for_component_ref (expry, &moffsety_known_p, &moffsety);
2859 expry = t;
2860 }
2861
2862 if (! DECL_P (exprx)(tree_code_type[(int) (((enum tree_code) (exprx)->base.code
))] == tcc_declaration)
|| ! DECL_P (expry)(tree_code_type[(int) (((enum tree_code) (expry)->base.code
))] == tcc_declaration)
)
2863 return 0;
2864
2865 /* If we refer to different gimple registers, or one gimple register
2866 and one non-gimple-register, we know they can't overlap. First,
2867 gimple registers don't have their addresses taken. Now, there
2868 could be more than one stack slot for (different versions of) the
2869 same gimple register, but we can presumably tell they don't
2870 overlap based on offsets from stack base addresses elsewhere.
2871 It's important that we don't proceed to DECL_RTL, because gimple
2872 registers may not pass DECL_RTL_SET_P, and make_decl_rtl won't be
2873 able to do anything about them since no SSA information will have
2874 remained to guide it. */
2875 if (is_gimple_reg (exprx) || is_gimple_reg (expry))
2876 return exprx != expry
2877 || (moffsetx_known_p && moffsety_known_p
2878 && MEM_SIZE_KNOWN_P (x)(get_mem_attrs (x)->size_known_p) && MEM_SIZE_KNOWN_P (y)(get_mem_attrs (y)->size_known_p)
2879 && !offset_overlap_p (moffsety - moffsetx,
2880 MEM_SIZE (x)(get_mem_attrs (x)->size), MEM_SIZE (y)(get_mem_attrs (y)->size)));
2881
2882 /* With invalid code we can end up storing into the constant pool.
2883 Bail out to avoid ICEing when creating RTL for this.
2884 See gfortran.dg/lto/20091028-2_0.f90. */
2885 if (TREE_CODE (exprx)((enum tree_code) (exprx)->base.code) == CONST_DECL
2886 || TREE_CODE (expry)((enum tree_code) (expry)->base.code) == CONST_DECL)
2887 return 1;
2888
2889 /* If one decl is known to be a function or label in a function and
2890 the other is some kind of data, they can't overlap. */
2891 if ((TREE_CODE (exprx)((enum tree_code) (exprx)->base.code) == FUNCTION_DECL
2892 || TREE_CODE (exprx)((enum tree_code) (exprx)->base.code) == LABEL_DECL)
2893 != (TREE_CODE (expry)((enum tree_code) (expry)->base.code) == FUNCTION_DECL
2894 || TREE_CODE (expry)((enum tree_code) (expry)->base.code) == LABEL_DECL))
2895 return 1;
2896
2897 /* If either of the decls doesn't have DECL_RTL set (e.g. marked as
2898 living in multiple places), we can't tell anything. Exception
2899 are FUNCTION_DECLs for which we can create DECL_RTL on demand. */
2900 if ((!DECL_RTL_SET_P (exprx)(((tree_contains_struct[(((enum tree_code) (exprx)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((exprx
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2900, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
&& TREE_CODE (exprx)((enum tree_code) (exprx)->base.code) != FUNCTION_DECL)
2901 || (!DECL_RTL_SET_P (expry)(((tree_contains_struct[(((enum tree_code) (expry)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((expry
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2901, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
&& TREE_CODE (expry)((enum tree_code) (expry)->base.code) != FUNCTION_DECL))
2902 return 0;
2903
2904 rtlx = DECL_RTL (exprx)((contains_struct_check ((exprx), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2904, __FUNCTION__))->decl_with_rtl.rtl ? (exprx)->decl_with_rtl
.rtl : (make_decl_rtl (exprx), (exprx)->decl_with_rtl.rtl)
)
;
2905 rtly = DECL_RTL (expry)((contains_struct_check ((expry), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2905, __FUNCTION__))->decl_with_rtl.rtl ? (expry)->decl_with_rtl
.rtl : (make_decl_rtl (expry), (expry)->decl_with_rtl.rtl)
)
;
2906
2907 /* If either RTL is not a MEM, it must be a REG or CONCAT, meaning they
2908 can't overlap unless they are the same because we never reuse that part
2909 of the stack frame used for locals for spilled pseudos. */
2910 if ((!MEM_P (rtlx)(((enum rtx_code) (rtlx)->code) == MEM) || !MEM_P (rtly)(((enum rtx_code) (rtly)->code) == MEM))
2911 && ! rtx_equal_p (rtlx, rtly))
2912 return 1;
2913
2914 /* If we have MEMs referring to different address spaces (which can
2915 potentially overlap), we cannot easily tell from the addresses
2916 whether the references overlap. */
2917 if (MEM_P (rtlx)(((enum rtx_code) (rtlx)->code) == MEM) && MEM_P (rtly)(((enum rtx_code) (rtly)->code) == MEM)
2918 && MEM_ADDR_SPACE (rtlx)(get_mem_attrs (rtlx)->addrspace) != MEM_ADDR_SPACE (rtly)(get_mem_attrs (rtly)->addrspace))
2919 return 0;
2920
2921 /* Get the base and offsets of both decls. If either is a register, we
2922 know both are and are the same, so use that as the base. The only
2923 we can avoid overlap is if we can deduce that they are nonoverlapping
2924 pieces of that decl, which is very rare. */
2925 basex = MEM_P (rtlx)(((enum rtx_code) (rtlx)->code) == MEM) ? XEXP (rtlx, 0)(((rtlx)->u.fld[0]).rt_rtx) : rtlx;
2926 basex = strip_offset_and_add (basex, &offsetx);
2927
2928 basey = MEM_P (rtly)(((enum rtx_code) (rtly)->code) == MEM) ? XEXP (rtly, 0)(((rtly)->u.fld[0]).rt_rtx) : rtly;
2929 basey = strip_offset_and_add (basey, &offsety);
2930
2931 /* If the bases are different, we know they do not overlap if both
2932 are constants or if one is a constant and the other a pointer into the
2933 stack frame. Otherwise a different base means we can't tell if they
2934 overlap or not. */
2935 if (compare_base_decls (exprx, expry) == 0)
2936 return ((CONSTANT_P (basex)((rtx_class[(int) (((enum rtx_code) (basex)->code))]) == RTX_CONST_OBJ
)
&& CONSTANT_P (basey)((rtx_class[(int) (((enum rtx_code) (basey)->code))]) == RTX_CONST_OBJ
)
)
2937 || (CONSTANT_P (basex)((rtx_class[(int) (((enum rtx_code) (basex)->code))]) == RTX_CONST_OBJ
)
&& REG_P (basey)(((enum rtx_code) (basey)->code) == REG)
2938 && REGNO_PTR_FRAME_P (REGNO (basey))(((rhs_regno(basey))) == 7 || ((rhs_regno(basey))) == 19 || (
(rhs_regno(basey))) == 6 || ((rhs_regno(basey))) == 16 || (((
rhs_regno(basey))) >= (76) && ((rhs_regno(basey)))
<= (((76)) + 4)))
)
2939 || (CONSTANT_P (basey)((rtx_class[(int) (((enum rtx_code) (basey)->code))]) == RTX_CONST_OBJ
)
&& REG_P (basex)(((enum rtx_code) (basex)->code) == REG)
2940 && REGNO_PTR_FRAME_P (REGNO (basex))(((rhs_regno(basex))) == 7 || ((rhs_regno(basex))) == 19 || (
(rhs_regno(basex))) == 6 || ((rhs_regno(basex))) == 16 || (((
rhs_regno(basex))) >= (76) && ((rhs_regno(basex)))
<= (((76)) + 4)))
));
2941
2942 /* Offset based disambiguation not appropriate for loop invariant */
2943 if (loop_invariant)
2944 return 0;
2945
2946 /* Offset based disambiguation is OK even if we do not know that the
2947 declarations are necessarily different
2948 (i.e. compare_base_decls (exprx, expry) == -1) */
2949
2950 sizex = (!MEM_P (rtlx)(((enum rtx_code) (rtlx)->code) == MEM) ? poly_int64 (GET_MODE_SIZE (GET_MODE (rtlx)((machine_mode) (rtlx)->mode)))
2951 : MEM_SIZE_KNOWN_P (rtlx)(get_mem_attrs (rtlx)->size_known_p) ? MEM_SIZE (rtlx)(get_mem_attrs (rtlx)->size)
2952 : -1);
2953 sizey = (!MEM_P (rtly)(((enum rtx_code) (rtly)->code) == MEM) ? poly_int64 (GET_MODE_SIZE (GET_MODE (rtly)((machine_mode) (rtly)->mode)))
2954 : MEM_SIZE_KNOWN_P (rtly)(get_mem_attrs (rtly)->size_known_p) ? MEM_SIZE (rtly)(get_mem_attrs (rtly)->size)
2955 : -1);
2956
2957 /* If we have an offset for either memref, it can update the values computed
2958 above. */
2959 if (moffsetx_known_p)
2960 offsetx += moffsetx, sizex -= moffsetx;
2961 if (moffsety_known_p)
2962 offsety += moffsety, sizey -= moffsety;
2963
2964 /* If a memref has both a size and an offset, we can use the smaller size.
2965 We can't do this if the offset isn't known because we must view this
2966 memref as being anywhere inside the DECL's MEM. */
2967 if (MEM_SIZE_KNOWN_P (x)(get_mem_attrs (x)->size_known_p) && moffsetx_known_p)
2968 sizex = MEM_SIZE (x)(get_mem_attrs (x)->size);
2969 if (MEM_SIZE_KNOWN_P (y)(get_mem_attrs (y)->size_known_p) && moffsety_known_p)
2970 sizey = MEM_SIZE (y)(get_mem_attrs (y)->size);
2971
2972 return !ranges_maybe_overlap_p (offsetx, sizex, offsety, sizey);
2973}
2974
2975/* Helper for true_dependence and canon_true_dependence.
2976 Checks for true dependence: X is read after store in MEM takes place.
2977
2978 If MEM_CANONICALIZED is FALSE, then X_ADDR and MEM_ADDR should be
2979 NULL_RTX, and the canonical addresses of MEM and X are both computed
2980 here. If MEM_CANONICALIZED, then MEM must be already canonicalized.
2981
2982 If X_ADDR is non-NULL, it is used in preference of XEXP (x, 0).
2983
2984 Returns 1 if there is a true dependence, 0 otherwise. */
2985
2986static int
2987true_dependence_1 (const_rtx mem, machine_mode mem_mode, rtx mem_addr,
2988 const_rtx x, rtx x_addr, bool mem_canonicalized)
2989{
2990 rtx true_mem_addr;
2991 rtx base;
2992 int ret;
2993
2994 gcc_checking_assert (mem_canonicalized ? (mem_addr != NULL_RTX)((void)(!(mem_canonicalized ? (mem_addr != (rtx) 0) : (mem_addr
== (rtx) 0 && x_addr == (rtx) 0)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2995, __FUNCTION__), 0 : 0))
2995 : (mem_addr == NULL_RTX && x_addr == NULL_RTX))((void)(!(mem_canonicalized ? (mem_addr != (rtx) 0) : (mem_addr
== (rtx) 0 && x_addr == (rtx) 0)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2995, __FUNCTION__), 0 : 0))
;
2996
2997 if (MEM_VOLATILE_P (x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2997, __FUNCTION__); _rtx; })->volatil)
&& MEM_VOLATILE_P (mem)(__extension__ ({ __typeof ((mem)) const _rtx = ((mem)); if (
((enum rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 2997, __FUNCTION__); _rtx; })->volatil)
)
2998 return 1;
2999
3000 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
3001 This is used in epilogue deallocation functions, and in cselib. */
3002 if (GET_MODE (x)((machine_mode) (x)->mode) == BLKmode((void) 0, E_BLKmode) && GET_CODE (XEXP (x, 0))((enum rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == SCRATCH)
3003 return 1;
3004 if (GET_MODE (mem)((machine_mode) (mem)->mode) == BLKmode((void) 0, E_BLKmode) && GET_CODE (XEXP (mem, 0))((enum rtx_code) ((((mem)->u.fld[0]).rt_rtx))->code) == SCRATCH)
3005 return 1;
3006 if (MEM_ALIAS_SET (x)(get_mem_attrs (x)->alias) == ALIAS_SET_MEMORY_BARRIER((alias_set_type) -1)
3007 || MEM_ALIAS_SET (mem)(get_mem_attrs (mem)->alias) == ALIAS_SET_MEMORY_BARRIER((alias_set_type) -1))
3008 return 1;
3009
3010 if (! x_addr)
3011 x_addr = XEXP (x, 0)(((x)->u.fld[0]).rt_rtx);
3012 x_addr = get_addr (x_addr);
3013
3014 if (! mem_addr)
3015 {
3016 mem_addr = XEXP (mem, 0)(((mem)->u.fld[0]).rt_rtx);
3017 if (mem_mode == VOIDmode((void) 0, E_VOIDmode))
3018 mem_mode = GET_MODE (mem)((machine_mode) (mem)->mode);
3019 }
3020 true_mem_addr = get_addr (mem_addr);
3021
3022 /* Read-only memory is by definition never modified, and therefore can't
3023 conflict with anything. However, don't assume anything when AND
3024 addresses are involved and leave to the code below to determine
3025 dependence. We don't expect to find read-only set on MEM, but
3026 stupid user tricks can produce them, so don't die. */
3027 if (MEM_READONLY_P (x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != MEM) rtl_check_failed_flag ("MEM_READONLY_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3027, __FUNCTION__); _rtx; })->unchanging)
3028 && GET_CODE (x_addr)((enum rtx_code) (x_addr)->code) != AND
3029 && GET_CODE (true_mem_addr)((enum rtx_code) (true_mem_addr)->code) != AND)
3030 return 0;
3031
3032 /* If we have MEMs referring to different address spaces (which can
3033 potentially overlap), we cannot easily tell from the addresses
3034 whether the references overlap. */
3035 if (MEM_ADDR_SPACE (mem)(get_mem_attrs (mem)->addrspace) != MEM_ADDR_SPACE (x)(get_mem_attrs (x)->addrspace))
3036 return 1;
3037
3038 base = find_base_term (x_addr);
3039 if (base && (GET_CODE (base)((enum rtx_code) (base)->code) == LABEL_REF
3040 || (GET_CODE (base)((enum rtx_code) (base)->code) == SYMBOL_REF
3041 && CONSTANT_POOL_ADDRESS_P (base)(__extension__ ({ __typeof ((base)) const _rtx = ((base)); if
(((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("CONSTANT_POOL_ADDRESS_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3041, __FUNCTION__); _rtx; })->unchanging)
)))
3042 return 0;
3043
3044 rtx mem_base = find_base_term (true_mem_addr);
3045 if (! base_alias_check (x_addr, base, true_mem_addr, mem_base,
3046 GET_MODE (x)((machine_mode) (x)->mode), mem_mode))
3047 return 0;
3048
3049 x_addr = canon_rtx (x_addr);
3050 if (!mem_canonicalized)
3051 mem_addr = canon_rtx (true_mem_addr);
3052
3053 if ((ret = memrefs_conflict_p (GET_MODE_SIZE (mem_mode), mem_addr,
3054 SIZE_FOR_MODE (x)(GET_MODE_SIZE (((machine_mode) (x)->mode))), x_addr, 0)) != -1)
3055 return ret;
3056
3057 if (mems_in_disjoint_alias_sets_p (x, mem))
3058 return 0;
3059
3060 if (nonoverlapping_memrefs_p (mem, x, false))
3061 return 0;
3062
3063 return rtx_refs_may_alias_p (x, mem, true);
3064}
3065
3066/* True dependence: X is read after store in MEM takes place. */
3067
3068int
3069true_dependence (const_rtx mem, machine_mode mem_mode, const_rtx x)
3070{
3071 return true_dependence_1 (mem, mem_mode, NULL_RTX(rtx) 0,
3072 x, NULL_RTX(rtx) 0, /*mem_canonicalized=*/false);
3073}
3074
3075/* Canonical true dependence: X is read after store in MEM takes place.
3076 Variant of true_dependence which assumes MEM has already been
3077 canonicalized (hence we no longer do that here).
3078 The mem_addr argument has been added, since true_dependence_1 computed
3079 this value prior to canonicalizing. */
3080
3081int
3082canon_true_dependence (const_rtx mem, machine_mode mem_mode, rtx mem_addr,
3083 const_rtx x, rtx x_addr)
3084{
3085 return true_dependence_1 (mem, mem_mode, mem_addr,
3086 x, x_addr, /*mem_canonicalized=*/true);
3087}
3088
3089/* Returns nonzero if a write to X might alias a previous read from
3090 (or, if WRITEP is true, a write to) MEM.
3091 If X_CANONCALIZED is true, then X_ADDR is the canonicalized address of X,
3092 and X_MODE the mode for that access.
3093 If MEM_CANONICALIZED is true, MEM is canonicalized. */
3094
3095static int
3096write_dependence_p (const_rtx mem,
3097 const_rtx x, machine_mode x_mode, rtx x_addr,
3098 bool mem_canonicalized, bool x_canonicalized, bool writep)
3099{
3100 rtx mem_addr;
3101 rtx true_mem_addr, true_x_addr;
3102 rtx base;
3103 int ret;
3104
3105 gcc_checking_assert (x_canonicalized((void)(!(x_canonicalized ? (x_addr != (rtx) 0 && (x_mode
!= ((void) 0, E_VOIDmode) || ((machine_mode) (x)->mode) ==
((void) 0, E_VOIDmode))) : (x_addr == (rtx) 0 && x_mode
== ((void) 0, E_VOIDmode))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3108, __FUNCTION__), 0 : 0))
3106 ? (x_addr != NULL_RTX((void)(!(x_canonicalized ? (x_addr != (rtx) 0 && (x_mode
!= ((void) 0, E_VOIDmode) || ((machine_mode) (x)->mode) ==
((void) 0, E_VOIDmode))) : (x_addr == (rtx) 0 && x_mode
== ((void) 0, E_VOIDmode))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3108, __FUNCTION__), 0 : 0))
3107 && (x_mode != VOIDmode || GET_MODE (x) == VOIDmode))((void)(!(x_canonicalized ? (x_addr != (rtx) 0 && (x_mode
!= ((void) 0, E_VOIDmode) || ((machine_mode) (x)->mode) ==
((void) 0, E_VOIDmode))) : (x_addr == (rtx) 0 && x_mode
== ((void) 0, E_VOIDmode))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3108, __FUNCTION__), 0 : 0))
3108 : (x_addr == NULL_RTX && x_mode == VOIDmode))((void)(!(x_canonicalized ? (x_addr != (rtx) 0 && (x_mode
!= ((void) 0, E_VOIDmode) || ((machine_mode) (x)->mode) ==
((void) 0, E_VOIDmode))) : (x_addr == (rtx) 0 && x_mode
== ((void) 0, E_VOIDmode))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3108, __FUNCTION__), 0 : 0))
;
3109
3110 if (MEM_VOLATILE_P (x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3110, __FUNCTION__); _rtx; })->volatil)
&& MEM_VOLATILE_P (mem)(__extension__ ({ __typeof ((mem)) const _rtx = ((mem)); if (
((enum rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3110, __FUNCTION__); _rtx; })->volatil)
)
3111 return 1;
3112
3113 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
3114 This is used in epilogue deallocation functions. */
3115 if (GET_MODE (x)((machine_mode) (x)->mode) == BLKmode((void) 0, E_BLKmode) && GET_CODE (XEXP (x, 0))((enum rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == SCRATCH)
3116 return 1;
3117 if (GET_MODE (mem)((machine_mode) (mem)->mode) == BLKmode((void) 0, E_BLKmode) && GET_CODE (XEXP (mem, 0))((enum rtx_code) ((((mem)->u.fld[0]).rt_rtx))->code) == SCRATCH)
3118 return 1;
3119 if (MEM_ALIAS_SET (x)(get_mem_attrs (x)->alias) == ALIAS_SET_MEMORY_BARRIER((alias_set_type) -1)
3120 || MEM_ALIAS_SET (mem)(get_mem_attrs (mem)->alias) == ALIAS_SET_MEMORY_BARRIER((alias_set_type) -1))
3121 return 1;
3122
3123 if (!x_addr)
3124 x_addr = XEXP (x, 0)(((x)->u.fld[0]).rt_rtx);
3125 true_x_addr = get_addr (x_addr);
3126
3127 mem_addr = XEXP (mem, 0)(((mem)->u.fld[0]).rt_rtx);
3128 true_mem_addr = get_addr (mem_addr);
3129
3130 /* A read from read-only memory can't conflict with read-write memory.
3131 Don't assume anything when AND addresses are involved and leave to
3132 the code below to determine dependence. */
3133 if (!writep
3134 && MEM_READONLY_P (mem)(__extension__ ({ __typeof ((mem)) const _rtx = ((mem)); if (
((enum rtx_code) (_rtx)->code) != MEM) rtl_check_failed_flag
("MEM_READONLY_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3134, __FUNCTION__); _rtx; })->unchanging)
3135 && GET_CODE (true_x_addr)((enum rtx_code) (true_x_addr)->code) != AND
3136 && GET_CODE (true_mem_addr)((enum rtx_code) (true_mem_addr)->code) != AND)
3137 return 0;
3138
3139 /* If we have MEMs referring to different address spaces (which can
3140 potentially overlap), we cannot easily tell from the addresses
3141 whether the references overlap. */
3142 if (MEM_ADDR_SPACE (mem)(get_mem_attrs (mem)->addrspace) != MEM_ADDR_SPACE (x)(get_mem_attrs (x)->addrspace))
3143 return 1;
3144
3145 base = find_base_term (true_mem_addr);
3146 if (! writep
3147 && base
3148 && (GET_CODE (base)((enum rtx_code) (base)->code) == LABEL_REF
3149 || (GET_CODE (base)((enum rtx_code) (base)->code) == SYMBOL_REF
3150 && CONSTANT_POOL_ADDRESS_P (base)(__extension__ ({ __typeof ((base)) const _rtx = ((base)); if
(((enum rtx_code) (_rtx)->code) != SYMBOL_REF) rtl_check_failed_flag
("CONSTANT_POOL_ADDRESS_P", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3150, __FUNCTION__); _rtx; })->unchanging)
)))
3151 return 0;
3152
3153 rtx x_base = find_base_term (true_x_addr);
3154 if (! base_alias_check (true_x_addr, x_base, true_mem_addr, base,
3155 GET_MODE (x)((machine_mode) (x)->mode), GET_MODE (mem)((machine_mode) (mem)->mode)))
3156 return 0;
3157
3158 if (!x_canonicalized)
3159 {
3160 x_addr = canon_rtx (true_x_addr);
3161 x_mode = GET_MODE (x)((machine_mode) (x)->mode);
3162 }
3163 if (!mem_canonicalized)
3164 mem_addr = canon_rtx (true_mem_addr);
3165
3166 if ((ret = memrefs_conflict_p (SIZE_FOR_MODE (mem)(GET_MODE_SIZE (((machine_mode) (mem)->mode))), mem_addr,
3167 GET_MODE_SIZE (x_mode), x_addr, 0)) != -1)
3168 return ret;
3169
3170 if (nonoverlapping_memrefs_p (x, mem, false))
3171 return 0;
3172
3173 return rtx_refs_may_alias_p (x, mem, false);
3174}
3175
3176/* Anti dependence: X is written after read in MEM takes place. */
3177
3178int
3179anti_dependence (const_rtx mem, const_rtx x)
3180{
3181 return write_dependence_p (mem, x, VOIDmode((void) 0, E_VOIDmode), NULL_RTX(rtx) 0,
3182 /*mem_canonicalized=*/false,
3183 /*x_canonicalized*/false, /*writep=*/false);
3184}
3185
3186/* Likewise, but we already have a canonicalized MEM, and X_ADDR for X.
3187 Also, consider X in X_MODE (which might be from an enclosing
3188 STRICT_LOW_PART / ZERO_EXTRACT).
3189 If MEM_CANONICALIZED is true, MEM is canonicalized. */
3190
3191int
3192canon_anti_dependence (const_rtx mem, bool mem_canonicalized,
3193 const_rtx x, machine_mode x_mode, rtx x_addr)
3194{
3195 return write_dependence_p (mem, x, x_mode, x_addr,
3196 mem_canonicalized, /*x_canonicalized=*/true,
3197 /*writep=*/false);
3198}
3199
3200/* Output dependence: X is written after store in MEM takes place. */
3201
3202int
3203output_dependence (const_rtx mem, const_rtx x)
3204{
3205 return write_dependence_p (mem, x, VOIDmode((void) 0, E_VOIDmode), NULL_RTX(rtx) 0,
3206 /*mem_canonicalized=*/false,
3207 /*x_canonicalized*/false, /*writep=*/true);
3208}
3209
3210/* Likewise, but we already have a canonicalized MEM, and X_ADDR for X.
3211 Also, consider X in X_MODE (which might be from an enclosing
3212 STRICT_LOW_PART / ZERO_EXTRACT).
3213 If MEM_CANONICALIZED is true, MEM is canonicalized. */
3214
3215int
3216canon_output_dependence (const_rtx mem, bool mem_canonicalized,
3217 const_rtx x, machine_mode x_mode, rtx x_addr)
3218{
3219 return write_dependence_p (mem, x, x_mode, x_addr,
3220 mem_canonicalized, /*x_canonicalized=*/true,
3221 /*writep=*/true);
3222}
3223
3224
3225
3226/* Check whether X may be aliased with MEM. Don't do offset-based
3227 memory disambiguation & TBAA. */
3228int
3229may_alias_p (const_rtx mem, const_rtx x)
3230{
3231 rtx x_addr, mem_addr;
3232
3233 if (MEM_VOLATILE_P (x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3233, __FUNCTION__); _rtx; })->volatil)
&& MEM_VOLATILE_P (mem)(__extension__ ({ __typeof ((mem)) const _rtx = ((mem)); if (
((enum rtx_code) (_rtx)->code) != MEM && ((enum rtx_code
) (_rtx)->code) != ASM_OPERANDS && ((enum rtx_code
) (_rtx)->code) != ASM_INPUT) rtl_check_failed_flag ("MEM_VOLATILE_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3233, __FUNCTION__); _rtx; })->volatil)
)
3234 return 1;
3235
3236 /* (mem:BLK (scratch)) is a special mechanism to conflict with everything.
3237 This is used in epilogue deallocation functions. */
3238 if (GET_MODE (x)((machine_mode) (x)->mode) == BLKmode((void) 0, E_BLKmode) && GET_CODE (XEXP (x, 0))((enum rtx_code) ((((x)->u.fld[0]).rt_rtx))->code) == SCRATCH)
3239 return 1;
3240 if (GET_MODE (mem)((machine_mode) (mem)->mode) == BLKmode((void) 0, E_BLKmode) && GET_CODE (XEXP (mem, 0))((enum rtx_code) ((((mem)->u.fld[0]).rt_rtx))->code) == SCRATCH)
3241 return 1;
3242 if (MEM_ALIAS_SET (x)(get_mem_attrs (x)->alias) == ALIAS_SET_MEMORY_BARRIER((alias_set_type) -1)
3243 || MEM_ALIAS_SET (mem)(get_mem_attrs (mem)->alias) == ALIAS_SET_MEMORY_BARRIER((alias_set_type) -1))
3244 return 1;
3245
3246 x_addr = XEXP (x, 0)(((x)->u.fld[0]).rt_rtx);
3247 x_addr = get_addr (x_addr);
3248
3249 mem_addr = XEXP (mem, 0)(((mem)->u.fld[0]).rt_rtx);
3250 mem_addr = get_addr (mem_addr);
3251
3252 /* Read-only memory is by definition never modified, and therefore can't
3253 conflict with anything. However, don't assume anything when AND
3254 addresses are involved and leave to the code below to determine
3255 dependence. We don't expect to find read-only set on MEM, but
3256 stupid user tricks can produce them, so don't die. */
3257 if (MEM_READONLY_P (x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != MEM) rtl_check_failed_flag ("MEM_READONLY_P"
, _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3257, __FUNCTION__); _rtx; })->unchanging)
3258 && GET_CODE (x_addr)((enum rtx_code) (x_addr)->code) != AND
3259 && GET_CODE (mem_addr)((enum rtx_code) (mem_addr)->code) != AND)
3260 return 0;
3261
3262 /* If we have MEMs referring to different address spaces (which can
3263 potentially overlap), we cannot easily tell from the addresses
3264 whether the references overlap. */
3265 if (MEM_ADDR_SPACE (mem)(get_mem_attrs (mem)->addrspace) != MEM_ADDR_SPACE (x)(get_mem_attrs (x)->addrspace))
3266 return 1;
3267
3268 rtx x_base = find_base_term (x_addr);
3269 rtx mem_base = find_base_term (mem_addr);
3270 if (! base_alias_check (x_addr, x_base, mem_addr, mem_base,
3271 GET_MODE (x)((machine_mode) (x)->mode), GET_MODE (mem_addr)((machine_mode) (mem_addr)->mode)))
3272 return 0;
3273
3274 if (nonoverlapping_memrefs_p (mem, x, true))
3275 return 0;
3276
3277 /* TBAA not valid for loop_invarint */
3278 return rtx_refs_may_alias_p (x, mem, false);
3279}
3280
3281void
3282init_alias_target (void)
3283{
3284 int i;
3285
3286 if (!arg_base_value)
3287 arg_base_value = gen_rtx_ADDRESS (VOIDmode, 0)gen_rtx_fmt_i_stat ((ADDRESS), ((((void) 0, E_VOIDmode))), ((
0)) )
;
3288
3289 memset (static_reg_base_value(this_target_rtl->x_static_reg_base_value), 0, sizeof static_reg_base_value(this_target_rtl->x_static_reg_base_value));
3290
3291 for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
3292 /* Check whether this register can hold an incoming pointer
3293 argument. FUNCTION_ARG_REGNO_P tests outgoing register
3294 numbers, so translate if necessary due to register windows. */
3295 if (FUNCTION_ARG_REGNO_P (OUTGOING_REGNO (i))ix86_function_arg_regno_p ((i))
3296 && targetm.hard_regno_mode_ok (i, Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))
))
3297 static_reg_base_value(this_target_rtl->x_static_reg_base_value)[i] = arg_base_value;
3298
3299 /* RTL code is required to be consistent about whether it uses the
3300 stack pointer, the frame pointer or the argument pointer to
3301 access a given area of the frame. We can therefore use the
3302 base address to distinguish between the different areas. */
3303 static_reg_base_value(this_target_rtl->x_static_reg_base_value)[STACK_POINTER_REGNUM7]
3304 = unique_base_value (UNIQUE_BASE_VALUE_SP-1);
3305 static_reg_base_value(this_target_rtl->x_static_reg_base_value)[ARG_POINTER_REGNUM16]
3306 = unique_base_value (UNIQUE_BASE_VALUE_ARGP-2);
3307 static_reg_base_value(this_target_rtl->x_static_reg_base_value)[FRAME_POINTER_REGNUM19]
3308 = unique_base_value (UNIQUE_BASE_VALUE_FP-3);
3309
3310 /* The above rules extend post-reload, with eliminations applying
3311 consistently to each of the three pointers. Cope with cases in
3312 which the frame pointer is eliminated to the hard frame pointer
3313 rather than the stack pointer. */
3314 if (!HARD_FRAME_POINTER_IS_FRAME_POINTER(6 == 19))
3315 static_reg_base_value(this_target_rtl->x_static_reg_base_value)[HARD_FRAME_POINTER_REGNUM6]
3316 = unique_base_value (UNIQUE_BASE_VALUE_HFP-4);
3317}
3318
3319/* Set MEMORY_MODIFIED when X modifies DATA (that is assumed
3320 to be memory reference. */
3321static bool memory_modified;
3322static void
3323memory_modified_1 (rtx x, const_rtx pat ATTRIBUTE_UNUSED__attribute__ ((__unused__)), void *data)
3324{
3325 if (MEM_P (x)(((enum rtx_code) (x)->code) == MEM))
3326 {
3327 if (anti_dependence (x, (const_rtx)data) || output_dependence (x, (const_rtx)data))
3328 memory_modified = true;
3329 }
3330}
3331
3332
3333/* Return true when INSN possibly modify memory contents of MEM
3334 (i.e. address can be modified). */
3335bool
3336memory_modified_in_insn_p (const_rtx mem, const_rtx insn)
3337{
3338 if (!INSN_P (insn)(((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN)) || (((enum rtx_code) (insn)->code) ==
DEBUG_INSN))
)
3339 return false;
3340 /* Conservatively assume all non-readonly MEMs might be modified in
3341 calls. */
3342 if (CALL_P (insn)(((enum rtx_code) (insn)->code) == CALL_INSN))
3343 return true;
3344 memory_modified = false;
3345 note_stores (as_a<const rtx_insn *> (insn), memory_modified_1,
3346 CONST_CAST_RTX(mem)(const_cast<struct rtx_def *> (((mem)))));
3347 return memory_modified;
3348}
3349
3350/* Initialize the aliasing machinery. Initialize the REG_KNOWN_VALUE
3351 array. */
3352
3353void
3354init_alias_analysis (void)
3355{
3356 unsigned int maxreg = max_reg_num ();
3357 int changed, pass;
3358 int i;
3359 unsigned int ui;
3360 rtx_insn *insn;
3361 rtx val;
3362 int rpo_cnt;
3363 int *rpo;
3364
3365 timevar_push (TV_ALIAS_ANALYSIS);
3366
3367 vec_safe_grow_cleared (reg_known_value, maxreg - FIRST_PSEUDO_REGISTER76,
3368 true);
3369 reg_known_equiv_p = sbitmap_alloc (maxreg - FIRST_PSEUDO_REGISTER76);
3370 bitmap_clear (reg_known_equiv_p);
3371
3372 /* If we have memory allocated from the previous run, use it. */
3373 if (old_reg_base_value)
3374 reg_base_value = old_reg_base_value;
3375
3376 if (reg_base_value)
3377 reg_base_value->truncate (0);
3378
3379 vec_safe_grow_cleared (reg_base_value, maxreg, true);
3380
3381 new_reg_base_value = XNEWVEC (rtx, maxreg)((rtx *) xmalloc (sizeof (rtx) * (maxreg)));
3382 reg_seen = sbitmap_alloc (maxreg);
3383
3384 /* The basic idea is that each pass through this loop will use the
3385 "constant" information from the previous pass to propagate alias
3386 information through another level of assignments.
3387
3388 The propagation is done on the CFG in reverse post-order, to propagate
3389 things forward as far as possible in each iteration.
3390
3391 This could get expensive if the assignment chains are long. Maybe
3392 we should throttle the number of iterations, possibly based on
3393 the optimization level or flag_expensive_optimizations.
3394
3395 We could propagate more information in the first pass by making use
3396 of DF_REG_DEF_COUNT to determine immediately that the alias information
3397 for a pseudo is "constant".
3398
3399 A program with an uninitialized variable can cause an infinite loop
3400 here. Instead of doing a full dataflow analysis to detect such problems
3401 we just cap the number of iterations for the loop.
3402
3403 The state of the arrays for the set chain in question does not matter
3404 since the program has undefined behavior. */
3405
3406 rpo = XNEWVEC (int, n_basic_blocks_for_fn (cfun))((int *) xmalloc (sizeof (int) * ((((cfun + 0))->cfg->x_n_basic_blocks
))))
;
3407 rpo_cnt = pre_and_rev_post_order_compute (NULLnullptr, rpo, false);
3408
3409 pass = 0;
3410 do
3411 {
3412 /* Assume nothing will change this iteration of the loop. */
3413 changed = 0;
3414
3415 /* We want to assign the same IDs each iteration of this loop, so
3416 start counting from one each iteration of the loop. */
3417 unique_id = 1;
3418
3419 /* We're at the start of the function each iteration through the
3420 loop, so we're copying arguments. */
3421 copying_arguments = true;
3422
3423 /* Wipe the potential alias information clean for this pass. */
3424 memset (new_reg_base_value, 0, maxreg * sizeof (rtx));
3425
3426 /* Wipe the reg_seen array clean. */
3427 bitmap_clear (reg_seen);
3428
3429 /* Initialize the alias information for this pass. */
3430 for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
3431 if (static_reg_base_value(this_target_rtl->x_static_reg_base_value)[i]
3432 /* Don't treat the hard frame pointer as special if we
3433 eliminated the frame pointer to the stack pointer instead. */
3434 && !(i == HARD_FRAME_POINTER_REGNUM6
3435 && reload_completed
3436 && !frame_pointer_needed((&x_rtl)->frame_pointer_needed)
3437 && targetm.can_eliminate (FRAME_POINTER_REGNUM19,
3438 STACK_POINTER_REGNUM7)))
3439 {
3440 new_reg_base_value[i] = static_reg_base_value(this_target_rtl->x_static_reg_base_value)[i];
3441 bitmap_set_bit (reg_seen, i);
3442 }
3443
3444 /* Walk the insns adding values to the new_reg_base_value array. */
3445 for (i = 0; i < rpo_cnt; i++)
3446 {
3447 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i])((*(((cfun + 0))->cfg->x_basic_block_info))[(rpo[i])]);
3448 FOR_BB_INSNS (bb, insn)for ((insn) = (bb)->il.x.head_; (insn) && (insn) !=
NEXT_INSN ((bb)->il.x.rtl->end_); (insn) = NEXT_INSN (
insn))
3449 {
3450 if (NONDEBUG_INSN_P (insn)((((enum rtx_code) (insn)->code) == INSN) || (((enum rtx_code
) (insn)->code) == JUMP_INSN) || (((enum rtx_code) (insn)->
code) == CALL_INSN))
)
3451 {
3452 rtx note, set;
3453
3454 /* If this insn has a noalias note, process it, Otherwise,
3455 scan for sets. A simple set will have no side effects
3456 which could change the base value of any other register. */
3457
3458 if (GET_CODE (PATTERN (insn))((enum rtx_code) (PATTERN (insn))->code) == SET
3459 && REG_NOTES (insn)(((insn)->u.fld[6]).rt_rtx) != 0
3460 && find_reg_note (insn, REG_NOALIAS, NULL_RTX(rtx) 0))
3461 record_set (SET_DEST (PATTERN (insn))(((PATTERN (insn))->u.fld[0]).rt_rtx), NULL_RTX(rtx) 0, NULLnullptr);
3462 else
3463 note_stores (insn, record_set, NULLnullptr);
3464
3465 set = single_set (insn);
3466
3467 if (set != 0
3468 && REG_P (SET_DEST (set))(((enum rtx_code) ((((set)->u.fld[0]).rt_rtx))->code) ==
REG)
3469 && REGNO (SET_DEST (set))(rhs_regno((((set)->u.fld[0]).rt_rtx))) >= FIRST_PSEUDO_REGISTER76)
3470 {
3471 unsigned int regno = REGNO (SET_DEST (set))(rhs_regno((((set)->u.fld[0]).rt_rtx)));
3472 rtx src = SET_SRC (set)(((set)->u.fld[1]).rt_rtx);
3473 rtx t;
3474
3475 note = find_reg_equal_equiv_note (insn);
3476 if (note && REG_NOTE_KIND (note)((enum reg_note) ((machine_mode) (note)->mode)) == REG_EQUAL
3477 && DF_REG_DEF_COUNT (regno)(df->def_regs[(regno)]->n_refs) != 1)
3478 note = NULL_RTX(rtx) 0;
3479
3480 poly_int64 offset;
3481 if (note != NULL_RTX(rtx) 0
3482 && GET_CODE (XEXP (note, 0))((enum rtx_code) ((((note)->u.fld[0]).rt_rtx))->code) != EXPR_LIST
3483 && ! rtx_varies_p (XEXP (note, 0)(((note)->u.fld[0]).rt_rtx), 1)
3484 && ! reg_overlap_mentioned_p (SET_DEST (set)(((set)->u.fld[0]).rt_rtx),
3485 XEXP (note, 0)(((note)->u.fld[0]).rt_rtx)))
3486 {
3487 set_reg_known_value (regno, XEXP (note, 0)(((note)->u.fld[0]).rt_rtx));
3488 set_reg_known_equiv_p (regno,
3489 REG_NOTE_KIND (note)((enum reg_note) ((machine_mode) (note)->mode)) == REG_EQUIV);
3490 }
3491 else if (DF_REG_DEF_COUNT (regno)(df->def_regs[(regno)]->n_refs) == 1
3492 && GET_CODE (src)((enum rtx_code) (src)->code) == PLUS
3493 && REG_P (XEXP (src, 0))(((enum rtx_code) ((((src)->u.fld[0]).rt_rtx))->code) ==
REG)
3494 && (t = get_reg_known_value (REGNO (XEXP (src, 0))(rhs_regno((((src)->u.fld[0]).rt_rtx)))))
3495 && poly_int_rtx_p (XEXP (src, 1)(((src)->u.fld[1]).rt_rtx), &offset))
3496 {
3497 t = plus_constant (GET_MODE (src)((machine_mode) (src)->mode), t, offset);
3498 set_reg_known_value (regno, t);
3499 set_reg_known_equiv_p (regno, false);
3500 }
3501 else if (DF_REG_DEF_COUNT (regno)(df->def_regs[(regno)]->n_refs) == 1
3502 && ! rtx_varies_p (src, 1))
3503 {
3504 set_reg_known_value (regno, src);
3505 set_reg_known_equiv_p (regno, false);
3506 }
3507 }
3508 }
3509 else if (NOTE_P (insn)(((enum rtx_code) (insn)->code) == NOTE)
3510 && NOTE_KIND (insn)(((insn)->u.fld[4]).rt_int) == NOTE_INSN_FUNCTION_BEG)
3511 copying_arguments = false;
3512 }
3513 }
3514
3515 /* Now propagate values from new_reg_base_value to reg_base_value. */
3516 gcc_assert (maxreg == (unsigned int) max_reg_num ())((void)(!(maxreg == (unsigned int) max_reg_num ()) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/alias.c"
, 3516, __FUNCTION__), 0 : 0))
;
3517
3518 for (ui = 0; ui < maxreg; ui++)
3519 {
3520 if (new_reg_base_value[ui]
3521 && new_reg_base_value[ui] != (*reg_base_value)[ui]
3522 && ! rtx_equal_p (new_reg_base_value[ui], (*reg_base_value)[ui]))
3523 {
3524 (*reg_base_value)[ui] = new_reg_base_value[ui];
3525 changed = 1;
3526 }
3527 }
3528 }
3529 while (changed && ++pass < MAX_ALIAS_LOOP_PASSES10);
3530 XDELETEVEC (rpo)free ((void*) (rpo));
3531
3532 /* Fill in the remaining entries. */
3533 FOR_EACH_VEC_ELT (*reg_known_value, i, val)for (i = 0; (*reg_known_value).iterate ((i), &(val)); ++(
i))
3534 {
3535 int regno = i + FIRST_PSEUDO_REGISTER76;
3536 if (! val)
3537 set_reg_known_value (regno, regno_reg_rtx[regno]);
3538 }
3539
3540 /* Clean up. */
3541 free (new_reg_base_value);
3542 new_reg_base_value = 0;
3543 sbitmap_free (reg_seen);
3544 reg_seen = 0;
3545 timevar_pop (TV_ALIAS_ANALYSIS);
3546}
3547
3548/* Equate REG_BASE_VALUE (reg1) to REG_BASE_VALUE (reg2).
3549 Special API for var-tracking pass purposes. */
3550
3551void
3552vt_equate_reg_base_value (const_rtx reg1, const_rtx reg2)
3553{
3554 (*reg_base_value)[REGNO (reg1)(rhs_regno(reg1))] = REG_BASE_VALUE (reg2)((rhs_regno(reg2)) < vec_safe_length (reg_base_value) ? (*
reg_base_value)[(rhs_regno(reg2))] : 0)
;
3555}
3556
3557void
3558end_alias_analysis (void)
3559{
3560 old_reg_base_value = reg_base_value;
3561 vec_free (reg_known_value);
3562 sbitmap_free (reg_known_equiv_p);
3563}
3564
3565void
3566dump_alias_stats_in_alias_c (FILE *s)
3567{
3568 fprintf (s, " TBAA oracle: %llu disambiguations %llu queries\n"
3569 " %llu are in alias set 0\n"
3570 " %llu queries asked about the same object\n"
3571 " %llu queries asked about the same alias set\n"
3572 " %llu access volatile\n"
3573 " %llu are dependent in the DAG\n"
3574 " %llu are aritificially in conflict with void *\n",
3575 alias_stats.num_disambiguated,
3576 alias_stats.num_alias_zero + alias_stats.num_same_alias_set
3577 + alias_stats.num_same_objects + alias_stats.num_volatile
3578 + alias_stats.num_dag + alias_stats.num_disambiguated
3579 + alias_stats.num_universal,
3580 alias_stats.num_alias_zero, alias_stats.num_same_alias_set,
3581 alias_stats.num_same_objects, alias_stats.num_volatile,
3582 alias_stats.num_dag, alias_stats.num_universal);
3583}
3584#include "gt-alias.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
20.1
'exact' is false
20.1
'exact' is false
)
21
Taking false branch
229 return (pfx ? pfx->m_num : 0) + reserve;
230 else if (!pfx
21.1
'pfx' is non-null, which participates in a condition later
21.1
'pfx' is non-null, which participates in a condition later
)
22
Taking false branch
231 return MAX (4, reserve)((4) > (reserve) ? (4) : (reserve));
232 return calculate_allocation_1 (pfx->m_alloc, pfx->m_num + reserve);
23
Returning value, which participates in a condition later
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 == NULLnullptr)
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 = NULLnullptr;
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 = NULLnullptr;
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 ? &v->m_vecpfx : 0, reserve, exact);
18
Assuming 'v' is non-null
19
'?' condition is true
20
Calling 'vec_prefix::calculate_allocation'
24
Returning from 'vec_prefix::calculate_allocation'
368 if (!alloc)
25
Assuming 'alloc' is 0, which participates in a condition later
26
Taking true branch
369 {
370 ::ggc_free (v);
371 v = NULLnullptr;
27
Null pointer value stored to 'alias_sets'
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
10.1
'v' is non-null
10.1
'v' is non-null
? v->space (nelems) : nelems == 0
;
11
'?' condition is true
12
Value assigned to 'alias_sets', which participates in a condition later
13
Returning value, which participates in a condition later
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 () : NULLnullptr;
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
8.1
'nelems' is 1
8.1
'nelems' is 1
? !vec_safe_space (v, nelems) : false;
9
'?' condition is true
10
Calling 'vec_safe_space<alias_set_entry *, va_gc>'
14
Returning from 'vec_safe_space<alias_set_entry *, va_gc>'
15
Assuming the condition is true
696 if (extend
15.1
'extend' is true
15.1
'extend' is true
)
16
Taking true branch
697 A::reserve (v, nelems, exact PASS_MEM_STAT);
17
Calling 'va_gc::reserve'
28
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 = NULLnullptr;
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);
8
Calling 'vec_safe_reserve<alias_set_entry *, va_gc>'
29
Returning from 'vec_safe_reserve<alias_set_entry *, va_gc>'
814 return v->quick_push (obj);
30
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) : NULLnullptr;
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 = NULLnullptr;
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 NULLnullptr;
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 NULLnullptr;
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 != NULLnullptr; }
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 : NULLnullptr; }
1477
1478 const T *address (void) const
1479 { return m_vec ? m_vec->m_vecdata : NULLnullptr; }
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 = NULLnullptr; }
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 = NULLnullptr;
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 = NULLnullptr;
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 = NULLnullptr;
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 = NULLnullptr;
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 == NULLnullptr)
1716 return;
1717
1718 v->release ();
1719 delete v;
1720 v = NULLnullptr;
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 = NULLnullptr;
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 = NULLnullptr;
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);