Bug Summary

File:build/gcc/var-tracking.c
Warning:line 8861, column 8
Value stored to 'mode' is never read

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 var-tracking.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-yvltfk.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c
1/* Variable tracking routines for the GNU compiler.
2 Copyright (C) 2002-2021 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20/* This file contains the variable tracking pass. It computes where
21 variables are located (which registers or where in memory) at each position
22 in instruction stream and emits notes describing the locations.
23 Debug information (DWARF2 location lists) is finally generated from
24 these notes.
25 With this debug information, it is possible to show variables
26 even when debugging optimized code.
27
28 How does the variable tracking pass work?
29
30 First, it scans RTL code for uses, stores and clobbers (register/memory
31 references in instructions), for call insns and for stack adjustments
32 separately for each basic block and saves them to an array of micro
33 operations.
34 The micro operations of one instruction are ordered so that
35 pre-modifying stack adjustment < use < use with no var < call insn <
36 < clobber < set < post-modifying stack adjustment
37
38 Then, a forward dataflow analysis is performed to find out how locations
39 of variables change through code and to propagate the variable locations
40 along control flow graph.
41 The IN set for basic block BB is computed as a union of OUT sets of BB's
42 predecessors, the OUT set for BB is copied from the IN set for BB and
43 is changed according to micro operations in BB.
44
45 The IN and OUT sets for basic blocks consist of a current stack adjustment
46 (used for adjusting offset of variables addressed using stack pointer),
47 the table of structures describing the locations of parts of a variable
48 and for each physical register a linked list for each physical register.
49 The linked list is a list of variable parts stored in the register,
50 i.e. it is a list of triplets (reg, decl, offset) where decl is
51 REG_EXPR (reg) and offset is REG_OFFSET (reg). The linked list is used for
52 effective deleting appropriate variable parts when we set or clobber the
53 register.
54
55 There may be more than one variable part in a register. The linked lists
56 should be pretty short so it is a good data structure here.
57 For example in the following code, register allocator may assign same
58 register to variables A and B, and both of them are stored in the same
59 register in CODE:
60
61 if (cond)
62 set A;
63 else
64 set B;
65 CODE;
66 if (cond)
67 use A;
68 else
69 use B;
70
71 Finally, the NOTE_INSN_VAR_LOCATION notes describing the variable locations
72 are emitted to appropriate positions in RTL code. Each such a note describes
73 the location of one variable at the point in instruction stream where the
74 note is. There is no need to emit a note for each variable before each
75 instruction, we only emit these notes where the location of variable changes
76 (this means that we also emit notes for changes between the OUT set of the
77 previous block and the IN set of the current block).
78
79 The notes consist of two parts:
80 1. the declaration (from REG_EXPR or MEM_EXPR)
81 2. the location of a variable - it is either a simple register/memory
82 reference (for simple variables, for example int),
83 or a parallel of register/memory references (for a large variables
84 which consist of several parts, for example long long).
85
86*/
87
88#include "config.h"
89#include "system.h"
90#include "coretypes.h"
91#include "backend.h"
92#include "target.h"
93#include "rtl.h"
94#include "tree.h"
95#include "cfghooks.h"
96#include "alloc-pool.h"
97#include "tree-pass.h"
98#include "memmodel.h"
99#include "tm_p.h"
100#include "insn-config.h"
101#include "regs.h"
102#include "emit-rtl.h"
103#include "recog.h"
104#include "diagnostic.h"
105#include "varasm.h"
106#include "stor-layout.h"
107#include "cfgrtl.h"
108#include "cfganal.h"
109#include "reload.h"
110#include "calls.h"
111#include "tree-dfa.h"
112#include "tree-ssa.h"
113#include "cselib.h"
114#include "tree-pretty-print.h"
115#include "rtl-iter.h"
116#include "fibonacci_heap.h"
117#include "print-rtl.h"
118#include "function-abi.h"
119
120typedef fibonacci_heap <long, basic_block_def> bb_heap_t;
121
122/* var-tracking.c assumes that tree code with the same value as VALUE rtx code
123 has no chance to appear in REG_EXPR/MEM_EXPRs and isn't a decl.
124 Currently the value is the same as IDENTIFIER_NODE, which has such
125 a property. If this compile time assertion ever fails, make sure that
126 the new tree code that equals (int) VALUE has the same property. */
127extern char check_value_val[(int) VALUE == (int) IDENTIFIER_NODE ? 1 : -1];
128
129/* Type of micro operation. */
130enum micro_operation_type
131{
132 MO_USE, /* Use location (REG or MEM). */
133 MO_USE_NO_VAR,/* Use location which is not associated with a variable
134 or the variable is not trackable. */
135 MO_VAL_USE, /* Use location which is associated with a value. */
136 MO_VAL_LOC, /* Use location which appears in a debug insn. */
137 MO_VAL_SET, /* Set location associated with a value. */
138 MO_SET, /* Set location. */
139 MO_COPY, /* Copy the same portion of a variable from one
140 location to another. */
141 MO_CLOBBER, /* Clobber location. */
142 MO_CALL, /* Call insn. */
143 MO_ADJUST /* Adjust stack pointer. */
144
145};
146
147static const char * const ATTRIBUTE_UNUSED__attribute__ ((__unused__))
148micro_operation_type_name[] = {
149 "MO_USE",
150 "MO_USE_NO_VAR",
151 "MO_VAL_USE",
152 "MO_VAL_LOC",
153 "MO_VAL_SET",
154 "MO_SET",
155 "MO_COPY",
156 "MO_CLOBBER",
157 "MO_CALL",
158 "MO_ADJUST"
159};
160
161/* Where shall the note be emitted? BEFORE or AFTER the instruction.
162 Notes emitted as AFTER_CALL are to take effect during the call,
163 rather than after the call. */
164enum emit_note_where
165{
166 EMIT_NOTE_BEFORE_INSN,
167 EMIT_NOTE_AFTER_INSN,
168 EMIT_NOTE_AFTER_CALL_INSN
169};
170
171/* Structure holding information about micro operation. */
172struct micro_operation
173{
174 /* Type of micro operation. */
175 enum micro_operation_type type;
176
177 /* The instruction which the micro operation is in, for MO_USE,
178 MO_USE_NO_VAR, MO_CALL and MO_ADJUST, or the subsequent
179 instruction or note in the original flow (before any var-tracking
180 notes are inserted, to simplify emission of notes), for MO_SET
181 and MO_CLOBBER. */
182 rtx_insn *insn;
183
184 union {
185 /* Location. For MO_SET and MO_COPY, this is the SET that
186 performs the assignment, if known, otherwise it is the target
187 of the assignment. For MO_VAL_USE and MO_VAL_SET, it is a
188 CONCAT of the VALUE and the LOC associated with it. For
189 MO_VAL_LOC, it is a CONCAT of the VALUE and the VAR_LOCATION
190 associated with it. */
191 rtx loc;
192
193 /* Stack adjustment. */
194 HOST_WIDE_INTlong adjust;
195 } u;
196};
197
198
199/* A declaration of a variable, or an RTL value being handled like a
200 declaration. */
201typedef void *decl_or_value;
202
203/* Return true if a decl_or_value DV is a DECL or NULL. */
204static inline bool
205dv_is_decl_p (decl_or_value dv)
206{
207 return !dv || (int) TREE_CODE ((tree) dv)((enum tree_code) ((tree) dv)->base.code) != (int) VALUE;
208}
209
210/* Return true if a decl_or_value is a VALUE rtl. */
211static inline bool
212dv_is_value_p (decl_or_value dv)
213{
214 return dv && !dv_is_decl_p (dv);
215}
216
217/* Return the decl in the decl_or_value. */
218static inline tree
219dv_as_decl (decl_or_value dv)
220{
221 gcc_checking_assert (dv_is_decl_p (dv))((void)(!(dv_is_decl_p (dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 221, __FUNCTION__), 0 : 0))
;
222 return (tree) dv;
223}
224
225/* Return the value in the decl_or_value. */
226static inline rtx
227dv_as_value (decl_or_value dv)
228{
229 gcc_checking_assert (dv_is_value_p (dv))((void)(!(dv_is_value_p (dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 229, __FUNCTION__), 0 : 0))
;
230 return (rtx)dv;
231}
232
233/* Return the opaque pointer in the decl_or_value. */
234static inline void *
235dv_as_opaque (decl_or_value dv)
236{
237 return dv;
238}
239
240
241/* Description of location of a part of a variable. The content of a physical
242 register is described by a chain of these structures.
243 The chains are pretty short (usually 1 or 2 elements) and thus
244 chain is the best data structure. */
245struct attrs
246{
247 /* Pointer to next member of the list. */
248 attrs *next;
249
250 /* The rtx of register. */
251 rtx loc;
252
253 /* The declaration corresponding to LOC. */
254 decl_or_value dv;
255
256 /* Offset from start of DECL. */
257 HOST_WIDE_INTlong offset;
258};
259
260/* Structure for chaining the locations. */
261struct location_chain
262{
263 /* Next element in the chain. */
264 location_chain *next;
265
266 /* The location (REG, MEM or VALUE). */
267 rtx loc;
268
269 /* The "value" stored in this location. */
270 rtx set_src;
271
272 /* Initialized? */
273 enum var_init_status init;
274};
275
276/* A vector of loc_exp_dep holds the active dependencies of a one-part
277 DV on VALUEs, i.e., the VALUEs expanded so as to form the current
278 location of DV. Each entry is also part of VALUE' s linked-list of
279 backlinks back to DV. */
280struct loc_exp_dep
281{
282 /* The dependent DV. */
283 decl_or_value dv;
284 /* The dependency VALUE or DECL_DEBUG. */
285 rtx value;
286 /* The next entry in VALUE's backlinks list. */
287 struct loc_exp_dep *next;
288 /* A pointer to the pointer to this entry (head or prev's next) in
289 the doubly-linked list. */
290 struct loc_exp_dep **pprev;
291};
292
293
294/* This data structure holds information about the depth of a variable
295 expansion. */
296struct expand_depth
297{
298 /* This measures the complexity of the expanded expression. It
299 grows by one for each level of expansion that adds more than one
300 operand. */
301 int complexity;
302 /* This counts the number of ENTRY_VALUE expressions in an
303 expansion. We want to minimize their use. */
304 int entryvals;
305};
306
307/* Type for dependencies actively used when expand FROM into cur_loc. */
308typedef vec<loc_exp_dep, va_heap, vl_embed> deps_vec;
309
310/* This data structure is allocated for one-part variables at the time
311 of emitting notes. */
312struct onepart_aux
313{
314 /* Doubly-linked list of dependent DVs. These are DVs whose cur_loc
315 computation used the expansion of this variable, and that ought
316 to be notified should this variable change. If the DV's cur_loc
317 expanded to NULL, all components of the loc list are regarded as
318 active, so that any changes in them give us a chance to get a
319 location. Otherwise, only components of the loc that expanded to
320 non-NULL are regarded as active dependencies. */
321 loc_exp_dep *backlinks;
322 /* This holds the LOC that was expanded into cur_loc. We need only
323 mark a one-part variable as changed if the FROM loc is removed,
324 or if it has no known location and a loc is added, or if it gets
325 a change notification from any of its active dependencies. */
326 rtx from;
327 /* The depth of the cur_loc expression. */
328 expand_depth depth;
329 /* Dependencies actively used when expand FROM into cur_loc. */
330 deps_vec deps;
331};
332
333/* Structure describing one part of variable. */
334struct variable_part
335{
336 /* Chain of locations of the part. */
337 location_chain *loc_chain;
338
339 /* Location which was last emitted to location list. */
340 rtx cur_loc;
341
342 union variable_aux
343 {
344 /* The offset in the variable, if !var->onepart. */
345 HOST_WIDE_INTlong offset;
346
347 /* Pointer to auxiliary data, if var->onepart and emit_notes. */
348 struct onepart_aux *onepaux;
349 } aux;
350};
351
352/* Maximum number of location parts. */
353#define MAX_VAR_PARTS16 16
354
355/* Enumeration type used to discriminate various types of one-part
356 variables. */
357enum onepart_enum
358{
359 /* Not a one-part variable. */
360 NOT_ONEPART = 0,
361 /* A one-part DECL that is not a DEBUG_EXPR_DECL. */
362 ONEPART_VDECL = 1,
363 /* A DEBUG_EXPR_DECL. */
364 ONEPART_DEXPR = 2,
365 /* A VALUE. */
366 ONEPART_VALUE = 3
367};
368
369/* Structure describing where the variable is located. */
370struct variable
371{
372 /* The declaration of the variable, or an RTL value being handled
373 like a declaration. */
374 decl_or_value dv;
375
376 /* Reference count. */
377 int refcount;
378
379 /* Number of variable parts. */
380 char n_var_parts;
381
382 /* What type of DV this is, according to enum onepart_enum. */
383 ENUM_BITFIELD (onepart_enum)enum onepart_enum onepart : CHAR_BIT8;
384
385 /* True if this variable_def struct is currently in the
386 changed_variables hash table. */
387 bool in_changed_variables;
388
389 /* The variable parts. */
390 variable_part var_part[1];
391};
392
393/* Pointer to the BB's information specific to variable tracking pass. */
394#define VTI(BB)((variable_tracking_info *) (BB)->aux) ((variable_tracking_info *) (BB)->aux)
395
396/* Return MEM_OFFSET (MEM) as a HOST_WIDE_INT, or 0 if we can't. */
397
398static inline HOST_WIDE_INTlong
399int_mem_offset (const_rtx mem)
400{
401 HOST_WIDE_INTlong offset;
402 if (MEM_OFFSET_KNOWN_P (mem)(get_mem_attrs (mem)->offset_known_p) && MEM_OFFSET (mem)(get_mem_attrs (mem)->offset).is_constant (&offset))
403 return offset;
404 return 0;
405}
406
407#if CHECKING_P1 && (GCC_VERSION(4 * 1000 + 2) >= 2007)
408
409/* Access VAR's Ith part's offset, checking that it's not a one-part
410 variable. */
411#define VAR_PART_OFFSET(var, i)__extension__ (*({ variable *const __v = (var); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 411, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
__extension__ \
412(*({ variable *const __v = (var); \
413 gcc_checking_assert (!__v->onepart)((void)(!(!__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 413, __FUNCTION__), 0 : 0))
; \
414 &__v->var_part[(i)].aux.offset; }))
415
416/* Access VAR's one-part auxiliary data, checking that it is a
417 one-part variable. */
418#define VAR_LOC_1PAUX(var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 418, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
__extension__ \
419(*({ variable *const __v = (var); \
420 gcc_checking_assert (__v->onepart)((void)(!(__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 420, __FUNCTION__), 0 : 0))
; \
421 &__v->var_part[0].aux.onepaux; }))
422
423#else
424#define VAR_PART_OFFSET(var, i)__extension__ (*({ variable *const __v = (var); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 424, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
((var)->var_part[(i)].aux.offset)
425#define VAR_LOC_1PAUX(var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 425, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
((var)->var_part[0].aux.onepaux)
426#endif
427
428/* These are accessor macros for the one-part auxiliary data. When
429 convenient for users, they're guarded by tests that the data was
430 allocated. */
431#define VAR_LOC_DEP_LST(var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 431, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; })) ? __extension__ (*({ variable *const __v = (var); ((void
)(!(__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 431, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))->backlinks : nullptr)
(VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 431, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
\
432 ? VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 432, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
->backlinks \
433 : NULLnullptr)
434#define VAR_LOC_DEP_LSTP(var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 434, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; })) ? &__extension__ (*({ variable *const __v = (var); (
(void)(!(__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 434, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))->backlinks : nullptr)
(VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 434, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
\
435 ? &VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 435, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
->backlinks \
436 : NULLnullptr)
437#define VAR_LOC_FROM(var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 437, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))->from)
(VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 437, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
->from)
438#define VAR_LOC_DEPTH(var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 438, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))->depth)
(VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 438, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
->depth)
439#define VAR_LOC_DEP_VEC(var)var_loc_dep_vec (var) var_loc_dep_vec (var)
440
441/* Implements the VAR_LOC_DEP_VEC above as a function to work around
442 a bogus -Wnonnull (PR c/95554). */
443
444static inline deps_vec*
445var_loc_dep_vec (variable *var)
446{
447 return VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 447, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
? &VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 447, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.onepaux
; }))
->deps : NULLnullptr;
448}
449
450
451typedef unsigned int dvuid;
452
453/* Return the uid of DV. */
454
455static inline dvuid
456dv_uid (decl_or_value dv)
457{
458 if (dv_is_value_p (dv))
459 return CSELIB_VAL_PTR (dv_as_value (dv))(((dv_as_value (dv))->u.fld[0]).rt_cselib)->uid;
460 else
461 return DECL_UID (dv_as_decl (dv))((contains_struct_check ((dv_as_decl (dv)), (TS_DECL_MINIMAL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 461, __FUNCTION__))->decl_minimal.uid)
;
462}
463
464/* Compute the hash from the uid. */
465
466static inline hashval_t
467dv_uid2hash (dvuid uid)
468{
469 return uid;
470}
471
472/* The hash function for a mask table in a shared_htab chain. */
473
474static inline hashval_t
475dv_htab_hash (decl_or_value dv)
476{
477 return dv_uid2hash (dv_uid (dv));
478}
479
480static void variable_htab_free (void *);
481
482/* Variable hashtable helpers. */
483
484struct variable_hasher : pointer_hash <variable>
485{
486 typedef void *compare_type;
487 static inline hashval_t hash (const variable *);
488 static inline bool equal (const variable *, const void *);
489 static inline void remove (variable *);
490};
491
492/* The hash function for variable_htab, computes the hash value
493 from the declaration of variable X. */
494
495inline hashval_t
496variable_hasher::hash (const variable *v)
497{
498 return dv_htab_hash (v->dv);
499}
500
501/* Compare the declaration of variable X with declaration Y. */
502
503inline bool
504variable_hasher::equal (const variable *v, const void *y)
505{
506 decl_or_value dv = CONST_CAST2 (decl_or_value, const void *, y)(const_cast<decl_or_value> (y));
507
508 return (dv_as_opaque (v->dv) == dv_as_opaque (dv));
509}
510
511/* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
512
513inline void
514variable_hasher::remove (variable *var)
515{
516 variable_htab_free (var);
517}
518
519typedef hash_table<variable_hasher> variable_table_type;
520typedef variable_table_type::iterator variable_iterator_type;
521
522/* Structure for passing some other parameters to function
523 emit_note_insn_var_location. */
524struct emit_note_data
525{
526 /* The instruction which the note will be emitted before/after. */
527 rtx_insn *insn;
528
529 /* Where the note will be emitted (before/after insn)? */
530 enum emit_note_where where;
531
532 /* The variables and values active at this point. */
533 variable_table_type *vars;
534};
535
536/* Structure holding a refcounted hash table. If refcount > 1,
537 it must be first unshared before modified. */
538struct shared_hash
539{
540 /* Reference count. */
541 int refcount;
542
543 /* Actual hash table. */
544 variable_table_type *htab;
545};
546
547/* Structure holding the IN or OUT set for a basic block. */
548struct dataflow_set
549{
550 /* Adjustment of stack offset. */
551 HOST_WIDE_INTlong stack_adjust;
552
553 /* Attributes for registers (lists of attrs). */
554 attrs *regs[FIRST_PSEUDO_REGISTER76];
555
556 /* Variable locations. */
557 shared_hash *vars;
558
559 /* Vars that is being traversed. */
560 shared_hash *traversed_vars;
561};
562
563/* The structure (one for each basic block) containing the information
564 needed for variable tracking. */
565struct variable_tracking_info
566{
567 /* The vector of micro operations. */
568 vec<micro_operation> mos;
569
570 /* The IN and OUT set for dataflow analysis. */
571 dataflow_set in;
572 dataflow_set out;
573
574 /* The permanent-in dataflow set for this block. This is used to
575 hold values for which we had to compute entry values. ??? This
576 should probably be dynamically allocated, to avoid using more
577 memory in non-debug builds. */
578 dataflow_set *permp;
579
580 /* Has the block been visited in DFS? */
581 bool visited;
582
583 /* Has the block been flooded in VTA? */
584 bool flooded;
585
586};
587
588/* Alloc pool for struct attrs_def. */
589object_allocator<attrs> attrs_pool ("attrs pool");
590
591/* Alloc pool for struct variable_def with MAX_VAR_PARTS entries. */
592
593static pool_allocator var_pool
594 ("variable_def pool", sizeof (variable) +
595 (MAX_VAR_PARTS16 - 1) * sizeof (((variable *)NULLnullptr)->var_part[0]));
596
597/* Alloc pool for struct variable_def with a single var_part entry. */
598static pool_allocator valvar_pool
599 ("small variable_def pool", sizeof (variable));
600
601/* Alloc pool for struct location_chain. */
602static object_allocator<location_chain> location_chain_pool
603 ("location_chain pool");
604
605/* Alloc pool for struct shared_hash. */
606static object_allocator<shared_hash> shared_hash_pool ("shared_hash pool");
607
608/* Alloc pool for struct loc_exp_dep_s for NOT_ONEPART variables. */
609object_allocator<loc_exp_dep> loc_exp_dep_pool ("loc_exp_dep pool");
610
611/* Changed variables, notes will be emitted for them. */
612static variable_table_type *changed_variables;
613
614/* Shall notes be emitted? */
615static bool emit_notes;
616
617/* Values whose dynamic location lists have gone empty, but whose
618 cselib location lists are still usable. Use this to hold the
619 current location, the backlinks, etc, during emit_notes. */
620static variable_table_type *dropped_values;
621
622/* Empty shared hashtable. */
623static shared_hash *empty_shared_hash;
624
625/* Scratch register bitmap used by cselib_expand_value_rtx. */
626static bitmap scratch_regs = NULLnullptr;
627
628#ifdef HAVE_window_save
629struct GTY(()) parm_reg {
630 rtx outgoing;
631 rtx incoming;
632};
633
634
635/* Vector of windowed parameter registers, if any. */
636static vec<parm_reg, va_gc> *windowed_parm_regs = NULLnullptr;
637#endif
638
639/* Variable used to tell whether cselib_process_insn called our hook. */
640static bool cselib_hook_called;
641
642/* Local function prototypes. */
643static void stack_adjust_offset_pre_post (rtx, HOST_WIDE_INTlong *,
644 HOST_WIDE_INTlong *);
645static void insn_stack_adjust_offset_pre_post (rtx_insn *, HOST_WIDE_INTlong *,
646 HOST_WIDE_INTlong *);
647static bool vt_stack_adjustments (void);
648
649static void init_attrs_list_set (attrs **);
650static void attrs_list_clear (attrs **);
651static attrs *attrs_list_member (attrs *, decl_or_value, HOST_WIDE_INTlong);
652static void attrs_list_insert (attrs **, decl_or_value, HOST_WIDE_INTlong, rtx);
653static void attrs_list_copy (attrs **, attrs *);
654static void attrs_list_union (attrs **, attrs *);
655
656static variable **unshare_variable (dataflow_set *set, variable **slot,
657 variable *var, enum var_init_status);
658static void vars_copy (variable_table_type *, variable_table_type *);
659static tree var_debug_decl (tree);
660static void var_reg_set (dataflow_set *, rtx, enum var_init_status, rtx);
661static void var_reg_delete_and_set (dataflow_set *, rtx, bool,
662 enum var_init_status, rtx);
663static void var_reg_delete (dataflow_set *, rtx, bool);
664static void var_regno_delete (dataflow_set *, int);
665static void var_mem_set (dataflow_set *, rtx, enum var_init_status, rtx);
666static void var_mem_delete_and_set (dataflow_set *, rtx, bool,
667 enum var_init_status, rtx);
668static void var_mem_delete (dataflow_set *, rtx, bool);
669
670static void dataflow_set_init (dataflow_set *);
671static void dataflow_set_clear (dataflow_set *);
672static void dataflow_set_copy (dataflow_set *, dataflow_set *);
673static int variable_union_info_cmp_pos (const void *, const void *);
674static void dataflow_set_union (dataflow_set *, dataflow_set *);
675static location_chain *find_loc_in_1pdv (rtx, variable *,
676 variable_table_type *);
677static bool canon_value_cmp (rtx, rtx);
678static int loc_cmp (rtx, rtx);
679static bool variable_part_different_p (variable_part *, variable_part *);
680static bool onepart_variable_different_p (variable *, variable *);
681static bool variable_different_p (variable *, variable *);
682static bool dataflow_set_different (dataflow_set *, dataflow_set *);
683static void dataflow_set_destroy (dataflow_set *);
684
685static bool track_expr_p (tree, bool);
686static void add_uses_1 (rtx *, void *);
687static void add_stores (rtx, const_rtx, void *);
688static bool compute_bb_dataflow (basic_block);
689static bool vt_find_locations (void);
690
691static void dump_attrs_list (attrs *);
692static void dump_var (variable *);
693static void dump_vars (variable_table_type *);
694static void dump_dataflow_set (dataflow_set *);
695static void dump_dataflow_sets (void);
696
697static void set_dv_changed (decl_or_value, bool);
698static void variable_was_changed (variable *, dataflow_set *);
699static variable **set_slot_part (dataflow_set *, rtx, variable **,
700 decl_or_value, HOST_WIDE_INTlong,
701 enum var_init_status, rtx);
702static void set_variable_part (dataflow_set *, rtx,
703 decl_or_value, HOST_WIDE_INTlong,
704 enum var_init_status, rtx, enum insert_option);
705static variable **clobber_slot_part (dataflow_set *, rtx,
706 variable **, HOST_WIDE_INTlong, rtx);
707static void clobber_variable_part (dataflow_set *, rtx,
708 decl_or_value, HOST_WIDE_INTlong, rtx);
709static variable **delete_slot_part (dataflow_set *, rtx, variable **,
710 HOST_WIDE_INTlong);
711static void delete_variable_part (dataflow_set *, rtx,
712 decl_or_value, HOST_WIDE_INTlong);
713static void emit_notes_in_bb (basic_block, dataflow_set *);
714static void vt_emit_notes (void);
715
716static void vt_add_function_parameters (void);
717static bool vt_initialize (void);
718static void vt_finalize (void);
719
720/* Callback for stack_adjust_offset_pre_post, called via for_each_inc_dec. */
721
722static int
723stack_adjust_offset_pre_post_cb (rtx, rtx op, rtx dest, rtx src, rtx srcoff,
724 void *arg)
725{
726 if (dest != stack_pointer_rtx((this_target_rtl->x_global_rtl)[GR_STACK_POINTER]))
727 return 0;
728
729 switch (GET_CODE (op)((enum rtx_code) (op)->code))
730 {
731 case PRE_INC:
732 case PRE_DEC:
733 ((HOST_WIDE_INTlong *)arg)[0] -= INTVAL (srcoff)((srcoff)->u.hwint[0]);
734 return 0;
735 case POST_INC:
736 case POST_DEC:
737 ((HOST_WIDE_INTlong *)arg)[1] -= INTVAL (srcoff)((srcoff)->u.hwint[0]);
738 return 0;
739 case PRE_MODIFY:
740 case POST_MODIFY:
741 /* We handle only adjustments by constant amount. */
742 gcc_assert (GET_CODE (src) == PLUS((void)(!(((enum rtx_code) (src)->code) == PLUS &&
(((enum rtx_code) ((((src)->u.fld[1]).rt_rtx))->code) ==
CONST_INT) && (((src)->u.fld[0]).rt_rtx) == ((this_target_rtl
->x_global_rtl)[GR_STACK_POINTER])) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 744, __FUNCTION__), 0 : 0))
743 && CONST_INT_P (XEXP (src, 1))((void)(!(((enum rtx_code) (src)->code) == PLUS &&
(((enum rtx_code) ((((src)->u.fld[1]).rt_rtx))->code) ==
CONST_INT) && (((src)->u.fld[0]).rt_rtx) == ((this_target_rtl
->x_global_rtl)[GR_STACK_POINTER])) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 744, __FUNCTION__), 0 : 0))
744 && XEXP (src, 0) == stack_pointer_rtx)((void)(!(((enum rtx_code) (src)->code) == PLUS &&
(((enum rtx_code) ((((src)->u.fld[1]).rt_rtx))->code) ==
CONST_INT) && (((src)->u.fld[0]).rt_rtx) == ((this_target_rtl
->x_global_rtl)[GR_STACK_POINTER])) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 744, __FUNCTION__), 0 : 0))
;
745 ((HOST_WIDE_INTlong *)arg)[GET_CODE (op)((enum rtx_code) (op)->code) == POST_MODIFY]
746 -= INTVAL (XEXP (src, 1))(((((src)->u.fld[1]).rt_rtx))->u.hwint[0]);
747 return 0;
748 default:
749 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 749, __FUNCTION__))
;
750 }
751}
752
753/* Given a SET, calculate the amount of stack adjustment it contains
754 PRE- and POST-modifying stack pointer.
755 This function is similar to stack_adjust_offset. */
756
757static void
758stack_adjust_offset_pre_post (rtx pattern, HOST_WIDE_INTlong *pre,
759 HOST_WIDE_INTlong *post)
760{
761 rtx src = SET_SRC (pattern)(((pattern)->u.fld[1]).rt_rtx);
762 rtx dest = SET_DEST (pattern)(((pattern)->u.fld[0]).rt_rtx);
763 enum rtx_code code;
764
765 if (dest == stack_pointer_rtx((this_target_rtl->x_global_rtl)[GR_STACK_POINTER]))
766 {
767 /* (set (reg sp) (plus (reg sp) (const_int))) */
768 code = GET_CODE (src)((enum rtx_code) (src)->code);
769 if (! (code == PLUS || code == MINUS)
770 || XEXP (src, 0)(((src)->u.fld[0]).rt_rtx) != stack_pointer_rtx((this_target_rtl->x_global_rtl)[GR_STACK_POINTER])
771 || !CONST_INT_P (XEXP (src, 1))(((enum rtx_code) ((((src)->u.fld[1]).rt_rtx))->code) ==
CONST_INT)
)
772 return;
773
774 if (code == MINUS)
775 *post += INTVAL (XEXP (src, 1))(((((src)->u.fld[1]).rt_rtx))->u.hwint[0]);
776 else
777 *post -= INTVAL (XEXP (src, 1))(((((src)->u.fld[1]).rt_rtx))->u.hwint[0]);
778 return;
779 }
780 HOST_WIDE_INTlong res[2] = { 0, 0 };
781 for_each_inc_dec (pattern, stack_adjust_offset_pre_post_cb, res);
782 *pre += res[0];
783 *post += res[1];
784}
785
786/* Given an INSN, calculate the amount of stack adjustment it contains
787 PRE- and POST-modifying stack pointer. */
788
789static void
790insn_stack_adjust_offset_pre_post (rtx_insn *insn, HOST_WIDE_INTlong *pre,
791 HOST_WIDE_INTlong *post)
792{
793 rtx pattern;
794
795 *pre = 0;
796 *post = 0;
797
798 pattern = PATTERN (insn);
799 if (RTX_FRAME_RELATED_P (insn)(__extension__ ({ __typeof ((insn)) const _rtx = ((insn)); if
(((enum rtx_code) (_rtx)->code) != DEBUG_INSN && (
(enum rtx_code) (_rtx)->code) != INSN && ((enum rtx_code
) (_rtx)->code) != CALL_INSN && ((enum rtx_code) (
_rtx)->code) != JUMP_INSN && ((enum rtx_code) (_rtx
)->code) != BARRIER && ((enum rtx_code) (_rtx)->
code) != SET) rtl_check_failed_flag ("RTX_FRAME_RELATED_P",_rtx
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 799, __FUNCTION__); _rtx; })->frame_related)
)
800 {
801 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX(rtx) 0);
802 if (expr)
803 pattern = XEXP (expr, 0)(((expr)->u.fld[0]).rt_rtx);
804 }
805
806 if (GET_CODE (pattern)((enum rtx_code) (pattern)->code) == SET)
807 stack_adjust_offset_pre_post (pattern, pre, post);
808 else if (GET_CODE (pattern)((enum rtx_code) (pattern)->code) == PARALLEL
809 || GET_CODE (pattern)((enum rtx_code) (pattern)->code) == SEQUENCE)
810 {
811 int i;
812
813 /* There may be stack adjustments inside compound insns. Search
814 for them. */
815 for ( i = XVECLEN (pattern, 0)(((((pattern)->u.fld[0]).rt_rtvec))->num_elem) - 1; i >= 0; i--)
816 if (GET_CODE (XVECEXP (pattern, 0, i))((enum rtx_code) ((((((pattern)->u.fld[0]).rt_rtvec))->
elem[i]))->code)
== SET)
817 stack_adjust_offset_pre_post (XVECEXP (pattern, 0, i)(((((pattern)->u.fld[0]).rt_rtvec))->elem[i]), pre, post);
818 }
819}
820
821/* Compute stack adjustments for all blocks by traversing DFS tree.
822 Return true when the adjustments on all incoming edges are consistent.
823 Heavily borrowed from pre_and_rev_post_order_compute. */
824
825static bool
826vt_stack_adjustments (void)
827{
828 edge_iterator *stack;
829 int sp;
830
831 /* Initialize entry block. */
832 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))((variable_tracking_info *) ((((cfun + 0))->cfg->x_entry_block_ptr
))->aux)
->visited = true;
833 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))((variable_tracking_info *) ((((cfun + 0))->cfg->x_entry_block_ptr
))->aux)
->in.stack_adjust
834 = INCOMING_FRAME_SP_OFFSET((cfun + 0)->machine->func_type == TYPE_EXCEPTION ? 2 *
(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
0) ? 8 : 4) : (((global_options.x_ix86_isa_flags & (1UL <<
1)) != 0) ? 8 : 4))
;
835 VTI (ENTRY_BLOCK_PTR_FOR_FN (cfun))((variable_tracking_info *) ((((cfun + 0))->cfg->x_entry_block_ptr
))->aux)
->out.stack_adjust
836 = INCOMING_FRAME_SP_OFFSET((cfun + 0)->machine->func_type == TYPE_EXCEPTION ? 2 *
(((global_options.x_ix86_isa_flags & (1UL << 1)) !=
0) ? 8 : 4) : (((global_options.x_ix86_isa_flags & (1UL <<
1)) != 0) ? 8 : 4))
;
837
838 /* Allocate stack for back-tracking up CFG. */
839 stack = XNEWVEC (edge_iterator, n_basic_blocks_for_fn (cfun) + 1)((edge_iterator *) xmalloc (sizeof (edge_iterator) * ((((cfun
+ 0))->cfg->x_n_basic_blocks) + 1)))
;
840 sp = 0;
841
842 /* Push the first edge on to the stack. */
843 stack[sp++] = ei_start (ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs)ei_start_1 (&((((cfun + 0))->cfg->x_entry_block_ptr
)->succs))
;
844
845 while (sp)
846 {
847 edge_iterator ei;
848 basic_block src;
849 basic_block dest;
850
851 /* Look at the edge on the top of the stack. */
852 ei = stack[sp - 1];
853 src = ei_edge (ei)->src;
854 dest = ei_edge (ei)->dest;
855
856 /* Check if the edge destination has been visited yet. */
857 if (!VTI (dest)((variable_tracking_info *) (dest)->aux)->visited)
858 {
859 rtx_insn *insn;
860 HOST_WIDE_INTlong pre, post, offset;
861 VTI (dest)((variable_tracking_info *) (dest)->aux)->visited = true;
862 VTI (dest)((variable_tracking_info *) (dest)->aux)->in.stack_adjust = offset = VTI (src)((variable_tracking_info *) (src)->aux)->out.stack_adjust;
863
864 if (dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
865 for (insn = BB_HEAD (dest)(dest)->il.x.head_;
866 insn != NEXT_INSN (BB_END (dest)(dest)->il.x.rtl->end_);
867 insn = NEXT_INSN (insn))
868 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))
)
869 {
870 insn_stack_adjust_offset_pre_post (insn, &pre, &post);
871 offset += pre + post;
872 }
873
874 VTI (dest)((variable_tracking_info *) (dest)->aux)->out.stack_adjust = offset;
875
876 if (EDGE_COUNT (dest->succs)vec_safe_length (dest->succs) > 0)
877 /* Since the DEST node has been visited for the first
878 time, check its successors. */
879 stack[sp++] = ei_start (dest->succs)ei_start_1 (&(dest->succs));
880 }
881 else
882 {
883 /* We can end up with different stack adjustments for the exit block
884 of a shrink-wrapped function if stack_adjust_offset_pre_post
885 doesn't understand the rtx pattern used to restore the stack
886 pointer in the epilogue. For example, on s390(x), the stack
887 pointer is often restored via a load-multiple instruction
888 and so no stack_adjust offset is recorded for it. This means
889 that the stack offset at the end of the epilogue block is the
890 same as the offset before the epilogue, whereas other paths
891 to the exit block will have the correct stack_adjust.
892
893 It is safe to ignore these differences because (a) we never
894 use the stack_adjust for the exit block in this pass and
895 (b) dwarf2cfi checks whether the CFA notes in a shrink-wrapped
896 function are correct.
897
898 We must check whether the adjustments on other edges are
899 the same though. */
900 if (dest != EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)
901 && VTI (dest)((variable_tracking_info *) (dest)->aux)->in.stack_adjust != VTI (src)((variable_tracking_info *) (src)->aux)->out.stack_adjust)
902 {
903 free (stack);
904 return false;
905 }
906
907 if (! ei_one_before_end_p (ei))
908 /* Go to the next edge. */
909 ei_next (&stack[sp - 1]);
910 else
911 /* Return to previous level if there are no more edges. */
912 sp--;
913 }
914 }
915
916 free (stack);
917 return true;
918}
919
920/* arg_pointer_rtx resp. frame_pointer_rtx if stack_pointer_rtx or
921 hard_frame_pointer_rtx is being mapped to it and offset for it. */
922static rtx cfa_base_rtx;
923static HOST_WIDE_INTlong cfa_base_offset;
924
925/* Compute a CFA-based value for an ADJUSTMENT made to stack_pointer_rtx
926 or hard_frame_pointer_rtx. */
927
928static inline rtx
929compute_cfa_pointer (poly_int64 adjustment)
930{
931 return plus_constant (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)))
, cfa_base_rtx, adjustment + cfa_base_offset);
932}
933
934/* Adjustment for hard_frame_pointer_rtx to cfa base reg,
935 or -1 if the replacement shouldn't be done. */
936static poly_int64 hard_frame_pointer_adjustment = -1;
937
938/* Data for adjust_mems callback. */
939
940class adjust_mem_data
941{
942public:
943 bool store;
944 machine_mode mem_mode;
945 HOST_WIDE_INTlong stack_adjust;
946 auto_vec<rtx> side_effects;
947};
948
949/* Helper for adjust_mems. Return true if X is suitable for
950 transformation of wider mode arithmetics to narrower mode. */
951
952static bool
953use_narrower_mode_test (rtx x, const_rtx subreg)
954{
955 subrtx_var_iterator::array_type array;
956 FOR_EACH_SUBRTX_VAR (iter, array, x, NONCONST)for (subrtx_var_iterator iter (array, x, rtx_nonconst_subrtx_bounds
); !iter.at_end (); iter.next ())
957 {
958 rtx x = *iter;
959 if (CONSTANT_P (x)((rtx_class[(int) (((enum rtx_code) (x)->code))]) == RTX_CONST_OBJ
)
)
960 iter.skip_subrtxes ();
961 else
962 switch (GET_CODE (x)((enum rtx_code) (x)->code))
963 {
964 case REG:
965 if (cselib_lookup (x, GET_MODE (SUBREG_REG (subreg))((machine_mode) ((((subreg)->u.fld[0]).rt_rtx))->mode), 0, VOIDmode((void) 0, E_VOIDmode)))
966 return false;
967 if (!validate_subreg (GET_MODE (subreg)((machine_mode) (subreg)->mode), GET_MODE (x)((machine_mode) (x)->mode), x,
968 subreg_lowpart_offset (GET_MODE (subreg)((machine_mode) (subreg)->mode),
969 GET_MODE (x)((machine_mode) (x)->mode))))
970 return false;
971 break;
972 case PLUS:
973 case MINUS:
974 case MULT:
975 break;
976 case ASHIFT:
977 if (GET_MODE (XEXP (x, 1))((machine_mode) ((((x)->u.fld[1]).rt_rtx))->mode) != VOIDmode((void) 0, E_VOIDmode))
978 {
979 enum machine_mode mode = GET_MODE (subreg)((machine_mode) (subreg)->mode);
980 rtx op1 = XEXP (x, 1)(((x)->u.fld[1]).rt_rtx);
981 enum machine_mode op1_mode = GET_MODE (op1)((machine_mode) (op1)->mode);
982 if (GET_MODE_PRECISION (as_a <scalar_int_mode> (mode))
983 < GET_MODE_PRECISION (as_a <scalar_int_mode> (op1_mode)))
984 {
985 poly_uint64 byte = subreg_lowpart_offset (mode, op1_mode);
986 if (GET_CODE (op1)((enum rtx_code) (op1)->code) == SUBREG || GET_CODE (op1)((enum rtx_code) (op1)->code) == CONCAT)
987 {
988 if (!simplify_subreg (mode, op1, op1_mode, byte))
989 return false;
990 }
991 else if (!validate_subreg (mode, op1_mode, op1, byte))
992 return false;
993 }
994 }
995 iter.substitute (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx));
996 break;
997 default:
998 return false;
999 }
1000 }
1001 return true;
1002}
1003
1004/* Transform X into narrower mode MODE from wider mode WMODE. */
1005
1006static rtx
1007use_narrower_mode (rtx x, scalar_int_mode mode, scalar_int_mode wmode)
1008{
1009 rtx op0, op1;
1010 if (CONSTANT_P (x)((rtx_class[(int) (((enum rtx_code) (x)->code))]) == RTX_CONST_OBJ
)
)
1011 return lowpart_subreg (mode, x, wmode);
1012 switch (GET_CODE (x)((enum rtx_code) (x)->code))
1013 {
1014 case REG:
1015 return lowpart_subreg (mode, x, wmode);
1016 case PLUS:
1017 case MINUS:
1018 case MULT:
1019 op0 = use_narrower_mode (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), mode, wmode);
1020 op1 = use_narrower_mode (XEXP (x, 1)(((x)->u.fld[1]).rt_rtx), mode, wmode);
1021 return simplify_gen_binary (GET_CODE (x)((enum rtx_code) (x)->code), mode, op0, op1);
1022 case ASHIFT:
1023 op0 = use_narrower_mode (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), mode, wmode);
1024 op1 = XEXP (x, 1)(((x)->u.fld[1]).rt_rtx);
1025 /* Ensure shift amount is not wider than mode. */
1026 if (GET_MODE (op1)((machine_mode) (op1)->mode) == VOIDmode((void) 0, E_VOIDmode))
1027 op1 = lowpart_subreg (mode, op1, wmode);
1028 else if (GET_MODE_PRECISION (mode)
1029 < GET_MODE_PRECISION (as_a <scalar_int_mode> (GET_MODE (op1)((machine_mode) (op1)->mode))))
1030 op1 = lowpart_subreg (mode, op1, GET_MODE (op1)((machine_mode) (op1)->mode));
1031 return simplify_gen_binary (ASHIFT, mode, op0, op1);
1032 default:
1033 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1033, __FUNCTION__))
;
1034 }
1035}
1036
1037/* Helper function for adjusting used MEMs. */
1038
1039static rtx
1040adjust_mems (rtx loc, const_rtx old_rtx, void *data)
1041{
1042 class adjust_mem_data *amd = (class adjust_mem_data *) data;
1043 rtx mem, addr = loc, tem;
1044 machine_mode mem_mode_save;
1045 bool store_save;
1046 scalar_int_mode tem_mode, tem_subreg_mode;
1047 poly_int64 size;
1048 switch (GET_CODE (loc)((enum rtx_code) (loc)->code))
1049 {
1050 case REG:
1051 /* Don't do any sp or fp replacements outside of MEM addresses
1052 on the LHS. */
1053 if (amd->mem_mode == VOIDmode((void) 0, E_VOIDmode) && amd->store)
1054 return loc;
1055 if (loc == stack_pointer_rtx((this_target_rtl->x_global_rtl)[GR_STACK_POINTER])
1056 && !frame_pointer_needed((&x_rtl)->frame_pointer_needed)
1057 && cfa_base_rtx)
1058 return compute_cfa_pointer (amd->stack_adjust);
1059 else if (loc == hard_frame_pointer_rtx((this_target_rtl->x_global_rtl)[GR_HARD_FRAME_POINTER])
1060 && frame_pointer_needed((&x_rtl)->frame_pointer_needed)
1061 && maybe_ne (hard_frame_pointer_adjustment, -1)
1062 && cfa_base_rtx)
1063 return compute_cfa_pointer (hard_frame_pointer_adjustment);
1064 gcc_checking_assert (loc != virtual_incoming_args_rtx)((void)(!(loc != ((this_target_rtl->x_global_rtl)[GR_VIRTUAL_INCOMING_ARGS
])) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1064, __FUNCTION__), 0 : 0))
;
1065 return loc;
1066 case MEM:
1067 mem = loc;
1068 if (!amd->store)
1069 {
1070 mem = targetm.delegitimize_address (mem);
1071 if (mem != loc && !MEM_P (mem)(((enum rtx_code) (mem)->code) == MEM))
1072 return simplify_replace_fn_rtx (mem, old_rtx, adjust_mems, data);
1073 }
1074
1075 addr = XEXP (mem, 0)(((mem)->u.fld[0]).rt_rtx);
1076 mem_mode_save = amd->mem_mode;
1077 amd->mem_mode = GET_MODE (mem)((machine_mode) (mem)->mode);
1078 store_save = amd->store;
1079 amd->store = false;
1080 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1081 amd->store = store_save;
1082 amd->mem_mode = mem_mode_save;
1083 if (mem == loc)
1084 addr = targetm.delegitimize_address (addr);
1085 if (addr != XEXP (mem, 0)(((mem)->u.fld[0]).rt_rtx))
1086 mem = replace_equiv_address_nv (mem, addr);
1087 if (!amd->store)
1088 mem = avoid_constant_pool_reference (mem);
1089 return mem;
1090 case PRE_INC:
1091 case PRE_DEC:
1092 size = GET_MODE_SIZE (amd->mem_mode);
1093 addr = plus_constant (GET_MODE (loc)((machine_mode) (loc)->mode), XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx),
1094 GET_CODE (loc)((enum rtx_code) (loc)->code) == PRE_INC ? size : -size);
1095 /* FALLTHRU */
1096 case POST_INC:
1097 case POST_DEC:
1098 if (addr == loc)
1099 addr = XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx);
1100 gcc_assert (amd->mem_mode != VOIDmode && amd->mem_mode != BLKmode)((void)(!(amd->mem_mode != ((void) 0, E_VOIDmode) &&
amd->mem_mode != ((void) 0, E_BLKmode)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1100, __FUNCTION__), 0 : 0))
;
1101 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1102 size = GET_MODE_SIZE (amd->mem_mode);
1103 tem = plus_constant (GET_MODE (loc)((machine_mode) (loc)->mode), XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx),
1104 (GET_CODE (loc)((enum rtx_code) (loc)->code) == PRE_INC
1105 || GET_CODE (loc)((enum rtx_code) (loc)->code) == POST_INC) ? size : -size);
1106 store_save = amd->store;
1107 amd->store = false;
1108 tem = simplify_replace_fn_rtx (tem, old_rtx, adjust_mems, data);
1109 amd->store = store_save;
1110 amd->side_effects.safe_push (gen_rtx_SET (XEXP (loc, 0), tem)gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), (((((loc
)->u.fld[0]).rt_rtx))), ((tem)) )
);
1111 return addr;
1112 case PRE_MODIFY:
1113 addr = XEXP (loc, 1)(((loc)->u.fld[1]).rt_rtx);
1114 /* FALLTHRU */
1115 case POST_MODIFY:
1116 if (addr == loc)
1117 addr = XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx);
1118 gcc_assert (amd->mem_mode != VOIDmode)((void)(!(amd->mem_mode != ((void) 0, E_VOIDmode)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1118, __FUNCTION__), 0 : 0))
;
1119 addr = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1120 store_save = amd->store;
1121 amd->store = false;
1122 tem = simplify_replace_fn_rtx (XEXP (loc, 1)(((loc)->u.fld[1]).rt_rtx), old_rtx,
1123 adjust_mems, data);
1124 amd->store = store_save;
1125 amd->side_effects.safe_push (gen_rtx_SET (XEXP (loc, 0), tem)gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), (((((loc
)->u.fld[0]).rt_rtx))), ((tem)) )
);
1126 return addr;
1127 case SUBREG:
1128 /* First try without delegitimization of whole MEMs and
1129 avoid_constant_pool_reference, which is more likely to succeed. */
1130 store_save = amd->store;
1131 amd->store = true;
1132 addr = simplify_replace_fn_rtx (SUBREG_REG (loc)(((loc)->u.fld[0]).rt_rtx), old_rtx, adjust_mems,
1133 data);
1134 amd->store = store_save;
1135 mem = simplify_replace_fn_rtx (addr, old_rtx, adjust_mems, data);
1136 if (mem == SUBREG_REG (loc)(((loc)->u.fld[0]).rt_rtx))
1137 {
1138 tem = loc;
1139 goto finish_subreg;
1140 }
1141 tem = simplify_gen_subreg (GET_MODE (loc)((machine_mode) (loc)->mode), mem,
1142 GET_MODE (SUBREG_REG (loc))((machine_mode) ((((loc)->u.fld[0]).rt_rtx))->mode),
1143 SUBREG_BYTE (loc)(((loc)->u.fld[1]).rt_subreg));
1144 if (tem)
1145 goto finish_subreg;
1146 tem = simplify_gen_subreg (GET_MODE (loc)((machine_mode) (loc)->mode), addr,
1147 GET_MODE (SUBREG_REG (loc))((machine_mode) ((((loc)->u.fld[0]).rt_rtx))->mode),
1148 SUBREG_BYTE (loc)(((loc)->u.fld[1]).rt_subreg));
1149 if (tem == NULL_RTX(rtx) 0)
1150 tem = gen_rtx_raw_SUBREG (GET_MODE (loc), addr, SUBREG_BYTE (loc))gen_rtx_fmt_ep_stat ((SUBREG), ((((machine_mode) (loc)->mode
))), ((addr)), (((((loc)->u.fld[1]).rt_subreg))) )
;
1151 finish_subreg:
1152 if (MAY_HAVE_DEBUG_BIND_INSNSglobal_options.x_flag_var_tracking_assignments
1153 && GET_CODE (tem)((enum rtx_code) (tem)->code) == SUBREG
1154 && (GET_CODE (SUBREG_REG (tem))((enum rtx_code) ((((tem)->u.fld[0]).rt_rtx))->code) == PLUS
1155 || GET_CODE (SUBREG_REG (tem))((enum rtx_code) ((((tem)->u.fld[0]).rt_rtx))->code) == MINUS
1156 || GET_CODE (SUBREG_REG (tem))((enum rtx_code) ((((tem)->u.fld[0]).rt_rtx))->code) == MULT
1157 || GET_CODE (SUBREG_REG (tem))((enum rtx_code) ((((tem)->u.fld[0]).rt_rtx))->code) == ASHIFT)
1158 && is_a <scalar_int_mode> (GET_MODE (tem)((machine_mode) (tem)->mode), &tem_mode)
1159 && is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (tem))((machine_mode) ((((tem)->u.fld[0]).rt_rtx))->mode),
1160 &tem_subreg_mode)
1161 && (GET_MODE_PRECISION (tem_mode)
1162 < GET_MODE_PRECISION (tem_subreg_mode))
1163 && subreg_lowpart_p (tem)
1164 && use_narrower_mode_test (SUBREG_REG (tem)(((tem)->u.fld[0]).rt_rtx), tem))
1165 return use_narrower_mode (SUBREG_REG (tem)(((tem)->u.fld[0]).rt_rtx), tem_mode, tem_subreg_mode);
1166 return tem;
1167 case ASM_OPERANDS:
1168 /* Don't do any replacements in second and following
1169 ASM_OPERANDS of inline-asm with multiple sets.
1170 ASM_OPERANDS_INPUT_VEC, ASM_OPERANDS_INPUT_CONSTRAINT_VEC
1171 and ASM_OPERANDS_LABEL_VEC need to be equal between
1172 all the ASM_OPERANDs in the insn and adjust_insn will
1173 fix this up. */
1174 if (ASM_OPERANDS_OUTPUT_IDX (loc)(((loc)->u.fld[2]).rt_int) != 0)
1175 return loc;
1176 break;
1177 default:
1178 break;
1179 }
1180 return NULL_RTX(rtx) 0;
1181}
1182
1183/* Helper function for replacement of uses. */
1184
1185static void
1186adjust_mem_uses (rtx *x, void *data)
1187{
1188 rtx new_x = simplify_replace_fn_rtx (*x, NULL_RTX(rtx) 0, adjust_mems, data);
1189 if (new_x != *x)
1190 validate_change (NULL_RTX(rtx) 0, x, new_x, true);
1191}
1192
1193/* Helper function for replacement of stores. */
1194
1195static void
1196adjust_mem_stores (rtx loc, const_rtx expr, void *data)
1197{
1198 if (MEM_P (loc)(((enum rtx_code) (loc)->code) == MEM))
1199 {
1200 rtx new_dest = simplify_replace_fn_rtx (SET_DEST (expr)(((expr)->u.fld[0]).rt_rtx), NULL_RTX(rtx) 0,
1201 adjust_mems, data);
1202 if (new_dest != SET_DEST (expr)(((expr)->u.fld[0]).rt_rtx))
1203 {
1204 rtx xexpr = CONST_CAST_RTX (expr)(const_cast<struct rtx_def *> (((expr))));
1205 validate_change (NULL_RTX(rtx) 0, &SET_DEST (xexpr)(((xexpr)->u.fld[0]).rt_rtx), new_dest, true);
1206 }
1207 }
1208}
1209
1210/* Simplify INSN. Remove all {PRE,POST}_{INC,DEC,MODIFY} rtxes,
1211 replace them with their value in the insn and add the side-effects
1212 as other sets to the insn. */
1213
1214static void
1215adjust_insn (basic_block bb, rtx_insn *insn)
1216{
1217 rtx set;
1218
1219#ifdef HAVE_window_save
1220 /* If the target machine has an explicit window save instruction, the
1221 transformation OUTGOING_REGNO -> INCOMING_REGNO is done there. */
1222 if (RTX_FRAME_RELATED_P (insn)(__extension__ ({ __typeof ((insn)) const _rtx = ((insn)); if
(((enum rtx_code) (_rtx)->code) != DEBUG_INSN && (
(enum rtx_code) (_rtx)->code) != INSN && ((enum rtx_code
) (_rtx)->code) != CALL_INSN && ((enum rtx_code) (
_rtx)->code) != JUMP_INSN && ((enum rtx_code) (_rtx
)->code) != BARRIER && ((enum rtx_code) (_rtx)->
code) != SET) rtl_check_failed_flag ("RTX_FRAME_RELATED_P",_rtx
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1222, __FUNCTION__); _rtx; })->frame_related)
1223 && find_reg_note (insn, REG_CFA_WINDOW_SAVE, NULL_RTX(rtx) 0))
1224 {
1225 unsigned int i, nregs = vec_safe_length (windowed_parm_regs);
1226 rtx rtl = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nregs * 2))gen_rtx_fmt_E_stat ((PARALLEL), ((((void) 0, E_VOIDmode))), (
(rtvec_alloc (nregs * 2))) )
;
1227 parm_reg *p;
1228
1229 FOR_EACH_VEC_SAFE_ELT (windowed_parm_regs, i, p)for (i = 0; vec_safe_iterate ((windowed_parm_regs), (i), &
(p)); ++(i))
1230 {
1231 XVECEXP (rtl, 0, i * 2)(((((rtl)->u.fld[0]).rt_rtvec))->elem[i * 2])
1232 = gen_rtx_SET (p->incoming, p->outgoing)gen_rtx_fmt_ee_stat ((SET), (((void) 0, E_VOIDmode)), ((p->
incoming)), ((p->outgoing)) )
;
1233 /* Do not clobber the attached DECL, but only the REG. */
1234 XVECEXP (rtl, 0, i * 2 + 1)(((((rtl)->u.fld[0]).rt_rtvec))->elem[i * 2 + 1])
1235 = gen_rtx_CLOBBER (GET_MODE (p->outgoing),gen_rtx_fmt_e_stat ((CLOBBER), ((((machine_mode) (p->outgoing
)->mode))), ((gen_raw_REG (((machine_mode) (p->outgoing
)->mode), (rhs_regno(p->outgoing))))) )
1236 gen_raw_REG (GET_MODE (p->outgoing),gen_rtx_fmt_e_stat ((CLOBBER), ((((machine_mode) (p->outgoing
)->mode))), ((gen_raw_REG (((machine_mode) (p->outgoing
)->mode), (rhs_regno(p->outgoing))))) )
1237 REGNO (p->outgoing)))gen_rtx_fmt_e_stat ((CLOBBER), ((((machine_mode) (p->outgoing
)->mode))), ((gen_raw_REG (((machine_mode) (p->outgoing
)->mode), (rhs_regno(p->outgoing))))) )
;
1238 }
1239
1240 validate_change (NULL_RTX(rtx) 0, &PATTERN (insn), rtl, true);
1241 return;
1242 }
1243#endif
1244
1245 adjust_mem_data amd;
1246 amd.mem_mode = VOIDmode((void) 0, E_VOIDmode);
1247 amd.stack_adjust = -VTI (bb)((variable_tracking_info *) (bb)->aux)->out.stack_adjust;
1248
1249 amd.store = true;
1250 note_stores (insn, adjust_mem_stores, &amd);
1251
1252 amd.store = false;
1253 if (GET_CODE (PATTERN (insn))((enum rtx_code) (PATTERN (insn))->code) == PARALLEL
1254 && asm_noperands (PATTERN (insn)) > 0
1255 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0))((enum rtx_code) ((((((PATTERN (insn))->u.fld[0]).rt_rtvec
))->elem[0]))->code)
== SET)
1256 {
1257 rtx body, set0;
1258 int i;
1259
1260 /* inline-asm with multiple sets is tiny bit more complicated,
1261 because the 3 vectors in ASM_OPERANDS need to be shared between
1262 all ASM_OPERANDS in the instruction. adjust_mems will
1263 not touch ASM_OPERANDS other than the first one, asm_noperands
1264 test above needs to be called before that (otherwise it would fail)
1265 and afterwards this code fixes it up. */
1266 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1267 body = PATTERN (insn);
1268 set0 = XVECEXP (body, 0, 0)(((((body)->u.fld[0]).rt_rtvec))->elem[0]);
1269 gcc_checking_assert (GET_CODE (set0) == SET((void)(!(((enum rtx_code) (set0)->code) == SET &&
((enum rtx_code) ((((set0)->u.fld[1]).rt_rtx))->code) ==
ASM_OPERANDS && ((((((set0)->u.fld[1]).rt_rtx))->
u.fld[2]).rt_int) == 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1271, __FUNCTION__), 0 : 0))
1270 && GET_CODE (SET_SRC (set0)) == ASM_OPERANDS((void)(!(((enum rtx_code) (set0)->code) == SET &&
((enum rtx_code) ((((set0)->u.fld[1]).rt_rtx))->code) ==
ASM_OPERANDS && ((((((set0)->u.fld[1]).rt_rtx))->
u.fld[2]).rt_int) == 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1271, __FUNCTION__), 0 : 0))
1271 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set0)) == 0)((void)(!(((enum rtx_code) (set0)->code) == SET &&
((enum rtx_code) ((((set0)->u.fld[1]).rt_rtx))->code) ==
ASM_OPERANDS && ((((((set0)->u.fld[1]).rt_rtx))->
u.fld[2]).rt_int) == 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1271, __FUNCTION__), 0 : 0))
;
1272 for (i = 1; i < XVECLEN (body, 0)(((((body)->u.fld[0]).rt_rtvec))->num_elem); i++)
1273 if (GET_CODE (XVECEXP (body, 0, i))((enum rtx_code) ((((((body)->u.fld[0]).rt_rtvec))->elem
[i]))->code)
!= SET)
1274 break;
1275 else
1276 {
1277 set = XVECEXP (body, 0, i)(((((body)->u.fld[0]).rt_rtvec))->elem[i]);
1278 gcc_checking_assert (GET_CODE (SET_SRC (set)) == ASM_OPERANDS((void)(!(((enum rtx_code) ((((set)->u.fld[1]).rt_rtx))->
code) == ASM_OPERANDS && ((((((set)->u.fld[1]).rt_rtx
))->u.fld[2]).rt_int) == i) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1280, __FUNCTION__), 0 : 0))
1279 && ASM_OPERANDS_OUTPUT_IDX (SET_SRC (set))((void)(!(((enum rtx_code) ((((set)->u.fld[1]).rt_rtx))->
code) == ASM_OPERANDS && ((((((set)->u.fld[1]).rt_rtx
))->u.fld[2]).rt_int) == i) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1280, __FUNCTION__), 0 : 0))
1280 == i)((void)(!(((enum rtx_code) ((((set)->u.fld[1]).rt_rtx))->
code) == ASM_OPERANDS && ((((((set)->u.fld[1]).rt_rtx
))->u.fld[2]).rt_int) == i) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1280, __FUNCTION__), 0 : 0))
;
1281 if (ASM_OPERANDS_INPUT_VEC (SET_SRC (set))((((((set)->u.fld[1]).rt_rtx))->u.fld[3]).rt_rtvec)
1282 != ASM_OPERANDS_INPUT_VEC (SET_SRC (set0))((((((set0)->u.fld[1]).rt_rtx))->u.fld[3]).rt_rtvec)
1283 || ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set))((((((set)->u.fld[1]).rt_rtx))->u.fld[4]).rt_rtvec)
1284 != ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0))((((((set0)->u.fld[1]).rt_rtx))->u.fld[4]).rt_rtvec)
1285 || ASM_OPERANDS_LABEL_VEC (SET_SRC (set))((((((set)->u.fld[1]).rt_rtx))->u.fld[5]).rt_rtvec)
1286 != ASM_OPERANDS_LABEL_VEC (SET_SRC (set0))((((((set0)->u.fld[1]).rt_rtx))->u.fld[5]).rt_rtvec))
1287 {
1288 rtx newsrc = shallow_copy_rtx (SET_SRC (set)(((set)->u.fld[1]).rt_rtx));
1289 ASM_OPERANDS_INPUT_VEC (newsrc)(((newsrc)->u.fld[3]).rt_rtvec)
1290 = ASM_OPERANDS_INPUT_VEC (SET_SRC (set0))((((((set0)->u.fld[1]).rt_rtx))->u.fld[3]).rt_rtvec);
1291 ASM_OPERANDS_INPUT_CONSTRAINT_VEC (newsrc)(((newsrc)->u.fld[4]).rt_rtvec)
1292 = ASM_OPERANDS_INPUT_CONSTRAINT_VEC (SET_SRC (set0))((((((set0)->u.fld[1]).rt_rtx))->u.fld[4]).rt_rtvec);
1293 ASM_OPERANDS_LABEL_VEC (newsrc)(((newsrc)->u.fld[5]).rt_rtvec)
1294 = ASM_OPERANDS_LABEL_VEC (SET_SRC (set0))((((((set0)->u.fld[1]).rt_rtx))->u.fld[5]).rt_rtvec);
1295 validate_change (NULL_RTX(rtx) 0, &SET_SRC (set)(((set)->u.fld[1]).rt_rtx), newsrc, true);
1296 }
1297 }
1298 }
1299 else
1300 note_uses (&PATTERN (insn), adjust_mem_uses, &amd);
1301
1302 /* For read-only MEMs containing some constant, prefer those
1303 constants. */
1304 set = single_set (insn);
1305 if (set && MEM_P (SET_SRC (set))(((enum rtx_code) ((((set)->u.fld[1]).rt_rtx))->code) ==
MEM)
&& MEM_READONLY_P (SET_SRC (set))(__extension__ ({ __typeof (((((set)->u.fld[1]).rt_rtx))) const
_rtx = (((((set)->u.fld[1]).rt_rtx))); 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/var-tracking.c"
, 1305, __FUNCTION__); _rtx; })->unchanging)
)
1306 {
1307 rtx note = find_reg_equal_equiv_note (insn);
1308
1309 if (note && CONSTANT_P (XEXP (note, 0))((rtx_class[(int) (((enum rtx_code) ((((note)->u.fld[0]).rt_rtx
))->code))]) == RTX_CONST_OBJ)
)
1310 validate_change (NULL_RTX(rtx) 0, &SET_SRC (set)(((set)->u.fld[1]).rt_rtx), XEXP (note, 0)(((note)->u.fld[0]).rt_rtx), true);
1311 }
1312
1313 if (!amd.side_effects.is_empty ())
1314 {
1315 rtx *pat, new_pat;
1316 int i, oldn;
1317
1318 pat = &PATTERN (insn);
1319 if (GET_CODE (*pat)((enum rtx_code) (*pat)->code) == COND_EXEC)
1320 pat = &COND_EXEC_CODE (*pat)(((*pat)->u.fld[1]).rt_rtx);
1321 if (GET_CODE (*pat)((enum rtx_code) (*pat)->code) == PARALLEL)
1322 oldn = XVECLEN (*pat, 0)(((((*pat)->u.fld[0]).rt_rtvec))->num_elem);
1323 else
1324 oldn = 1;
1325 unsigned int newn = amd.side_effects.length ();
1326 new_pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (oldn + newn))gen_rtx_fmt_E_stat ((PARALLEL), ((((void) 0, E_VOIDmode))), (
(rtvec_alloc (oldn + newn))) )
;
1327 if (GET_CODE (*pat)((enum rtx_code) (*pat)->code) == PARALLEL)
1328 for (i = 0; i < oldn; i++)
1329 XVECEXP (new_pat, 0, i)(((((new_pat)->u.fld[0]).rt_rtvec))->elem[i]) = XVECEXP (*pat, 0, i)(((((*pat)->u.fld[0]).rt_rtvec))->elem[i]);
1330 else
1331 XVECEXP (new_pat, 0, 0)(((((new_pat)->u.fld[0]).rt_rtvec))->elem[0]) = *pat;
1332
1333 rtx effect;
1334 unsigned int j;
1335 FOR_EACH_VEC_ELT_REVERSE (amd.side_effects, j, effect)for (j = (amd.side_effects).length () - 1; (amd.side_effects)
.iterate ((j), &(effect)); (j)--)
1336 XVECEXP (new_pat, 0, j + oldn)(((((new_pat)->u.fld[0]).rt_rtvec))->elem[j + oldn]) = effect;
1337 validate_change (NULL_RTX(rtx) 0, pat, new_pat, true);
1338 }
1339}
1340
1341/* Return the DEBUG_EXPR of a DEBUG_EXPR_DECL or the VALUE in DV. */
1342static inline rtx
1343dv_as_rtx (decl_or_value dv)
1344{
1345 tree decl;
1346
1347 if (dv_is_value_p (dv))
1348 return dv_as_value (dv);
1349
1350 decl = dv_as_decl (dv);
1351
1352 gcc_checking_assert (TREE_CODE (decl) == DEBUG_EXPR_DECL)((void)(!(((enum tree_code) (decl)->base.code) == DEBUG_EXPR_DECL
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1352, __FUNCTION__), 0 : 0))
;
1353 return DECL_RTL_KNOWN_SET (decl)__extension__ ({ tree const __d = (decl); ((void)(!((((tree_contains_struct
[(((enum tree_code) (__d)->base.code))][(TS_DECL_WRTL)])) &&
(contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1353, __FUNCTION__))->decl_with_rtl.rtl != nullptr)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1353, __FUNCTION__), 0 : 0)); &*((((tree_contains_struct
[(((enum tree_code) (__d)->base.code))][(TS_DECL_WRTL)])) &&
(contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1353, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1353, __FUNCTION__))->decl_with_rtl.rtl ? (__d)->decl_with_rtl
.rtl : (make_decl_rtl (__d), (__d)->decl_with_rtl.rtl)) : nullptr
); })
;
1354}
1355
1356/* Return nonzero if a decl_or_value must not have more than one
1357 variable part. The returned value discriminates among various
1358 kinds of one-part DVs ccording to enum onepart_enum. */
1359static inline onepart_enum
1360dv_onepart_p (decl_or_value dv)
1361{
1362 tree decl;
1363
1364 if (!MAY_HAVE_DEBUG_BIND_INSNSglobal_options.x_flag_var_tracking_assignments)
1365 return NOT_ONEPART;
1366
1367 if (dv_is_value_p (dv))
1368 return ONEPART_VALUE;
1369
1370 decl = dv_as_decl (dv);
1371
1372 if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == DEBUG_EXPR_DECL)
1373 return ONEPART_DEXPR;
1374
1375 if (target_for_debug_bind (decl) != NULL_TREE(tree) nullptr)
1376 return ONEPART_VDECL;
1377
1378 return NOT_ONEPART;
1379}
1380
1381/* Return the variable pool to be used for a dv of type ONEPART. */
1382static inline pool_allocator &
1383onepart_pool (onepart_enum onepart)
1384{
1385 return onepart ? valvar_pool : var_pool;
1386}
1387
1388/* Allocate a variable_def from the corresponding variable pool. */
1389static inline variable *
1390onepart_pool_allocate (onepart_enum onepart)
1391{
1392 return (variable*) onepart_pool (onepart).allocate ();
1393}
1394
1395/* Build a decl_or_value out of a decl. */
1396static inline decl_or_value
1397dv_from_decl (tree decl)
1398{
1399 decl_or_value dv;
1400 dv = decl;
1401 gcc_checking_assert (dv_is_decl_p (dv))((void)(!(dv_is_decl_p (dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1401, __FUNCTION__), 0 : 0))
;
1402 return dv;
1403}
1404
1405/* Build a decl_or_value out of a value. */
1406static inline decl_or_value
1407dv_from_value (rtx value)
1408{
1409 decl_or_value dv;
1410 dv = value;
1411 gcc_checking_assert (dv_is_value_p (dv))((void)(!(dv_is_value_p (dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1411, __FUNCTION__), 0 : 0))
;
1412 return dv;
1413}
1414
1415/* Return a value or the decl of a debug_expr as a decl_or_value. */
1416static inline decl_or_value
1417dv_from_rtx (rtx x)
1418{
1419 decl_or_value dv;
1420
1421 switch (GET_CODE (x)((enum rtx_code) (x)->code))
1422 {
1423 case DEBUG_EXPR:
1424 dv = dv_from_decl (DEBUG_EXPR_TREE_DECL (x)(((x)->u.fld[0]).rt_tree));
1425 gcc_checking_assert (DECL_RTL_KNOWN_SET (DEBUG_EXPR_TREE_DECL (x)) == x)((void)(!(__extension__ ({ tree const __d = ((((x)->u.fld[
0]).rt_tree)); ((void)(!((((tree_contains_struct[(((enum tree_code
) (__d)->base.code))][(TS_DECL_WRTL)])) && (contains_struct_check
((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1425, __FUNCTION__))->decl_with_rtl.rtl != nullptr)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1425, __FUNCTION__), 0 : 0)); &*((((tree_contains_struct
[(((enum tree_code) (__d)->base.code))][(TS_DECL_WRTL)])) &&
(contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1425, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1425, __FUNCTION__))->decl_with_rtl.rtl ? (__d)->decl_with_rtl
.rtl : (make_decl_rtl (__d), (__d)->decl_with_rtl.rtl)) : nullptr
); }) == x) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1425, __FUNCTION__), 0 : 0))
;
1426 break;
1427
1428 case VALUE:
1429 dv = dv_from_value (x);
1430 break;
1431
1432 default:
1433 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1433, __FUNCTION__))
;
1434 }
1435
1436 return dv;
1437}
1438
1439extern void debug_dv (decl_or_value dv);
1440
1441DEBUG_FUNCTION__attribute__ ((__used__)) void
1442debug_dv (decl_or_value dv)
1443{
1444 if (dv_is_value_p (dv))
1445 debug_rtx (dv_as_value (dv));
1446 else
1447 debug_generic_stmt (dv_as_decl (dv));
1448}
1449
1450static void loc_exp_dep_clear (variable *var);
1451
1452/* Free the element of VARIABLE_HTAB (its type is struct variable_def). */
1453
1454static void
1455variable_htab_free (void *elem)
1456{
1457 int i;
1458 variable *var = (variable *) elem;
1459 location_chain *node, *next;
1460
1461 gcc_checking_assert (var->refcount > 0)((void)(!(var->refcount > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1461, __FUNCTION__), 0 : 0))
;
1462
1463 var->refcount--;
1464 if (var->refcount > 0)
1465 return;
1466
1467 for (i = 0; i < var->n_var_parts; i++)
1468 {
1469 for (node = var->var_part[i].loc_chain; node; node = next)
1470 {
1471 next = node->next;
1472 delete node;
1473 }
1474 var->var_part[i].loc_chain = NULLnullptr;
1475 }
1476 if (var->onepart && VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1476, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
)
1477 {
1478 loc_exp_dep_clear (var);
1479 if (VAR_LOC_DEP_LST (var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1479, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; })) ? __extension__ (*({ variable *const __v = (var)
; ((void)(!(__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1479, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))->backlinks : nullptr)
)
1480 VAR_LOC_DEP_LST (var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1480, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; })) ? __extension__ (*({ variable *const __v = (var)
; ((void)(!(__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1480, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))->backlinks : nullptr)
->pprev = NULLnullptr;
1481 XDELETE (VAR_LOC_1PAUX (var))free ((void*) (__extension__ (*({ variable *const __v = (var)
; ((void)(!(__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1481, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))))
;
1482 /* These may be reused across functions, so reset
1483 e.g. NO_LOC_P. */
1484 if (var->onepart == ONEPART_DEXPR)
1485 set_dv_changed (var->dv, true);
1486 }
1487 onepart_pool (var->onepart).remove (var);
1488}
1489
1490/* Initialize the set (array) SET of attrs to empty lists. */
1491
1492static void
1493init_attrs_list_set (attrs **set)
1494{
1495 int i;
1496
1497 for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
1498 set[i] = NULLnullptr;
1499}
1500
1501/* Make the list *LISTP empty. */
1502
1503static void
1504attrs_list_clear (attrs **listp)
1505{
1506 attrs *list, *next;
1507
1508 for (list = *listp; list; list = next)
1509 {
1510 next = list->next;
1511 delete list;
1512 }
1513 *listp = NULLnullptr;
1514}
1515
1516/* Return true if the pair of DECL and OFFSET is the member of the LIST. */
1517
1518static attrs *
1519attrs_list_member (attrs *list, decl_or_value dv, HOST_WIDE_INTlong offset)
1520{
1521 for (; list; list = list->next)
1522 if (dv_as_opaque (list->dv) == dv_as_opaque (dv) && list->offset == offset)
1523 return list;
1524 return NULLnullptr;
1525}
1526
1527/* Insert the triplet DECL, OFFSET, LOC to the list *LISTP. */
1528
1529static void
1530attrs_list_insert (attrs **listp, decl_or_value dv,
1531 HOST_WIDE_INTlong offset, rtx loc)
1532{
1533 attrs *list = new attrs;
1534 list->loc = loc;
1535 list->dv = dv;
1536 list->offset = offset;
1537 list->next = *listp;
1538 *listp = list;
1539}
1540
1541/* Copy all nodes from SRC and create a list *DSTP of the copies. */
1542
1543static void
1544attrs_list_copy (attrs **dstp, attrs *src)
1545{
1546 attrs_list_clear (dstp);
1547 for (; src; src = src->next)
1548 {
1549 attrs *n = new attrs;
1550 n->loc = src->loc;
1551 n->dv = src->dv;
1552 n->offset = src->offset;
1553 n->next = *dstp;
1554 *dstp = n;
1555 }
1556}
1557
1558/* Add all nodes from SRC which are not in *DSTP to *DSTP. */
1559
1560static void
1561attrs_list_union (attrs **dstp, attrs *src)
1562{
1563 for (; src; src = src->next)
1564 {
1565 if (!attrs_list_member (*dstp, src->dv, src->offset))
1566 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1567 }
1568}
1569
1570/* Combine nodes that are not onepart nodes from SRC and SRC2 into
1571 *DSTP. */
1572
1573static void
1574attrs_list_mpdv_union (attrs **dstp, attrs *src, attrs *src2)
1575{
1576 gcc_assert (!*dstp)((void)(!(!*dstp) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1576, __FUNCTION__), 0 : 0))
;
1577 for (; src; src = src->next)
1578 {
1579 if (!dv_onepart_p (src->dv))
1580 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1581 }
1582 for (src = src2; src; src = src->next)
1583 {
1584 if (!dv_onepart_p (src->dv)
1585 && !attrs_list_member (*dstp, src->dv, src->offset))
1586 attrs_list_insert (dstp, src->dv, src->offset, src->loc);
1587 }
1588}
1589
1590/* Shared hashtable support. */
1591
1592/* Return true if VARS is shared. */
1593
1594static inline bool
1595shared_hash_shared (shared_hash *vars)
1596{
1597 return vars->refcount > 1;
1598}
1599
1600/* Return the hash table for VARS. */
1601
1602static inline variable_table_type *
1603shared_hash_htab (shared_hash *vars)
1604{
1605 return vars->htab;
1606}
1607
1608/* Return true if VAR is shared, or maybe because VARS is shared. */
1609
1610static inline bool
1611shared_var_p (variable *var, shared_hash *vars)
1612{
1613 /* Don't count an entry in the changed_variables table as a duplicate. */
1614 return ((var->refcount > 1 + (int) var->in_changed_variables)
1615 || shared_hash_shared (vars));
1616}
1617
1618/* Copy variables into a new hash table. */
1619
1620static shared_hash *
1621shared_hash_unshare (shared_hash *vars)
1622{
1623 shared_hash *new_vars = new shared_hash;
1624 gcc_assert (vars->refcount > 1)((void)(!(vars->refcount > 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1624, __FUNCTION__), 0 : 0))
;
1625 new_vars->refcount = 1;
1626 new_vars->htab = new variable_table_type (vars->htab->elements () + 3);
1627 vars_copy (new_vars->htab, vars->htab);
1628 vars->refcount--;
1629 return new_vars;
1630}
1631
1632/* Increment reference counter on VARS and return it. */
1633
1634static inline shared_hash *
1635shared_hash_copy (shared_hash *vars)
1636{
1637 vars->refcount++;
1638 return vars;
1639}
1640
1641/* Decrement reference counter and destroy hash table if not shared
1642 anymore. */
1643
1644static void
1645shared_hash_destroy (shared_hash *vars)
1646{
1647 gcc_checking_assert (vars->refcount > 0)((void)(!(vars->refcount > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1647, __FUNCTION__), 0 : 0))
;
1648 if (--vars->refcount == 0)
1649 {
1650 delete vars->htab;
1651 delete vars;
1652 }
1653}
1654
1655/* Unshare *PVARS if shared and return slot for DV. If INS is
1656 INSERT, insert it if not already present. */
1657
1658static inline variable **
1659shared_hash_find_slot_unshare_1 (shared_hash **pvars, decl_or_value dv,
1660 hashval_t dvhash, enum insert_option ins)
1661{
1662 if (shared_hash_shared (*pvars))
1663 *pvars = shared_hash_unshare (*pvars);
1664 return shared_hash_htab (*pvars)->find_slot_with_hash (dv, dvhash, ins);
1665}
1666
1667static inline variable **
1668shared_hash_find_slot_unshare (shared_hash **pvars, decl_or_value dv,
1669 enum insert_option ins)
1670{
1671 return shared_hash_find_slot_unshare_1 (pvars, dv, dv_htab_hash (dv), ins);
1672}
1673
1674/* Return slot for DV, if it is already present in the hash table.
1675 If it is not present, insert it only VARS is not shared, otherwise
1676 return NULL. */
1677
1678static inline variable **
1679shared_hash_find_slot_1 (shared_hash *vars, decl_or_value dv, hashval_t dvhash)
1680{
1681 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash,
1682 shared_hash_shared (vars)
1683 ? NO_INSERT : INSERT);
1684}
1685
1686static inline variable **
1687shared_hash_find_slot (shared_hash *vars, decl_or_value dv)
1688{
1689 return shared_hash_find_slot_1 (vars, dv, dv_htab_hash (dv));
1690}
1691
1692/* Return slot for DV only if it is already present in the hash table. */
1693
1694static inline variable **
1695shared_hash_find_slot_noinsert_1 (shared_hash *vars, decl_or_value dv,
1696 hashval_t dvhash)
1697{
1698 return shared_hash_htab (vars)->find_slot_with_hash (dv, dvhash, NO_INSERT);
1699}
1700
1701static inline variable **
1702shared_hash_find_slot_noinsert (shared_hash *vars, decl_or_value dv)
1703{
1704 return shared_hash_find_slot_noinsert_1 (vars, dv, dv_htab_hash (dv));
1705}
1706
1707/* Return variable for DV or NULL if not already present in the hash
1708 table. */
1709
1710static inline variable *
1711shared_hash_find_1 (shared_hash *vars, decl_or_value dv, hashval_t dvhash)
1712{
1713 return shared_hash_htab (vars)->find_with_hash (dv, dvhash);
1714}
1715
1716static inline variable *
1717shared_hash_find (shared_hash *vars, decl_or_value dv)
1718{
1719 return shared_hash_find_1 (vars, dv, dv_htab_hash (dv));
1720}
1721
1722/* Return true if TVAL is better than CVAL as a canonival value. We
1723 choose lowest-numbered VALUEs, using the RTX address as a
1724 tie-breaker. The idea is to arrange them into a star topology,
1725 such that all of them are at most one step away from the canonical
1726 value, and the canonical value has backlinks to all of them, in
1727 addition to all the actual locations. We don't enforce this
1728 topology throughout the entire dataflow analysis, though.
1729 */
1730
1731static inline bool
1732canon_value_cmp (rtx tval, rtx cval)
1733{
1734 return !cval
1735 || CSELIB_VAL_PTR (tval)(((tval)->u.fld[0]).rt_cselib)->uid < CSELIB_VAL_PTR (cval)(((cval)->u.fld[0]).rt_cselib)->uid;
1736}
1737
1738static bool dst_can_be_shared;
1739
1740/* Return a copy of a variable VAR and insert it to dataflow set SET. */
1741
1742static variable **
1743unshare_variable (dataflow_set *set, variable **slot, variable *var,
1744 enum var_init_status initialized)
1745{
1746 variable *new_var;
1747 int i;
1748
1749 new_var = onepart_pool_allocate (var->onepart);
1750 new_var->dv = var->dv;
1751 new_var->refcount = 1;
1752 var->refcount--;
1753 new_var->n_var_parts = var->n_var_parts;
1754 new_var->onepart = var->onepart;
1755 new_var->in_changed_variables = false;
1756
1757 if (! flag_var_tracking_uninitglobal_options.x_flag_var_tracking_uninit)
1758 initialized = VAR_INIT_STATUS_INITIALIZED;
1759
1760 for (i = 0; i < var->n_var_parts; i++)
1761 {
1762 location_chain *node;
1763 location_chain **nextp;
1764
1765 if (i == 0 && var->onepart)
1766 {
1767 /* One-part auxiliary data is only used while emitting
1768 notes, so propagate it to the new variable in the active
1769 dataflow set. If we're not emitting notes, this will be
1770 a no-op. */
1771 gcc_checking_assert (!VAR_LOC_1PAUX (var) || emit_notes)((void)(!(!__extension__ (*({ variable *const __v = (var); ((
void)(!(__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1771, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; })) || emit_notes) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1771, __FUNCTION__), 0 : 0))
;
1772 VAR_LOC_1PAUX (new_var)__extension__ (*({ variable *const __v = (new_var); ((void)(!
(__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1772, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
= VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1772, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
;
1773 VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1773, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
= NULLnullptr;
1774 }
1775 else
1776 VAR_PART_OFFSET (new_var, i)__extension__ (*({ variable *const __v = (new_var); ((void)(!
(!__v->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1776, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
= VAR_PART_OFFSET (var, i)__extension__ (*({ variable *const __v = (var); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1776, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
;
1777 nextp = &new_var->var_part[i].loc_chain;
1778 for (node = var->var_part[i].loc_chain; node; node = node->next)
1779 {
1780 location_chain *new_lc;
1781
1782 new_lc = new location_chain;
1783 new_lc->next = NULLnullptr;
1784 if (node->init > initialized)
1785 new_lc->init = node->init;
1786 else
1787 new_lc->init = initialized;
1788 if (node->set_src && !(MEM_P (node->set_src)(((enum rtx_code) (node->set_src)->code) == MEM)))
1789 new_lc->set_src = node->set_src;
1790 else
1791 new_lc->set_src = NULLnullptr;
1792 new_lc->loc = node->loc;
1793
1794 *nextp = new_lc;
1795 nextp = &new_lc->next;
1796 }
1797
1798 new_var->var_part[i].cur_loc = var->var_part[i].cur_loc;
1799 }
1800
1801 dst_can_be_shared = false;
1802 if (shared_hash_shared (set->vars))
1803 slot = shared_hash_find_slot_unshare (&set->vars, var->dv, NO_INSERT);
1804 else if (set->traversed_vars && set->vars != set->traversed_vars)
1805 slot = shared_hash_find_slot_noinsert (set->vars, var->dv);
1806 *slot = new_var;
1807 if (var->in_changed_variables)
1808 {
1809 variable **cslot
1810 = changed_variables->find_slot_with_hash (var->dv,
1811 dv_htab_hash (var->dv),
1812 NO_INSERT);
1813 gcc_assert (*cslot == (void *) var)((void)(!(*cslot == (void *) var) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1813, __FUNCTION__), 0 : 0))
;
1814 var->in_changed_variables = false;
1815 variable_htab_free (var);
1816 *cslot = new_var;
1817 new_var->in_changed_variables = true;
1818 }
1819 return slot;
1820}
1821
1822/* Copy all variables from hash table SRC to hash table DST. */
1823
1824static void
1825vars_copy (variable_table_type *dst, variable_table_type *src)
1826{
1827 variable_iterator_type hi;
1828 variable *var;
1829
1830 FOR_EACH_HASH_TABLE_ELEMENT (*src, var, variable, hi)for ((hi) = (*src).begin (); (hi) != (*src).end () ? (var = *
(hi) , true) : false; ++(hi))
1831 {
1832 variable **dstp;
1833 var->refcount++;
1834 dstp = dst->find_slot_with_hash (var->dv, dv_htab_hash (var->dv),
1835 INSERT);
1836 *dstp = var;
1837 }
1838}
1839
1840/* Map a decl to its main debug decl. */
1841
1842static inline tree
1843var_debug_decl (tree decl)
1844{
1845 if (decl && VAR_P (decl)(((enum tree_code) (decl)->base.code) == VAR_DECL) && DECL_HAS_DEBUG_EXPR_P (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1845, __FUNCTION__, (VAR_DECL)))->decl_common.debug_expr_is_from
)
)
1846 {
1847 tree debugdecl = DECL_DEBUG_EXPR (decl)(decl_debug_expr_lookup ((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1847, __FUNCTION__, (VAR_DECL)))))
;
1848 if (DECL_P (debugdecl)(tree_code_type[(int) (((enum tree_code) (debugdecl)->base
.code))] == tcc_declaration)
)
1849 decl = debugdecl;
1850 }
1851
1852 return decl;
1853}
1854
1855/* Set the register LOC to contain DV, OFFSET. */
1856
1857static void
1858var_reg_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1859 decl_or_value dv, HOST_WIDE_INTlong offset, rtx set_src,
1860 enum insert_option iopt)
1861{
1862 attrs *node;
1863 bool decl_p = dv_is_decl_p (dv);
1864
1865 if (decl_p)
1866 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
1867
1868 for (node = set->regs[REGNO (loc)(rhs_regno(loc))]; node; node = node->next)
1869 if (dv_as_opaque (node->dv) == dv_as_opaque (dv)
1870 && node->offset == offset)
1871 break;
1872 if (!node)
1873 attrs_list_insert (&set->regs[REGNO (loc)(rhs_regno(loc))], dv, offset, loc);
1874 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
1875}
1876
1877/* Return true if we should track a location that is OFFSET bytes from
1878 a variable. Store the constant offset in *OFFSET_OUT if so. */
1879
1880static bool
1881track_offset_p (poly_int64 offset, HOST_WIDE_INTlong *offset_out)
1882{
1883 HOST_WIDE_INTlong const_offset;
1884 if (!offset.is_constant (&const_offset)
1885 || !IN_RANGE (const_offset, 0, MAX_VAR_PARTS - 1)((unsigned long) (const_offset) - (unsigned long) (0) <= (
unsigned long) (16 - 1) - (unsigned long) (0))
)
1886 return false;
1887 *offset_out = const_offset;
1888 return true;
1889}
1890
1891/* Return the offset of a register that track_offset_p says we
1892 should track. */
1893
1894static HOST_WIDE_INTlong
1895get_tracked_reg_offset (rtx loc)
1896{
1897 HOST_WIDE_INTlong offset;
1898 if (!track_offset_p (REG_OFFSET (loc)(((&(loc)->u.reg)->attrs) == 0 ? 0 : ((&(loc)->
u.reg)->attrs)->offset)
, &offset))
1899 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 1899, __FUNCTION__))
;
1900 return offset;
1901}
1902
1903/* Set the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). */
1904
1905static void
1906var_reg_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
1907 rtx set_src)
1908{
1909 tree decl = REG_EXPR (loc)(((&(loc)->u.reg)->attrs) == 0 ? 0 : ((&(loc)->
u.reg)->attrs)->decl)
;
1910 HOST_WIDE_INTlong offset = get_tracked_reg_offset (loc);
1911
1912 var_reg_decl_set (set, loc, initialized,
1913 dv_from_decl (decl), offset, set_src, INSERT);
1914}
1915
1916static enum var_init_status
1917get_init_value (dataflow_set *set, rtx loc, decl_or_value dv)
1918{
1919 variable *var;
1920 int i;
1921 enum var_init_status ret_val = VAR_INIT_STATUS_UNKNOWN;
1922
1923 if (! flag_var_tracking_uninitglobal_options.x_flag_var_tracking_uninit)
1924 return VAR_INIT_STATUS_INITIALIZED;
1925
1926 var = shared_hash_find (set->vars, dv);
1927 if (var)
1928 {
1929 for (i = 0; i < var->n_var_parts && ret_val == VAR_INIT_STATUS_UNKNOWN; i++)
1930 {
1931 location_chain *nextp;
1932 for (nextp = var->var_part[i].loc_chain; nextp; nextp = nextp->next)
1933 if (rtx_equal_p (nextp->loc, loc))
1934 {
1935 ret_val = nextp->init;
1936 break;
1937 }
1938 }
1939 }
1940
1941 return ret_val;
1942}
1943
1944/* Delete current content of register LOC in dataflow set SET and set
1945 the register to contain REG_EXPR (LOC), REG_OFFSET (LOC). If
1946 MODIFY is true, any other live copies of the same variable part are
1947 also deleted from the dataflow set, otherwise the variable part is
1948 assumed to be copied from another location holding the same
1949 part. */
1950
1951static void
1952var_reg_delete_and_set (dataflow_set *set, rtx loc, bool modify,
1953 enum var_init_status initialized, rtx set_src)
1954{
1955 tree decl = REG_EXPR (loc)(((&(loc)->u.reg)->attrs) == 0 ? 0 : ((&(loc)->
u.reg)->attrs)->decl)
;
1956 HOST_WIDE_INTlong offset = get_tracked_reg_offset (loc);
1957 attrs *node, *next;
1958 attrs **nextp;
1959
1960 decl = var_debug_decl (decl);
1961
1962 if (initialized == VAR_INIT_STATUS_UNKNOWN)
1963 initialized = get_init_value (set, loc, dv_from_decl (decl));
1964
1965 nextp = &set->regs[REGNO (loc)(rhs_regno(loc))];
1966 for (node = *nextp; node; node = next)
1967 {
1968 next = node->next;
1969 if (dv_as_opaque (node->dv) != decl || node->offset != offset)
1970 {
1971 delete_variable_part (set, node->loc, node->dv, node->offset);
1972 delete node;
1973 *nextp = next;
1974 }
1975 else
1976 {
1977 node->loc = loc;
1978 nextp = &node->next;
1979 }
1980 }
1981 if (modify)
1982 clobber_variable_part (set, loc, dv_from_decl (decl), offset, set_src);
1983 var_reg_set (set, loc, initialized, set_src);
1984}
1985
1986/* Delete the association of register LOC in dataflow set SET with any
1987 variables that aren't onepart. If CLOBBER is true, also delete any
1988 other live copies of the same variable part, and delete the
1989 association with onepart dvs too. */
1990
1991static void
1992var_reg_delete (dataflow_set *set, rtx loc, bool clobber)
1993{
1994 attrs **nextp = &set->regs[REGNO (loc)(rhs_regno(loc))];
1995 attrs *node, *next;
1996
1997 HOST_WIDE_INTlong offset;
1998 if (clobber && track_offset_p (REG_OFFSET (loc)(((&(loc)->u.reg)->attrs) == 0 ? 0 : ((&(loc)->
u.reg)->attrs)->offset)
, &offset))
1999 {
2000 tree decl = REG_EXPR (loc)(((&(loc)->u.reg)->attrs) == 0 ? 0 : ((&(loc)->
u.reg)->attrs)->decl)
;
2001
2002 decl = var_debug_decl (decl);
2003
2004 clobber_variable_part (set, NULLnullptr, dv_from_decl (decl), offset, NULLnullptr);
2005 }
2006
2007 for (node = *nextp; node; node = next)
2008 {
2009 next = node->next;
2010 if (clobber || !dv_onepart_p (node->dv))
2011 {
2012 delete_variable_part (set, node->loc, node->dv, node->offset);
2013 delete node;
2014 *nextp = next;
2015 }
2016 else
2017 nextp = &node->next;
2018 }
2019}
2020
2021/* Delete content of register with number REGNO in dataflow set SET. */
2022
2023static void
2024var_regno_delete (dataflow_set *set, int regno)
2025{
2026 attrs **reg = &set->regs[regno];
2027 attrs *node, *next;
2028
2029 for (node = *reg; node; node = next)
2030 {
2031 next = node->next;
2032 delete_variable_part (set, node->loc, node->dv, node->offset);
2033 delete node;
2034 }
2035 *reg = NULLnullptr;
2036}
2037
2038/* Return true if I is the negated value of a power of two. */
2039static bool
2040negative_power_of_two_p (HOST_WIDE_INTlong i)
2041{
2042 unsigned HOST_WIDE_INTlong x = -(unsigned HOST_WIDE_INTlong)i;
2043 return pow2_or_zerop (x);
2044}
2045
2046/* Strip constant offsets and alignments off of LOC. Return the base
2047 expression. */
2048
2049static rtx
2050vt_get_canonicalize_base (rtx loc)
2051{
2052 while ((GET_CODE (loc)((enum rtx_code) (loc)->code) == PLUS
2053 || GET_CODE (loc)((enum rtx_code) (loc)->code) == AND)
2054 && GET_CODE (XEXP (loc, 1))((enum rtx_code) ((((loc)->u.fld[1]).rt_rtx))->code) == CONST_INT
2055 && (GET_CODE (loc)((enum rtx_code) (loc)->code) != AND
2056 || negative_power_of_two_p (INTVAL (XEXP (loc, 1))(((((loc)->u.fld[1]).rt_rtx))->u.hwint[0]))))
2057 loc = XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx);
2058
2059 return loc;
2060}
2061
2062/* This caches canonicalized addresses for VALUEs, computed using
2063 information in the global cselib table. */
2064static hash_map<rtx, rtx> *global_get_addr_cache;
2065
2066/* This caches canonicalized addresses for VALUEs, computed using
2067 information from the global cache and information pertaining to a
2068 basic block being analyzed. */
2069static hash_map<rtx, rtx> *local_get_addr_cache;
2070
2071static rtx vt_canonicalize_addr (dataflow_set *, rtx);
2072
2073/* Return the canonical address for LOC, that must be a VALUE, using a
2074 cached global equivalence or computing it and storing it in the
2075 global cache. */
2076
2077static rtx
2078get_addr_from_global_cache (rtx const loc)
2079{
2080 rtx x;
2081
2082 gcc_checking_assert (GET_CODE (loc) == VALUE)((void)(!(((enum rtx_code) (loc)->code) == VALUE) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2082, __FUNCTION__), 0 : 0))
;
2083
2084 bool existed;
2085 rtx *slot = &global_get_addr_cache->get_or_insert (loc, &existed);
2086 if (existed)
2087 return *slot;
2088
2089 x = canon_rtx (get_addr (loc));
2090
2091 /* Tentative, avoiding infinite recursion. */
2092 *slot = x;
2093
2094 if (x != loc)
2095 {
2096 rtx nx = vt_canonicalize_addr (NULLnullptr, x);
2097 if (nx != x)
2098 {
2099 /* The table may have moved during recursion, recompute
2100 SLOT. */
2101 *global_get_addr_cache->get (loc) = x = nx;
2102 }
2103 }
2104
2105 return x;
2106}
2107
2108/* Return the canonical address for LOC, that must be a VALUE, using a
2109 cached local equivalence or computing it and storing it in the
2110 local cache. */
2111
2112static rtx
2113get_addr_from_local_cache (dataflow_set *set, rtx const loc)
2114{
2115 rtx x;
2116 decl_or_value dv;
2117 variable *var;
2118 location_chain *l;
2119
2120 gcc_checking_assert (GET_CODE (loc) == VALUE)((void)(!(((enum rtx_code) (loc)->code) == VALUE) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2120, __FUNCTION__), 0 : 0))
;
2121
2122 bool existed;
2123 rtx *slot = &local_get_addr_cache->get_or_insert (loc, &existed);
2124 if (existed)
2125 return *slot;
2126
2127 x = get_addr_from_global_cache (loc);
2128
2129 /* Tentative, avoiding infinite recursion. */
2130 *slot = x;
2131
2132 /* Recurse to cache local expansion of X, or if we need to search
2133 for a VALUE in the expansion. */
2134 if (x != loc)
2135 {
2136 rtx nx = vt_canonicalize_addr (set, x);
2137 if (nx != x)
2138 {
2139 slot = local_get_addr_cache->get (loc);
2140 *slot = x = nx;
2141 }
2142 return x;
2143 }
2144
2145 dv = dv_from_rtx (x);
2146 var = shared_hash_find (set->vars, dv);
2147 if (!var)
2148 return x;
2149
2150 /* Look for an improved equivalent expression. */
2151 for (l = var->var_part[0].loc_chain; l; l = l->next)
2152 {
2153 rtx base = vt_get_canonicalize_base (l->loc);
2154 if (GET_CODE (base)((enum rtx_code) (base)->code) == VALUE
2155 && canon_value_cmp (base, loc))
2156 {
2157 rtx nx = vt_canonicalize_addr (set, l->loc);
2158 if (x != nx)
2159 {
2160 slot = local_get_addr_cache->get (loc);
2161 *slot = x = nx;
2162 }
2163 break;
2164 }
2165 }
2166
2167 return x;
2168}
2169
2170/* Canonicalize LOC using equivalences from SET in addition to those
2171 in the cselib static table. It expects a VALUE-based expression,
2172 and it will only substitute VALUEs with other VALUEs or
2173 function-global equivalences, so that, if two addresses have base
2174 VALUEs that are locally or globally related in ways that
2175 memrefs_conflict_p cares about, they will both canonicalize to
2176 expressions that have the same base VALUE.
2177
2178 The use of VALUEs as canonical base addresses enables the canonical
2179 RTXs to remain unchanged globally, if they resolve to a constant,
2180 or throughout a basic block otherwise, so that they can be cached
2181 and the cache needs not be invalidated when REGs, MEMs or such
2182 change. */
2183
2184static rtx
2185vt_canonicalize_addr (dataflow_set *set, rtx oloc)
2186{
2187 poly_int64 ofst = 0, term;
2188 machine_mode mode = GET_MODE (oloc)((machine_mode) (oloc)->mode);
2189 rtx loc = oloc;
2190 rtx x;
2191 bool retry = true;
2192
2193 while (retry)
2194 {
2195 while (GET_CODE (loc)((enum rtx_code) (loc)->code) == PLUS
2196 && poly_int_rtx_p (XEXP (loc, 1)(((loc)->u.fld[1]).rt_rtx), &term))
2197 {
2198 ofst += term;
2199 loc = XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx);
2200 }
2201
2202 /* Alignment operations can't normally be combined, so just
2203 canonicalize the base and we're done. We'll normally have
2204 only one stack alignment anyway. */
2205 if (GET_CODE (loc)((enum rtx_code) (loc)->code) == AND
2206 && GET_CODE (XEXP (loc, 1))((enum rtx_code) ((((loc)->u.fld[1]).rt_rtx))->code) == CONST_INT
2207 && negative_power_of_two_p (INTVAL (XEXP (loc, 1))(((((loc)->u.fld[1]).rt_rtx))->u.hwint[0])))
2208 {
2209 x = vt_canonicalize_addr (set, XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx));
2210 if (x != XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx))
2211 loc = gen_rtx_AND (mode, x, XEXP (loc, 1))gen_rtx_fmt_ee_stat ((AND), ((mode)), ((x)), (((((loc)->u.
fld[1]).rt_rtx))) )
;
2212 retry = false;
2213 }
2214
2215 if (GET_CODE (loc)((enum rtx_code) (loc)->code) == VALUE)
2216 {
2217 if (set)
2218 loc = get_addr_from_local_cache (set, loc);
2219 else
2220 loc = get_addr_from_global_cache (loc);
2221
2222 /* Consolidate plus_constants. */
2223 while (maybe_ne (ofst, 0)
2224 && GET_CODE (loc)((enum rtx_code) (loc)->code) == PLUS
2225 && poly_int_rtx_p (XEXP (loc, 1)(((loc)->u.fld[1]).rt_rtx), &term))
2226 {
2227 ofst += term;
2228 loc = XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx);
2229 }
2230
2231 retry = false;
2232 }
2233 else
2234 {
2235 x = canon_rtx (loc);
2236 if (retry)
2237 retry = (x != loc);
2238 loc = x;
2239 }
2240 }
2241
2242 /* Add OFST back in. */
2243 if (maybe_ne (ofst, 0))
2244 {
2245 /* Don't build new RTL if we can help it. */
2246 if (strip_offset (oloc, &term) == loc && known_eq (term, ofst)(!maybe_ne (term, ofst)))
2247 return oloc;
2248
2249 loc = plus_constant (mode, loc, ofst);
2250 }
2251
2252 return loc;
2253}
2254
2255/* Return true iff there's a true dependence between MLOC and LOC.
2256 MADDR must be a canonicalized version of MLOC's address. */
2257
2258static inline bool
2259vt_canon_true_dep (dataflow_set *set, rtx mloc, rtx maddr, rtx loc)
2260{
2261 if (GET_CODE (loc)((enum rtx_code) (loc)->code) != MEM)
2262 return false;
2263
2264 rtx addr = vt_canonicalize_addr (set, XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx));
2265 if (!canon_true_dependence (mloc, GET_MODE (mloc)((machine_mode) (mloc)->mode), maddr, loc, addr))
2266 return false;
2267
2268 return true;
2269}
2270
2271/* Hold parameters for the hashtab traversal function
2272 drop_overlapping_mem_locs, see below. */
2273
2274struct overlapping_mems
2275{
2276 dataflow_set *set;
2277 rtx loc, addr;
2278};
2279
2280/* Remove all MEMs that overlap with COMS->LOC from the location list
2281 of a hash table entry for a onepart variable. COMS->ADDR must be a
2282 canonicalized form of COMS->LOC's address, and COMS->LOC must be
2283 canonicalized itself. */
2284
2285int
2286drop_overlapping_mem_locs (variable **slot, overlapping_mems *coms)
2287{
2288 dataflow_set *set = coms->set;
2289 rtx mloc = coms->loc, addr = coms->addr;
2290 variable *var = *slot;
2291
2292 if (var->onepart != NOT_ONEPART)
2293 {
2294 location_chain *loc, **locp;
2295 bool changed = false;
2296 rtx cur_loc;
2297
2298 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2298, __FUNCTION__), 0 : 0))
;
2299
2300 if (shared_var_p (var, set->vars))
2301 {
2302 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
2303 if (vt_canon_true_dep (set, mloc, addr, loc->loc))
2304 break;
2305
2306 if (!loc)
2307 return 1;
2308
2309 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
2310 var = *slot;
2311 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2311, __FUNCTION__), 0 : 0))
;
2312 }
2313
2314 if (VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2314, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
)
2315 cur_loc = VAR_LOC_FROM (var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2315, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))->from)
;
2316 else
2317 cur_loc = var->var_part[0].cur_loc;
2318
2319 for (locp = &var->var_part[0].loc_chain, loc = *locp;
2320 loc; loc = *locp)
2321 {
2322 if (!vt_canon_true_dep (set, mloc, addr, loc->loc))
2323 {
2324 locp = &loc->next;
2325 continue;
2326 }
2327
2328 *locp = loc->next;
2329 /* If we have deleted the location which was last emitted
2330 we have to emit new location so add the variable to set
2331 of changed variables. */
2332 if (cur_loc == loc->loc)
2333 {
2334 changed = true;
2335 var->var_part[0].cur_loc = NULLnullptr;
2336 if (VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2336, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
)
2337 VAR_LOC_FROM (var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2337, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))->from)
= NULLnullptr;
2338 }
2339 delete loc;
2340 }
2341
2342 if (!var->var_part[0].loc_chain)
2343 {
2344 var->n_var_parts--;
2345 changed = true;
2346 }
2347 if (changed)
2348 variable_was_changed (var, set);
2349 }
2350
2351 return 1;
2352}
2353
2354/* Remove from SET all VALUE bindings to MEMs that overlap with LOC. */
2355
2356static void
2357clobber_overlapping_mems (dataflow_set *set, rtx loc)
2358{
2359 struct overlapping_mems coms;
2360
2361 gcc_checking_assert (GET_CODE (loc) == MEM)((void)(!(((enum rtx_code) (loc)->code) == MEM) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2361, __FUNCTION__), 0 : 0))
;
2362
2363 coms.set = set;
2364 coms.loc = canon_rtx (loc);
2365 coms.addr = vt_canonicalize_addr (set, XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx));
2366
2367 set->traversed_vars = set->vars;
2368 shared_hash_htab (set->vars)
2369 ->traverse <overlapping_mems*, drop_overlapping_mem_locs> (&coms);
2370 set->traversed_vars = NULLnullptr;
2371}
2372
2373/* Set the location of DV, OFFSET as the MEM LOC. */
2374
2375static void
2376var_mem_decl_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2377 decl_or_value dv, HOST_WIDE_INTlong offset, rtx set_src,
2378 enum insert_option iopt)
2379{
2380 if (dv_is_decl_p (dv))
2381 dv = dv_from_decl (var_debug_decl (dv_as_decl (dv)));
2382
2383 set_variable_part (set, loc, dv, offset, initialized, set_src, iopt);
2384}
2385
2386/* Set the location part of variable MEM_EXPR (LOC) in dataflow set
2387 SET to LOC.
2388 Adjust the address first if it is stack pointer based. */
2389
2390static void
2391var_mem_set (dataflow_set *set, rtx loc, enum var_init_status initialized,
2392 rtx set_src)
2393{
2394 tree decl = MEM_EXPR (loc)(get_mem_attrs (loc)->expr);
2395 HOST_WIDE_INTlong offset = int_mem_offset (loc);
2396
2397 var_mem_decl_set (set, loc, initialized,
2398 dv_from_decl (decl), offset, set_src, INSERT);
2399}
2400
2401/* Delete and set the location part of variable MEM_EXPR (LOC) in
2402 dataflow set SET to LOC. If MODIFY is true, any other live copies
2403 of the same variable part are also deleted from the dataflow set,
2404 otherwise the variable part is assumed to be copied from another
2405 location holding the same part.
2406 Adjust the address first if it is stack pointer based. */
2407
2408static void
2409var_mem_delete_and_set (dataflow_set *set, rtx loc, bool modify,
2410 enum var_init_status initialized, rtx set_src)
2411{
2412 tree decl = MEM_EXPR (loc)(get_mem_attrs (loc)->expr);
2413 HOST_WIDE_INTlong offset = int_mem_offset (loc);
2414
2415 clobber_overlapping_mems (set, loc);
2416 decl = var_debug_decl (decl);
2417
2418 if (initialized == VAR_INIT_STATUS_UNKNOWN)
2419 initialized = get_init_value (set, loc, dv_from_decl (decl));
2420
2421 if (modify)
2422 clobber_variable_part (set, NULLnullptr, dv_from_decl (decl), offset, set_src);
2423 var_mem_set (set, loc, initialized, set_src);
2424}
2425
2426/* Delete the location part LOC from dataflow set SET. If CLOBBER is
2427 true, also delete any other live copies of the same variable part.
2428 Adjust the address first if it is stack pointer based. */
2429
2430static void
2431var_mem_delete (dataflow_set *set, rtx loc, bool clobber)
2432{
2433 tree decl = MEM_EXPR (loc)(get_mem_attrs (loc)->expr);
2434 HOST_WIDE_INTlong offset = int_mem_offset (loc);
2435
2436 clobber_overlapping_mems (set, loc);
2437 decl = var_debug_decl (decl);
2438 if (clobber)
2439 clobber_variable_part (set, NULLnullptr, dv_from_decl (decl), offset, NULLnullptr);
2440 delete_variable_part (set, loc, dv_from_decl (decl), offset);
2441}
2442
2443/* Return true if LOC should not be expanded for location expressions,
2444 or used in them. */
2445
2446static inline bool
2447unsuitable_loc (rtx loc)
2448{
2449 switch (GET_CODE (loc)((enum rtx_code) (loc)->code))
2450 {
2451 case PC:
2452 case SCRATCH:
2453 case ASM_INPUT:
2454 case ASM_OPERANDS:
2455 return true;
2456
2457 default:
2458 return false;
2459 }
2460}
2461
2462/* Bind VAL to LOC in SET. If MODIFIED, detach LOC from any values
2463 bound to it. */
2464
2465static inline void
2466val_bind (dataflow_set *set, rtx val, rtx loc, bool modified)
2467{
2468 if (REG_P (loc)(((enum rtx_code) (loc)->code) == REG))
2469 {
2470 if (modified)
2471 var_regno_delete (set, REGNO (loc)(rhs_regno(loc)));
2472 var_reg_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2473 dv_from_value (val), 0, NULL_RTX(rtx) 0, INSERT);
2474 }
2475 else if (MEM_P (loc)(((enum rtx_code) (loc)->code) == MEM))
2476 {
2477 struct elt_loc_list *l = CSELIB_VAL_PTR (val)(((val)->u.fld[0]).rt_cselib)->locs;
2478
2479 if (modified)
2480 clobber_overlapping_mems (set, loc);
2481
2482 if (l && GET_CODE (l->loc)((enum rtx_code) (l->loc)->code) == VALUE)
2483 l = canonical_cselib_val (CSELIB_VAL_PTR (l->loc)(((l->loc)->u.fld[0]).rt_cselib))->locs;
2484
2485 /* If this MEM is a global constant, we don't need it in the
2486 dynamic tables. ??? We should test this before emitting the
2487 micro-op in the first place. */
2488 while (l)
2489 if (GET_CODE (l->loc)((enum rtx_code) (l->loc)->code) == MEM && XEXP (l->loc, 0)(((l->loc)->u.fld[0]).rt_rtx) == XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx))
2490 break;
2491 else
2492 l = l->next;
2493
2494 if (!l)
2495 var_mem_decl_set (set, loc, VAR_INIT_STATUS_INITIALIZED,
2496 dv_from_value (val), 0, NULL_RTX(rtx) 0, INSERT);
2497 }
2498 else
2499 {
2500 /* Other kinds of equivalences are necessarily static, at least
2501 so long as we do not perform substitutions while merging
2502 expressions. */
2503 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2503, __FUNCTION__))
;
2504 set_variable_part (set, loc, dv_from_value (val), 0,
2505 VAR_INIT_STATUS_INITIALIZED, NULL_RTX(rtx) 0, INSERT);
2506 }
2507}
2508
2509/* Bind a value to a location it was just stored in. If MODIFIED
2510 holds, assume the location was modified, detaching it from any
2511 values bound to it. */
2512
2513static void
2514val_store (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn,
2515 bool modified)
2516{
2517 cselib_val *v = CSELIB_VAL_PTR (val)(((val)->u.fld[0]).rt_cselib);
2518
2519 gcc_assert (cselib_preserved_value_p (v))((void)(!(cselib_preserved_value_p (v)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2519, __FUNCTION__), 0 : 0))
;
2520
2521 if (dump_file)
2522 {
2523 fprintf (dump_file, "%i: ", insn ? INSN_UID (insn) : 0);
2524 print_inline_rtx (dump_file, loc, 0);
2525 fprintf (dump_file, " evaluates to ");
2526 print_inline_rtx (dump_file, val, 0);
2527 if (v->locs)
2528 {
2529 struct elt_loc_list *l;
2530 for (l = v->locs; l; l = l->next)
2531 {
2532 fprintf (dump_file, "\n%i: ", INSN_UID (l->setting_insn));
2533 print_inline_rtx (dump_file, l->loc, 0);
2534 }
2535 }
2536 fprintf (dump_file, "\n");
2537 }
2538
2539 gcc_checking_assert (!unsuitable_loc (loc))((void)(!(!unsuitable_loc (loc)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2539, __FUNCTION__), 0 : 0))
;
2540
2541 val_bind (set, val, loc, modified);
2542}
2543
2544/* Clear (canonical address) slots that reference X. */
2545
2546bool
2547local_get_addr_clear_given_value (rtx const &, rtx *slot, rtx x)
2548{
2549 if (vt_get_canonicalize_base (*slot) == x)
2550 *slot = NULLnullptr;
2551 return true;
2552}
2553
2554/* Reset this node, detaching all its equivalences. Return the slot
2555 in the variable hash table that holds dv, if there is one. */
2556
2557static void
2558val_reset (dataflow_set *set, decl_or_value dv)
2559{
2560 variable *var = shared_hash_find (set->vars, dv) ;
2561 location_chain *node;
2562 rtx cval;
2563
2564 if (!var || !var->n_var_parts)
2565 return;
2566
2567 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2567, __FUNCTION__), 0 : 0))
;
2568
2569 if (var->onepart == ONEPART_VALUE)
2570 {
2571 rtx x = dv_as_value (dv);
2572
2573 /* Relationships in the global cache don't change, so reset the
2574 local cache entry only. */
2575 rtx *slot = local_get_addr_cache->get (x);
2576 if (slot)
2577 {
2578 /* If the value resolved back to itself, odds are that other
2579 values may have cached it too. These entries now refer
2580 to the old X, so detach them too. Entries that used the
2581 old X but resolved to something else remain ok as long as
2582 that something else isn't also reset. */
2583 if (*slot == x)
2584 local_get_addr_cache
2585 ->traverse<rtx, local_get_addr_clear_given_value> (x);
2586 *slot = NULLnullptr;
2587 }
2588 }
2589
2590 cval = NULLnullptr;
2591 for (node = var->var_part[0].loc_chain; node; node = node->next)
2592 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE
2593 && canon_value_cmp (node->loc, cval))
2594 cval = node->loc;
2595
2596 for (node = var->var_part[0].loc_chain; node; node = node->next)
2597 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE && cval != node->loc)
2598 {
2599 /* Redirect the equivalence link to the new canonical
2600 value, or simply remove it if it would point at
2601 itself. */
2602 if (cval)
2603 set_variable_part (set, cval, dv_from_value (node->loc),
2604 0, node->init, node->set_src, NO_INSERT);
2605 delete_variable_part (set, dv_as_value (dv),
2606 dv_from_value (node->loc), 0);
2607 }
2608
2609 if (cval)
2610 {
2611 decl_or_value cdv = dv_from_value (cval);
2612
2613 /* Keep the remaining values connected, accumulating links
2614 in the canonical value. */
2615 for (node = var->var_part[0].loc_chain; node; node = node->next)
2616 {
2617 if (node->loc == cval)
2618 continue;
2619 else if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == REG)
2620 var_reg_decl_set (set, node->loc, node->init, cdv, 0,
2621 node->set_src, NO_INSERT);
2622 else if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == MEM)
2623 var_mem_decl_set (set, node->loc, node->init, cdv, 0,
2624 node->set_src, NO_INSERT);
2625 else
2626 set_variable_part (set, node->loc, cdv, 0,
2627 node->init, node->set_src, NO_INSERT);
2628 }
2629 }
2630
2631 /* We remove this last, to make sure that the canonical value is not
2632 removed to the point of requiring reinsertion. */
2633 if (cval)
2634 delete_variable_part (set, dv_as_value (dv), dv_from_value (cval), 0);
2635
2636 clobber_variable_part (set, NULLnullptr, dv, 0, NULLnullptr);
2637}
2638
2639/* Find the values in a given location and map the val to another
2640 value, if it is unique, or add the location as one holding the
2641 value. */
2642
2643static void
2644val_resolve (dataflow_set *set, rtx val, rtx loc, rtx_insn *insn)
2645{
2646 decl_or_value dv = dv_from_value (val);
2647
2648 if (dump_file && (dump_flags & TDF_DETAILS))
2649 {
2650 if (insn)
2651 fprintf (dump_file, "%i: ", INSN_UID (insn));
2652 else
2653 fprintf (dump_file, "head: ");
2654 print_inline_rtx (dump_file, val, 0);
2655 fputs (" is at ", dump_file);
2656 print_inline_rtx (dump_file, loc, 0);
2657 fputc ('\n', dump_file);
2658 }
2659
2660 val_reset (set, dv);
2661
2662 gcc_checking_assert (!unsuitable_loc (loc))((void)(!(!unsuitable_loc (loc)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2662, __FUNCTION__), 0 : 0))
;
2663
2664 if (REG_P (loc)(((enum rtx_code) (loc)->code) == REG))
2665 {
2666 attrs *node, *found = NULLnullptr;
2667
2668 for (node = set->regs[REGNO (loc)(rhs_regno(loc))]; node; node = node->next)
2669 if (dv_is_value_p (node->dv)
2670 && GET_MODE (dv_as_value (node->dv))((machine_mode) (dv_as_value (node->dv))->mode) == GET_MODE (loc)((machine_mode) (loc)->mode))
2671 {
2672 found = node;
2673
2674 /* Map incoming equivalences. ??? Wouldn't it be nice if
2675 we just started sharing the location lists? Maybe a
2676 circular list ending at the value itself or some
2677 such. */
2678 set_variable_part (set, dv_as_value (node->dv),
2679 dv_from_value (val), node->offset,
2680 VAR_INIT_STATUS_INITIALIZED, NULL_RTX(rtx) 0, INSERT);
2681 set_variable_part (set, val, node->dv, node->offset,
2682 VAR_INIT_STATUS_INITIALIZED, NULL_RTX(rtx) 0, INSERT);
2683 }
2684
2685 /* If we didn't find any equivalence, we need to remember that
2686 this value is held in the named register. */
2687 if (found)
2688 return;
2689 }
2690 /* ??? Attempt to find and merge equivalent MEMs or other
2691 expressions too. */
2692
2693 val_bind (set, val, loc, false);
2694}
2695
2696/* Initialize dataflow set SET to be empty.
2697 VARS_SIZE is the initial size of hash table VARS. */
2698
2699static void
2700dataflow_set_init (dataflow_set *set)
2701{
2702 init_attrs_list_set (set->regs);
2703 set->vars = shared_hash_copy (empty_shared_hash);
2704 set->stack_adjust = 0;
2705 set->traversed_vars = NULLnullptr;
2706}
2707
2708/* Delete the contents of dataflow set SET. */
2709
2710static void
2711dataflow_set_clear (dataflow_set *set)
2712{
2713 int i;
2714
2715 for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
2716 attrs_list_clear (&set->regs[i]);
2717
2718 shared_hash_destroy (set->vars);
2719 set->vars = shared_hash_copy (empty_shared_hash);
2720}
2721
2722/* Copy the contents of dataflow set SRC to DST. */
2723
2724static void
2725dataflow_set_copy (dataflow_set *dst, dataflow_set *src)
2726{
2727 int i;
2728
2729 for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
2730 attrs_list_copy (&dst->regs[i], src->regs[i]);
2731
2732 shared_hash_destroy (dst->vars);
2733 dst->vars = shared_hash_copy (src->vars);
2734 dst->stack_adjust = src->stack_adjust;
2735}
2736
2737/* Information for merging lists of locations for a given offset of variable.
2738 */
2739struct variable_union_info
2740{
2741 /* Node of the location chain. */
2742 location_chain *lc;
2743
2744 /* The sum of positions in the input chains. */
2745 int pos;
2746
2747 /* The position in the chain of DST dataflow set. */
2748 int pos_dst;
2749};
2750
2751/* Buffer for location list sorting and its allocated size. */
2752static struct variable_union_info *vui_vec;
2753static int vui_allocated;
2754
2755/* Compare function for qsort, order the structures by POS element. */
2756
2757static int
2758variable_union_info_cmp_pos (const void *n1, const void *n2)
2759{
2760 const struct variable_union_info *const i1 =
2761 (const struct variable_union_info *) n1;
2762 const struct variable_union_info *const i2 =
2763 ( const struct variable_union_info *) n2;
2764
2765 if (i1->pos != i2->pos)
2766 return i1->pos - i2->pos;
2767
2768 return (i1->pos_dst - i2->pos_dst);
2769}
2770
2771/* Compute union of location parts of variable *SLOT and the same variable
2772 from hash table DATA. Compute "sorted" union of the location chains
2773 for common offsets, i.e. the locations of a variable part are sorted by
2774 a priority where the priority is the sum of the positions in the 2 chains
2775 (if a location is only in one list the position in the second list is
2776 defined to be larger than the length of the chains).
2777 When we are updating the location parts the newest location is in the
2778 beginning of the chain, so when we do the described "sorted" union
2779 we keep the newest locations in the beginning. */
2780
2781static int
2782variable_union (variable *src, dataflow_set *set)
2783{
2784 variable *dst;
2785 variable **dstp;
2786 int i, j, k;
2787
2788 dstp = shared_hash_find_slot (set->vars, src->dv);
2789 if (!dstp || !*dstp)
2790 {
2791 src->refcount++;
2792
2793 dst_can_be_shared = false;
2794 if (!dstp)
2795 dstp = shared_hash_find_slot_unshare (&set->vars, src->dv, INSERT);
2796
2797 *dstp = src;
2798
2799 /* Continue traversing the hash table. */
2800 return 1;
2801 }
2802 else
2803 dst = *dstp;
2804
2805 gcc_assert (src->n_var_parts)((void)(!(src->n_var_parts) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2805, __FUNCTION__), 0 : 0))
;
2806 gcc_checking_assert (src->onepart == dst->onepart)((void)(!(src->onepart == dst->onepart) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2806, __FUNCTION__), 0 : 0))
;
2807
2808 /* We can combine one-part variables very efficiently, because their
2809 entries are in canonical order. */
2810 if (src->onepart)
2811 {
2812 location_chain **nodep, *dnode, *snode;
2813
2814 gcc_assert (src->n_var_parts == 1((void)(!(src->n_var_parts == 1 && dst->n_var_parts
== 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2815, __FUNCTION__), 0 : 0))
2815 && dst->n_var_parts == 1)((void)(!(src->n_var_parts == 1 && dst->n_var_parts
== 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2815, __FUNCTION__), 0 : 0))
;
2816
2817 snode = src->var_part[0].loc_chain;
2818 gcc_assert (snode)((void)(!(snode) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2818, __FUNCTION__), 0 : 0))
;
2819
2820 restart_onepart_unshared:
2821 nodep = &dst->var_part[0].loc_chain;
2822 dnode = *nodep;
2823 gcc_assert (dnode)((void)(!(dnode) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2823, __FUNCTION__), 0 : 0))
;
2824
2825 while (snode)
2826 {
2827 int r = dnode ? loc_cmp (dnode->loc, snode->loc) : 1;
2828
2829 if (r > 0)
2830 {
2831 location_chain *nnode;
2832
2833 if (shared_var_p (dst, set->vars))
2834 {
2835 dstp = unshare_variable (set, dstp, dst,
2836 VAR_INIT_STATUS_INITIALIZED);
2837 dst = *dstp;
2838 goto restart_onepart_unshared;
2839 }
2840
2841 *nodep = nnode = new location_chain;
2842 nnode->loc = snode->loc;
2843 nnode->init = snode->init;
2844 if (!snode->set_src || MEM_P (snode->set_src)(((enum rtx_code) (snode->set_src)->code) == MEM))
2845 nnode->set_src = NULLnullptr;
2846 else
2847 nnode->set_src = snode->set_src;
2848 nnode->next = dnode;
2849 dnode = nnode;
2850 }
2851 else if (r == 0)
2852 gcc_checking_assert (rtx_equal_p (dnode->loc, snode->loc))((void)(!(rtx_equal_p (dnode->loc, snode->loc)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2852, __FUNCTION__), 0 : 0))
;
2853
2854 if (r >= 0)
2855 snode = snode->next;
2856
2857 nodep = &dnode->next;
2858 dnode = *nodep;
2859 }
2860
2861 return 1;
2862 }
2863
2864 gcc_checking_assert (!src->onepart)((void)(!(!src->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2864, __FUNCTION__), 0 : 0))
;
2865
2866 /* Count the number of location parts, result is K. */
2867 for (i = 0, j = 0, k = 0;
2868 i < src->n_var_parts && j < dst->n_var_parts; k++)
2869 {
2870 if (VAR_PART_OFFSET (src, i)__extension__ (*({ variable *const __v = (src); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2870, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
== VAR_PART_OFFSET (dst, j)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2870, __FUNCTION__), 0 : 0)); &__v->var_part[(j)].aux
.offset; }))
)
2871 {
2872 i++;
2873 j++;
2874 }
2875 else if (VAR_PART_OFFSET (src, i)__extension__ (*({ variable *const __v = (src); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2875, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
< VAR_PART_OFFSET (dst, j)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2875, __FUNCTION__), 0 : 0)); &__v->var_part[(j)].aux
.offset; }))
)
2876 i++;
2877 else
2878 j++;
2879 }
2880 k += src->n_var_parts - i;
2881 k += dst->n_var_parts - j;
2882
2883 /* We track only variables whose size is <= MAX_VAR_PARTS bytes
2884 thus there are at most MAX_VAR_PARTS different offsets. */
2885 gcc_checking_assert (dst->onepart ? k == 1 : k <= MAX_VAR_PARTS)((void)(!(dst->onepart ? k == 1 : k <= 16) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2885, __FUNCTION__), 0 : 0))
;
2886
2887 if (dst->n_var_parts != k && shared_var_p (dst, set->vars))
2888 {
2889 dstp = unshare_variable (set, dstp, dst, VAR_INIT_STATUS_UNKNOWN);
2890 dst = *dstp;
2891 }
2892
2893 i = src->n_var_parts - 1;
2894 j = dst->n_var_parts - 1;
2895 dst->n_var_parts = k;
2896
2897 for (k--; k >= 0; k--)
2898 {
2899 location_chain *node, *node2;
2900
2901 if (i >= 0 && j >= 0
2902 && VAR_PART_OFFSET (src, i)__extension__ (*({ variable *const __v = (src); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2902, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
== VAR_PART_OFFSET (dst, j)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2902, __FUNCTION__), 0 : 0)); &__v->var_part[(j)].aux
.offset; }))
)
2903 {
2904 /* Compute the "sorted" union of the chains, i.e. the locations which
2905 are in both chains go first, they are sorted by the sum of
2906 positions in the chains. */
2907 int dst_l, src_l;
2908 int ii, jj, n;
2909 struct variable_union_info *vui;
2910
2911 /* If DST is shared compare the location chains.
2912 If they are different we will modify the chain in DST with
2913 high probability so make a copy of DST. */
2914 if (shared_var_p (dst, set->vars))
2915 {
2916 for (node = src->var_part[i].loc_chain,
2917 node2 = dst->var_part[j].loc_chain; node && node2;
2918 node = node->next, node2 = node2->next)
2919 {
2920 if (!((REG_P (node2->loc)(((enum rtx_code) (node2->loc)->code) == REG)
2921 && REG_P (node->loc)(((enum rtx_code) (node->loc)->code) == REG)
2922 && REGNO (node2->loc)(rhs_regno(node2->loc)) == REGNO (node->loc)(rhs_regno(node->loc)))
2923 || rtx_equal_p (node2->loc, node->loc)))
2924 {
2925 if (node2->init < node->init)
2926 node2->init = node->init;
2927 break;
2928 }
2929 }
2930 if (node || node2)
2931 {
2932 dstp = unshare_variable (set, dstp, dst,
2933 VAR_INIT_STATUS_UNKNOWN);
2934 dst = (variable *)*dstp;
2935 }
2936 }
2937
2938 src_l = 0;
2939 for (node = src->var_part[i].loc_chain; node; node = node->next)
2940 src_l++;
2941 dst_l = 0;
2942 for (node = dst->var_part[j].loc_chain; node; node = node->next)
2943 dst_l++;
2944
2945 if (dst_l == 1)
2946 {
2947 /* The most common case, much simpler, no qsort is needed. */
2948 location_chain *dstnode = dst->var_part[j].loc_chain;
2949 dst->var_part[k].loc_chain = dstnode;
2950 VAR_PART_OFFSET (dst, k)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2950, __FUNCTION__), 0 : 0)); &__v->var_part[(k)].aux
.offset; }))
= VAR_PART_OFFSET (dst, j)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 2950, __FUNCTION__), 0 : 0)); &__v->var_part[(j)].aux
.offset; }))
;
2951 node2 = dstnode;
2952 for (node = src->var_part[i].loc_chain; node; node = node->next)
2953 if (!((REG_P (dstnode->loc)(((enum rtx_code) (dstnode->loc)->code) == REG)
2954 && REG_P (node->loc)(((enum rtx_code) (node->loc)->code) == REG)
2955 && REGNO (dstnode->loc)(rhs_regno(dstnode->loc)) == REGNO (node->loc)(rhs_regno(node->loc)))
2956 || rtx_equal_p (dstnode->loc, node->loc)))
2957 {
2958 location_chain *new_node;
2959
2960 /* Copy the location from SRC. */
2961 new_node = new location_chain;
2962 new_node->loc = node->loc;
2963 new_node->init = node->init;
2964 if (!node->set_src || MEM_P (node->set_src)(((enum rtx_code) (node->set_src)->code) == MEM))
2965 new_node->set_src = NULLnullptr;
2966 else
2967 new_node->set_src = node->set_src;
2968 node2->next = new_node;
2969 node2 = new_node;
2970 }
2971 node2->next = NULLnullptr;
2972 }
2973 else
2974 {
2975 if (src_l + dst_l > vui_allocated)
2976 {
2977 vui_allocated = MAX (vui_allocated * 2, src_l + dst_l)((vui_allocated * 2) > (src_l + dst_l) ? (vui_allocated * 2
) : (src_l + dst_l))
;
2978 vui_vec = XRESIZEVEC (struct variable_union_info, vui_vec,((struct variable_union_info *) xrealloc ((void *) (vui_vec),
sizeof (struct variable_union_info) * (vui_allocated)))
2979 vui_allocated)((struct variable_union_info *) xrealloc ((void *) (vui_vec),
sizeof (struct variable_union_info) * (vui_allocated)))
;
2980 }
2981 vui = vui_vec;
2982
2983 /* Fill in the locations from DST. */
2984 for (node = dst->var_part[j].loc_chain, jj = 0; node;
2985 node = node->next, jj++)
2986 {
2987 vui[jj].lc = node;
2988 vui[jj].pos_dst = jj;
2989
2990 /* Pos plus value larger than a sum of 2 valid positions. */
2991 vui[jj].pos = jj + src_l + dst_l;
2992 }
2993
2994 /* Fill in the locations from SRC. */
2995 n = dst_l;
2996 for (node = src->var_part[i].loc_chain, ii = 0; node;
2997 node = node->next, ii++)
2998 {
2999 /* Find location from NODE. */
3000 for (jj = 0; jj < dst_l; jj++)
3001 {
3002 if ((REG_P (vui[jj].lc->loc)(((enum rtx_code) (vui[jj].lc->loc)->code) == REG)
3003 && REG_P (node->loc)(((enum rtx_code) (node->loc)->code) == REG)
3004 && REGNO (vui[jj].lc->loc)(rhs_regno(vui[jj].lc->loc)) == REGNO (node->loc)(rhs_regno(node->loc)))
3005 || rtx_equal_p (vui[jj].lc->loc, node->loc))
3006 {
3007 vui[jj].pos = jj + ii;
3008 break;
3009 }
3010 }
3011 if (jj >= dst_l) /* The location has not been found. */
3012 {
3013 location_chain *new_node;
3014
3015 /* Copy the location from SRC. */
3016 new_node = new location_chain;
3017 new_node->loc = node->loc;
3018 new_node->init = node->init;
3019 if (!node->set_src || MEM_P (node->set_src)(((enum rtx_code) (node->set_src)->code) == MEM))
3020 new_node->set_src = NULLnullptr;
3021 else
3022 new_node->set_src = node->set_src;
3023 vui[n].lc = new_node;
3024 vui[n].pos_dst = src_l + dst_l;
3025 vui[n].pos = ii + src_l + dst_l;
3026 n++;
3027 }
3028 }
3029
3030 if (dst_l == 2)
3031 {
3032 /* Special case still very common case. For dst_l == 2
3033 all entries dst_l ... n-1 are sorted, with for i >= dst_l
3034 vui[i].pos == i + src_l + dst_l. */
3035 if (vui[0].pos > vui[1].pos)
3036 {
3037 /* Order should be 1, 0, 2... */
3038 dst->var_part[k].loc_chain = vui[1].lc;
3039 vui[1].lc->next = vui[0].lc;
3040 if (n >= 3)
3041 {
3042 vui[0].lc->next = vui[2].lc;
3043 vui[n - 1].lc->next = NULLnullptr;
3044 }
3045 else
3046 vui[0].lc->next = NULLnullptr;
3047 ii = 3;
3048 }
3049 else
3050 {
3051 dst->var_part[k].loc_chain = vui[0].lc;
3052 if (n >= 3 && vui[2].pos < vui[1].pos)
3053 {
3054 /* Order should be 0, 2, 1, 3... */
3055 vui[0].lc->next = vui[2].lc;
3056 vui[2].lc->next = vui[1].lc;
3057 if (n >= 4)
3058 {
3059 vui[1].lc->next = vui[3].lc;
3060 vui[n - 1].lc->next = NULLnullptr;
3061 }
3062 else
3063 vui[1].lc->next = NULLnullptr;
3064 ii = 4;
3065 }
3066 else
3067 {
3068 /* Order should be 0, 1, 2... */
3069 ii = 1;
3070 vui[n - 1].lc->next = NULLnullptr;
3071 }
3072 }
3073 for (; ii < n; ii++)
3074 vui[ii - 1].lc->next = vui[ii].lc;
3075 }
3076 else
3077 {
3078 qsort (vui, n, sizeof (struct variable_union_info),gcc_qsort (vui, n, sizeof (struct variable_union_info), variable_union_info_cmp_pos
)
3079 variable_union_info_cmp_pos)gcc_qsort (vui, n, sizeof (struct variable_union_info), variable_union_info_cmp_pos
)
;
3080
3081 /* Reconnect the nodes in sorted order. */
3082 for (ii = 1; ii < n; ii++)
3083 vui[ii - 1].lc->next = vui[ii].lc;
3084 vui[n - 1].lc->next = NULLnullptr;
3085 dst->var_part[k].loc_chain = vui[0].lc;
3086 }
3087
3088 VAR_PART_OFFSET (dst, k)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3088, __FUNCTION__), 0 : 0)); &__v->var_part[(k)].aux
.offset; }))
= VAR_PART_OFFSET (dst, j)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3088, __FUNCTION__), 0 : 0)); &__v->var_part[(j)].aux
.offset; }))
;
3089 }
3090 i--;
3091 j--;
3092 }
3093 else if ((i >= 0 && j >= 0
3094 && VAR_PART_OFFSET (src, i)__extension__ (*({ variable *const __v = (src); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3094, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
< VAR_PART_OFFSET (dst, j)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3094, __FUNCTION__), 0 : 0)); &__v->var_part[(j)].aux
.offset; }))
)
3095 || i < 0)
3096 {
3097 dst->var_part[k] = dst->var_part[j];
3098 j--;
3099 }
3100 else if ((i >= 0 && j >= 0
3101 && VAR_PART_OFFSET (src, i)__extension__ (*({ variable *const __v = (src); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3101, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
> VAR_PART_OFFSET (dst, j)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3101, __FUNCTION__), 0 : 0)); &__v->var_part[(j)].aux
.offset; }))
)
3102 || j < 0)
3103 {
3104 location_chain **nextp;
3105
3106 /* Copy the chain from SRC. */
3107 nextp = &dst->var_part[k].loc_chain;
3108 for (node = src->var_part[i].loc_chain; node; node = node->next)
3109 {
3110 location_chain *new_lc;
3111
3112 new_lc = new location_chain;
3113 new_lc->next = NULLnullptr;
3114 new_lc->init = node->init;
3115 if (!node->set_src || MEM_P (node->set_src)(((enum rtx_code) (node->set_src)->code) == MEM))
3116 new_lc->set_src = NULLnullptr;
3117 else
3118 new_lc->set_src = node->set_src;
3119 new_lc->loc = node->loc;
3120
3121 *nextp = new_lc;
3122 nextp = &new_lc->next;
3123 }
3124
3125 VAR_PART_OFFSET (dst, k)__extension__ (*({ variable *const __v = (dst); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3125, __FUNCTION__), 0 : 0)); &__v->var_part[(k)].aux
.offset; }))
= VAR_PART_OFFSET (src, i)__extension__ (*({ variable *const __v = (src); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3125, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
;
3126 i--;
3127 }
3128 dst->var_part[k].cur_loc = NULLnullptr;
3129 }
3130
3131 if (flag_var_tracking_uninitglobal_options.x_flag_var_tracking_uninit)
3132 for (i = 0; i < src->n_var_parts && i < dst->n_var_parts; i++)
3133 {
3134 location_chain *node, *node2;
3135 for (node = src->var_part[i].loc_chain; node; node = node->next)
3136 for (node2 = dst->var_part[i].loc_chain; node2; node2 = node2->next)
3137 if (rtx_equal_p (node->loc, node2->loc))
3138 {
3139 if (node->init > node2->init)
3140 node2->init = node->init;
3141 }
3142 }
3143
3144 /* Continue traversing the hash table. */
3145 return 1;
3146}
3147
3148/* Compute union of dataflow sets SRC and DST and store it to DST. */
3149
3150static void
3151dataflow_set_union (dataflow_set *dst, dataflow_set *src)
3152{
3153 int i;
3154
3155 for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
3156 attrs_list_union (&dst->regs[i], src->regs[i]);
3157
3158 if (dst->vars == empty_shared_hash)
3159 {
3160 shared_hash_destroy (dst->vars);
3161 dst->vars = shared_hash_copy (src->vars);
3162 }
3163 else
3164 {
3165 variable_iterator_type hi;
3166 variable *var;
3167
3168 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (src->vars),for ((hi) = (*shared_hash_htab (src->vars)).begin (); (hi)
!= (*shared_hash_htab (src->vars)).end () ? (var = *(hi) ,
true) : false; ++(hi))
3169 var, variable, hi)for ((hi) = (*shared_hash_htab (src->vars)).begin (); (hi)
!= (*shared_hash_htab (src->vars)).end () ? (var = *(hi) ,
true) : false; ++(hi))
3170 variable_union (var, dst);
3171 }
3172}
3173
3174/* Whether the value is currently being expanded. */
3175#define VALUE_RECURSED_INTO(x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3175, __FUNCTION__); _rtx; })->used)
\
3176 (RTL_FLAG_CHECK2 ("VALUE_RECURSED_INTO", (x), VALUE, DEBUG_EXPR)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3176, __FUNCTION__); _rtx; })
->used)
3177
3178/* Whether no expansion was found, saving useless lookups.
3179 It must only be set when VALUE_CHANGED is clear. */
3180#define NO_LOC_P(x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("NO_LOC_P"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3180, __FUNCTION__); _rtx; })->return_val)
\
3181 (RTL_FLAG_CHECK2 ("NO_LOC_P", (x), VALUE, DEBUG_EXPR)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("NO_LOC_P"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3181, __FUNCTION__); _rtx; })
->return_val)
3182
3183/* Whether cur_loc in the value needs to be (re)computed. */
3184#define VALUE_CHANGED(x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != VALUE) rtl_check_failed_flag (
"VALUE_CHANGED", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3184, __FUNCTION__); _rtx; })->frame_related)
\
3185 (RTL_FLAG_CHECK1 ("VALUE_CHANGED", (x), VALUE)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != VALUE) rtl_check_failed_flag (
"VALUE_CHANGED", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3185, __FUNCTION__); _rtx; })
->frame_related)
3186/* Whether cur_loc in the decl needs to be (re)computed. */
3187#define DECL_CHANGED(x)((x)->base.visited) TREE_VISITED (x)((x)->base.visited)
3188
3189/* Record (if NEWV) that DV needs to have its cur_loc recomputed. For
3190 user DECLs, this means they're in changed_variables. Values and
3191 debug exprs may be left with this flag set if no user variable
3192 requires them to be evaluated. */
3193
3194static inline void
3195set_dv_changed (decl_or_value dv, bool newv)
3196{
3197 switch (dv_onepart_p (dv))
3198 {
3199 case ONEPART_VALUE:
3200 if (newv)
3201 NO_LOC_P (dv_as_value (dv))(__extension__ ({ __typeof ((dv_as_value (dv))) const _rtx = (
(dv_as_value (dv))); if (((enum rtx_code) (_rtx)->code) !=
VALUE && ((enum rtx_code) (_rtx)->code) != DEBUG_EXPR
) rtl_check_failed_flag ("NO_LOC_P",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3201, __FUNCTION__); _rtx; })->return_val)
= false;
3202 VALUE_CHANGED (dv_as_value (dv))(__extension__ ({ __typeof ((dv_as_value (dv))) const _rtx = (
(dv_as_value (dv))); if (((enum rtx_code) (_rtx)->code) !=
VALUE) rtl_check_failed_flag ("VALUE_CHANGED", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3202, __FUNCTION__); _rtx; })->frame_related)
= newv;
3203 break;
3204
3205 case ONEPART_DEXPR:
3206 if (newv)
3207 NO_LOC_P (DECL_RTL_KNOWN_SET (dv_as_decl (dv)))(__extension__ ({ __typeof ((__extension__ ({ tree const __d =
(dv_as_decl (dv)); ((void)(!((((tree_contains_struct[(((enum
tree_code) (__d)->base.code))][(TS_DECL_WRTL)])) &&
(contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3207, __FUNCTION__))->decl_with_rtl.rtl != nullptr)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3207, __FUNCTION__), 0 : 0)); &*((((tree_contains_struct
[(((enum tree_code) (__d)->base.code))][(TS_DECL_WRTL)])) &&
(contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3207, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3207, __FUNCTION__))->decl_with_rtl.rtl ? (__d)->decl_with_rtl
.rtl : (make_decl_rtl (__d), (__d)->decl_with_rtl.rtl)) : nullptr
); }))) const _rtx = ((__extension__ ({ tree const __d = (dv_as_decl
(dv)); ((void)(!((((tree_contains_struct[(((enum tree_code) (
__d)->base.code))][(TS_DECL_WRTL)])) && (contains_struct_check
((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3207, __FUNCTION__))->decl_with_rtl.rtl != nullptr)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3207, __FUNCTION__), 0 : 0)); &*((((tree_contains_struct
[(((enum tree_code) (__d)->base.code))][(TS_DECL_WRTL)])) &&
(contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3207, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((__d), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3207, __FUNCTION__))->decl_with_rtl.rtl ? (__d)->decl_with_rtl
.rtl : (make_decl_rtl (__d), (__d)->decl_with_rtl.rtl)) : nullptr
); }))); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("NO_LOC_P",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3207, __FUNCTION__); _rtx; })->return_val)
= false;
3208 /* Fall through. */
3209
3210 default:
3211 DECL_CHANGED (dv_as_decl (dv))((dv_as_decl (dv))->base.visited) = newv;
3212 break;
3213 }
3214}
3215
3216/* Return true if DV needs to have its cur_loc recomputed. */
3217
3218static inline bool
3219dv_changed_p (decl_or_value dv)
3220{
3221 return (dv_is_value_p (dv)
3222 ? VALUE_CHANGED (dv_as_value (dv))(__extension__ ({ __typeof ((dv_as_value (dv))) const _rtx = (
(dv_as_value (dv))); if (((enum rtx_code) (_rtx)->code) !=
VALUE) rtl_check_failed_flag ("VALUE_CHANGED", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3222, __FUNCTION__); _rtx; })->frame_related)
3223 : DECL_CHANGED (dv_as_decl (dv))((dv_as_decl (dv))->base.visited));
3224}
3225
3226/* Return a location list node whose loc is rtx_equal to LOC, in the
3227 location list of a one-part variable or value VAR, or in that of
3228 any values recursively mentioned in the location lists. VARS must
3229 be in star-canonical form. */
3230
3231static location_chain *
3232find_loc_in_1pdv (rtx loc, variable *var, variable_table_type *vars)
3233{
3234 location_chain *node;
3235 enum rtx_code loc_code;
3236
3237 if (!var)
3238 return NULLnullptr;
3239
3240 gcc_checking_assert (var->onepart)((void)(!(var->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3240, __FUNCTION__), 0 : 0))
;
3241
3242 if (!var->n_var_parts)
3243 return NULLnullptr;
3244
3245 gcc_checking_assert (loc != dv_as_opaque (var->dv))((void)(!(loc != dv_as_opaque (var->dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3245, __FUNCTION__), 0 : 0))
;
3246
3247 loc_code = GET_CODE (loc)((enum rtx_code) (loc)->code);
3248 for (node = var->var_part[0].loc_chain; node; node = node->next)
3249 {
3250 decl_or_value dv;
3251 variable *rvar;
3252
3253 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) != loc_code)
3254 {
3255 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) != VALUE)
3256 continue;
3257 }
3258 else if (loc == node->loc)
3259 return node;
3260 else if (loc_code != VALUE)
3261 {
3262 if (rtx_equal_p (loc, node->loc))
3263 return node;
3264 continue;
3265 }
3266
3267 /* Since we're in star-canonical form, we don't need to visit
3268 non-canonical nodes: one-part variables and non-canonical
3269 values would only point back to the canonical node. */
3270 if (dv_is_value_p (var->dv)
3271 && !canon_value_cmp (node->loc, dv_as_value (var->dv)))
3272 {
3273 /* Skip all subsequent VALUEs. */
3274 while (node->next && GET_CODE (node->next->loc)((enum rtx_code) (node->next->loc)->code) == VALUE)
3275 {
3276 node = node->next;
3277 gcc_checking_assert (!canon_value_cmp (node->loc,((void)(!(!canon_value_cmp (node->loc, dv_as_value (var->
dv))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3278, __FUNCTION__), 0 : 0))
3278 dv_as_value (var->dv)))((void)(!(!canon_value_cmp (node->loc, dv_as_value (var->
dv))) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3278, __FUNCTION__), 0 : 0))
;
3279 if (loc == node->loc)
3280 return node;
3281 }
3282 continue;
3283 }
3284
3285 gcc_checking_assert (node == var->var_part[0].loc_chain)((void)(!(node == var->var_part[0].loc_chain) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3285, __FUNCTION__), 0 : 0))
;
3286 gcc_checking_assert (!node->next)((void)(!(!node->next) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3286, __FUNCTION__), 0 : 0))
;
3287
3288 dv = dv_from_value (node->loc);
3289 rvar = vars->find_with_hash (dv, dv_htab_hash (dv));
3290 return find_loc_in_1pdv (loc, rvar, vars);
3291 }
3292
3293 /* ??? Gotta look in cselib_val locations too. */
3294
3295 return NULLnullptr;
3296}
3297
3298/* Hash table iteration argument passed to variable_merge. */
3299struct dfset_merge
3300{
3301 /* The set in which the merge is to be inserted. */
3302 dataflow_set *dst;
3303 /* The set that we're iterating in. */
3304 dataflow_set *cur;
3305 /* The set that may contain the other dv we are to merge with. */
3306 dataflow_set *src;
3307 /* Number of onepart dvs in src. */
3308 int src_onepart_cnt;
3309};
3310
3311/* Insert LOC in *DNODE, if it's not there yet. The list must be in
3312 loc_cmp order, and it is maintained as such. */
3313
3314static void
3315insert_into_intersection (location_chain **nodep, rtx loc,
3316 enum var_init_status status)
3317{
3318 location_chain *node;
3319 int r;
3320
3321 for (node = *nodep; node; nodep = &node->next, node = *nodep)
3322 if ((r = loc_cmp (node->loc, loc)) == 0)
3323 {
3324 node->init = MIN (node->init, status)((node->init) < (status) ? (node->init) : (status));
3325 return;
3326 }
3327 else if (r > 0)
3328 break;
3329
3330 node = new location_chain;
3331
3332 node->loc = loc;
3333 node->set_src = NULLnullptr;
3334 node->init = status;
3335 node->next = *nodep;
3336 *nodep = node;
3337}
3338
3339/* Insert in DEST the intersection of the locations present in both
3340 S1NODE and S2VAR, directly or indirectly. S1NODE is from a
3341 variable in DSM->cur, whereas S2VAR is from DSM->src. dvar is in
3342 DSM->dst. */
3343
3344static void
3345intersect_loc_chains (rtx val, location_chain **dest, struct dfset_merge *dsm,
3346 location_chain *s1node, variable *s2var)
3347{
3348 dataflow_set *s1set = dsm->cur;
3349 dataflow_set *s2set = dsm->src;
3350 location_chain *found;
3351
3352 if (s2var)
3353 {
3354 location_chain *s2node;
3355
3356 gcc_checking_assert (s2var->onepart)((void)(!(s2var->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3356, __FUNCTION__), 0 : 0))
;
3357
3358 if (s2var->n_var_parts)
3359 {
3360 s2node = s2var->var_part[0].loc_chain;
3361
3362 for (; s1node && s2node;
3363 s1node = s1node->next, s2node = s2node->next)
3364 if (s1node->loc != s2node->loc)
3365 break;
3366 else if (s1node->loc == val)
3367 continue;
3368 else
3369 insert_into_intersection (dest, s1node->loc,
3370 MIN (s1node->init, s2node->init)((s1node->init) < (s2node->init) ? (s1node->init)
: (s2node->init))
);
3371 }
3372 }
3373
3374 for (; s1node; s1node = s1node->next)
3375 {
3376 if (s1node->loc == val)
3377 continue;
3378
3379 if ((found = find_loc_in_1pdv (s1node->loc, s2var,
3380 shared_hash_htab (s2set->vars))))
3381 {
3382 insert_into_intersection (dest, s1node->loc,
3383 MIN (s1node->init, found->init)((s1node->init) < (found->init) ? (s1node->init) :
(found->init))
);
3384 continue;
3385 }
3386
3387 if (GET_CODE (s1node->loc)((enum rtx_code) (s1node->loc)->code) == VALUE
3388 && !VALUE_RECURSED_INTO (s1node->loc)(__extension__ ({ __typeof ((s1node->loc)) const _rtx = ((
s1node->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE
&& ((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3388, __FUNCTION__); _rtx; })->used)
)
3389 {
3390 decl_or_value dv = dv_from_value (s1node->loc);
3391 variable *svar = shared_hash_find (s1set->vars, dv);
3392 if (svar)
3393 {
3394 if (svar->n_var_parts == 1)
3395 {
3396 VALUE_RECURSED_INTO (s1node->loc)(__extension__ ({ __typeof ((s1node->loc)) const _rtx = ((
s1node->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE
&& ((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3396, __FUNCTION__); _rtx; })->used)
= true;
3397 intersect_loc_chains (val, dest, dsm,
3398 svar->var_part[0].loc_chain,
3399 s2var);
3400 VALUE_RECURSED_INTO (s1node->loc)(__extension__ ({ __typeof ((s1node->loc)) const _rtx = ((
s1node->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE
&& ((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3400, __FUNCTION__); _rtx; })->used)
= false;
3401 }
3402 }
3403 }
3404
3405 /* ??? gotta look in cselib_val locations too. */
3406
3407 /* ??? if the location is equivalent to any location in src,
3408 searched recursively
3409
3410 add to dst the values needed to represent the equivalence
3411
3412 telling whether locations S is equivalent to another dv's
3413 location list:
3414
3415 for each location D in the list
3416
3417 if S and D satisfy rtx_equal_p, then it is present
3418
3419 else if D is a value, recurse without cycles
3420
3421 else if S and D have the same CODE and MODE
3422
3423 for each operand oS and the corresponding oD
3424
3425 if oS and oD are not equivalent, then S an D are not equivalent
3426
3427 else if they are RTX vectors
3428
3429 if any vector oS element is not equivalent to its respective oD,
3430 then S and D are not equivalent
3431
3432 */
3433
3434
3435 }
3436}
3437
3438/* Return -1 if X should be before Y in a location list for a 1-part
3439 variable, 1 if Y should be before X, and 0 if they're equivalent
3440 and should not appear in the list. */
3441
3442static int
3443loc_cmp (rtx x, rtx y)
3444{
3445 int i, j, r;
3446 RTX_CODEenum rtx_code code = GET_CODE (x)((enum rtx_code) (x)->code);
3447 const char *fmt;
3448
3449 if (x == y)
3450 return 0;
3451
3452 if (REG_P (x)(((enum rtx_code) (x)->code) == REG))
3453 {
3454 if (!REG_P (y)(((enum rtx_code) (y)->code) == REG))
3455 return -1;
3456 gcc_assert (GET_MODE (x) == GET_MODE (y))((void)(!(((machine_mode) (x)->mode) == ((machine_mode) (y
)->mode)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3456, __FUNCTION__), 0 : 0))
;
3457 if (REGNO (x)(rhs_regno(x)) == REGNO (y)(rhs_regno(y)))
3458 return 0;
3459 else if (REGNO (x)(rhs_regno(x)) < REGNO (y)(rhs_regno(y)))
3460 return -1;
3461 else
3462 return 1;
3463 }
3464
3465 if (REG_P (y)(((enum rtx_code) (y)->code) == REG))
3466 return 1;
3467
3468 if (MEM_P (x)(((enum rtx_code) (x)->code) == MEM))
3469 {
3470 if (!MEM_P (y)(((enum rtx_code) (y)->code) == MEM))
3471 return -1;
3472 gcc_assert (GET_MODE (x) == GET_MODE (y))((void)(!(((machine_mode) (x)->mode) == ((machine_mode) (y
)->mode)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3472, __FUNCTION__), 0 : 0))
;
3473 return loc_cmp (XEXP (x, 0)(((x)->u.fld[0]).rt_rtx), XEXP (y, 0)(((y)->u.fld[0]).rt_rtx));
3474 }
3475
3476 if (MEM_P (y)(((enum rtx_code) (y)->code) == MEM))
3477 return 1;
3478
3479 if (GET_CODE (x)((enum rtx_code) (x)->code) == VALUE)
3480 {
3481 if (GET_CODE (y)((enum rtx_code) (y)->code) != VALUE)
3482 return -1;
3483 /* Don't assert the modes are the same, that is true only
3484 when not recursing. (subreg:QI (value:SI 1:1) 0)
3485 and (subreg:QI (value:DI 2:2) 0) can be compared,
3486 even when the modes are different. */
3487 if (canon_value_cmp (x, y))
3488 return -1;
3489 else
3490 return 1;
3491 }
3492
3493 if (GET_CODE (y)((enum rtx_code) (y)->code) == VALUE)
3494 return 1;
3495
3496 /* Entry value is the least preferable kind of expression. */
3497 if (GET_CODE (x)((enum rtx_code) (x)->code) == ENTRY_VALUE)
3498 {
3499 if (GET_CODE (y)((enum rtx_code) (y)->code) != ENTRY_VALUE)
3500 return 1;
3501 gcc_assert (GET_MODE (x) == GET_MODE (y))((void)(!(((machine_mode) (x)->mode) == ((machine_mode) (y
)->mode)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3501, __FUNCTION__), 0 : 0))
;
3502 return loc_cmp (ENTRY_VALUE_EXP (x)(((x)->u.fld[0]).rt_rtx), ENTRY_VALUE_EXP (y)(((y)->u.fld[0]).rt_rtx));
3503 }
3504
3505 if (GET_CODE (y)((enum rtx_code) (y)->code) == ENTRY_VALUE)
3506 return -1;
3507
3508 if (GET_CODE (x)((enum rtx_code) (x)->code) == GET_CODE (y)((enum rtx_code) (y)->code))
3509 /* Compare operands below. */;
3510 else if (GET_CODE (x)((enum rtx_code) (x)->code) < GET_CODE (y)((enum rtx_code) (y)->code))
3511 return -1;
3512 else
3513 return 1;
3514
3515 gcc_assert (GET_MODE (x) == GET_MODE (y))((void)(!(((machine_mode) (x)->mode) == ((machine_mode) (y
)->mode)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3515, __FUNCTION__), 0 : 0))
;
3516
3517 if (GET_CODE (x)((enum rtx_code) (x)->code) == DEBUG_EXPR)
3518 {
3519 if (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))(-((contains_struct_check (((tree_check ((((((x)->u.fld[0]
).rt_tree))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3519, __FUNCTION__, (DEBUG_EXPR_DECL)))), (TS_DECL_MINIMAL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3519, __FUNCTION__))->decl_minimal.uid))
3520 < DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y))(-((contains_struct_check (((tree_check ((((((y)->u.fld[0]
).rt_tree))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3520, __FUNCTION__, (DEBUG_EXPR_DECL)))), (TS_DECL_MINIMAL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3520, __FUNCTION__))->decl_minimal.uid))
)
3521 return -1;
3522 gcc_checking_assert (DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))((void)(!((-((contains_struct_check (((tree_check ((((((x)->
u.fld[0]).rt_tree))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3522, __FUNCTION__, (DEBUG_EXPR_DECL)))), (TS_DECL_MINIMAL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3522, __FUNCTION__))->decl_minimal.uid)) > (-((contains_struct_check
(((tree_check ((((((y)->u.fld[0]).rt_tree))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3523, __FUNCTION__, (DEBUG_EXPR_DECL)))), (TS_DECL_MINIMAL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3523, __FUNCTION__))->decl_minimal.uid))) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3523, __FUNCTION__), 0 : 0))
3523 > DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (y)))((void)(!((-((contains_struct_check (((tree_check ((((((x)->
u.fld[0]).rt_tree))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3522, __FUNCTION__, (DEBUG_EXPR_DECL)))), (TS_DECL_MINIMAL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3522, __FUNCTION__))->decl_minimal.uid)) > (-((contains_struct_check
(((tree_check ((((((y)->u.fld[0]).rt_tree))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3523, __FUNCTION__, (DEBUG_EXPR_DECL)))), (TS_DECL_MINIMAL)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3523, __FUNCTION__))->decl_minimal.uid))) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3523, __FUNCTION__), 0 : 0))
;
3524 return 1;
3525 }
3526
3527 fmt = GET_RTX_FORMAT (code)(rtx_format[(int) (code)]);
3528 for (i = 0; i < GET_RTX_LENGTH (code)(rtx_length[(int) (code)]); i++)
3529 switch (fmt[i])
3530 {
3531 case 'w':
3532 if (XWINT (x, i)((x)->u.hwint[i]) == XWINT (y, i)((y)->u.hwint[i]))
3533 break;
3534 else if (XWINT (x, i)((x)->u.hwint[i]) < XWINT (y, i)((y)->u.hwint[i]))
3535 return -1;
3536 else
3537 return 1;
3538
3539 case 'n':
3540 case 'i':
3541 if (XINT (x, i)(((x)->u.fld[i]).rt_int) == XINT (y, i)(((y)->u.fld[i]).rt_int))
3542 break;
3543 else if (XINT (x, i)(((x)->u.fld[i]).rt_int) < XINT (y, i)(((y)->u.fld[i]).rt_int))
3544 return -1;
3545 else
3546 return 1;
3547
3548 case 'p':
3549 r = compare_sizes_for_sort (SUBREG_BYTE (x)(((x)->u.fld[1]).rt_subreg), SUBREG_BYTE (y)(((y)->u.fld[1]).rt_subreg));
3550 if (r != 0)
3551 return r;
3552 break;
3553
3554 case 'V':
3555 case 'E':
3556 /* Compare the vector length first. */
3557 if (XVECLEN (x, i)(((((x)->u.fld[i]).rt_rtvec))->num_elem) == XVECLEN (y, i)(((((y)->u.fld[i]).rt_rtvec))->num_elem))
3558 /* Compare the vectors elements. */;
3559 else if (XVECLEN (x, i)(((((x)->u.fld[i]).rt_rtvec))->num_elem) < XVECLEN (y, i)(((((y)->u.fld[i]).rt_rtvec))->num_elem))
3560 return -1;
3561 else
3562 return 1;
3563
3564 for (j = 0; j < XVECLEN (x, i)(((((x)->u.fld[i]).rt_rtvec))->num_elem); j++)
3565 if ((r = loc_cmp (XVECEXP (x, i, j)(((((x)->u.fld[i]).rt_rtvec))->elem[j]),
3566 XVECEXP (y, i, j)(((((y)->u.fld[i]).rt_rtvec))->elem[j]))))
3567 return r;
3568 break;
3569
3570 case 'e':
3571 if ((r = loc_cmp (XEXP (x, i)(((x)->u.fld[i]).rt_rtx), XEXP (y, i)(((y)->u.fld[i]).rt_rtx))))
3572 return r;
3573 break;
3574
3575 case 'S':
3576 case 's':
3577 if (XSTR (x, i)(((x)->u.fld[i]).rt_str) == XSTR (y, i)(((y)->u.fld[i]).rt_str))
3578 break;
3579 if (!XSTR (x, i)(((x)->u.fld[i]).rt_str))
3580 return -1;
3581 if (!XSTR (y, i)(((y)->u.fld[i]).rt_str))
3582 return 1;
3583 if ((r = strcmp (XSTR (x, i)(((x)->u.fld[i]).rt_str), XSTR (y, i)(((y)->u.fld[i]).rt_str))) == 0)
3584 break;
3585 else if (r < 0)
3586 return -1;
3587 else
3588 return 1;
3589
3590 case 'u':
3591 /* These are just backpointers, so they don't matter. */
3592 break;
3593
3594 case '0':
3595 case 't':
3596 break;
3597
3598 /* It is believed that rtx's at this level will never
3599 contain anything but integers and other rtx's,
3600 except for within LABEL_REFs and SYMBOL_REFs. */
3601 default:
3602 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3602, __FUNCTION__))
;
3603 }
3604 if (CONST_WIDE_INT_P (x)(((enum rtx_code) (x)->code) == CONST_WIDE_INT))
3605 {
3606 /* Compare the vector length first. */
3607 if (CONST_WIDE_INT_NUNITS (x)((int)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (
((enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag
("CWI_GET_NUM_ELEM", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3607, __FUNCTION__); _rtx; })->u2.num_elem)
>= CONST_WIDE_INT_NUNITS (y)((int)__extension__ ({ __typeof ((y)) const _rtx = ((y)); if (
((enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag
("CWI_GET_NUM_ELEM", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3607, __FUNCTION__); _rtx; })->u2.num_elem)
)
3608 return 1;
3609 else if (CONST_WIDE_INT_NUNITS (x)((int)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (
((enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag
("CWI_GET_NUM_ELEM", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3609, __FUNCTION__); _rtx; })->u2.num_elem)
< CONST_WIDE_INT_NUNITS (y)((int)__extension__ ({ __typeof ((y)) const _rtx = ((y)); if (
((enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag
("CWI_GET_NUM_ELEM", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3609, __FUNCTION__); _rtx; })->u2.num_elem)
)
3610 return -1;
3611
3612 /* Compare the vectors elements. */;
3613 for (j = CONST_WIDE_INT_NUNITS (x)((int)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (
((enum rtx_code) (_rtx)->code) != CONST_WIDE_INT) rtl_check_failed_flag
("CWI_GET_NUM_ELEM", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3613, __FUNCTION__); _rtx; })->u2.num_elem)
- 1; j >= 0 ; j--)
3614 {
3615 if (CONST_WIDE_INT_ELT (x, j)((x)->u.hwiv.elem[j]) < CONST_WIDE_INT_ELT (y, j)((y)->u.hwiv.elem[j]))
3616 return -1;
3617 if (CONST_WIDE_INT_ELT (x, j)((x)->u.hwiv.elem[j]) > CONST_WIDE_INT_ELT (y, j)((y)->u.hwiv.elem[j]))
3618 return 1;
3619 }
3620 }
3621
3622 return 0;
3623}
3624
3625/* Check the order of entries in one-part variables. */
3626
3627int
3628canonicalize_loc_order_check (variable **slot,
3629 dataflow_set *data ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
3630{
3631 variable *var = *slot;
3632 location_chain *node, *next;
3633
3634#ifdef ENABLE_RTL_CHECKING
3635 int i;
3636 for (i = 0; i < var->n_var_parts; i++)
3637 gcc_assert (var->var_part[0].cur_loc == NULL)((void)(!(var->var_part[0].cur_loc == nullptr) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3637, __FUNCTION__), 0 : 0))
;
3638 gcc_assert (!var->in_changed_variables)((void)(!(!var->in_changed_variables) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3638, __FUNCTION__), 0 : 0))
;
3639#endif
3640
3641 if (!var->onepart)
3642 return 1;
3643
3644 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3644, __FUNCTION__), 0 : 0))
;
3645 node = var->var_part[0].loc_chain;
3646 gcc_assert (node)((void)(!(node) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3646, __FUNCTION__), 0 : 0))
;
3647
3648 while ((next = node->next))
3649 {
3650 gcc_assert (loc_cmp (node->loc, next->loc) < 0)((void)(!(loc_cmp (node->loc, next->loc) < 0) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3650, __FUNCTION__), 0 : 0))
;
3651 node = next;
3652 }
3653
3654 return 1;
3655}
3656
3657/* Mark with VALUE_RECURSED_INTO values that have neighbors that are
3658 more likely to be chosen as canonical for an equivalence set.
3659 Ensure less likely values can reach more likely neighbors, making
3660 the connections bidirectional. */
3661
3662int
3663canonicalize_values_mark (variable **slot, dataflow_set *set)
3664{
3665 variable *var = *slot;
3666 decl_or_value dv = var->dv;
3667 rtx val;
3668 location_chain *node;
3669
3670 if (!dv_is_value_p (dv))
3671 return 1;
3672
3673 gcc_checking_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3673, __FUNCTION__), 0 : 0))
;
3674
3675 val = dv_as_value (dv);
3676
3677 for (node = var->var_part[0].loc_chain; node; node = node->next)
3678 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE)
3679 {
3680 if (canon_value_cmp (node->loc, val))
3681 VALUE_RECURSED_INTO (val)(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if (
((enum rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3681, __FUNCTION__); _rtx; })->used)
= true;
3682 else
3683 {
3684 decl_or_value odv = dv_from_value (node->loc);
3685 variable **oslot;
3686 oslot = shared_hash_find_slot_noinsert (set->vars, odv);
3687
3688 set_slot_part (set, val, oslot, odv, 0,
3689 node->init, NULL_RTX(rtx) 0);
3690
3691 VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3691, __FUNCTION__); _rtx; })->used)
= true;
3692 }
3693 }
3694
3695 return 1;
3696}
3697
3698/* Remove redundant entries from equivalence lists in onepart
3699 variables, canonicalizing equivalence sets into star shapes. */
3700
3701int
3702canonicalize_values_star (variable **slot, dataflow_set *set)
3703{
3704 variable *var = *slot;
3705 decl_or_value dv = var->dv;
3706 location_chain *node;
3707 decl_or_value cdv;
3708 rtx val, cval;
3709 variable **cslot;
3710 bool has_value;
3711 bool has_marks;
3712
3713 if (!var->onepart)
3714 return 1;
3715
3716 gcc_checking_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3716, __FUNCTION__), 0 : 0))
;
3717
3718 if (dv_is_value_p (dv))
3719 {
3720 cval = dv_as_value (dv);
3721 if (!VALUE_RECURSED_INTO (cval)(__extension__ ({ __typeof ((cval)) const _rtx = ((cval)); if
(((enum rtx_code) (_rtx)->code) != VALUE && ((enum
rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3721, __FUNCTION__); _rtx; })->used)
)
3722 return 1;
3723 VALUE_RECURSED_INTO (cval)(__extension__ ({ __typeof ((cval)) const _rtx = ((cval)); if
(((enum rtx_code) (_rtx)->code) != VALUE && ((enum
rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3723, __FUNCTION__); _rtx; })->used)
= false;
3724 }
3725 else
3726 cval = NULL_RTX(rtx) 0;
3727
3728 restart:
3729 val = cval;
3730 has_value = false;
3731 has_marks = false;
3732
3733 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3733, __FUNCTION__), 0 : 0))
;
3734
3735 for (node = var->var_part[0].loc_chain; node; node = node->next)
3736 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE)
3737 {
3738 has_value = true;
3739 if (VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3739, __FUNCTION__); _rtx; })->used)
)
3740 has_marks = true;
3741 if (canon_value_cmp (node->loc, cval))
3742 cval = node->loc;
3743 }
3744
3745 if (!has_value)
3746 return 1;
3747
3748 if (cval == val)
3749 {
3750 if (!has_marks || dv_is_decl_p (dv))
3751 return 1;
3752
3753 /* Keep it marked so that we revisit it, either after visiting a
3754 child node, or after visiting a new parent that might be
3755 found out. */
3756 VALUE_RECURSED_INTO (val)(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if (
((enum rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3756, __FUNCTION__); _rtx; })->used)
= true;
3757
3758 for (node = var->var_part[0].loc_chain; node; node = node->next)
3759 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE
3760 && VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3760, __FUNCTION__); _rtx; })->used)
)
3761 {
3762 cval = node->loc;
3763 restart_with_cval:
3764 VALUE_RECURSED_INTO (cval)(__extension__ ({ __typeof ((cval)) const _rtx = ((cval)); if
(((enum rtx_code) (_rtx)->code) != VALUE && ((enum
rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3764, __FUNCTION__); _rtx; })->used)
= false;
3765 dv = dv_from_value (cval);
3766 slot = shared_hash_find_slot_noinsert (set->vars, dv);
3767 if (!slot)
3768 {
3769 gcc_assert (dv_is_decl_p (var->dv))((void)(!(dv_is_decl_p (var->dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3769, __FUNCTION__), 0 : 0))
;
3770 /* The canonical value was reset and dropped.
3771 Remove it. */
3772 clobber_variable_part (set, NULLnullptr, var->dv, 0, NULLnullptr);
3773 return 1;
3774 }
3775 var = *slot;
3776 gcc_assert (dv_is_value_p (var->dv))((void)(!(dv_is_value_p (var->dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3776, __FUNCTION__), 0 : 0))
;
3777 if (var->n_var_parts == 0)
3778 return 1;
3779 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3779, __FUNCTION__), 0 : 0))
;
3780 goto restart;
3781 }
3782
3783 VALUE_RECURSED_INTO (val)(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if (
((enum rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3783, __FUNCTION__); _rtx; })->used)
= false;
3784
3785 return 1;
3786 }
3787
3788 /* Push values to the canonical one. */
3789 cdv = dv_from_value (cval);
3790 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3791
3792 for (node = var->var_part[0].loc_chain; node; node = node->next)
3793 if (node->loc != cval)
3794 {
3795 cslot = set_slot_part (set, node->loc, cslot, cdv, 0,
3796 node->init, NULL_RTX(rtx) 0);
3797 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE)
3798 {
3799 decl_or_value ndv = dv_from_value (node->loc);
3800
3801 set_variable_part (set, cval, ndv, 0, node->init, NULL_RTX(rtx) 0,
3802 NO_INSERT);
3803
3804 if (canon_value_cmp (node->loc, val))
3805 {
3806 /* If it could have been a local minimum, it's not any more,
3807 since it's now neighbor to cval, so it may have to push
3808 to it. Conversely, if it wouldn't have prevailed over
3809 val, then whatever mark it has is fine: if it was to
3810 push, it will now push to a more canonical node, but if
3811 it wasn't, then it has already pushed any values it might
3812 have to. */
3813 VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3813, __FUNCTION__); _rtx; })->used)
= true;
3814 /* Make sure we visit node->loc by ensuring we cval is
3815 visited too. */
3816 VALUE_RECURSED_INTO (cval)(__extension__ ({ __typeof ((cval)) const _rtx = ((cval)); if
(((enum rtx_code) (_rtx)->code) != VALUE && ((enum
rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3816, __FUNCTION__); _rtx; })->used)
= true;
3817 }
3818 else if (!VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3818, __FUNCTION__); _rtx; })->used)
)
3819 /* If we have no need to "recurse" into this node, it's
3820 already "canonicalized", so drop the link to the old
3821 parent. */
3822 clobber_variable_part (set, cval, ndv, 0, NULLnullptr);
3823 }
3824 else if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == REG)
3825 {
3826 attrs *list = set->regs[REGNO (node->loc)(rhs_regno(node->loc))], **listp;
3827
3828 /* Change an existing attribute referring to dv so that it
3829 refers to cdv, removing any duplicate this might
3830 introduce, and checking that no previous duplicates
3831 existed, all in a single pass. */
3832
3833 while (list)
3834 {
3835 if (list->offset == 0
3836 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3837 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3838 break;
3839
3840 list = list->next;
3841 }
3842
3843 gcc_assert (list)((void)(!(list) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3843, __FUNCTION__), 0 : 0))
;
3844 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3845 {
3846 list->dv = cdv;
3847 for (listp = &list->next; (list = *listp); listp = &list->next)
3848 {
3849 if (list->offset)
3850 continue;
3851
3852 if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3853 {
3854 *listp = list->next;
3855 delete list;
3856 list = *listp;
3857 break;
3858 }
3859
3860 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (dv))((void)(!(dv_as_opaque (list->dv) != dv_as_opaque (dv)) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3860, __FUNCTION__), 0 : 0))
;
3861 }
3862 }
3863 else if (dv_as_opaque (list->dv) == dv_as_opaque (cdv))
3864 {
3865 for (listp = &list->next; (list = *listp); listp = &list->next)
3866 {
3867 if (list->offset)
3868 continue;
3869
3870 if (dv_as_opaque (list->dv) == dv_as_opaque (dv))
3871 {
3872 *listp = list->next;
3873 delete list;
3874 list = *listp;
3875 break;
3876 }
3877
3878 gcc_assert (dv_as_opaque (list->dv) != dv_as_opaque (cdv))((void)(!(dv_as_opaque (list->dv) != dv_as_opaque (cdv)) ?
fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3878, __FUNCTION__), 0 : 0))
;
3879 }
3880 }
3881 else
3882 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3882, __FUNCTION__))
;
3883
3884 if (flag_checkingglobal_options.x_flag_checking)
3885 while (list)
3886 {
3887 if (list->offset == 0
3888 && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
3889 || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
3890 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3890, __FUNCTION__))
;
3891
3892 list = list->next;
3893 }
3894 }
3895 }
3896
3897 if (val)
3898 set_slot_part (set, val, cslot, cdv, 0,
3899 VAR_INIT_STATUS_INITIALIZED, NULL_RTX(rtx) 0);
3900
3901 slot = clobber_slot_part (set, cval, slot, 0, NULLnullptr);
3902
3903 /* Variable may have been unshared. */
3904 var = *slot;
3905 gcc_checking_assert (var->n_var_parts && var->var_part[0].loc_chain->loc == cval((void)(!(var->n_var_parts && var->var_part[0].
loc_chain->loc == cval && var->var_part[0].loc_chain
->next == nullptr) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3906, __FUNCTION__), 0 : 0))
3906 && var->var_part[0].loc_chain->next == NULL)((void)(!(var->n_var_parts && var->var_part[0].
loc_chain->loc == cval && var->var_part[0].loc_chain
->next == nullptr) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3906, __FUNCTION__), 0 : 0))
;
3907
3908 if (VALUE_RECURSED_INTO (cval)(__extension__ ({ __typeof ((cval)) const _rtx = ((cval)); if
(((enum rtx_code) (_rtx)->code) != VALUE && ((enum
rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3908, __FUNCTION__); _rtx; })->used)
)
3909 goto restart_with_cval;
3910
3911 return 1;
3912}
3913
3914/* Bind one-part variables to the canonical value in an equivalence
3915 set. Not doing this causes dataflow convergence failure in rare
3916 circumstances, see PR42873. Unfortunately we can't do this
3917 efficiently as part of canonicalize_values_star, since we may not
3918 have determined or even seen the canonical value of a set when we
3919 get to a variable that references another member of the set. */
3920
3921int
3922canonicalize_vars_star (variable **slot, dataflow_set *set)
3923{
3924 variable *var = *slot;
3925 decl_or_value dv = var->dv;
3926 location_chain *node;
3927 rtx cval;
3928 decl_or_value cdv;
3929 variable **cslot;
3930 variable *cvar;
3931 location_chain *cnode;
3932
3933 if (!var->onepart || var->onepart == ONEPART_VALUE)
3934 return 1;
3935
3936 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3936, __FUNCTION__), 0 : 0))
;
3937
3938 node = var->var_part[0].loc_chain;
3939
3940 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) != VALUE)
3941 return 1;
3942
3943 gcc_assert (!node->next)((void)(!(!node->next) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3943, __FUNCTION__), 0 : 0))
;
3944 cval = node->loc;
3945
3946 /* Push values to the canonical one. */
3947 cdv = dv_from_value (cval);
3948 cslot = shared_hash_find_slot_noinsert (set->vars, cdv);
3949 if (!cslot)
3950 return 1;
3951 cvar = *cslot;
3952 gcc_assert (cvar->n_var_parts == 1)((void)(!(cvar->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3952, __FUNCTION__), 0 : 0))
;
3953
3954 cnode = cvar->var_part[0].loc_chain;
3955
3956 /* CVAL is canonical if its value list contains non-VALUEs or VALUEs
3957 that are not “more canonical” than it. */
3958 if (GET_CODE (cnode->loc)((enum rtx_code) (cnode->loc)->code) != VALUE
3959 || !canon_value_cmp (cnode->loc, cval))
3960 return 1;
3961
3962 /* CVAL was found to be non-canonical. Change the variable to point
3963 to the canonical VALUE. */
3964 gcc_assert (!cnode->next)((void)(!(!cnode->next) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3964, __FUNCTION__), 0 : 0))
;
3965 cval = cnode->loc;
3966
3967 slot = set_slot_part (set, cval, slot, dv, 0,
3968 node->init, node->set_src);
3969 clobber_slot_part (set, cval, slot, 0, node->set_src);
3970
3971 return 1;
3972}
3973
3974/* Combine variable or value in *S1SLOT (in DSM->cur) with the
3975 corresponding entry in DSM->src. Multi-part variables are combined
3976 with variable_union, whereas onepart dvs are combined with
3977 intersection. */
3978
3979static int
3980variable_merge_over_cur (variable *s1var, struct dfset_merge *dsm)
3981{
3982 dataflow_set *dst = dsm->dst;
3983 variable **dstslot;
3984 variable *s2var, *dvar = NULLnullptr;
3985 decl_or_value dv = s1var->dv;
3986 onepart_enum onepart = s1var->onepart;
3987 rtx val;
3988 hashval_t dvhash;
3989 location_chain *node, **nodep;
3990
3991 /* If the incoming onepart variable has an empty location list, then
3992 the intersection will be just as empty. For other variables,
3993 it's always union. */
3994 gcc_checking_assert (s1var->n_var_parts((void)(!(s1var->n_var_parts && s1var->var_part
[0].loc_chain) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3995, __FUNCTION__), 0 : 0))
3995 && s1var->var_part[0].loc_chain)((void)(!(s1var->n_var_parts && s1var->var_part
[0].loc_chain) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 3995, __FUNCTION__), 0 : 0))
;
3996
3997 if (!onepart)
3998 return variable_union (s1var, dst);
3999
4000 gcc_checking_assert (s1var->n_var_parts == 1)((void)(!(s1var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4000, __FUNCTION__), 0 : 0))
;
4001
4002 dvhash = dv_htab_hash (dv);
4003 if (dv_is_value_p (dv))
4004 val = dv_as_value (dv);
4005 else
4006 val = NULLnullptr;
4007
4008 s2var = shared_hash_find_1 (dsm->src->vars, dv, dvhash);
4009 if (!s2var)
4010 {
4011 dst_can_be_shared = false;
4012 return 1;
4013 }
4014
4015 dsm->src_onepart_cnt--;
4016 gcc_assert (s2var->var_part[0].loc_chain((void)(!(s2var->var_part[0].loc_chain && s2var->
onepart == onepart && s2var->n_var_parts == 1) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4018, __FUNCTION__), 0 : 0))
4017 && s2var->onepart == onepart((void)(!(s2var->var_part[0].loc_chain && s2var->
onepart == onepart && s2var->n_var_parts == 1) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4018, __FUNCTION__), 0 : 0))
4018 && s2var->n_var_parts == 1)((void)(!(s2var->var_part[0].loc_chain && s2var->
onepart == onepart && s2var->n_var_parts == 1) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4018, __FUNCTION__), 0 : 0))
;
4019
4020 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4021 if (dstslot)
4022 {
4023 dvar = *dstslot;
4024 gcc_assert (dvar->refcount == 1((void)(!(dvar->refcount == 1 && dvar->onepart ==
onepart && dvar->n_var_parts == 1) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4026, __FUNCTION__), 0 : 0))
4025 && dvar->onepart == onepart((void)(!(dvar->refcount == 1 && dvar->onepart ==
onepart && dvar->n_var_parts == 1) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4026, __FUNCTION__), 0 : 0))
4026 && dvar->n_var_parts == 1)((void)(!(dvar->refcount == 1 && dvar->onepart ==
onepart && dvar->n_var_parts == 1) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4026, __FUNCTION__), 0 : 0))
;
4027 nodep = &dvar->var_part[0].loc_chain;
4028 }
4029 else
4030 {
4031 nodep = &node;
4032 node = NULLnullptr;
4033 }
4034
4035 if (!dstslot && !onepart_variable_different_p (s1var, s2var))
4036 {
4037 dstslot = shared_hash_find_slot_unshare_1 (&dst->vars, dv,
4038 dvhash, INSERT);
4039 *dstslot = dvar = s2var;
4040 dvar->refcount++;
4041 }
4042 else
4043 {
4044 dst_can_be_shared = false;
4045
4046 intersect_loc_chains (val, nodep, dsm,
4047 s1var->var_part[0].loc_chain, s2var);
4048
4049 if (!dstslot)
4050 {
4051 if (node)
4052 {
4053 dvar = onepart_pool_allocate (onepart);
4054 dvar->dv = dv;
4055 dvar->refcount = 1;
4056 dvar->n_var_parts = 1;
4057 dvar->onepart = onepart;
4058 dvar->in_changed_variables = false;
4059 dvar->var_part[0].loc_chain = node;
4060 dvar->var_part[0].cur_loc = NULLnullptr;
4061 if (onepart)
4062 VAR_LOC_1PAUX (dvar)__extension__ (*({ variable *const __v = (dvar); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4062, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
= NULLnullptr;
4063 else
4064 VAR_PART_OFFSET (dvar, 0)__extension__ (*({ variable *const __v = (dvar); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4064, __FUNCTION__), 0 : 0)); &__v->var_part[(0)].aux
.offset; }))
= 0;
4065
4066 dstslot
4067 = shared_hash_find_slot_unshare_1 (&dst->vars, dv, dvhash,
4068 INSERT);
4069 gcc_assert (!*dstslot)((void)(!(!*dstslot) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4069, __FUNCTION__), 0 : 0))
;
4070 *dstslot = dvar;
4071 }
4072 else
4073 return 1;
4074 }
4075 }
4076
4077 nodep = &dvar->var_part[0].loc_chain;
4078 while ((node = *nodep))
4079 {
4080 location_chain **nextp = &node->next;
4081
4082 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == REG)
4083 {
4084 attrs *list;
4085
4086 for (list = dst->regs[REGNO (node->loc)(rhs_regno(node->loc))]; list; list = list->next)
4087 if (GET_MODE (node->loc)((machine_mode) (node->loc)->mode) == GET_MODE (list->loc)((machine_mode) (list->loc)->mode)
4088 && dv_is_value_p (list->dv))
4089 break;
4090
4091 if (!list)
4092 attrs_list_insert (&dst->regs[REGNO (node->loc)(rhs_regno(node->loc))],
4093 dv, 0, node->loc);
4094 /* If this value became canonical for another value that had
4095 this register, we want to leave it alone. */
4096 else if (dv_as_value (list->dv) != val)
4097 {
4098 dstslot = set_slot_part (dst, dv_as_value (list->dv),
4099 dstslot, dv, 0,
4100 node->init, NULL_RTX(rtx) 0);
4101 dstslot = delete_slot_part (dst, node->loc, dstslot, 0);
4102
4103 /* Since nextp points into the removed node, we can't
4104 use it. The pointer to the next node moved to nodep.
4105 However, if the variable we're walking is unshared
4106 during our walk, we'll keep walking the location list
4107 of the previously-shared variable, in which case the
4108 node won't have been removed, and we'll want to skip
4109 it. That's why we test *nodep here. */
4110 if (*nodep != node)
4111 nextp = nodep;
4112 }
4113 }
4114 else
4115 /* Canonicalization puts registers first, so we don't have to
4116 walk it all. */
4117 break;
4118 nodep = nextp;
4119 }
4120
4121 if (dvar != *dstslot)
4122 dvar = *dstslot;
4123 nodep = &dvar->var_part[0].loc_chain;
4124
4125 if (val)
4126 {
4127 /* Mark all referenced nodes for canonicalization, and make sure
4128 we have mutual equivalence links. */
4129 VALUE_RECURSED_INTO (val)(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if (
((enum rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4129, __FUNCTION__); _rtx; })->used)
= true;
4130 for (node = *nodep; node; node = node->next)
4131 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE)
4132 {
4133 VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4133, __FUNCTION__); _rtx; })->used)
= true;
4134 set_variable_part (dst, val, dv_from_value (node->loc), 0,
4135 node->init, NULLnullptr, INSERT);
4136 }
4137
4138 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4139 gcc_assert (*dstslot == dvar)((void)(!(*dstslot == dvar) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4139, __FUNCTION__), 0 : 0))
;
4140 canonicalize_values_star (dstslot, dst);
4141 gcc_checking_assert (dstslot((void)(!(dstslot == shared_hash_find_slot_noinsert_1 (dst->
vars, dv, dvhash)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4143, __FUNCTION__), 0 : 0))
4142 == shared_hash_find_slot_noinsert_1 (dst->vars,((void)(!(dstslot == shared_hash_find_slot_noinsert_1 (dst->
vars, dv, dvhash)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4143, __FUNCTION__), 0 : 0))
4143 dv, dvhash))((void)(!(dstslot == shared_hash_find_slot_noinsert_1 (dst->
vars, dv, dvhash)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4143, __FUNCTION__), 0 : 0))
;
4144 dvar = *dstslot;
4145 }
4146 else
4147 {
4148 bool has_value = false, has_other = false;
4149
4150 /* If we have one value and anything else, we're going to
4151 canonicalize this, so make sure all values have an entry in
4152 the table and are marked for canonicalization. */
4153 for (node = *nodep; node; node = node->next)
4154 {
4155 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE)
4156 {
4157 /* If this was marked during register canonicalization,
4158 we know we have to canonicalize values. */
4159 if (has_value)
4160 has_other = true;
4161 has_value = true;
4162 if (has_other)
4163 break;
4164 }
4165 else
4166 {
4167 has_other = true;
4168 if (has_value)
4169 break;
4170 }
4171 }
4172
4173 if (has_value && has_other)
4174 {
4175 for (node = *nodep; node; node = node->next)
4176 {
4177 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE)
4178 {
4179 decl_or_value dv = dv_from_value (node->loc);
4180 variable **slot = NULLnullptr;
4181
4182 if (shared_hash_shared (dst->vars))
4183 slot = shared_hash_find_slot_noinsert (dst->vars, dv);
4184 if (!slot)
4185 slot = shared_hash_find_slot_unshare (&dst->vars, dv,
4186 INSERT);
4187 if (!*slot)
4188 {
4189 variable *var = onepart_pool_allocate (ONEPART_VALUE);
4190 var->dv = dv;
4191 var->refcount = 1;
4192 var->n_var_parts = 1;
4193 var->onepart = ONEPART_VALUE;
4194 var->in_changed_variables = false;
4195 var->var_part[0].loc_chain = NULLnullptr;
4196 var->var_part[0].cur_loc = NULLnullptr;
4197 VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4197, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
= NULLnullptr;
4198 *slot = var;
4199 }
4200
4201 VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4201, __FUNCTION__); _rtx; })->used)
= true;
4202 }
4203 }
4204
4205 dstslot = shared_hash_find_slot_noinsert_1 (dst->vars, dv, dvhash);
4206 gcc_assert (*dstslot == dvar)((void)(!(*dstslot == dvar) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4206, __FUNCTION__), 0 : 0))
;
4207 canonicalize_values_star (dstslot, dst);
4208 gcc_checking_assert (dstslot((void)(!(dstslot == shared_hash_find_slot_noinsert_1 (dst->
vars, dv, dvhash)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4210, __FUNCTION__), 0 : 0))
4209 == shared_hash_find_slot_noinsert_1 (dst->vars,((void)(!(dstslot == shared_hash_find_slot_noinsert_1 (dst->
vars, dv, dvhash)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4210, __FUNCTION__), 0 : 0))
4210 dv, dvhash))((void)(!(dstslot == shared_hash_find_slot_noinsert_1 (dst->
vars, dv, dvhash)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4210, __FUNCTION__), 0 : 0))
;
4211 dvar = *dstslot;
4212 }
4213 }
4214
4215 if (!onepart_variable_different_p (dvar, s2var))
4216 {
4217 variable_htab_free (dvar);
4218 *dstslot = dvar = s2var;
4219 dvar->refcount++;
4220 }
4221 else if (s2var != s1var && !onepart_variable_different_p (dvar, s1var))
4222 {
4223 variable_htab_free (dvar);
4224 *dstslot = dvar = s1var;
4225 dvar->refcount++;
4226 dst_can_be_shared = false;
4227 }
4228 else
4229 dst_can_be_shared = false;
4230
4231 return 1;
4232}
4233
4234/* Copy s2slot (in DSM->src) to DSM->dst if the variable is a
4235 multi-part variable. Unions of multi-part variables and
4236 intersections of one-part ones will be handled in
4237 variable_merge_over_cur(). */
4238
4239static int
4240variable_merge_over_src (variable *s2var, struct dfset_merge *dsm)
4241{
4242 dataflow_set *dst = dsm->dst;
4243 decl_or_value dv = s2var->dv;
4244
4245 if (!s2var->onepart)
4246 {
4247 variable **dstp = shared_hash_find_slot (dst->vars, dv);
4248 *dstp = s2var;
4249 s2var->refcount++;
4250 return 1;
4251 }
4252
4253 dsm->src_onepart_cnt++;
4254 return 1;
4255}
4256
4257/* Combine dataflow set information from SRC2 into DST, using PDST
4258 to carry over information across passes. */
4259
4260static void
4261dataflow_set_merge (dataflow_set *dst, dataflow_set *src2)
4262{
4263 dataflow_set cur = *dst;
4264 dataflow_set *src1 = &cur;
4265 struct dfset_merge dsm;
4266 int i;
4267 size_t src1_elems, src2_elems;
4268 variable_iterator_type hi;
4269 variable *var;
4270
4271 src1_elems = shared_hash_htab (src1->vars)->elements ();
4272 src2_elems = shared_hash_htab (src2->vars)->elements ();
4273 dataflow_set_init (dst);
4274 dst->stack_adjust = cur.stack_adjust;
4275 shared_hash_destroy (dst->vars);
4276 dst->vars = new shared_hash;
4277 dst->vars->refcount = 1;
4278 dst->vars->htab = new variable_table_type (MAX (src1_elems, src2_elems)((src1_elems) > (src2_elems) ? (src1_elems) : (src2_elems)
)
);
4279
4280 for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
4281 attrs_list_mpdv_union (&dst->regs[i], src1->regs[i], src2->regs[i]);
4282
4283 dsm.dst = dst;
4284 dsm.src = src2;
4285 dsm.cur = src1;
4286 dsm.src_onepart_cnt = 0;
4287
4288 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.src->vars),for ((hi) = (*shared_hash_htab (dsm.src->vars)).begin (); (
hi) != (*shared_hash_htab (dsm.src->vars)).end () ? (var =
*(hi) , true) : false; ++(hi))
4289 var, variable, hi)for ((hi) = (*shared_hash_htab (dsm.src->vars)).begin (); (
hi) != (*shared_hash_htab (dsm.src->vars)).end () ? (var =
*(hi) , true) : false; ++(hi))
4290 variable_merge_over_src (var, &dsm);
4291 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (dsm.cur->vars),for ((hi) = (*shared_hash_htab (dsm.cur->vars)).begin (); (
hi) != (*shared_hash_htab (dsm.cur->vars)).end () ? (var =
*(hi) , true) : false; ++(hi))
4292 var, variable, hi)for ((hi) = (*shared_hash_htab (dsm.cur->vars)).begin (); (
hi) != (*shared_hash_htab (dsm.cur->vars)).end () ? (var =
*(hi) , true) : false; ++(hi))
4293 variable_merge_over_cur (var, &dsm);
4294
4295 if (dsm.src_onepart_cnt)
4296 dst_can_be_shared = false;
4297
4298 dataflow_set_destroy (src1);
4299}
4300
4301/* Mark register equivalences. */
4302
4303static void
4304dataflow_set_equiv_regs (dataflow_set *set)
4305{
4306 int i;
4307 attrs *list, **listp;
4308
4309 for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
4310 {
4311 rtx canon[NUM_MACHINE_MODES];
4312
4313 /* If the list is empty or one entry, no need to canonicalize
4314 anything. */
4315 if (set->regs[i] == NULLnullptr || set->regs[i]->next == NULLnullptr)
4316 continue;
4317
4318 memset (canon, 0, sizeof (canon));
4319
4320 for (list = set->regs[i]; list; list = list->next)
4321 if (list->offset == 0 && dv_is_value_p (list->dv))
4322 {
4323 rtx val = dv_as_value (list->dv);
4324 rtx *cvalp = &canon[(int)GET_MODE (val)((machine_mode) (val)->mode)];
4325 rtx cval = *cvalp;
4326
4327 if (canon_value_cmp (val, cval))
4328 *cvalp = val;
4329 }
4330
4331 for (list = set->regs[i]; list; list = list->next)
4332 if (list->offset == 0 && dv_onepart_p (list->dv))
4333 {
4334 rtx cval = canon[(int)GET_MODE (list->loc)((machine_mode) (list->loc)->mode)];
4335
4336 if (!cval)
4337 continue;
4338
4339 if (dv_is_value_p (list->dv))
4340 {
4341 rtx val = dv_as_value (list->dv);
4342
4343 if (val == cval)
4344 continue;
4345
4346 VALUE_RECURSED_INTO (val)(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if (
((enum rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4346, __FUNCTION__); _rtx; })->used)
= true;
4347 set_variable_part (set, val, dv_from_value (cval), 0,
4348 VAR_INIT_STATUS_INITIALIZED,
4349 NULLnullptr, NO_INSERT);
4350 }
4351
4352 VALUE_RECURSED_INTO (cval)(__extension__ ({ __typeof ((cval)) const _rtx = ((cval)); if
(((enum rtx_code) (_rtx)->code) != VALUE && ((enum
rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4352, __FUNCTION__); _rtx; })->used)
= true;
4353 set_variable_part (set, cval, list->dv, 0,
4354 VAR_INIT_STATUS_INITIALIZED, NULLnullptr, NO_INSERT);
4355 }
4356
4357 for (listp = &set->regs[i]; (list = *listp);
4358 listp = list ? &list->next : listp)
4359 if (list->offset == 0 && dv_onepart_p (list->dv))
4360 {
4361 rtx cval = canon[(int)GET_MODE (list->loc)((machine_mode) (list->loc)->mode)];
4362 variable **slot;
4363
4364 if (!cval)
4365 continue;
4366
4367 if (dv_is_value_p (list->dv))
4368 {
4369 rtx val = dv_as_value (list->dv);
4370 if (!VALUE_RECURSED_INTO (val)(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if (
((enum rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4370, __FUNCTION__); _rtx; })->used)
)
4371 continue;
4372 }
4373
4374 slot = shared_hash_find_slot_noinsert (set->vars, list->dv);
4375 canonicalize_values_star (slot, set);
4376 if (*listp != list)
4377 list = NULLnullptr;
4378 }
4379 }
4380}
4381
4382/* Remove any redundant values in the location list of VAR, which must
4383 be unshared and 1-part. */
4384
4385static void
4386remove_duplicate_values (variable *var)
4387{
4388 location_chain *node, **nodep;
4389
4390 gcc_assert (var->onepart)((void)(!(var->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4390, __FUNCTION__), 0 : 0))
;
4391 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4391, __FUNCTION__), 0 : 0))
;
4392 gcc_assert (var->refcount == 1)((void)(!(var->refcount == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4392, __FUNCTION__), 0 : 0))
;
4393
4394 for (nodep = &var->var_part[0].loc_chain; (node = *nodep); )
4395 {
4396 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE)
4397 {
4398 if (VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4398, __FUNCTION__); _rtx; })->used)
)
4399 {
4400 /* Remove duplicate value node. */
4401 *nodep = node->next;
4402 delete node;
4403 continue;
4404 }
4405 else
4406 VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4406, __FUNCTION__); _rtx; })->used)
= true;
4407 }
4408 nodep = &node->next;
4409 }
4410
4411 for (node = var->var_part[0].loc_chain; node; node = node->next)
4412 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE)
4413 {
4414 gcc_assert (VALUE_RECURSED_INTO (node->loc))((void)(!((__extension__ ({ __typeof ((node->loc)) const _rtx
= ((node->loc)); if (((enum rtx_code) (_rtx)->code) !=
VALUE && ((enum rtx_code) (_rtx)->code) != DEBUG_EXPR
) rtl_check_failed_flag ("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4414, __FUNCTION__); _rtx; })->used)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4414, __FUNCTION__), 0 : 0))
;
4415 VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4415, __FUNCTION__); _rtx; })->used)
= false;
4416 }
4417}
4418
4419
4420/* Hash table iteration argument passed to variable_post_merge. */
4421struct dfset_post_merge
4422{
4423 /* The new input set for the current block. */
4424 dataflow_set *set;
4425 /* Pointer to the permanent input set for the current block, or
4426 NULL. */
4427 dataflow_set **permp;
4428};
4429
4430/* Create values for incoming expressions associated with one-part
4431 variables that don't have value numbers for them. */
4432
4433int
4434variable_post_merge_new_vals (variable **slot, dfset_post_merge *dfpm)
4435{
4436 dataflow_set *set = dfpm->set;
4437 variable *var = *slot;
4438 location_chain *node;
4439
4440 if (!var->onepart || !var->n_var_parts)
4441 return 1;
4442
4443 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4443, __FUNCTION__), 0 : 0))
;
4444
4445 if (dv_is_decl_p (var->dv))
4446 {
4447 bool check_dupes = false;
4448
4449 restart:
4450 for (node = var->var_part[0].loc_chain; node; node = node->next)
4451 {
4452 if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE)
4453 gcc_assert (!VALUE_RECURSED_INTO (node->loc))((void)(!(!(__extension__ ({ __typeof ((node->loc)) const _rtx
= ((node->loc)); if (((enum rtx_code) (_rtx)->code) !=
VALUE && ((enum rtx_code) (_rtx)->code) != DEBUG_EXPR
) rtl_check_failed_flag ("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4453, __FUNCTION__); _rtx; })->used)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4453, __FUNCTION__), 0 : 0))
;
4454 else if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == REG)
4455 {
4456 attrs *att, **attp, **curp = NULLnullptr;
4457
4458 if (var->refcount != 1)
4459 {
4460 slot = unshare_variable (set, slot, var,
4461 VAR_INIT_STATUS_INITIALIZED);
4462 var = *slot;
4463 goto restart;
4464 }
4465
4466 for (attp = &set->regs[REGNO (node->loc)(rhs_regno(node->loc))]; (att = *attp);
4467 attp = &att->next)
4468 if (att->offset == 0
4469 && GET_MODE (att->loc)((machine_mode) (att->loc)->mode) == GET_MODE (node->loc)((machine_mode) (node->loc)->mode))
4470 {
4471 if (dv_is_value_p (att->dv))
4472 {
4473 rtx cval = dv_as_value (att->dv);
4474 node->loc = cval;
4475 check_dupes = true;
4476 break;
4477 }
4478 else if (dv_as_opaque (att->dv) == dv_as_opaque (var->dv))
4479 curp = attp;
4480 }
4481
4482 if (!curp)
4483 {
4484 curp = attp;
4485 while (*curp)
4486 if ((*curp)->offset == 0
4487 && GET_MODE ((*curp)->loc)((machine_mode) ((*curp)->loc)->mode) == GET_MODE (node->loc)((machine_mode) (node->loc)->mode)
4488 && dv_as_opaque ((*curp)->dv) == dv_as_opaque (var->dv))
4489 break;
4490 else
4491 curp = &(*curp)->next;
4492 gcc_assert (*curp)((void)(!(*curp) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4492, __FUNCTION__), 0 : 0))
;
4493 }
4494
4495 if (!att)
4496 {
4497 decl_or_value cdv;
4498 rtx cval;
4499
4500 if (!*dfpm->permp)
4501 {
4502 *dfpm->permp = XNEW (dataflow_set)((dataflow_set *) xmalloc (sizeof (dataflow_set)));
4503 dataflow_set_init (*dfpm->permp);
4504 }
4505
4506 for (att = (*dfpm->permp)->regs[REGNO (node->loc)(rhs_regno(node->loc))];
4507 att; att = att->next)
4508 if (GET_MODE (att->loc)((machine_mode) (att->loc)->mode) == GET_MODE (node->loc)((machine_mode) (node->loc)->mode))
4509 {
4510 gcc_assert (att->offset == 0((void)(!(att->offset == 0 && dv_is_value_p (att->
dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4511, __FUNCTION__), 0 : 0))
4511 && dv_is_value_p (att->dv))((void)(!(att->offset == 0 && dv_is_value_p (att->
dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4511, __FUNCTION__), 0 : 0))
;
4512 val_reset (set, att->dv);
4513 break;
4514 }
4515
4516 if (att)
4517 {
4518 cdv = att->dv;
4519 cval = dv_as_value (cdv);
4520 }
4521 else
4522 {
4523 /* Create a unique value to hold this register,
4524 that ought to be found and reused in
4525 subsequent rounds. */
4526 cselib_val *v;
4527 gcc_assert (!cselib_lookup (node->loc,((void)(!(!cselib_lookup (node->loc, ((machine_mode) (node
->loc)->mode), 0, ((void) 0, E_VOIDmode))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4529, __FUNCTION__), 0 : 0))
4528 GET_MODE (node->loc), 0,((void)(!(!cselib_lookup (node->loc, ((machine_mode) (node
->loc)->mode), 0, ((void) 0, E_VOIDmode))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4529, __FUNCTION__), 0 : 0))
4529 VOIDmode))((void)(!(!cselib_lookup (node->loc, ((machine_mode) (node
->loc)->mode), 0, ((void) 0, E_VOIDmode))) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4529, __FUNCTION__), 0 : 0))
;
4530 v = cselib_lookup (node->loc, GET_MODE (node->loc)((machine_mode) (node->loc)->mode), 1,
4531 VOIDmode((void) 0, E_VOIDmode));
4532 cselib_preserve_value (v);
4533 cselib_invalidate_rtx (node->loc);
4534 cval = v->val_rtx;
4535 cdv = dv_from_value (cval);
4536 if (dump_file)
4537 fprintf (dump_file,
4538 "Created new value %u:%u for reg %i\n",
4539 v->uid, v->hash, REGNO (node->loc)(rhs_regno(node->loc)));
4540 }
4541
4542 var_reg_decl_set (*dfpm->permp, node->loc,
4543 VAR_INIT_STATUS_INITIALIZED,
4544 cdv, 0, NULLnullptr, INSERT);
4545
4546 node->loc = cval;
4547 check_dupes = true;
4548 }
4549
4550 /* Remove attribute referring to the decl, which now
4551 uses the value for the register, already existing or
4552 to be added when we bring perm in. */
4553 att = *curp;
4554 *curp = att->next;
4555 delete att;
4556 }
4557 }
4558
4559 if (check_dupes)
4560 remove_duplicate_values (var);
4561 }
4562
4563 return 1;
4564}
4565
4566/* Reset values in the permanent set that are not associated with the
4567 chosen expression. */
4568
4569int
4570variable_post_merge_perm_vals (variable **pslot, dfset_post_merge *dfpm)
4571{
4572 dataflow_set *set = dfpm->set;
4573 variable *pvar = *pslot, *var;
4574 location_chain *pnode;
4575 decl_or_value dv;
4576 attrs *att;
4577
4578 gcc_assert (dv_is_value_p (pvar->dv)((void)(!(dv_is_value_p (pvar->dv) && pvar->n_var_parts
== 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4579, __FUNCTION__), 0 : 0))
4579 && pvar->n_var_parts == 1)((void)(!(dv_is_value_p (pvar->dv) && pvar->n_var_parts
== 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4579, __FUNCTION__), 0 : 0))
;
4580 pnode = pvar->var_part[0].loc_chain;
4581 gcc_assert (pnode((void)(!(pnode && !pnode->next && (((enum
rtx_code) (pnode->loc)->code) == REG)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4583, __FUNCTION__), 0 : 0))
4582 && !pnode->next((void)(!(pnode && !pnode->next && (((enum
rtx_code) (pnode->loc)->code) == REG)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4583, __FUNCTION__), 0 : 0))
4583 && REG_P (pnode->loc))((void)(!(pnode && !pnode->next && (((enum
rtx_code) (pnode->loc)->code) == REG)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4583, __FUNCTION__), 0 : 0))
;
4584
4585 dv = pvar->dv;
4586
4587 var = shared_hash_find (set->vars, dv);
4588 if (var)
4589 {
4590 /* Although variable_post_merge_new_vals may have made decls
4591 non-star-canonical, values that pre-existed in canonical form
4592 remain canonical, and newly-created values reference a single
4593 REG, so they are canonical as well. Since VAR has the
4594 location list for a VALUE, using find_loc_in_1pdv for it is
4595 fine, since VALUEs don't map back to DECLs. */
4596 if (find_loc_in_1pdv (pnode->loc, var, shared_hash_htab (set->vars)))
4597 return 1;
4598 val_reset (set, dv);
4599 }
4600
4601 for (att = set->regs[REGNO (pnode->loc)(rhs_regno(pnode->loc))]; att; att = att->next)
4602 if (att->offset == 0
4603 && GET_MODE (att->loc)((machine_mode) (att->loc)->mode) == GET_MODE (pnode->loc)((machine_mode) (pnode->loc)->mode)
4604 && dv_is_value_p (att->dv))
4605 break;
4606
4607 /* If there is a value associated with this register already, create
4608 an equivalence. */
4609 if (att && dv_as_value (att->dv) != dv_as_value (dv))
4610 {
4611 rtx cval = dv_as_value (att->dv);
4612 set_variable_part (set, cval, dv, 0, pnode->init, NULLnullptr, INSERT);
4613 set_variable_part (set, dv_as_value (dv), att->dv, 0, pnode->init,
4614 NULLnullptr, INSERT);
4615 }
4616 else if (!att)
4617 {
4618 attrs_list_insert (&set->regs[REGNO (pnode->loc)(rhs_regno(pnode->loc))],
4619 dv, 0, pnode->loc);
4620 variable_union (pvar, set);
4621 }
4622
4623 return 1;
4624}
4625
4626/* Just checking stuff and registering register attributes for
4627 now. */
4628
4629static void
4630dataflow_post_merge_adjust (dataflow_set *set, dataflow_set **permp)
4631{
4632 struct dfset_post_merge dfpm;
4633
4634 dfpm.set = set;
4635 dfpm.permp = permp;
4636
4637 shared_hash_htab (set->vars)
4638 ->traverse <dfset_post_merge*, variable_post_merge_new_vals> (&dfpm);
4639 if (*permp)
4640 shared_hash_htab ((*permp)->vars)
4641 ->traverse <dfset_post_merge*, variable_post_merge_perm_vals> (&dfpm);
4642 shared_hash_htab (set->vars)
4643 ->traverse <dataflow_set *, canonicalize_values_star> (set);
4644 shared_hash_htab (set->vars)
4645 ->traverse <dataflow_set *, canonicalize_vars_star> (set);
4646}
4647
4648/* Return a node whose loc is a MEM that refers to EXPR in the
4649 location list of a one-part variable or value VAR, or in that of
4650 any values recursively mentioned in the location lists. */
4651
4652static location_chain *
4653find_mem_expr_in_1pdv (tree expr, rtx val, variable_table_type *vars)
4654{
4655 location_chain *node;
4656 decl_or_value dv;
4657 variable *var;
4658 location_chain *where = NULLnullptr;
4659
4660 if (!val)
4661 return NULLnullptr;
4662
4663 gcc_assert (GET_CODE (val) == VALUE((void)(!(((enum rtx_code) (val)->code) == VALUE &&
!(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if
(((enum rtx_code) (_rtx)->code) != VALUE && ((enum
rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4664, __FUNCTION__); _rtx; })->used)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4664, __FUNCTION__), 0 : 0))
4664 && !VALUE_RECURSED_INTO (val))((void)(!(((enum rtx_code) (val)->code) == VALUE &&
!(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if
(((enum rtx_code) (_rtx)->code) != VALUE && ((enum
rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4664, __FUNCTION__); _rtx; })->used)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4664, __FUNCTION__), 0 : 0))
;
4665
4666 dv = dv_from_value (val);
4667 var = vars->find_with_hash (dv, dv_htab_hash (dv));
4668
4669 if (!var)
4670 return NULLnullptr;
4671
4672 gcc_assert (var->onepart)((void)(!(var->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4672, __FUNCTION__), 0 : 0))
;
4673
4674 if (!var->n_var_parts)
4675 return NULLnullptr;
4676
4677 VALUE_RECURSED_INTO (val)(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if (
((enum rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4677, __FUNCTION__); _rtx; })->used)
= true;
4678
4679 for (node = var->var_part[0].loc_chain; node; node = node->next)
4680 if (MEM_P (node->loc)(((enum rtx_code) (node->loc)->code) == MEM)
4681 && MEM_EXPR (node->loc)(get_mem_attrs (node->loc)->expr) == expr
4682 && int_mem_offset (node->loc) == 0)
4683 {
4684 where = node;
4685 break;
4686 }
4687 else if (GET_CODE (node->loc)((enum rtx_code) (node->loc)->code) == VALUE
4688 && !VALUE_RECURSED_INTO (node->loc)(__extension__ ({ __typeof ((node->loc)) const _rtx = ((node
->loc)); if (((enum rtx_code) (_rtx)->code) != VALUE &&
((enum rtx_code) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag
("VALUE_RECURSED_INTO",_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4688, __FUNCTION__); _rtx; })->used)
4689 && (where = find_mem_expr_in_1pdv (expr, node->loc, vars)))
4690 break;
4691
4692 VALUE_RECURSED_INTO (val)(__extension__ ({ __typeof ((val)) const _rtx = ((val)); if (
((enum rtx_code) (_rtx)->code) != VALUE && ((enum rtx_code
) (_rtx)->code) != DEBUG_EXPR) rtl_check_failed_flag ("VALUE_RECURSED_INTO"
,_rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4692, __FUNCTION__); _rtx; })->used)
= false;
4693
4694 return where;
4695}
4696
4697/* Return TRUE if the value of MEM may vary across a call. */
4698
4699static bool
4700mem_dies_at_call (rtx mem)
4701{
4702 tree expr = MEM_EXPR (mem)(get_mem_attrs (mem)->expr);
4703 tree decl;
4704
4705 if (!expr)
4706 return true;
4707
4708 decl = get_base_address (expr);
4709
4710 if (!decl)
4711 return true;
4712
4713 if (!DECL_P (decl)(tree_code_type[(int) (((enum tree_code) (decl)->base.code
))] == tcc_declaration)
)
4714 return true;
4715
4716 return (may_be_aliased (decl)
4717 || (!TREE_READONLY (decl)((non_type_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4717, __FUNCTION__))->base.readonly_flag)
&& is_global_var (decl)));
4718}
4719
4720/* Remove all MEMs from the location list of a hash table entry for a
4721 one-part variable, except those whose MEM attributes map back to
4722 the variable itself, directly or within a VALUE. */
4723
4724int
4725dataflow_set_preserve_mem_locs (variable **slot, dataflow_set *set)
4726{
4727 variable *var = *slot;
4728
4729 if (var->onepart == ONEPART_VDECL || var->onepart == ONEPART_DEXPR)
4730 {
4731 tree decl = dv_as_decl (var->dv);
4732 location_chain *loc, **locp;
4733 bool changed = false;
4734
4735 if (!var->n_var_parts)
4736 return 1;
4737
4738 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4738, __FUNCTION__), 0 : 0))
;
4739
4740 if (shared_var_p (var, set->vars))
4741 {
4742 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4743 {
4744 /* We want to remove dying MEMs that don't refer to DECL. */
4745 if (GET_CODE (loc->loc)((enum rtx_code) (loc->loc)->code) == MEM
4746 && (MEM_EXPR (loc->loc)(get_mem_attrs (loc->loc)->expr) != decl
4747 || int_mem_offset (loc->loc) != 0)
4748 && mem_dies_at_call (loc->loc))
4749 break;
4750 /* We want to move here MEMs that do refer to DECL. */
4751 else if (GET_CODE (loc->loc)((enum rtx_code) (loc->loc)->code) == VALUE
4752 && find_mem_expr_in_1pdv (decl, loc->loc,
4753 shared_hash_htab (set->vars)))
4754 break;
4755 }
4756
4757 if (!loc)
4758 return 1;
4759
4760 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4761 var = *slot;
4762 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4762, __FUNCTION__), 0 : 0))
;
4763 }
4764
4765 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4766 loc; loc = *locp)
4767 {
4768 rtx old_loc = loc->loc;
4769 if (GET_CODE (old_loc)((enum rtx_code) (old_loc)->code) == VALUE)
4770 {
4771 location_chain *mem_node
4772 = find_mem_expr_in_1pdv (decl, loc->loc,
4773 shared_hash_htab (set->vars));
4774
4775 /* ??? This picks up only one out of multiple MEMs that
4776 refer to the same variable. Do we ever need to be
4777 concerned about dealing with more than one, or, given
4778 that they should all map to the same variable
4779 location, their addresses will have been merged and
4780 they will be regarded as equivalent? */
4781 if (mem_node)
4782 {
4783 loc->loc = mem_node->loc;
4784 loc->set_src = mem_node->set_src;
4785 loc->init = MIN (loc->init, mem_node->init)((loc->init) < (mem_node->init) ? (loc->init) : (
mem_node->init))
;
4786 }
4787 }
4788
4789 if (GET_CODE (loc->loc)((enum rtx_code) (loc->loc)->code) != MEM
4790 || (MEM_EXPR (loc->loc)(get_mem_attrs (loc->loc)->expr) == decl
4791 && int_mem_offset (loc->loc) == 0)
4792 || !mem_dies_at_call (loc->loc))
4793 {
4794 if (old_loc != loc->loc && emit_notes)
4795 {
4796 if (old_loc == var->var_part[0].cur_loc)
4797 {
4798 changed = true;
4799 var->var_part[0].cur_loc = NULLnullptr;
4800 }
4801 }
4802 locp = &loc->next;
4803 continue;
4804 }
4805
4806 if (emit_notes)
4807 {
4808 if (old_loc == var->var_part[0].cur_loc)
4809 {
4810 changed = true;
4811 var->var_part[0].cur_loc = NULLnullptr;
4812 }
4813 }
4814 *locp = loc->next;
4815 delete loc;
4816 }
4817
4818 if (!var->var_part[0].loc_chain)
4819 {
4820 var->n_var_parts--;
4821 changed = true;
4822 }
4823 if (changed)
4824 variable_was_changed (var, set);
4825 }
4826
4827 return 1;
4828}
4829
4830/* Remove all MEMs from the location list of a hash table entry for a
4831 onepart variable. */
4832
4833int
4834dataflow_set_remove_mem_locs (variable **slot, dataflow_set *set)
4835{
4836 variable *var = *slot;
4837
4838 if (var->onepart != NOT_ONEPART)
4839 {
4840 location_chain *loc, **locp;
4841 bool changed = false;
4842 rtx cur_loc;
4843
4844 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4844, __FUNCTION__), 0 : 0))
;
4845
4846 if (shared_var_p (var, set->vars))
4847 {
4848 for (loc = var->var_part[0].loc_chain; loc; loc = loc->next)
4849 if (GET_CODE (loc->loc)((enum rtx_code) (loc->loc)->code) == MEM
4850 && mem_dies_at_call (loc->loc))
4851 break;
4852
4853 if (!loc)
4854 return 1;
4855
4856 slot = unshare_variable (set, slot, var, VAR_INIT_STATUS_UNKNOWN);
4857 var = *slot;
4858 gcc_assert (var->n_var_parts == 1)((void)(!(var->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4858, __FUNCTION__), 0 : 0))
;
4859 }
4860
4861 if (VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4861, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
)
4862 cur_loc = VAR_LOC_FROM (var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4862, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))->from)
;
4863 else
4864 cur_loc = var->var_part[0].cur_loc;
4865
4866 for (locp = &var->var_part[0].loc_chain, loc = *locp;
4867 loc; loc = *locp)
4868 {
4869 if (GET_CODE (loc->loc)((enum rtx_code) (loc->loc)->code) != MEM
4870 || !mem_dies_at_call (loc->loc))
4871 {
4872 locp = &loc->next;
4873 continue;
4874 }
4875
4876 *locp = loc->next;
4877 /* If we have deleted the location which was last emitted
4878 we have to emit new location so add the variable to set
4879 of changed variables. */
4880 if (cur_loc == loc->loc)
4881 {
4882 changed = true;
4883 var->var_part[0].cur_loc = NULLnullptr;
4884 if (VAR_LOC_1PAUX (var)__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4884, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))
)
4885 VAR_LOC_FROM (var)(__extension__ (*({ variable *const __v = (var); ((void)(!(__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4885, __FUNCTION__), 0 : 0)); &__v->var_part[0].aux.
onepaux; }))->from)
= NULLnullptr;
4886 }
4887 delete loc;
4888 }
4889
4890 if (!var->var_part[0].loc_chain)
4891 {
4892 var->n_var_parts--;
4893 changed = true;
4894 }
4895 if (changed)
4896 variable_was_changed (var, set);
4897 }
4898
4899 return 1;
4900}
4901
4902/* Remove all variable-location information about call-clobbered
4903 registers, as well as associations between MEMs and VALUEs. */
4904
4905static void
4906dataflow_set_clear_at_call (dataflow_set *set, rtx_insn *call_insn)
4907{
4908 unsigned int r;
4909 hard_reg_set_iterator hrsi;
4910
4911 HARD_REG_SET callee_clobbers
4912 = insn_callee_abi (call_insn).full_reg_clobbers ();
4913
4914 EXECUTE_IF_SET_IN_HARD_REG_SET (callee_clobbers, 0, r, hrsi)for (hard_reg_set_iter_init (&(hrsi), (callee_clobbers), (
0), &(r)); hard_reg_set_iter_set (&(hrsi), &(r));
hard_reg_set_iter_next (&(hrsi), &(r)))
4915 var_regno_delete (set, r);
4916
4917 if (MAY_HAVE_DEBUG_BIND_INSNSglobal_options.x_flag_var_tracking_assignments)
4918 {
4919 set->traversed_vars = set->vars;
4920 shared_hash_htab (set->vars)
4921 ->traverse <dataflow_set *, dataflow_set_preserve_mem_locs> (set);
4922 set->traversed_vars = set->vars;
4923 shared_hash_htab (set->vars)
4924 ->traverse <dataflow_set *, dataflow_set_remove_mem_locs> (set);
4925 set->traversed_vars = NULLnullptr;
4926 }
4927}
4928
4929static bool
4930variable_part_different_p (variable_part *vp1, variable_part *vp2)
4931{
4932 location_chain *lc1, *lc2;
4933
4934 for (lc1 = vp1->loc_chain; lc1; lc1 = lc1->next)
4935 {
4936 for (lc2 = vp2->loc_chain; lc2; lc2 = lc2->next)
4937 {
4938 if (REG_P (lc1->loc)(((enum rtx_code) (lc1->loc)->code) == REG) && REG_P (lc2->loc)(((enum rtx_code) (lc2->loc)->code) == REG))
4939 {
4940 if (REGNO (lc1->loc)(rhs_regno(lc1->loc)) == REGNO (lc2->loc)(rhs_regno(lc2->loc)))
4941 break;
4942 }
4943 if (rtx_equal_p (lc1->loc, lc2->loc))
4944 break;
4945 }
4946 if (!lc2)
4947 return true;
4948 }
4949 return false;
4950}
4951
4952/* Return true if one-part variables VAR1 and VAR2 are different.
4953 They must be in canonical order. */
4954
4955static bool
4956onepart_variable_different_p (variable *var1, variable *var2)
4957{
4958 location_chain *lc1, *lc2;
4959
4960 if (var1 == var2)
4961 return false;
4962
4963 gcc_assert (var1->n_var_parts == 1((void)(!(var1->n_var_parts == 1 && var2->n_var_parts
== 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4964, __FUNCTION__), 0 : 0))
4964 && var2->n_var_parts == 1)((void)(!(var1->n_var_parts == 1 && var2->n_var_parts
== 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4964, __FUNCTION__), 0 : 0))
;
4965
4966 lc1 = var1->var_part[0].loc_chain;
4967 lc2 = var2->var_part[0].loc_chain;
4968
4969 gcc_assert (lc1 && lc2)((void)(!(lc1 && lc2) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4969, __FUNCTION__), 0 : 0))
;
4970
4971 while (lc1 && lc2)
4972 {
4973 if (loc_cmp (lc1->loc, lc2->loc))
4974 return true;
4975 lc1 = lc1->next;
4976 lc2 = lc2->next;
4977 }
4978
4979 return lc1 != lc2;
4980}
4981
4982/* Return true if one-part variables VAR1 and VAR2 are different.
4983 They must be in canonical order. */
4984
4985static void
4986dump_onepart_variable_differences (variable *var1, variable *var2)
4987{
4988 location_chain *lc1, *lc2;
4989
4990 gcc_assert (var1 != var2)((void)(!(var1 != var2) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4990, __FUNCTION__), 0 : 0))
;
4991 gcc_assert (dump_file)((void)(!(dump_file) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4991, __FUNCTION__), 0 : 0))
;
4992 gcc_assert (dv_as_opaque (var1->dv) == dv_as_opaque (var2->dv))((void)(!(dv_as_opaque (var1->dv) == dv_as_opaque (var2->
dv)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4992, __FUNCTION__), 0 : 0))
;
4993 gcc_assert (var1->n_var_parts == 1((void)(!(var1->n_var_parts == 1 && var2->n_var_parts
== 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4994, __FUNCTION__), 0 : 0))
4994 && var2->n_var_parts == 1)((void)(!(var1->n_var_parts == 1 && var2->n_var_parts
== 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4994, __FUNCTION__), 0 : 0))
;
4995
4996 lc1 = var1->var_part[0].loc_chain;
4997 lc2 = var2->var_part[0].loc_chain;
4998
4999 gcc_assert (lc1 && lc2)((void)(!(lc1 && lc2) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 4999, __FUNCTION__), 0 : 0))
;
5000
5001 while (lc1 && lc2)
5002 {
5003 switch (loc_cmp (lc1->loc, lc2->loc))
5004 {
5005 case -1:
5006 fprintf (dump_file, "removed: ");
5007 print_rtl_single (dump_file, lc1->loc);
5008 lc1 = lc1->next;
5009 continue;
5010 case 0:
5011 break;
5012 case 1:
5013 fprintf (dump_file, "added: ");
5014 print_rtl_single (dump_file, lc2->loc);
5015 lc2 = lc2->next;
5016 continue;
5017 default:
5018 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5018, __FUNCTION__))
;
5019 }
5020 lc1 = lc1->next;
5021 lc2 = lc2->next;
5022 }
5023
5024 while (lc1)
5025 {
5026 fprintf (dump_file, "removed: ");
5027 print_rtl_single (dump_file, lc1->loc);
5028 lc1 = lc1->next;
5029 }
5030
5031 while (lc2)
5032 {
5033 fprintf (dump_file, "added: ");
5034 print_rtl_single (dump_file, lc2->loc);
5035 lc2 = lc2->next;
5036 }
5037}
5038
5039/* Return true if variables VAR1 and VAR2 are different. */
5040
5041static bool
5042variable_different_p (variable *var1, variable *var2)
5043{
5044 int i;
5045
5046 if (var1 == var2)
5047 return false;
5048
5049 if (var1->onepart != var2->onepart)
5050 return true;
5051
5052 if (var1->n_var_parts != var2->n_var_parts)
5053 return true;
5054
5055 if (var1->onepart && var1->n_var_parts)
5056 {
5057 gcc_checking_assert (dv_as_opaque (var1->dv) == dv_as_opaque (var2->dv)((void)(!(dv_as_opaque (var1->dv) == dv_as_opaque (var2->
dv) && var1->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5058, __FUNCTION__), 0 : 0))
5058 && var1->n_var_parts == 1)((void)(!(dv_as_opaque (var1->dv) == dv_as_opaque (var2->
dv) && var1->n_var_parts == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5058, __FUNCTION__), 0 : 0))
;
5059 /* One-part values have locations in a canonical order. */
5060 return onepart_variable_different_p (var1, var2);
5061 }
5062
5063 for (i = 0; i < var1->n_var_parts; i++)
5064 {
5065 if (VAR_PART_OFFSET (var1, i)__extension__ (*({ variable *const __v = (var1); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5065, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
!= VAR_PART_OFFSET (var2, i)__extension__ (*({ variable *const __v = (var2); ((void)(!(!__v
->onepart) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5065, __FUNCTION__), 0 : 0)); &__v->var_part[(i)].aux
.offset; }))
)
5066 return true;
5067 if (variable_part_different_p (&var1->var_part[i], &var2->var_part[i]))
5068 return true;
5069 if (variable_part_different_p (&var2->var_part[i], &var1->var_part[i]))
5070 return true;
5071 }
5072 return false;
5073}
5074
5075/* Return true if dataflow sets OLD_SET and NEW_SET differ. */
5076
5077static bool
5078dataflow_set_different (dataflow_set *old_set, dataflow_set *new_set)
5079{
5080 variable_iterator_type hi;
5081 variable *var1;
5082 bool diffound = false;
5083 bool details = (dump_file && (dump_flags & TDF_DETAILS));
5084
5085#define RETRUE \
5086 do \
5087 { \
5088 if (!details) \
5089 return true; \
5090 else \
5091 diffound = true; \
5092 } \
5093 while (0)
5094
5095 if (old_set->vars == new_set->vars)
5096 return false;
5097
5098 if (shared_hash_htab (old_set->vars)->elements ()
5099 != shared_hash_htab (new_set->vars)->elements ())
5100 RETRUE;
5101
5102 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (old_set->vars),for ((hi) = (*shared_hash_htab (old_set->vars)).begin (); (
hi) != (*shared_hash_htab (old_set->vars)).end () ? (var1 =
*(hi) , true) : false; ++(hi))
5103 var1, variable, hi)for ((hi) = (*shared_hash_htab (old_set->vars)).begin (); (
hi) != (*shared_hash_htab (old_set->vars)).end () ? (var1 =
*(hi) , true) : false; ++(hi))
5104 {
5105 variable_table_type *htab = shared_hash_htab (new_set->vars);
5106 variable *var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv));
5107
5108 if (!var2)
5109 {
5110 if (dump_file && (dump_flags & TDF_DETAILS))
5111 {
5112 fprintf (dump_file, "dataflow difference found: removal of:\n");
5113 dump_var (var1);
5114 }
5115 RETRUE;
5116 }
5117 else if (variable_different_p (var1, var2))
5118 {
5119 if (details)
5120 {
5121 fprintf (dump_file, "dataflow difference found: "
5122 "old and new follow:\n");
5123 dump_var (var1);
5124 if (dv_onepart_p (var1->dv))
5125 dump_onepart_variable_differences (var1, var2);
5126 dump_var (var2);
5127 }
5128 RETRUE;
5129 }
5130 }
5131
5132 /* There's no need to traverse the second hashtab unless we want to
5133 print the details. If both have the same number of elements and
5134 the second one had all entries found in the first one, then the
5135 second can't have any extra entries. */
5136 if (!details)
5137 return diffound;
5138
5139 FOR_EACH_HASH_TABLE_ELEMENT (*shared_hash_htab (new_set->vars),for ((hi) = (*shared_hash_htab (new_set->vars)).begin (); (
hi) != (*shared_hash_htab (new_set->vars)).end () ? (var1 =
*(hi) , true) : false; ++(hi))
5140 var1, variable, hi)for ((hi) = (*shared_hash_htab (new_set->vars)).begin (); (
hi) != (*shared_hash_htab (new_set->vars)).end () ? (var1 =
*(hi) , true) : false; ++(hi))
5141 {
5142 variable_table_type *htab = shared_hash_htab (old_set->vars);
5143 variable *var2 = htab->find_with_hash (var1->dv, dv_htab_hash (var1->dv));
5144 if (!var2)
5145 {
5146 if (details)
5147 {
5148 fprintf (dump_file, "dataflow difference found: addition of:\n");
5149 dump_var (var1);
5150 }
5151 RETRUE;
5152 }
5153 }
5154
5155#undef RETRUE
5156
5157 return diffound;
5158}
5159
5160/* Free the contents of dataflow set SET. */
5161
5162static void
5163dataflow_set_destroy (dataflow_set *set)
5164{
5165 int i;
5166
5167 for (i = 0; i < FIRST_PSEUDO_REGISTER76; i++)
5168 attrs_list_clear (&set->regs[i]);
5169
5170 shared_hash_destroy (set->vars);
5171 set->vars = NULLnullptr;
5172}
5173
5174/* Return true if T is a tracked parameter with non-degenerate record type. */
5175
5176static bool
5177tracked_record_parameter_p (tree t)
5178{
5179 if (TREE_CODE (t)((enum tree_code) (t)->base.code) != PARM_DECL)
5180 return false;
5181
5182 if (DECL_MODE (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5182, __FUNCTION__))->decl_common.mode)
== BLKmode((void) 0, E_BLKmode))
5183 return false;
5184
5185 tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5185, __FUNCTION__))->typed.type)
;
5186 if (TREE_CODE (type)((enum tree_code) (type)->base.code) != RECORD_TYPE)
5187 return false;
5188
5189 if (TYPE_FIELDS (type)((tree_check3 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5189, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)
== NULL_TREE(tree) nullptr
5190 || DECL_CHAIN (TYPE_FIELDS (type))(((contains_struct_check (((contains_struct_check ((((tree_check3
((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5190, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values)), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5190, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5190, __FUNCTION__))->common.chain))
== NULL_TREE(tree) nullptr)
5191 return false;
5192
5193 return true;
5194}
5195
5196/* Shall EXPR be tracked? */
5197
5198static bool
5199track_expr_p (tree expr, bool need_rtl)
5200{
5201 rtx decl_rtl;
5202 tree realdecl;
5203
5204 if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == DEBUG_EXPR_DECL)
5205 return DECL_RTL_SET_P (expr)(((tree_contains_struct[(((enum tree_code) (expr)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((expr
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5205, __FUNCTION__))->decl_with_rtl.rtl != nullptr)
;
5206
5207 /* If EXPR is not a parameter or a variable do not track it. */
5208 if (!VAR_P (expr)(((enum tree_code) (expr)->base.code) == VAR_DECL) && TREE_CODE (expr)((enum tree_code) (expr)->base.code) != PARM_DECL)
5209 return 0;
5210
5211 /* It also must have a name... */
5212 if (!DECL_NAME (expr)((contains_struct_check ((expr), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5212, __FUNCTION__))->decl_minimal.name)
&& need_rtl)
5213 return 0;
5214
5215 /* ... and a RTL assigned to it. */
5216 decl_rtl = DECL_RTL_IF_SET (expr)((((tree_contains_struct[(((enum tree_code) (expr)->base.code
))][(TS_DECL_WRTL)])) && (contains_struct_check ((expr
), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5216, __FUNCTION__))->decl_with_rtl.rtl != nullptr) ? ((
contains_struct_check ((expr), (TS_DECL_WRTL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5216, __FUNCTION__))->decl_with_rtl.rtl ? (expr)->decl_with_rtl
.rtl : (make_decl_rtl (expr), (expr)->decl_with_rtl.rtl)) :
nullptr)
;
5217 if (!decl_rtl && need_rtl)
5218 return 0;
5219
5220 /* If this expression is really a debug alias of some other declaration, we
5221 don't need to track this expression if the ultimate declaration is
5222 ignored. */
5223 realdecl = expr;
5224 if (VAR_P (realdecl)(((enum tree_code) (realdecl)->base.code) == VAR_DECL) && DECL_HAS_DEBUG_EXPR_P (realdecl)((tree_check ((realdecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5224, __FUNCTION__, (VAR_DECL)))->decl_common.debug_expr_is_from
)
)
5225 {
5226 realdecl = DECL_DEBUG_EXPR (realdecl)(decl_debug_expr_lookup ((tree_check ((realdecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5226, __FUNCTION__, (VAR_DECL)))))
;
5227 if (!DECL_P (realdecl)(tree_code_type[(int) (((enum tree_code) (realdecl)->base.
code))] == tcc_declaration)
)
5228 {
5229 if (handled_component_p (realdecl)
5230 || (TREE_CODE (realdecl)((enum tree_code) (realdecl)->base.code) == MEM_REF
5231 && TREE_CODE (TREE_OPERAND (realdecl, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((realdecl), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5231, __FUNCTION__))))))->base.code)
== ADDR_EXPR))
5232 {
5233 HOST_WIDE_INTlong bitsize, bitpos;
5234 bool reverse;
5235 tree innerdecl
5236 = get_ref_base_and_extent_hwi (realdecl, &bitpos,
5237 &bitsize, &reverse);
5238 if (!innerdecl
5239 || !DECL_P (innerdecl)(tree_code_type[(int) (((enum tree_code) (innerdecl)->base
.code))] == tcc_declaration)
5240 || DECL_IGNORED_P (innerdecl)((contains_struct_check ((innerdecl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5240, __FUNCTION__))->decl_common.ignored_flag)
5241 /* Do not track declarations for parts of tracked record
5242 parameters since we want to track them as a whole. */
5243 || tracked_record_parameter_p (innerdecl)
5244 || TREE_STATIC (innerdecl)((innerdecl)->base.static_flag)
5245 || bitsize == 0
5246 || bitpos + bitsize > 256)
5247 return 0;
5248 else
5249 realdecl = expr;
5250 }
5251 else
5252 return 0;
5253 }
5254 }
5255
5256 /* Do not track EXPR if REALDECL it should be ignored for debugging
5257 purposes. */
5258 if (DECL_IGNORED_P (realdecl)((contains_struct_check ((realdecl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5258, __FUNCTION__))->decl_common.ignored_flag)
)
5259 return 0;
5260
5261 /* Do not track global variables until we are able to emit correct location
5262 list for them. */
5263 if (TREE_STATIC (realdecl)((realdecl)->base.static_flag))
5264 return 0;
5265
5266 /* When the EXPR is a DECL for alias of some variable (see example)
5267 the TREE_STATIC flag is not used. Disable tracking all DECLs whose
5268 DECL_RTL contains SYMBOL_REF.
5269
5270 Example:
5271 extern char **_dl_argv_internal __attribute__ ((alias ("_dl_argv")));
5272 char **_dl_argv;
5273 */
5274 if (decl_rtl && MEM_P (decl_rtl)(((enum rtx_code) (decl_rtl)->code) == MEM)
5275 && contains_symbol_ref_p (XEXP (decl_rtl, 0)(((decl_rtl)->u.fld[0]).rt_rtx)))
5276 return 0;
5277
5278 /* If RTX is a memory it should not be very large (because it would be
5279 an array or struct). */
5280 if (decl_rtl && MEM_P (decl_rtl)(((enum rtx_code) (decl_rtl)->code) == MEM))
5281 {
5282 /* Do not track structures and arrays. */
5283 if ((GET_MODE (decl_rtl)((machine_mode) (decl_rtl)->mode) == BLKmode((void) 0, E_BLKmode)
5284 || AGGREGATE_TYPE_P (TREE_TYPE (realdecl))(((enum tree_code) (((contains_struct_check ((realdecl), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5284, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
|| (((enum tree_code) (((contains_struct_check ((realdecl), (
TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5284, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
|| ((enum tree_code) (((contains_struct_check ((realdecl), (
TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5284, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
|| ((enum tree_code) (((contains_struct_check ((realdecl), (
TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5284, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))
)
5285 && !tracked_record_parameter_p (realdecl))
5286 return 0;
5287 if (MEM_SIZE_KNOWN_P (decl_rtl)(get_mem_attrs (decl_rtl)->size_known_p)
5288 && maybe_gt (MEM_SIZE (decl_rtl), MAX_VAR_PARTS)maybe_lt (16, (get_mem_attrs (decl_rtl)->size)))
5289 return 0;
5290 }
5291
5292 DECL_CHANGED (expr)((expr)->base.visited) = 0;
5293 DECL_CHANGED (realdecl)((realdecl)->base.visited) = 0;
5294 return 1;
5295}
5296
5297/* Determine whether a given LOC refers to the same variable part as
5298 EXPR+OFFSET. */
5299
5300static bool
5301same_variable_part_p (rtx loc, tree expr, poly_int64 offset)
5302{
5303 tree expr2;
5304 poly_int64 offset2;
5305
5306 if (! DECL_P (expr)(tree_code_type[(int) (((enum tree_code) (expr)->base.code
))] == tcc_declaration)
)
5307 return false;
5308
5309 if (REG_P (loc)(((enum rtx_code) (loc)->code) == REG))
5310 {
5311 expr2 = REG_EXPR (loc)(((&(loc)->u.reg)->attrs) == 0 ? 0 : ((&(loc)->
u.reg)->attrs)->decl)
;
5312 offset2 = REG_OFFSET (loc)(((&(loc)->u.reg)->attrs) == 0 ? 0 : ((&(loc)->
u.reg)->attrs)->offset)
;
5313 }
5314 else if (MEM_P (loc)(((enum rtx_code) (loc)->code) == MEM))
5315 {
5316 expr2 = MEM_EXPR (loc)(get_mem_attrs (loc)->expr);
5317 offset2 = int_mem_offset (loc);
5318 }
5319 else
5320 return false;
5321
5322 if (! expr2 || ! DECL_P (expr2)(tree_code_type[(int) (((enum tree_code) (expr2)->base.code
))] == tcc_declaration)
)
5323 return false;
5324
5325 expr = var_debug_decl (expr);
5326 expr2 = var_debug_decl (expr2);
5327
5328 return (expr == expr2 && known_eq (offset, offset2)(!maybe_ne (offset, offset2)));
5329}
5330
5331/* LOC is a REG or MEM that we would like to track if possible.
5332 If EXPR is null, we don't know what expression LOC refers to,
5333 otherwise it refers to EXPR + OFFSET. STORE_REG_P is true if
5334 LOC is an lvalue register.
5335
5336 Return true if EXPR is nonnull and if LOC, or some lowpart of it,
5337 is something we can track. When returning true, store the mode of
5338 the lowpart we can track in *MODE_OUT (if nonnull) and its offset
5339 from EXPR in *OFFSET_OUT (if nonnull). */
5340
5341static bool
5342track_loc_p (rtx loc, tree expr, poly_int64 offset, bool store_reg_p,
5343 machine_mode *mode_out, HOST_WIDE_INTlong *offset_out)
5344{
5345 machine_mode mode;
5346
5347 if (expr == NULLnullptr || !track_expr_p (expr, true))
5348 return false;
5349
5350 /* If REG was a paradoxical subreg, its REG_ATTRS will describe the
5351 whole subreg, but only the old inner part is really relevant. */
5352 mode = GET_MODE (loc)((machine_mode) (loc)->mode);
5353 if (REG_P (loc)(((enum rtx_code) (loc)->code) == REG) && !HARD_REGISTER_NUM_P (ORIGINAL_REGNO (loc))(((__extension__ ({ __typeof ((loc)) const _rtx = ((loc)); if
(((enum rtx_code) (_rtx)->code) != REG) rtl_check_failed_flag
("ORIGINAL_REGNO", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5353, __FUNCTION__); _rtx; })->u2.original_regno)) < 76
)
)
5354 {
5355 machine_mode pseudo_mode;
5356
5357 pseudo_mode = PSEUDO_REGNO_MODE (ORIGINAL_REGNO (loc))((machine_mode) (regno_reg_rtx[(__extension__ ({ __typeof ((loc
)) const _rtx = ((loc)); if (((enum rtx_code) (_rtx)->code
) != REG) rtl_check_failed_flag ("ORIGINAL_REGNO", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5357, __FUNCTION__); _rtx; })->u2.original_regno)])->
mode)
;
5358 if (paradoxical_subreg_p (mode, pseudo_mode))
5359 {
5360 offset += byte_lowpart_offset (pseudo_mode, mode);
5361 mode = pseudo_mode;
5362 }
5363 }
5364
5365 /* If LOC is a paradoxical lowpart of EXPR, refer to EXPR itself.
5366 Do the same if we are storing to a register and EXPR occupies
5367 the whole of register LOC; in that case, the whole of EXPR is
5368 being changed. We exclude complex modes from the second case
5369 because the real and imaginary parts are represented as separate
5370 pseudo registers, even if the whole complex value fits into one
5371 hard register. */
5372 if ((paradoxical_subreg_p (mode, DECL_MODE (expr)((contains_struct_check ((expr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5372, __FUNCTION__))->decl_common.mode)
)
5373 || (store_reg_p
5374 && !COMPLEX_MODE_P (DECL_MODE (expr))(((enum mode_class) mode_class[((contains_struct_check ((expr
), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5374, __FUNCTION__))->decl_common.mode)]) == MODE_COMPLEX_INT
|| ((enum mode_class) mode_class[((contains_struct_check ((expr
), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5374, __FUNCTION__))->decl_common.mode)]) == MODE_COMPLEX_FLOAT
)
5375 && hard_regno_nregs (REGNO (loc)(rhs_regno(loc)), DECL_MODE (expr)((contains_struct_check ((expr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5375, __FUNCTION__))->decl_common.mode)
) == 1))
5376 && known_eq (offset + byte_lowpart_offset (DECL_MODE (expr), mode), 0)(!maybe_ne (offset + byte_lowpart_offset (((contains_struct_check
((expr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5376, __FUNCTION__))->decl_common.mode), mode), 0))
)
5377 {
5378 mode = DECL_MODE (expr)((contains_struct_check ((expr), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5378, __FUNCTION__))->decl_common.mode)
;
5379 offset = 0;
5380 }
5381
5382 HOST_WIDE_INTlong const_offset;
5383 if (!track_offset_p (offset, &const_offset))
5384 return false;
5385
5386 if (mode_out)
5387 *mode_out = mode;
5388 if (offset_out)
5389 *offset_out = const_offset;
5390 return true;
5391}
5392
5393/* Return the MODE lowpart of LOC, or null if LOC is not something we
5394 want to track. When returning nonnull, make sure that the attributes
5395 on the returned value are updated. */
5396
5397static rtx
5398var_lowpart (machine_mode mode, rtx loc)
5399{
5400 unsigned int regno;
5401
5402 if (GET_MODE (loc)((machine_mode) (loc)->mode) == mode)
5403 return loc;
5404
5405 if (!REG_P (loc)(((enum rtx_code) (loc)->code) == REG) && !MEM_P (loc)(((enum rtx_code) (loc)->code) == MEM))
5406 return NULLnullptr;
5407
5408 poly_uint64 offset = byte_lowpart_offset (mode, GET_MODE (loc)((machine_mode) (loc)->mode));
5409
5410 if (MEM_P (loc)(((enum rtx_code) (loc)->code) == MEM))
5411 return adjust_address_nv (loc, mode, offset)adjust_address_1 (loc, mode, offset, 0, 1, 0, 0);
5412
5413 poly_uint64 reg_offset = subreg_lowpart_offset (mode, GET_MODE (loc)((machine_mode) (loc)->mode));
5414 regno = REGNO (loc)(rhs_regno(loc)) + subreg_regno_offset (REGNO (loc)(rhs_regno(loc)), GET_MODE (loc)((machine_mode) (loc)->mode),
5415 reg_offset, mode);
5416 return gen_rtx_REG_offset (loc, mode, regno, offset);
5417}
5418
5419/* Carry information about uses and stores while walking rtx. */
5420
5421struct count_use_info
5422{
5423 /* The insn where the RTX is. */
5424 rtx_insn *insn;
5425
5426 /* The basic block where insn is. */
5427 basic_block bb;
5428
5429 /* The array of n_sets sets in the insn, as determined by cselib. */
5430 struct cselib_set *sets;
5431 int n_sets;
5432
5433 /* True if we're counting stores, false otherwise. */
5434 bool store_p;
5435};
5436
5437/* Find a VALUE corresponding to X. */
5438
5439static inline cselib_val *
5440find_use_val (rtx x, machine_mode mode, struct count_use_info *cui)
5441{
5442 int i;
5443
5444 if (cui->sets)
5445 {
5446 /* This is called after uses are set up and before stores are
5447 processed by cselib, so it's safe to look up srcs, but not
5448 dsts. So we look up expressions that appear in srcs or in
5449 dest expressions, but we search the sets array for dests of
5450 stores. */
5451 if (cui->store_p)
5452 {
5453 /* Some targets represent memset and memcpy patterns
5454 by (set (mem:BLK ...) (reg:[QHSD]I ...)) or
5455 (set (mem:BLK ...) (const_int ...)) or
5456 (set (mem:BLK ...) (mem:BLK ...)). Don't return anything
5457 in that case, otherwise we end up with mode mismatches. */
5458 if (mode == BLKmode((void) 0, E_BLKmode) && MEM_P (x)(((enum rtx_code) (x)->code) == MEM))
5459 return NULLnullptr;
5460 for (i = 0; i < cui->n_sets; i++)
5461 if (cui->sets[i].dest == x)
5462 return cui->sets[i].src_elt;
5463 }
5464 else
5465 return cselib_lookup (x, mode, 0, VOIDmode((void) 0, E_VOIDmode));
5466 }
5467
5468 return NULLnullptr;
5469}
5470
5471/* Replace all registers and addresses in an expression with VALUE
5472 expressions that map back to them, unless the expression is a
5473 register. If no mapping is or can be performed, returns NULL. */
5474
5475static rtx
5476replace_expr_with_values (rtx loc)
5477{
5478 if (REG_P (loc)(((enum rtx_code) (loc)->code) == REG) || GET_CODE (loc)((enum rtx_code) (loc)->code) == ENTRY_VALUE)
5479 return NULLnullptr;
5480 else if (MEM_P (loc)(((enum rtx_code) (loc)->code) == MEM))
5481 {
5482 cselib_val *addr = cselib_lookup (XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx),
5483 get_address_mode (loc), 0,
5484 GET_MODE (loc)((machine_mode) (loc)->mode));
5485 if (addr)
5486 return replace_equiv_address_nv (loc, addr->val_rtx);
5487 else
5488 return NULLnullptr;
5489 }
5490 else
5491 return cselib_subst_to_values (loc, VOIDmode((void) 0, E_VOIDmode));
5492}
5493
5494/* Return true if X contains a DEBUG_EXPR. */
5495
5496static bool
5497rtx_debug_expr_p (const_rtx x)
5498{
5499 subrtx_iterator::array_type array;
5500 FOR_EACH_SUBRTX (iter, array, x, ALL)for (subrtx_iterator iter (array, x, rtx_all_subrtx_bounds); !
iter.at_end (); iter.next ())
5501 if (GET_CODE (*iter)((enum rtx_code) (*iter)->code) == DEBUG_EXPR)
5502 return true;
5503 return false;
5504}
5505
5506/* Determine what kind of micro operation to choose for a USE. Return
5507 MO_CLOBBER if no micro operation is to be generated. */
5508
5509static enum micro_operation_type
5510use_type (rtx loc, struct count_use_info *cui, machine_mode *modep)
5511{
5512 tree expr;
5513
5514 if (cui && cui->sets)
5515 {
5516 if (GET_CODE (loc)((enum rtx_code) (loc)->code) == VAR_LOCATION)
5517 {
5518 if (track_expr_p (PAT_VAR_LOCATION_DECL (loc)(((((loc))->u.fld[0]).rt_tree)), false))
5519 {
5520 rtx ploc = PAT_VAR_LOCATION_LOC (loc)(((((loc))->u.fld[1]).rt_rtx));
5521 if (! VAR_LOC_UNKNOWN_P (ploc)(((enum rtx_code) (ploc)->code) == CLOBBER && ((((
ploc))->u.fld[0]).rt_rtx) == (const_int_rtx[64]))
)
5522 {
5523 cselib_val *val = cselib_lookup (ploc, GET_MODE (loc)((machine_mode) (loc)->mode), 1,
5524 VOIDmode((void) 0, E_VOIDmode));
5525
5526 /* ??? flag_float_store and volatile mems are never
5527 given values, but we could in theory use them for
5528 locations. */
5529 gcc_assert (val || 1)((void)(!(val || 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5529, __FUNCTION__), 0 : 0))
;
5530 }
5531 return MO_VAL_LOC;
5532 }
5533 else
5534 return MO_CLOBBER;
5535 }
5536
5537 if (REG_P (loc)(((enum rtx_code) (loc)->code) == REG) || MEM_P (loc)(((enum rtx_code) (loc)->code) == MEM))
5538 {
5539 if (modep)
5540 *modep = GET_MODE (loc)((machine_mode) (loc)->mode);
5541 if (cui->store_p)
5542 {
5543 if (REG_P (loc)(((enum rtx_code) (loc)->code) == REG)
5544 || (find_use_val (loc, GET_MODE (loc)((machine_mode) (loc)->mode), cui)
5545 && cselib_lookup (XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx),
5546 get_address_mode (loc), 0,
5547 GET_MODE (loc)((machine_mode) (loc)->mode))))
5548 return MO_VAL_SET;
5549 }
5550 else
5551 {
5552 cselib_val *val = find_use_val (loc, GET_MODE (loc)((machine_mode) (loc)->mode), cui);
5553
5554 if (val && !cselib_preserved_value_p (val))
5555 return MO_VAL_USE;
5556 }
5557 }
5558 }
5559
5560 if (REG_P (loc)(((enum rtx_code) (loc)->code) == REG))
5561 {
5562 gcc_assert (REGNO (loc) < FIRST_PSEUDO_REGISTER)((void)(!((rhs_regno(loc)) < 76) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5562, __FUNCTION__), 0 : 0))
;
5563
5564 if (loc == cfa_base_rtx)
5565 return MO_CLOBBER;
5566 expr = REG_EXPR (loc)(((&(loc)->u.reg)->attrs) == 0 ? 0 : ((&(loc)->
u.reg)->attrs)->decl)
;
5567
5568 if (!expr)
5569 return MO_USE_NO_VAR;
5570 else if (target_for_debug_bind (var_debug_decl (expr)))
5571 return MO_CLOBBER;
5572 else if (track_loc_p (loc, expr, REG_OFFSET (loc)(((&(loc)->u.reg)->attrs) == 0 ? 0 : ((&(loc)->
u.reg)->attrs)->offset)
,
5573 false, modep, NULLnullptr))
5574 return MO_USE;
5575 else
5576 return MO_USE_NO_VAR;
5577 }
5578 else if (MEM_P (loc)(((enum rtx_code) (loc)->code) == MEM))
5579 {
5580 expr = MEM_EXPR (loc)(get_mem_attrs (loc)->expr);
5581
5582 if (!expr)
5583 return MO_CLOBBER;
5584 else if (target_for_debug_bind (var_debug_decl (expr)))
5585 return MO_CLOBBER;
5586 else if (track_loc_p (loc, expr, int_mem_offset (loc),
5587 false, modep, NULLnullptr)
5588 /* Multi-part variables shouldn't refer to one-part
5589 variable names such as VALUEs (never happens) or
5590 DEBUG_EXPRs (only happens in the presence of debug
5591 insns). */
5592 && (!MAY_HAVE_DEBUG_BIND_INSNSglobal_options.x_flag_var_tracking_assignments
5593 || !rtx_debug_expr_p (XEXP (loc, 0)(((loc)->u.fld[0]).rt_rtx))))
5594 return MO_USE;
5595 else
5596 return MO_CLOBBER;
5597 }
5598
5599 return MO_CLOBBER;
5600}
5601
5602/* Log to OUT information about micro-operation MOPT involving X in
5603 INSN of BB. */
5604
5605static inline void
5606log_op_type (rtx x, basic_block bb, rtx_insn *insn,
5607 enum micro_operation_type mopt, FILE *out)
5608{
5609 fprintf (out, "bb %i op %i insn %i %s ",
5610 bb->index, VTI (bb)((variable_tracking_info *) (bb)->aux)->mos.length (),
5611 INSN_UID (insn), micro_operation_type_name[mopt]);
5612 print_inline_rtx (out, x, 2);
5613 fputc ('\n', out);
5614}
5615
5616/* Tell whether the CONCAT used to holds a VALUE and its location
5617 needs value resolution, i.e., an attempt of mapping the location
5618 back to other incoming values. */
5619#define VAL_NEEDS_RESOLUTION(x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != CONCAT) rtl_check_failed_flag (
"VAL_NEEDS_RESOLUTION", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5619, __FUNCTION__); _rtx; })->volatil)
\
5620 (RTL_FLAG_CHECK1 ("VAL_NEEDS_RESOLUTION", (x), CONCAT)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != CONCAT) rtl_check_failed_flag (
"VAL_NEEDS_RESOLUTION", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5620, __FUNCTION__); _rtx; })
->volatil)
5621/* Whether the location in the CONCAT is a tracked expression, that
5622 should also be handled like a MO_USE. */
5623#define VAL_HOLDS_TRACK_EXPR(x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != CONCAT) rtl_check_failed_flag (
"VAL_HOLDS_TRACK_EXPR", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5623, __FUNCTION__); _rtx; })->used)
\
5624 (RTL_FLAG_CHECK1 ("VAL_HOLDS_TRACK_EXPR", (x), CONCAT)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != CONCAT) rtl_check_failed_flag (
"VAL_HOLDS_TRACK_EXPR", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5624, __FUNCTION__); _rtx; })
->used)
5625/* Whether the location in the CONCAT should be handled like a MO_COPY
5626 as well. */
5627#define VAL_EXPR_IS_COPIED(x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != CONCAT) rtl_check_failed_flag (
"VAL_EXPR_IS_COPIED", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5627, __FUNCTION__); _rtx; })->jump)
\
5628 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_COPIED", (x), CONCAT)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != CONCAT) rtl_check_failed_flag (
"VAL_EXPR_IS_COPIED", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5628, __FUNCTION__); _rtx; })
->jump)
5629/* Whether the location in the CONCAT should be handled like a
5630 MO_CLOBBER as well. */
5631#define VAL_EXPR_IS_CLOBBERED(x)(__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != CONCAT) rtl_check_failed_flag (
"VAL_EXPR_IS_CLOBBERED", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5631, __FUNCTION__); _rtx; })->unchanging)
\
5632 (RTL_FLAG_CHECK1 ("VAL_EXPR_IS_CLOBBERED", (x), CONCAT)__extension__ ({ __typeof ((x)) const _rtx = ((x)); if (((enum
rtx_code) (_rtx)->code) != CONCAT) rtl_check_failed_flag (
"VAL_EXPR_IS_CLOBBERED", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5632, __FUNCTION__); _rtx; })
->unchanging)
5633
5634/* All preserved VALUEs. */
5635static vec<rtx> preserved_values;
5636
5637/* Ensure VAL is preserved and remember it in a vector for vt_emit_notes. */
5638
5639static void
5640preserve_value (cselib_val *val)
5641{
5642 cselib_preserve_value (val);
5643 preserved_values.safe_push (val->val_rtx);
5644}
5645
5646/* Helper function for MO_VAL_LOC handling. Return non-zero if
5647 any rtxes not suitable for CONST use not replaced by VALUEs
5648 are discovered. */
5649
5650static bool
5651non_suitable_const (const_rtx x)
5652{
5653 subrtx_iterator::array_type array;
5654 FOR_EACH_SUBRTX (iter, array, x, ALL)for (subrtx_iterator iter (array, x, rtx_all_subrtx_bounds); !
iter.at_end (); iter.next ())
5655 {
5656 const_rtx x = *iter;
5657 switch (GET_CODE (x)((enum rtx_code) (x)->code))
5658 {
5659 case REG:
5660 case DEBUG_EXPR:
5661 case PC:
5662 case SCRATCH:
5663 case ASM_INPUT:
5664 case ASM_OPERANDS:
5665 return true;
5666 case MEM:
5667 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/var-tracking.c"
, 5667, __FUNCTION__); _rtx; })->unchanging)
)
5668 return true;
5669 break;
5670 default:
5671 break;
5672 }
5673 }
5674 return false;
5675}
5676
5677/* Add uses (register and memory references) LOC which will be tracked
5678 to VTI (bb)->mos. */
5679
5680static void
5681add_uses (rtx loc, struct count_use_info *cui)
5682{
5683 machine_mode mode = VOIDmode((void) 0, E_VOIDmode);
5684 enum micro_operation_type type = use_type (loc, cui, &mode);
5685
5686 if (type != MO_CLOBBER)
5687 {
5688 basic_block bb = cui->bb;
5689 micro_operation mo;
5690
5691 mo.type = type;
5692 mo.u.loc = type == MO_USE ? var_lowpart (mode, loc) : loc;
5693 mo.insn = cui->insn;
5694
5695 if (type == MO_VAL_LOC)
5696 {
5697 rtx oloc = loc;
5698 rtx vloc = PAT_VAR_LOCATION_LOC (oloc)(((((oloc))->u.fld[1]).rt_rtx));
5699 cselib_val *val;
5700
5701 gcc_assert (cui->sets)((void)(!(cui->sets) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5701, __FUNCTION__), 0 : 0))
;
5702
5703 if (MEM_P (vloc)(((enum rtx_code) (vloc)->code) == MEM)
5704 && !REG_P (XEXP (vloc, 0))(((enum rtx_code) ((((vloc)->u.fld[0]).rt_rtx))->code) ==
REG)
5705 && !MEM_P (XEXP (vloc, 0))(((enum rtx_code) ((((vloc)->u.fld[0]).rt_rtx))->code) ==
MEM)
)
5706 {
5707 rtx mloc = vloc;
5708 machine_mode address_mode = get_address_mode (mloc);
5709 cselib_val *val
5710 = cselib_lookup (XEXP (mloc, 0)(((mloc)->u.fld[0]).rt_rtx), address_mode, 0,
5711 GET_MODE (mloc)((machine_mode) (mloc)->mode));
5712
5713 if (val && !cselib_preserved_value_p (val))
5714 preserve_value (val);
5715 }
5716
5717 if (CONSTANT_P (vloc)((rtx_class[(int) (((enum rtx_code) (vloc)->code))]) == RTX_CONST_OBJ
)
5718 && (GET_CODE (vloc)((enum rtx_code) (vloc)->code) != CONST || non_suitable_const (vloc)))
5719 /* For constants don't look up any value. */;
5720 else if (!VAR_LOC_UNKNOWN_P (vloc)(((enum rtx_code) (vloc)->code) == CLOBBER && ((((
vloc))->u.fld[0]).rt_rtx) == (const_int_rtx[64]))
&& !unsuitable_loc (vloc)
5721 && (val = find_use_val (vloc, GET_MODE (oloc)((machine_mode) (oloc)->mode), cui)))
5722 {
5723 machine_mode mode2;
5724 enum micro_operation_type type2;
5725 rtx nloc = NULLnullptr;
5726 bool resolvable = REG_P (vloc)(((enum rtx_code) (vloc)->code) == REG) || MEM_P (vloc)(((enum rtx_code) (vloc)->code) == MEM);
5727
5728 if (resolvable)
5729 nloc = replace_expr_with_values (vloc);
5730
5731 if (nloc)
5732 {
5733 oloc = shallow_copy_rtx (oloc);
5734 PAT_VAR_LOCATION_LOC (oloc)(((((oloc))->u.fld[1]).rt_rtx)) = nloc;
5735 }
5736
5737 oloc = gen_rtx_CONCAT (mode, val->val_rtx, oloc)gen_rtx_fmt_ee_stat ((CONCAT), ((mode)), ((val->val_rtx)),
((oloc)) )
;
5738
5739 type2 = use_type (vloc, 0, &mode2);
5740
5741 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR((void)(!(type2 == MO_USE || type2 == MO_USE_NO_VAR || type2 ==
MO_CLOBBER) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5742, __FUNCTION__), 0 : 0))
5742 || type2 == MO_CLOBBER)((void)(!(type2 == MO_USE || type2 == MO_USE_NO_VAR || type2 ==
MO_CLOBBER) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5742, __FUNCTION__), 0 : 0))
;
5743
5744 if (type2 == MO_CLOBBER
5745 && !cselib_preserved_value_p (val))
5746 {
5747 VAL_NEEDS_RESOLUTION (oloc)(__extension__ ({ __typeof ((oloc)) const _rtx = ((oloc)); if
(((enum rtx_code) (_rtx)->code) != CONCAT) rtl_check_failed_flag
("VAL_NEEDS_RESOLUTION", _rtx, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5747, __FUNCTION__); _rtx; })->volatil)
= resolvable;
5748 preserve_value (val);
5749 }
5750 }
5751 else if (!VAR_LOC_UNKNOWN_P (vloc)(((enum rtx_code) (vloc)->code) == CLOBBER && ((((
vloc))->u.fld[0]).rt_rtx) == (const_int_rtx[64]))
)
5752 {
5753 oloc = shallow_copy_rtx (oloc);
5754 PAT_VAR_LOCATION_LOC (oloc)(((((oloc))->u.fld[1]).rt_rtx)) = gen_rtx_UNKNOWN_VAR_LOC ()(gen_rtx_fmt_e_stat ((CLOBBER), ((((void) 0, E_VOIDmode))), (
((const_int_rtx[64]))) ))
;
5755 }
5756
5757 mo.u.loc = oloc;
5758 }
5759 else if (type == MO_VAL_USE)
5760 {
5761 machine_mode mode2 = VOIDmode((void) 0, E_VOIDmode);
5762 enum micro_operation_type type2;
5763 cselib_val *val = find_use_val (loc, GET_MODE (loc)((machine_mode) (loc)->mode), cui);
5764 rtx vloc, oloc = loc, nloc;
5765
5766 gcc_assert (cui->sets)((void)(!(cui->sets) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5766, __FUNCTION__), 0 : 0))
;
5767
5768 if (MEM_P (oloc)(((enum rtx_code) (oloc)->code) == MEM)
5769 && !REG_P (XEXP (oloc, 0))(((enum rtx_code) ((((oloc)->u.fld[0]).rt_rtx))->code) ==
REG)
5770 && !MEM_P (XEXP (oloc, 0))(((enum rtx_code) ((((oloc)->u.fld[0]).rt_rtx))->code) ==
MEM)
)
5771 {
5772 rtx mloc = oloc;
5773 machine_mode address_mode = get_address_mode (mloc);
5774 cselib_val *val
5775 = cselib_lookup (XEXP (mloc, 0)(((mloc)->u.fld[0]).rt_rtx), address_mode, 0,
5776 GET_MODE (mloc)((machine_mode) (mloc)->mode));
5777
5778 if (val && !cselib_preserved_value_p (val))
5779 preserve_value (val);
5780 }
5781
5782 type2 = use_type (loc, 0, &mode2);
5783
5784 gcc_assert (type2 == MO_USE || type2 == MO_USE_NO_VAR((void)(!(type2 == MO_USE || type2 == MO_USE_NO_VAR || type2 ==
MO_CLOBBER) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5785, __FUNCTION__), 0 : 0))
5785 || type2 == MO_CLOBBER)((void)(!(type2 == MO_USE || type2 == MO_USE_NO_VAR || type2 ==
MO_CLOBBER) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/var-tracking.c"
, 5785, __FUNCTION__), 0 : 0))
;
5786
5787 if (type2 == MO_USE)
5788 vloc = var_lowpart (mode2, loc);
5789 else
5790 vloc = oloc;
5791
5792 /* The loc of a MO_VAL_USE may have two forms:
5793
5794 (concat val src): val is at src, a value-based
5795 representation.
5796
5797 (concat (concat val use) src): same as above, with use as
5798 the MO_USE tracked value, if it differs from src.
5799