Bug Summary

File:build/gcc/vr-values.c
Warning:line 572, column 4
Value stored to 'op' 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 vr-values.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 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.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/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/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 -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-ErZrNl.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c
1/* Support routines for Value Range Propagation (VRP).
2 Copyright (C) 2005-2021 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 3, or (at your option)
9any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "backend.h"
24#include "insn-codes.h"
25#include "tree.h"
26#include "gimple.h"
27#include "ssa.h"
28#include "optabs-tree.h"
29#include "gimple-pretty-print.h"
30#include "diagnostic-core.h"
31#include "flags.h"
32#include "fold-const.h"
33#include "calls.h"
34#include "cfganal.h"
35#include "gimple-fold.h"
36#include "gimple-iterator.h"
37#include "tree-cfg.h"
38#include "tree-ssa-loop-niter.h"
39#include "tree-ssa-loop.h"
40#include "intl.h"
41#include "cfgloop.h"
42#include "tree-scalar-evolution.h"
43#include "tree-ssa-propagate.h"
44#include "tree-chrec.h"
45#include "omp-general.h"
46#include "case-cfn-macros.h"
47#include "alloc-pool.h"
48#include "attribs.h"
49#include "range.h"
50#include "vr-values.h"
51#include "cfghooks.h"
52#include "range-op.h"
53#include "gimple-range.h"
54
55/* Set value range VR to a non-negative range of type TYPE. */
56
57static inline void
58set_value_range_to_nonnegative (value_range_equiv *vr, tree type)
59{
60 tree zero = build_int_cst (type, 0);
61 vr->update (zero, vrp_val_max (type));
62}
63
64/* Set value range VR to a range of a truthvalue of type TYPE. */
65
66static inline void
67set_value_range_to_truthvalue (value_range_equiv *vr, tree type)
68{
69 if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 69, __FUNCTION__))->type_common.precision)
== 1)
70 vr->set_varying (type);
71 else
72 vr->update (build_int_cst (type, 0), build_int_cst (type, 1));
73}
74
75/* Return the lattice entry for VAR or NULL if it doesn't exist or cannot
76 be initialized. */
77
78value_range_equiv *
79vr_values::get_lattice_entry (const_tree var)
80{
81 value_range_equiv *vr;
82 tree sym;
83 unsigned ver = SSA_NAME_VERSION (var)(tree_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 83, __FUNCTION__, (SSA_NAME)))->base.u.version
;
84
85 /* If we query the entry for a new SSA name avoid reallocating the lattice
86 since we should get here at most from the substitute-and-fold stage which
87 will never try to change values. */
88 if (ver >= num_vr_values)
89 return NULL__null;
90
91 vr = vr_value[ver];
92 if (vr)
93 return vr;
94
95 /* Create a default value range. */
96 vr = allocate_value_range_equiv ();
97 vr_value[ver] = vr;
98
99 /* After propagation finished return varying. */
100 if (values_propagated)
101 {
102 vr->set_varying (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 102, __FUNCTION__))->typed.type)
);
103 return vr;
104 }
105
106 vr->set_undefined ();
107
108 /* If VAR is a default definition of a parameter, the variable can
109 take any value in VAR's type. */
110 if (SSA_NAME_IS_DEFAULT_DEF (var)(tree_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 110, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
)
111 {
112 sym = SSA_NAME_VAR (var)((tree_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 112, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) __null
|| ((enum tree_code) ((var)->ssa_name.var)->base.code)
== IDENTIFIER_NODE ? (tree) __null : (var)->ssa_name.var)
;
113 if (TREE_CODE (sym)((enum tree_code) (sym)->base.code) == PARM_DECL)
114 {
115 /* Try to use the "nonnull" attribute to create ~[0, 0]
116 anti-ranges for pointers. Note that this is only valid with
117 default definitions of PARM_DECLs. */
118 if (POINTER_TYPE_P (TREE_TYPE (sym))(((enum tree_code) (((contains_struct_check ((sym), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 118, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((sym), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 118, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
119 && (nonnull_arg_p (sym)
120 || get_ptr_nonnull (var)))
121 {
122 vr->set_nonzero (TREE_TYPE (sym)((contains_struct_check ((sym), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 122, __FUNCTION__))->typed.type)
);
123 vr->equiv_clear ();
124 }
125 else if (INTEGRAL_TYPE_P (TREE_TYPE (sym))(((enum tree_code) (((contains_struct_check ((sym), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 125, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((sym), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 125, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((sym), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 125, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
)
126 {
127 get_range_info (var, *vr);
128 if (vr->undefined_p ())
129 vr->set_varying (TREE_TYPE (sym)((contains_struct_check ((sym), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 129, __FUNCTION__))->typed.type)
);
130 }
131 else
132 vr->set_varying (TREE_TYPE (sym)((contains_struct_check ((sym), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 132, __FUNCTION__))->typed.type)
);
133 }
134 else if (TREE_CODE (sym)((enum tree_code) (sym)->base.code) == RESULT_DECL
135 && DECL_BY_REFERENCE (sym)((tree_check3 ((sym), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 135, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL)))
->decl_common.decl_by_reference_flag)
)
136 {
137 vr->set_nonzero (TREE_TYPE (sym)((contains_struct_check ((sym), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 137, __FUNCTION__))->typed.type)
);
138 vr->equiv_clear ();
139 }
140 }
141
142 return vr;
143}
144
145/* Return value range information for VAR.
146
147 If we have no values ranges recorded (ie, VRP is not running), then
148 return NULL. Otherwise create an empty range if none existed for VAR. */
149
150const value_range_equiv *
151vr_values::get_value_range (const_tree var,
152 gimple *stmt ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
153{
154 /* If we have no recorded ranges, then return NULL. */
155 if (!vr_value)
156 return NULL__null;
157
158 value_range_equiv *vr = get_lattice_entry (var);
159
160 /* Reallocate the lattice if needed. */
161 if (!vr)
162 {
163 unsigned int old_sz = num_vr_values;
164 num_vr_values = num_ssa_names(vec_safe_length ((cfun + 0)->gimple_df->ssa_names)) + num_ssa_names(vec_safe_length ((cfun + 0)->gimple_df->ssa_names)) / 10;
165 vr_value = XRESIZEVEC (value_range_equiv *, vr_value, num_vr_values)((value_range_equiv * *) xrealloc ((void *) (vr_value), sizeof
(value_range_equiv *) * (num_vr_values)))
;
166 for ( ; old_sz < num_vr_values; old_sz++)
167 vr_value [old_sz] = NULL__null;
168
169 /* Now that the lattice has been resized, we should never fail. */
170 vr = get_lattice_entry (var);
171 gcc_assert (vr)((void)(!(vr) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 171, __FUNCTION__), 0 : 0))
;
172 }
173
174 return vr;
175}
176
177bool
178vr_values::range_of_expr (irange &r, tree expr, gimple *stmt)
179{
180 if (!gimple_range_ssa_p (expr))
181 return get_tree_range (r, expr);
182
183 if (const value_range *vr = get_value_range (expr, stmt))
184 {
185 if (vr->undefined_p () || vr->varying_p () || vr->constant_p ())
186 r = *vr;
187 else
188 {
189 value_range tmp = *vr;
190 tmp.normalize_symbolics ();
191 r = tmp;
192 }
193 return true;
194 }
195 return false;
196}
197
198tree
199vr_values::value_of_expr (tree op, gimple *)
200{
201 return op_with_constant_singleton_value_range (op);
202}
203
204tree
205vr_values::value_on_edge (edge, tree op)
206{
207 return op_with_constant_singleton_value_range (op);
208}
209
210tree
211vr_values::value_of_stmt (gimple *stmt, tree op)
212{
213 if (!op)
214 op = gimple_get_lhs (stmt);
215
216 gcc_checking_assert (!op|| op == gimple_get_lhs (stmt))((void)(!(!op|| op == gimple_get_lhs (stmt)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 216, __FUNCTION__), 0 : 0))
;
217
218 if (op)
219 return op_with_constant_singleton_value_range (op);
220 return NULL_TREE(tree) __null;
221}
222
223/* Set the lattice entry for DEF to VARYING. */
224
225void
226vr_values::set_def_to_varying (const_tree def)
227{
228 value_range_equiv *vr = get_lattice_entry (def);
229 if (vr)
230 vr->set_varying (TREE_TYPE (def)((contains_struct_check ((def), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 230, __FUNCTION__))->typed.type)
);
231}
232
233/* Set value-ranges of all SSA names defined by STMT to varying. */
234
235void
236vr_values::set_defs_to_varying (gimple *stmt)
237{
238 ssa_op_iter i;
239 tree def;
240 FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)for (def = op_iter_init_tree (&(i), stmt, 0x02); !op_iter_done
(&(i)); (void) (def = op_iter_next_tree (&(i))))
241 set_def_to_varying (def);
242}
243
244/* Update the value range and equivalence set for variable VAR to
245 NEW_VR. Return true if NEW_VR is different from VAR's previous
246 value.
247
248 NOTE: This function assumes that NEW_VR is a temporary value range
249 object created for the sole purpose of updating VAR's range. The
250 storage used by the equivalence set from NEW_VR will be freed by
251 this function. Do not call update_value_range when NEW_VR
252 is the range object associated with another SSA name. */
253
254bool
255vr_values::update_value_range (const_tree var, value_range_equiv *new_vr)
256{
257 value_range_equiv *old_vr;
258 bool is_new;
259
260 /* If there is a value-range on the SSA name from earlier analysis
261 factor that in. */
262 if (INTEGRAL_TYPE_P (TREE_TYPE (var))(((enum tree_code) (((contains_struct_check ((var), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 262, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((var), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 262, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((var), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 262, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
)
263 {
264 value_range_equiv nr;
265 get_range_info (var, nr);
266 if (!nr.undefined_p ())
267 new_vr->intersect (&nr);
268 }
269
270 /* Update the value range, if necessary. If we cannot allocate a lattice
271 entry for VAR keep it at VARYING. This happens when DOM feeds us stmts
272 with SSA names allocated after setting up the lattice. */
273 old_vr = get_lattice_entry (var);
274 if (!old_vr)
275 return false;
276 is_new = !old_vr->equal_p (*new_vr, /*ignore_equivs=*/false);
277
278 if (is_new)
279 {
280 /* Do not allow transitions up the lattice. The following
281 is slightly more awkward than just new_vr->type < old_vr->type
282 because VR_RANGE and VR_ANTI_RANGE need to be considered
283 the same. We may not have is_new when transitioning to
284 UNDEFINED. If old_vr->type is VARYING, we shouldn't be
285 called, if we are anyway, keep it VARYING. */
286 if (old_vr->varying_p ())
287 {
288 new_vr->set_varying (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 288, __FUNCTION__))->typed.type)
);
289 is_new = false;
290 }
291 else if (new_vr->undefined_p ())
292 {
293 old_vr->set_varying (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 293, __FUNCTION__))->typed.type)
);
294 new_vr->set_varying (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 294, __FUNCTION__))->typed.type)
);
295 return true;
296 }
297 else
298 old_vr->set (new_vr->min (), new_vr->max (), new_vr->equiv (),
299 new_vr->kind ());
300 }
301
302 new_vr->equiv_clear ();
303
304 return is_new;
305}
306
307/* Return true if value range VR involves exactly one symbol SYM. */
308
309static bool
310symbolic_range_based_on_p (value_range *vr, const_tree sym)
311{
312 bool neg, min_has_symbol, max_has_symbol;
313 tree inv;
314
315 if (is_gimple_min_invariant (vr->min ()))
316 min_has_symbol = false;
317 else if (get_single_symbol (vr->min (), &neg, &inv) == sym)
318 min_has_symbol = true;
319 else
320 return false;
321
322 if (is_gimple_min_invariant (vr->max ()))
323 max_has_symbol = false;
324 else if (get_single_symbol (vr->max (), &neg, &inv) == sym)
325 max_has_symbol = true;
326 else
327 return false;
328
329 return (min_has_symbol || max_has_symbol);
330}
331
332/* Return true if the result of assignment STMT is know to be non-zero. */
333
334static bool
335gimple_assign_nonzero_p (gimple *stmt)
336{
337 enum tree_code code = gimple_assign_rhs_code (stmt);
338 bool strict_overflow_p;
339 switch (get_gimple_rhs_class (code))
340 {
341 case GIMPLE_UNARY_RHS:
342 return tree_unary_nonzero_warnv_p (gimple_assign_rhs_code (stmt),
343 gimple_expr_type (stmt),
344 gimple_assign_rhs1 (stmt),
345 &strict_overflow_p);
346 case GIMPLE_BINARY_RHS:
347 return tree_binary_nonzero_warnv_p (gimple_assign_rhs_code (stmt),
348 gimple_expr_type (stmt),
349 gimple_assign_rhs1 (stmt),
350 gimple_assign_rhs2 (stmt),
351 &strict_overflow_p);
352 case GIMPLE_TERNARY_RHS:
353 return false;
354 case GIMPLE_SINGLE_RHS:
355 return tree_single_nonzero_warnv_p (gimple_assign_rhs1 (stmt),
356 &strict_overflow_p);
357 case GIMPLE_INVALID_RHS:
358 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 358, __FUNCTION__))
;
359 default:
360 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 360, __FUNCTION__))
;
361 }
362}
363
364/* Return true if STMT is known to compute a non-zero value. */
365
366static bool
367gimple_stmt_nonzero_p (gimple *stmt)
368{
369 switch (gimple_code (stmt))
370 {
371 case GIMPLE_ASSIGN:
372 return gimple_assign_nonzero_p (stmt);
373 case GIMPLE_CALL:
374 {
375 gcall *call_stmt = as_a<gcall *> (stmt);
376 return (gimple_call_nonnull_result_p (call_stmt)
377 || gimple_call_nonnull_arg (call_stmt));
378 }
379 default:
380 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 380, __FUNCTION__))
;
381 }
382}
383/* Like tree_expr_nonzero_p, but this function uses value ranges
384 obtained so far. */
385
386bool
387vr_values::vrp_stmt_computes_nonzero (gimple *stmt)
388{
389 if (gimple_stmt_nonzero_p (stmt))
390 return true;
391
392 /* If we have an expression of the form &X->a, then the expression
393 is nonnull if X is nonnull. */
394 if (is_gimple_assign (stmt)
395 && gimple_assign_rhs_code (stmt) == ADDR_EXPR)
396 {
397 tree expr = gimple_assign_rhs1 (stmt);
398 poly_int64 bitsize, bitpos;
399 tree offset;
400 machine_mode mode;
401 int unsignedp, reversep, volatilep;
402 tree base = get_inner_reference (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 402, __FUNCTION__)))))
, &bitsize,
403 &bitpos, &offset, &mode, &unsignedp,
404 &reversep, &volatilep);
405
406 if (base != NULL_TREE(tree) __null
407 && TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF
408 && TREE_CODE (TREE_OPERAND (base, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((base), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 408, __FUNCTION__))))))->base.code)
== SSA_NAME)
409 {
410 poly_offset_int off = 0;
411 bool off_cst = false;
412 if (offset == NULL_TREE(tree) __null || TREE_CODE (offset)((enum tree_code) (offset)->base.code) == INTEGER_CST)
413 {
414 off = mem_ref_offset (base);
415 if (offset)
416 off += poly_offset_int::from (wi::to_poly_wide (offset),
417 SIGNED);
418 off <<= LOG2_BITS_PER_UNIT3;
419 off += bitpos;
420 off_cst = true;
421 }
422 /* If &X->a is equal to X and X is ~[0, 0], the result is too.
423 For -fdelete-null-pointer-checks -fno-wrapv-pointer we don't
424 allow going from non-NULL pointer to NULL. */
425 if ((off_cst && known_eq (off, 0)(!maybe_ne (off, 0)))
426 || (flag_delete_null_pointer_checksglobal_options.x_flag_delete_null_pointer_checks
427 && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (expr))((((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 427, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 427, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((((contains_struct_check ((expr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 427, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 427, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
))
428 {
429 const value_range_equiv *vr
430 = get_value_range (TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 430, __FUNCTION__)))))
);
431 if (!range_includes_zero_p (vr))
432 return true;
433 }
434 /* If MEM_REF has a "positive" offset, consider it non-NULL
435 always, for -fdelete-null-pointer-checks also "negative"
436 ones. Punt for unknown offsets (e.g. variable ones). */
437 if (!TYPE_OVERFLOW_WRAPS (TREE_TYPE (expr))((((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 437, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 437, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((((contains_struct_check ((expr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 437, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 437, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
438 && off_cst
439 && known_ne (off, 0)(!maybe_eq (off, 0))
440 && (flag_delete_null_pointer_checksglobal_options.x_flag_delete_null_pointer_checks || known_gt (off, 0)(!maybe_le (off, 0))))
441 return true;
442 }
443 }
444
445 return false;
446}
447
448/* Returns true if EXPR is a valid value (as expected by compare_values) --
449 a gimple invariant, or SSA_NAME +- CST. */
450
451static bool
452valid_value_p (tree expr)
453{
454 if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == SSA_NAME)
455 return true;
456
457 if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == PLUS_EXPR
458 || TREE_CODE (expr)((enum tree_code) (expr)->base.code) == MINUS_EXPR)
459 return (TREE_CODE (TREE_OPERAND (expr, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((expr), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 459, __FUNCTION__))))))->base.code)
== SSA_NAME
460 && TREE_CODE (TREE_OPERAND (expr, 1))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((expr), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 460, __FUNCTION__))))))->base.code)
== INTEGER_CST);
461
462 return is_gimple_min_invariant (expr);
463}
464
465/* If OP has a value range with a single constant value return that,
466 otherwise return NULL_TREE. This returns OP itself if OP is a
467 constant. */
468
469tree
470vr_values::op_with_constant_singleton_value_range (tree op)
471{
472 if (is_gimple_min_invariant (op))
473 return op;
474
475 if (TREE_CODE (op)((enum tree_code) (op)->base.code) != SSA_NAME)
476 return NULL_TREE(tree) __null;
477
478 tree t;
479 if (get_value_range (op)->singleton_p (&t))
480 return t;
481 return NULL__null;
482}
483
484/* Return true if op is in a boolean [0, 1] value-range. */
485
486bool
487simplify_using_ranges::op_with_boolean_value_range_p (tree op)
488{
489 if (TYPE_PRECISION (TREE_TYPE (op))((tree_class_check ((((contains_struct_check ((op), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 489, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 489, __FUNCTION__))->type_common.precision)
== 1)
490 return true;
491
492 if (integer_zerop (op)
493 || integer_onep (op))
494 return true;
495
496 if (TREE_CODE (op)((enum tree_code) (op)->base.code) != SSA_NAME)
497 return false;
498
499 /* ?? Errr, this should probably check for [0,0] and [1,1] as well
500 as [0,1]. */
501 const value_range *vr = query->get_value_range (op);
502 return *vr == value_range (build_zero_cst (TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 502, __FUNCTION__))->typed.type)
),
503 build_one_cst (TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 503, __FUNCTION__))->typed.type)
));
504}
505
506/* Extract value range information for VAR when (OP COND_CODE LIMIT) is
507 true and store it in *VR_P. */
508
509void
510vr_values::extract_range_for_var_from_comparison_expr (tree var,
511 enum tree_code cond_code,
512 tree op, tree limit,
513 value_range_equiv *vr_p)
514{
515 tree min, max, type;
516 const value_range_equiv *limit_vr;
517 type = TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 517, __FUNCTION__))->typed.type)
;
518
519 /* For pointer arithmetic, we only keep track of pointer equality
520 and inequality. If we arrive here with unfolded conditions like
521 _1 > _1 do not derive anything. */
522 if ((POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE)
&& cond_code != NE_EXPR && cond_code != EQ_EXPR)
523 || limit == var)
524 {
525 vr_p->set_varying (type);
526 return;
527 }
528
529 /* If LIMIT is another SSA name and LIMIT has a range of its own,
530 try to use LIMIT's range to avoid creating symbolic ranges
531 unnecessarily. */
532 limit_vr = (TREE_CODE (limit)((enum tree_code) (limit)->base.code) == SSA_NAME) ? get_value_range (limit) : NULL__null;
533
534 /* LIMIT's range is only interesting if it has any useful information. */
535 if (! limit_vr
536 || limit_vr->undefined_p ()
537 || limit_vr->varying_p ()
538 || (limit_vr->symbolic_p ()
539 && ! (limit_vr->kind () == VR_RANGE
540 && (limit_vr->min () == limit_vr->max ()
541 || operand_equal_p (limit_vr->min (),
542 limit_vr->max (), 0)))))
543 limit_vr = NULL__null;
544
545 /* Initially, the new range has the same set of equivalences of
546 VAR's range. This will be revised before returning the final
547 value. Since assertions may be chained via mutually exclusive
548 predicates, we will need to trim the set of equivalences before
549 we are done. */
550 gcc_assert (vr_p->equiv () == NULL)((void)(!(vr_p->equiv () == __null) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 550, __FUNCTION__), 0 : 0))
;
551 vr_p->equiv_add (var, get_value_range (var), &vrp_equiv_obstack);
552
553 /* Extract a new range based on the asserted comparison for VAR and
554 LIMIT's value range. Notice that if LIMIT has an anti-range, we
555 will only use it for equality comparisons (EQ_EXPR). For any
556 other kind of assertion, we cannot derive a range from LIMIT's
557 anti-range that can be used to describe the new range. For
558 instance, ASSERT_EXPR <x_2, x_2 <= b_4>. If b_4 is ~[2, 10],
559 then b_4 takes on the ranges [-INF, 1] and [11, +INF]. There is
560 no single range for x_2 that could describe LE_EXPR, so we might
561 as well build the range [b_4, +INF] for it.
562 One special case we handle is extracting a range from a
563 range test encoded as (unsigned)var + CST <= limit. */
564 if (TREE_CODE (op)((enum tree_code) (op)->base.code) == NOP_EXPR
565 || TREE_CODE (op)((enum tree_code) (op)->base.code) == PLUS_EXPR)
566 {
567 if (TREE_CODE (op)((enum tree_code) (op)->base.code) == PLUS_EXPR)
568 {
569 min = fold_build1 (NEGATE_EXPR, TREE_TYPE (TREE_OPERAND (op, 1)),fold_build1_loc (((location_t) 0), NEGATE_EXPR, ((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((op), (1)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 569, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 569, __FUNCTION__))->typed.type), (*((const_cast<tree
*> (tree_operand_check ((op), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 570, __FUNCTION__))))) )
570 TREE_OPERAND (op, 1))fold_build1_loc (((location_t) 0), NEGATE_EXPR, ((contains_struct_check
(((*((const_cast<tree*> (tree_operand_check ((op), (1)
, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 569, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 569, __FUNCTION__))->typed.type), (*((const_cast<tree
*> (tree_operand_check ((op), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 570, __FUNCTION__))))) )
;
571 max = int_const_binop (PLUS_EXPR, limit, min);
572 op = TREE_OPERAND (op, 0)(*((const_cast<tree*> (tree_operand_check ((op), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 572, __FUNCTION__)))))
;
Value stored to 'op' is never read
573 }
574 else
575 {
576 min = build_int_cst (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 576, __FUNCTION__))->typed.type)
, 0);
577 max = limit;
578 }
579
580 /* Make sure to not set TREE_OVERFLOW on the final type
581 conversion. We are willingly interpreting large positive
582 unsigned values as negative signed values here. */
583 min = force_fit_type (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 583, __FUNCTION__))->typed.type)
, wi::to_widest (min), 0, false);
584 max = force_fit_type (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 584, __FUNCTION__))->typed.type)
, wi::to_widest (max), 0, false);
585
586 /* We can transform a max, min range to an anti-range or
587 vice-versa. Use set_and_canonicalize which does this for
588 us. */
589 if (cond_code == LE_EXPR)
590 vr_p->set (min, max, vr_p->equiv ());
591 else if (cond_code == GT_EXPR)
592 vr_p->set (min, max, vr_p->equiv (), VR_ANTI_RANGE);
593 else
594 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 594, __FUNCTION__))
;
595 }
596 else if (cond_code == EQ_EXPR)
597 {
598 enum value_range_kind range_kind;
599
600 if (limit_vr)
601 {
602 range_kind = limit_vr->kind ();
603 min = limit_vr->min ();
604 max = limit_vr->max ();
605 }
606 else
607 {
608 range_kind = VR_RANGE;
609 min = limit;
610 max = limit;
611 }
612
613 vr_p->update (min, max, range_kind);
614
615 /* When asserting the equality VAR == LIMIT and LIMIT is another
616 SSA name, the new range will also inherit the equivalence set
617 from LIMIT. */
618 if (TREE_CODE (limit)((enum tree_code) (limit)->base.code) == SSA_NAME)
619 vr_p->equiv_add (limit, get_value_range (limit), &vrp_equiv_obstack);
620 }
621 else if (cond_code == NE_EXPR)
622 {
623 /* As described above, when LIMIT's range is an anti-range and
624 this assertion is an inequality (NE_EXPR), then we cannot
625 derive anything from the anti-range. For instance, if
626 LIMIT's range was ~[0, 0], the assertion 'VAR != LIMIT' does
627 not imply that VAR's range is [0, 0]. So, in the case of
628 anti-ranges, we just assert the inequality using LIMIT and
629 not its anti-range.
630
631 If LIMIT_VR is a range, we can only use it to build a new
632 anti-range if LIMIT_VR is a single-valued range. For
633 instance, if LIMIT_VR is [0, 1], the predicate
634 VAR != [0, 1] does not mean that VAR's range is ~[0, 1].
635 Rather, it means that for value 0 VAR should be ~[0, 0]
636 and for value 1, VAR should be ~[1, 1]. We cannot
637 represent these ranges.
638
639 The only situation in which we can build a valid
640 anti-range is when LIMIT_VR is a single-valued range
641 (i.e., LIMIT_VR->MIN == LIMIT_VR->MAX). In that case,
642 build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX]. */
643 if (limit_vr
644 && limit_vr->kind () == VR_RANGE
645 && compare_values (limit_vr->min (), limit_vr->max ()) == 0)
646 {
647 min = limit_vr->min ();
648 max = limit_vr->max ();
649 }
650 else
651 {
652 /* In any other case, we cannot use LIMIT's range to build a
653 valid anti-range. */
654 min = max = limit;
655 }
656
657 /* If MIN and MAX cover the whole range for their type, then
658 just use the original LIMIT. */
659 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
660 && vrp_val_is_min (min)
661 && vrp_val_is_max (max))
662 min = max = limit;
663
664 vr_p->set (min, max, vr_p->equiv (), VR_ANTI_RANGE);
665 }
666 else if (cond_code == LE_EXPR || cond_code == LT_EXPR)
667 {
668 min = TYPE_MIN_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 668, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
;
669
670 if (limit_vr == NULL__null || limit_vr->kind () == VR_ANTI_RANGE)
671 max = limit;
672 else
673 {
674 /* If LIMIT_VR is of the form [N1, N2], we need to build the
675 range [MIN, N2] for LE_EXPR and [MIN, N2 - 1] for
676 LT_EXPR. */
677 max = limit_vr->max ();
678 }
679
680 /* If the maximum value forces us to be out of bounds, simply punt.
681 It would be pointless to try and do anything more since this
682 all should be optimized away above us. */
683 if (cond_code == LT_EXPR
684 && compare_values (max, min) == 0)
685 vr_p->set_varying (TREE_TYPE (min)((contains_struct_check ((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 685, __FUNCTION__))->typed.type)
);
686 else
687 {
688 /* For LT_EXPR, we create the range [MIN, MAX - 1]. */
689 if (cond_code == LT_EXPR)
690 {
691 if (TYPE_PRECISION (TREE_TYPE (max))((tree_class_check ((((contains_struct_check ((max), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 691, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 691, __FUNCTION__))->type_common.precision)
== 1
692 && !TYPE_UNSIGNED (TREE_TYPE (max))((tree_class_check ((((contains_struct_check ((max), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 692, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 692, __FUNCTION__))->base.u.bits.unsigned_flag)
)
693 max = fold_build2 (PLUS_EXPR, TREE_TYPE (max), max,fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
((max), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 693, __FUNCTION__))->typed.type), max, build_int_cst (((
contains_struct_check ((max), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 694, __FUNCTION__))->typed.type), -1) )
694 build_int_cst (TREE_TYPE (max), -1))fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
((max), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 693, __FUNCTION__))->typed.type), max, build_int_cst (((
contains_struct_check ((max), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 694, __FUNCTION__))->typed.type), -1) )
;
695 else
696 max = fold_build2 (MINUS_EXPR, TREE_TYPE (max), max,fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
((max), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 696, __FUNCTION__))->typed.type), max, build_int_cst (((
contains_struct_check ((max), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 697, __FUNCTION__))->typed.type), 1) )
697 build_int_cst (TREE_TYPE (max), 1))fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
((max), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 696, __FUNCTION__))->typed.type), max, build_int_cst (((
contains_struct_check ((max), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 697, __FUNCTION__))->typed.type), 1) )
;
698 /* Signal to compare_values_warnv this expr doesn't overflow. */
699 if (EXPR_P (max)((tree_code_type[(int) (((enum tree_code) (max)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (max)->base.code))]) <= tcc_expression)
)
700 TREE_NO_WARNING (max)((max)->base.nowarning_flag) = 1;
701 }
702
703 vr_p->update (min, max);
704 }
705 }
706 else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
707 {
708 max = TYPE_MAX_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 708, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
;
709
710 if (limit_vr == NULL__null || limit_vr->kind () == VR_ANTI_RANGE)
711 min = limit;
712 else
713 {
714 /* If LIMIT_VR is of the form [N1, N2], we need to build the
715 range [N1, MAX] for GE_EXPR and [N1 + 1, MAX] for
716 GT_EXPR. */
717 min = limit_vr->min ();
718 }
719
720 /* If the minimum value forces us to be out of bounds, simply punt.
721 It would be pointless to try and do anything more since this
722 all should be optimized away above us. */
723 if (cond_code == GT_EXPR
724 && compare_values (min, max) == 0)
725 vr_p->set_varying (TREE_TYPE (min)((contains_struct_check ((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 725, __FUNCTION__))->typed.type)
);
726 else
727 {
728 /* For GT_EXPR, we create the range [MIN + 1, MAX]. */
729 if (cond_code == GT_EXPR)
730 {
731 if (TYPE_PRECISION (TREE_TYPE (min))((tree_class_check ((((contains_struct_check ((min), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 731, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 731, __FUNCTION__))->type_common.precision)
== 1
732 && !TYPE_UNSIGNED (TREE_TYPE (min))((tree_class_check ((((contains_struct_check ((min), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 732, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 732, __FUNCTION__))->base.u.bits.unsigned_flag)
)
733 min = fold_build2 (MINUS_EXPR, TREE_TYPE (min), min,fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 733, __FUNCTION__))->typed.type), min, build_int_cst (((
contains_struct_check ((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 734, __FUNCTION__))->typed.type), -1) )
734 build_int_cst (TREE_TYPE (min), -1))fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 733, __FUNCTION__))->typed.type), min, build_int_cst (((
contains_struct_check ((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 734, __FUNCTION__))->typed.type), -1) )
;
735 else
736 min = fold_build2 (PLUS_EXPR, TREE_TYPE (min), min,fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 736, __FUNCTION__))->typed.type), min, build_int_cst (((
contains_struct_check ((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 737, __FUNCTION__))->typed.type), 1) )
737 build_int_cst (TREE_TYPE (min), 1))fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 736, __FUNCTION__))->typed.type), min, build_int_cst (((
contains_struct_check ((min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 737, __FUNCTION__))->typed.type), 1) )
;
738 /* Signal to compare_values_warnv this expr doesn't overflow. */
739 if (EXPR_P (min)((tree_code_type[(int) (((enum tree_code) (min)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (min)->base.code))]) <= tcc_expression)
)
740 TREE_NO_WARNING (min)((min)->base.nowarning_flag) = 1;
741 }
742
743 vr_p->update (min, max);
744 }
745 }
746 else
747 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 747, __FUNCTION__))
;
748
749 /* Finally intersect the new range with what we already know about var. */
750 vr_p->intersect (get_value_range (var));
751}
752
753/* Extract value range information from an ASSERT_EXPR EXPR and store
754 it in *VR_P. */
755
756void
757vr_values::extract_range_from_assert (value_range_equiv *vr_p, tree expr)
758{
759 tree var = ASSERT_EXPR_VAR (expr)(*((const_cast<tree*> (tree_operand_check (((tree_check
((expr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 759, __FUNCTION__, (ASSERT_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 759, __FUNCTION__)))))
;
760 tree cond = ASSERT_EXPR_COND (expr)(*((const_cast<tree*> (tree_operand_check (((tree_check
((expr), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 760, __FUNCTION__, (ASSERT_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 760, __FUNCTION__)))))
;
761 tree limit, op;
762 enum tree_code cond_code;
763 gcc_assert (COMPARISON_CLASS_P (cond))((void)(!((tree_code_type[(int) (((enum tree_code) (cond)->
base.code))] == tcc_comparison)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 763, __FUNCTION__), 0 : 0))
;
764
765 /* Find VAR in the ASSERT_EXPR conditional. */
766 if (var == TREE_OPERAND (cond, 0)(*((const_cast<tree*> (tree_operand_check ((cond), (0),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 766, __FUNCTION__)))))
767 || TREE_CODE (TREE_OPERAND (cond, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((cond), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 767, __FUNCTION__))))))->base.code)
== PLUS_EXPR
768 || TREE_CODE (TREE_OPERAND (cond, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((cond), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 768, __FUNCTION__))))))->base.code)
== NOP_EXPR)
769 {
770 /* If the predicate is of the form VAR COMP LIMIT, then we just
771 take LIMIT from the RHS and use the same comparison code. */
772 cond_code = TREE_CODE (cond)((enum tree_code) (cond)->base.code);
773 limit = TREE_OPERAND (cond, 1)(*((const_cast<tree*> (tree_operand_check ((cond), (1),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 773, __FUNCTION__)))))
;
774 op = TREE_OPERAND (cond, 0)(*((const_cast<tree*> (tree_operand_check ((cond), (0),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 774, __FUNCTION__)))))
;
775 }
776 else
777 {
778 /* If the predicate is of the form LIMIT COMP VAR, then we need
779 to flip around the comparison code to create the proper range
780 for VAR. */
781 cond_code = swap_tree_comparison (TREE_CODE (cond)((enum tree_code) (cond)->base.code));
782 limit = TREE_OPERAND (cond, 0)(*((const_cast<tree*> (tree_operand_check ((cond), (0),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 782, __FUNCTION__)))))
;
783 op = TREE_OPERAND (cond, 1)(*((const_cast<tree*> (tree_operand_check ((cond), (1),
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 783, __FUNCTION__)))))
;
784 }
785 extract_range_for_var_from_comparison_expr (var, cond_code, op,
786 limit, vr_p);
787}
788
789/* Extract range information from SSA name VAR and store it in VR. If
790 VAR has an interesting range, use it. Otherwise, create the
791 range [VAR, VAR] and return it. This is useful in situations where
792 we may have conditionals testing values of VARYING names. For
793 instance,
794
795 x_3 = y_5;
796 if (x_3 > y_5)
797 ...
798
799 Even if y_5 is deemed VARYING, we can determine that x_3 > y_5 is
800 always false. */
801
802void
803vr_values::extract_range_from_ssa_name (value_range_equiv *vr, tree var)
804{
805 const value_range_equiv *var_vr = get_value_range (var);
806
807 if (!var_vr->varying_p ())
808 vr->deep_copy (var_vr);
809 else
810 vr->set (var);
811
812 if (!vr->undefined_p ())
813 vr->equiv_add (var, get_value_range (var), &vrp_equiv_obstack);
814}
815
816/* Extract range information from a binary expression OP0 CODE OP1 based on
817 the ranges of each of its operands with resulting type EXPR_TYPE.
818 The resulting range is stored in *VR. */
819
820void
821vr_values::extract_range_from_binary_expr (value_range_equiv *vr,
822 enum tree_code code,
823 tree expr_type, tree op0, tree op1)
824{
825 /* Get value ranges for each operand. For constant operands, create
826 a new value range with the operand to simplify processing. */
827 value_range vr0, vr1;
828 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME)
829 vr0 = *(get_value_range (op0));
830 else if (is_gimple_min_invariant (op0))
831 vr0.set (op0);
832 else
833 vr0.set_varying (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 833, __FUNCTION__))->typed.type)
);
834
835 if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME)
836 vr1 = *(get_value_range (op1));
837 else if (is_gimple_min_invariant (op1))
838 vr1.set (op1);
839 else
840 vr1.set_varying (TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 840, __FUNCTION__))->typed.type)
);
841
842 /* If one argument is varying, we can sometimes still deduce a
843 range for the output: any + [3, +INF] is in [MIN+3, +INF]. */
844 if (INTEGRAL_TYPE_P (TREE_TYPE (op0))(((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 844, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 844, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 844, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
845 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0))((((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 845, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 845, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 845, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 845, __FUNCTION__))->base.u.bits.unsigned_flag &&
!global_options.x_flag_wrapv && !global_options.x_flag_trapv
))
)
846 {
847 if (vr0.varying_p () && !vr1.varying_p ())
848 vr0 = value_range (vrp_val_min (expr_type), vrp_val_max (expr_type));
849 else if (vr1.varying_p () && !vr0.varying_p ())
850 vr1 = value_range (vrp_val_min (expr_type), vrp_val_max (expr_type));
851 }
852
853 range_fold_binary_expr (vr, code, expr_type, &vr0, &vr1);
854
855 /* Set value_range for n in following sequence:
856 def = __builtin_memchr (arg, 0, sz)
857 n = def - arg
858 Here the range for n can be set to [0, PTRDIFF_MAX - 1]. */
859
860 if (vr->varying_p ()
861 && code == POINTER_DIFF_EXPR
862 && TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME
863 && TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME)
864 {
865 tree op0_ptype = TREE_TYPE (TREE_TYPE (op0))((contains_struct_check ((((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 865, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 865, __FUNCTION__))->typed.type)
;
866 tree op1_ptype = TREE_TYPE (TREE_TYPE (op1))((contains_struct_check ((((contains_struct_check ((op1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 866, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 866, __FUNCTION__))->typed.type)
;
867 gcall *call_stmt = NULL__null;
868
869 if (TYPE_MODE (op0_ptype)((((enum tree_code) ((tree_class_check ((op0_ptype), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 869, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(op0_ptype) : (op0_ptype)->type_common.mode)
== TYPE_MODE (char_type_node)((((enum tree_code) ((tree_class_check ((integer_types[itk_char
]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 869, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(integer_types[itk_char]) : (integer_types[itk_char])->type_common
.mode)
870 && TYPE_PRECISION (op0_ptype)((tree_class_check ((op0_ptype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 870, __FUNCTION__))->type_common.precision)
== TYPE_PRECISION (char_type_node)((tree_class_check ((integer_types[itk_char]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 870, __FUNCTION__))->type_common.precision)
871 && TYPE_MODE (op1_ptype)((((enum tree_code) ((tree_class_check ((op1_ptype), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 871, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(op1_ptype) : (op1_ptype)->type_common.mode)
== TYPE_MODE (char_type_node)((((enum tree_code) ((tree_class_check ((integer_types[itk_char
]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 871, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(integer_types[itk_char]) : (integer_types[itk_char])->type_common
.mode)
872 && TYPE_PRECISION (op1_ptype)((tree_class_check ((op1_ptype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 872, __FUNCTION__))->type_common.precision)
== TYPE_PRECISION (char_type_node)((tree_class_check ((integer_types[itk_char]), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 872, __FUNCTION__))->type_common.precision)
873 && (call_stmt = dyn_cast<gcall *>(SSA_NAME_DEF_STMT (op0)(tree_check ((op0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 873, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
))
874 && gimple_call_builtin_p (call_stmt, BUILT_IN_MEMCHR)
875 && operand_equal_p (op0, gimple_call_lhs (call_stmt), 0)
876 && operand_equal_p (op1, gimple_call_arg (call_stmt, 0), 0)
877 && integer_zerop (gimple_call_arg (call_stmt, 1)))
878 {
879 tree max = vrp_val_max (ptrdiff_type_nodeglobal_trees[TI_PTRDIFF_TYPE]);
880 wide_int wmax = wi::to_wide (max, TYPE_PRECISION (TREE_TYPE (max))((tree_class_check ((((contains_struct_check ((max), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 880, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 880, __FUNCTION__))->type_common.precision)
);
881 tree range_min = build_zero_cst (expr_type);
882 tree range_max = wide_int_to_tree (expr_type, wmax - 1);
883 vr->set (range_min, range_max);
884 return;
885 }
886 }
887
888 /* Try harder for PLUS and MINUS if the range of one operand is symbolic
889 and based on the other operand, for example if it was deduced from a
890 symbolic comparison. When a bound of the range of the first operand
891 is invariant, we set the corresponding bound of the new range to INF
892 in order to avoid recursing on the range of the second operand. */
893 if (vr->varying_p ()
894 && (code == PLUS_EXPR || code == MINUS_EXPR)
895 && TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME
896 && vr0.kind () == VR_RANGE
897 && symbolic_range_based_on_p (&vr0, op1))
898 {
899 const bool minus_p = (code == MINUS_EXPR);
900 value_range n_vr1;
901
902 /* Try with VR0 and [-INF, OP1]. */
903 if (is_gimple_min_invariant (minus_p ? vr0.max () : vr0.min ()))
904 n_vr1.set (vrp_val_min (expr_type), op1);
905
906 /* Try with VR0 and [OP1, +INF]. */
907 else if (is_gimple_min_invariant (minus_p ? vr0.min () : vr0.max ()))
908 n_vr1.set (op1, vrp_val_max (expr_type));
909
910 /* Try with VR0 and [OP1, OP1]. */
911 else
912 n_vr1.set (op1, op1);
913
914 range_fold_binary_expr (vr, code, expr_type, &vr0, &n_vr1);
915 }
916
917 if (vr->varying_p ()
918 && (code == PLUS_EXPR || code == MINUS_EXPR)
919 && TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME
920 && vr1.kind () == VR_RANGE
921 && symbolic_range_based_on_p (&vr1, op0))
922 {
923 const bool minus_p = (code == MINUS_EXPR);
924 value_range n_vr0;
925
926 /* Try with [-INF, OP0] and VR1. */
927 if (is_gimple_min_invariant (minus_p ? vr1.max () : vr1.min ()))
928 n_vr0.set (vrp_val_min (expr_type), op0);
929
930 /* Try with [OP0, +INF] and VR1. */
931 else if (is_gimple_min_invariant (minus_p ? vr1.min (): vr1.max ()))
932 n_vr0.set (op0, vrp_val_max (expr_type));
933
934 /* Try with [OP0, OP0] and VR1. */
935 else
936 n_vr0.set (op0);
937
938 range_fold_binary_expr (vr, code, expr_type, &n_vr0, &vr1);
939 }
940
941 /* If we didn't derive a range for MINUS_EXPR, and
942 op1's range is ~[op0,op0] or vice-versa, then we
943 can derive a non-null range. This happens often for
944 pointer subtraction. */
945 if (vr->varying_p ()
946 && (code == MINUS_EXPR || code == POINTER_DIFF_EXPR)
947 && TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME
948 && ((vr0.kind () == VR_ANTI_RANGE
949 && vr0.min () == op1
950 && vr0.min () == vr0.max ())
951 || (vr1.kind () == VR_ANTI_RANGE
952 && vr1.min () == op0
953 && vr1.min () == vr1.max ())))
954 {
955 vr->set_nonzero (expr_type);
956 vr->equiv_clear ();
957 }
958}
959
960/* Extract range information from a unary expression CODE OP0 based on
961 the range of its operand with resulting type TYPE.
962 The resulting range is stored in *VR. */
963
964void
965vr_values::extract_range_from_unary_expr (value_range_equiv *vr,
966 enum tree_code code,
967 tree type, tree op0)
968{
969 value_range vr0;
970
971 /* Get value ranges for the operand. For constant operands, create
972 a new value range with the operand to simplify processing. */
973 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME)
974 vr0 = *(get_value_range (op0));
975 else if (is_gimple_min_invariant (op0))
976 vr0.set (op0);
977 else
978 vr0.set_varying (type);
979
980 range_fold_unary_expr (vr, code, type, &vr0, TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 980, __FUNCTION__))->typed.type)
);
981}
982
983
984/* Extract range information from a conditional expression STMT based on
985 the ranges of each of its operands and the expression code. */
986
987void
988vr_values::extract_range_from_cond_expr (value_range_equiv *vr, gassign *stmt)
989{
990 /* Get value ranges for each operand. For constant operands, create
991 a new value range with the operand to simplify processing. */
992 tree op0 = gimple_assign_rhs2 (stmt);
993 value_range_equiv tem0;
994 const value_range_equiv *vr0 = &tem0;
995 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME)
996 vr0 = get_value_range (op0);
997 else if (is_gimple_min_invariant (op0))
998 tem0.set (op0);
999 else
1000 tem0.set_varying (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1000, __FUNCTION__))->typed.type)
);
1001
1002 tree op1 = gimple_assign_rhs3 (stmt);
1003 value_range_equiv tem1;
1004 const value_range_equiv *vr1 = &tem1;
1005 if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME)
1006 vr1 = get_value_range (op1);
1007 else if (is_gimple_min_invariant (op1))
1008 tem1.set (op1);
1009 else
1010 tem1.set_varying (TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1010, __FUNCTION__))->typed.type)
);
1011
1012 /* The resulting value range is the union of the operand ranges */
1013 vr->deep_copy (vr0);
1014 vr->union_ (vr1);
1015}
1016
1017
1018/* Extract range information from a comparison expression EXPR based
1019 on the range of its operand and the expression code. */
1020
1021void
1022vr_values::extract_range_from_comparison (value_range_equiv *vr,
1023 gimple *stmt)
1024{
1025 enum tree_code code = gimple_assign_rhs_code (stmt);
1026 tree type = gimple_expr_type (stmt);
1027 tree op0 = gimple_assign_rhs1 (stmt);
1028 tree op1 = gimple_assign_rhs2 (stmt);
1029 bool sop;
1030 tree val
1031 = simplifier.vrp_evaluate_conditional_warnv_with_ops (stmt, code, op0, op1,
1032 false, &sop, NULL__null);
1033 if (val)
1034 {
1035 /* Since this expression was found on the RHS of an assignment,
1036 its type may be different from _Bool. Convert VAL to EXPR's
1037 type. */
1038 val = fold_convert (type, val)fold_convert_loc (((location_t) 0), type, val);
1039 if (is_gimple_min_invariant (val))
1040 vr->set (val);
1041 else
1042 vr->update (val, val);
1043 }
1044 else
1045 /* The result of a comparison is always true or false. */
1046 set_value_range_to_truthvalue (vr, type);
1047}
1048
1049/* Helper function for simplify_internal_call_using_ranges and
1050 extract_range_basic. Return true if OP0 SUBCODE OP1 for
1051 SUBCODE {PLUS,MINUS,MULT}_EXPR is known to never overflow or
1052 always overflow. Set *OVF to true if it is known to always
1053 overflow. */
1054
1055static bool
1056check_for_binary_op_overflow (range_query *query,
1057 enum tree_code subcode, tree type,
1058 tree op0, tree op1, bool *ovf)
1059{
1060 value_range vr0, vr1;
1061 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME)
1062 vr0 = *query->get_value_range (op0);
1063 else if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == INTEGER_CST)
1064 vr0.set (op0);
1065 else
1066 vr0.set_varying (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1066, __FUNCTION__))->typed.type)
);
1067
1068 if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME)
1069 vr1 = *query->get_value_range (op1);
1070 else if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == INTEGER_CST)
1071 vr1.set (op1);
1072 else
1073 vr1.set_varying (TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1073, __FUNCTION__))->typed.type)
);
1074
1075 tree vr0min = vr0.min (), vr0max = vr0.max ();
1076 tree vr1min = vr1.min (), vr1max = vr1.max ();
1077 if (!range_int_cst_p (&vr0)
1078 || TREE_OVERFLOW (vr0min)((tree_class_check ((vr0min), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1078, __FUNCTION__))->base.public_flag)
1079 || TREE_OVERFLOW (vr0max)((tree_class_check ((vr0max), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1079, __FUNCTION__))->base.public_flag)
)
1080 {
1081 vr0min = vrp_val_min (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1081, __FUNCTION__))->typed.type)
);
1082 vr0max = vrp_val_max (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1082, __FUNCTION__))->typed.type)
);
1083 }
1084 if (!range_int_cst_p (&vr1)
1085 || TREE_OVERFLOW (vr1min)((tree_class_check ((vr1min), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1085, __FUNCTION__))->base.public_flag)
1086 || TREE_OVERFLOW (vr1max)((tree_class_check ((vr1max), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1086, __FUNCTION__))->base.public_flag)
)
1087 {
1088 vr1min = vrp_val_min (TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1088, __FUNCTION__))->typed.type)
);
1089 vr1max = vrp_val_max (TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1089, __FUNCTION__))->typed.type)
);
1090 }
1091 *ovf = arith_overflowed_p (subcode, type, vr0min,
1092 subcode == MINUS_EXPR ? vr1max : vr1min);
1093 if (arith_overflowed_p (subcode, type, vr0max,
1094 subcode == MINUS_EXPR ? vr1min : vr1max) != *ovf)
1095 return false;
1096 if (subcode == MULT_EXPR)
1097 {
1098 if (arith_overflowed_p (subcode, type, vr0min, vr1max) != *ovf
1099 || arith_overflowed_p (subcode, type, vr0max, vr1min) != *ovf)
1100 return false;
1101 }
1102 if (*ovf)
1103 {
1104 /* So far we found that there is an overflow on the boundaries.
1105 That doesn't prove that there is an overflow even for all values
1106 in between the boundaries. For that compute widest_int range
1107 of the result and see if it doesn't overlap the range of
1108 type. */
1109 widest_int wmin, wmax;
1110 widest_int w[4];
1111 int i;
1112 w[0] = wi::to_widest (vr0min);
1113 w[1] = wi::to_widest (vr0max);
1114 w[2] = wi::to_widest (vr1min);
1115 w[3] = wi::to_widest (vr1max);
1116 for (i = 0; i < 4; i++)
1117 {
1118 widest_int wt;
1119 switch (subcode)
1120 {
1121 case PLUS_EXPR:
1122 wt = wi::add (w[i & 1], w[2 + (i & 2) / 2]);
1123 break;
1124 case MINUS_EXPR:
1125 wt = wi::sub (w[i & 1], w[2 + (i & 2) / 2]);
1126 break;
1127 case MULT_EXPR:
1128 wt = wi::mul (w[i & 1], w[2 + (i & 2) / 2]);
1129 break;
1130 default:
1131 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1131, __FUNCTION__))
;
1132 }
1133 if (i == 0)
1134 {
1135 wmin = wt;
1136 wmax = wt;
1137 }
1138 else
1139 {
1140 wmin = wi::smin (wmin, wt);
1141 wmax = wi::smax (wmax, wt);
1142 }
1143 }
1144 /* The result of op0 CODE op1 is known to be in range
1145 [wmin, wmax]. */
1146 widest_int wtmin = wi::to_widest (vrp_val_min (type));
1147 widest_int wtmax = wi::to_widest (vrp_val_max (type));
1148 /* If all values in [wmin, wmax] are smaller than
1149 [wtmin, wtmax] or all are larger than [wtmin, wtmax],
1150 the arithmetic operation will always overflow. */
1151 if (wmax < wtmin || wmin > wtmax)
1152 return true;
1153 return false;
1154 }
1155 return true;
1156}
1157
1158/* Derive a range from a builtin. Set range in VR and return TRUE if
1159 successful. */
1160
1161bool
1162vr_values::extract_range_from_ubsan_builtin (value_range_equiv *vr, gimple *stmt)
1163{
1164 gcc_assert (is_gimple_call (stmt))((void)(!(is_gimple_call (stmt)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1164, __FUNCTION__), 0 : 0))
;
1165 tree type = gimple_expr_type (stmt);
1166 enum tree_code subcode = ERROR_MARK;
1167 combined_fn cfn = gimple_call_combined_fn (stmt);
1168 scalar_int_mode mode;
1169
1170 switch (cfn)
1171 {
1172 case CFN_UBSAN_CHECK_ADD:
1173 subcode = PLUS_EXPR;
1174 break;
1175 case CFN_UBSAN_CHECK_SUB:
1176 subcode = MINUS_EXPR;
1177 break;
1178 case CFN_UBSAN_CHECK_MUL:
1179 subcode = MULT_EXPR;
1180 break;
1181 default:
1182 break;
1183 }
1184 if (subcode != ERROR_MARK)
1185 {
1186 bool saved_flag_wrapv = flag_wrapvglobal_options.x_flag_wrapv;
1187 /* Pretend the arithmetics is wrapping. If there is
1188 any overflow, we'll complain, but will actually do
1189 wrapping operation. */
1190 flag_wrapvglobal_options.x_flag_wrapv = 1;
1191 extract_range_from_binary_expr (vr, subcode, type,
1192 gimple_call_arg (stmt, 0),
1193 gimple_call_arg (stmt, 1));
1194 flag_wrapvglobal_options.x_flag_wrapv = saved_flag_wrapv;
1195
1196 /* If for both arguments vrp_valueize returned non-NULL,
1197 this should have been already folded and if not, it
1198 wasn't folded because of overflow. Avoid removing the
1199 UBSAN_CHECK_* calls in that case. */
1200 if (vr->kind () == VR_RANGE
1201 && (vr->min () == vr->max ()
1202 || operand_equal_p (vr->min (), vr->max (), 0)))
1203 vr->set_varying (vr->type ());
1204
1205 return !vr->varying_p ();
1206 }
1207 return false;
1208}
1209
1210/* Try to derive a nonnegative or nonzero range out of STMT relying
1211 primarily on generic routines in fold in conjunction with range data.
1212 Store the result in *VR */
1213
1214void
1215vr_values::extract_range_basic (value_range_equiv *vr, gimple *stmt)
1216{
1217 bool sop;
1218 tree type = gimple_expr_type (stmt);
1219
1220 if (is_gimple_call (stmt))
1221 {
1222 combined_fn cfn = gimple_call_combined_fn (stmt);
1223 switch (cfn)
1224 {
1225 case CFN_UBSAN_CHECK_ADD:
1226 case CFN_UBSAN_CHECK_SUB:
1227 case CFN_UBSAN_CHECK_MUL:
1228 if (extract_range_from_ubsan_builtin (vr, stmt))
1229 return;
1230 break;
1231 default:
1232 if (range_of_builtin_call (*this, *vr, as_a<gcall *> (stmt)))
1233 {
1234 /* The original code nuked equivalences every time a
1235 range was found, so do the same here. */
1236 vr->equiv_clear ();
1237 return;
1238 }
1239 break;
1240 }
1241 }
1242 /* Handle extraction of the two results (result of arithmetics and
1243 a flag whether arithmetics overflowed) from {ADD,SUB,MUL}_OVERFLOW
1244 internal function. Similarly from ATOMIC_COMPARE_EXCHANGE. */
1245 else if (is_gimple_assign (stmt)
1246 && (gimple_assign_rhs_code (stmt) == REALPART_EXPR
1247 || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR)
1248 && INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
)
1249 {
1250 enum tree_code code = gimple_assign_rhs_code (stmt);
1251 tree op = gimple_assign_rhs1 (stmt);
1252 if (TREE_CODE (op)((enum tree_code) (op)->base.code) == code && TREE_CODE (TREE_OPERAND (op, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((op), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1252, __FUNCTION__))))))->base.code)
== SSA_NAME)
1253 {
1254 gimple *g = SSA_NAME_DEF_STMT (TREE_OPERAND (op, 0))(tree_check (((*((const_cast<tree*> (tree_operand_check
((op), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1254, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1254, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
;
1255 if (is_gimple_call (g) && gimple_call_internal_p (g))
1256 {
1257 enum tree_code subcode = ERROR_MARK;
1258 switch (gimple_call_internal_fn (g))
1259 {
1260 case IFN_ADD_OVERFLOW:
1261 subcode = PLUS_EXPR;
1262 break;
1263 case IFN_SUB_OVERFLOW:
1264 subcode = MINUS_EXPR;
1265 break;
1266 case IFN_MUL_OVERFLOW:
1267 subcode = MULT_EXPR;
1268 break;
1269 case IFN_ATOMIC_COMPARE_EXCHANGE:
1270 if (code == IMAGPART_EXPR)
1271 {
1272 /* This is the boolean return value whether compare and
1273 exchange changed anything or not. */
1274 vr->set (build_int_cst (type, 0),
1275 build_int_cst (type, 1));
1276 return;
1277 }
1278 break;
1279 default:
1280 break;
1281 }
1282 if (subcode != ERROR_MARK)
1283 {
1284 tree op0 = gimple_call_arg (g, 0);
1285 tree op1 = gimple_call_arg (g, 1);
1286 if (code == IMAGPART_EXPR)
1287 {
1288 bool ovf = false;
1289 if (check_for_binary_op_overflow (this, subcode, type,
1290 op0, op1, &ovf))
1291 vr->set (build_int_cst (type, ovf));
1292 else if (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1292, __FUNCTION__))->type_common.precision)
== 1
1293 && !TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1293, __FUNCTION__))->base.u.bits.unsigned_flag)
)
1294 vr->set_varying (type);
1295 else
1296 vr->set (build_int_cst (type, 0),
1297 build_int_cst (type, 1));
1298 }
1299 else if (types_compatible_p (type, TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1299, __FUNCTION__))->typed.type)
)
1300 && types_compatible_p (type, TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1300, __FUNCTION__))->typed.type)
))
1301 {
1302 bool saved_flag_wrapv = flag_wrapvglobal_options.x_flag_wrapv;
1303 /* Pretend the arithmetics is wrapping. If there is
1304 any overflow, IMAGPART_EXPR will be set. */
1305 flag_wrapvglobal_options.x_flag_wrapv = 1;
1306 extract_range_from_binary_expr (vr, subcode, type,
1307 op0, op1);
1308 flag_wrapvglobal_options.x_flag_wrapv = saved_flag_wrapv;
1309 }
1310 else
1311 {
1312 value_range_equiv vr0, vr1;
1313 bool saved_flag_wrapv = flag_wrapvglobal_options.x_flag_wrapv;
1314 /* Pretend the arithmetics is wrapping. If there is
1315 any overflow, IMAGPART_EXPR will be set. */
1316 flag_wrapvglobal_options.x_flag_wrapv = 1;
1317 extract_range_from_unary_expr (&vr0, NOP_EXPR,
1318 type, op0);
1319 extract_range_from_unary_expr (&vr1, NOP_EXPR,
1320 type, op1);
1321 range_fold_binary_expr (vr, subcode, type, &vr0, &vr1);
1322 flag_wrapvglobal_options.x_flag_wrapv = saved_flag_wrapv;
1323 }
1324 return;
1325 }
1326 }
1327 }
1328 }
1329 if (INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
1330 && gimple_stmt_nonnegative_warnv_p (stmt, &sop))
1331 set_value_range_to_nonnegative (vr, type);
1332 else if (vrp_stmt_computes_nonzero (stmt))
1333 {
1334 vr->set_nonzero (type);
1335 vr->equiv_clear ();
1336 }
1337 else
1338 vr->set_varying (type);
1339}
1340
1341
1342/* Try to compute a useful range out of assignment STMT and store it
1343 in *VR. */
1344
1345void
1346vr_values::extract_range_from_assignment (value_range_equiv *vr, gassign *stmt)
1347{
1348 enum tree_code code = gimple_assign_rhs_code (stmt);
1349
1350 if (code == ASSERT_EXPR)
1351 extract_range_from_assert (vr, gimple_assign_rhs1 (stmt));
1352 else if (code == SSA_NAME)
1353 extract_range_from_ssa_name (vr, gimple_assign_rhs1 (stmt));
1354 else if (TREE_CODE_CLASS (code)tree_code_type[(int) (code)] == tcc_binary)
1355 extract_range_from_binary_expr (vr, gimple_assign_rhs_code (stmt),
1356 gimple_expr_type (stmt),
1357 gimple_assign_rhs1 (stmt),
1358 gimple_assign_rhs2 (stmt));
1359 else if (TREE_CODE_CLASS (code)tree_code_type[(int) (code)] == tcc_unary)
1360 extract_range_from_unary_expr (vr, gimple_assign_rhs_code (stmt),
1361 gimple_expr_type (stmt),
1362 gimple_assign_rhs1 (stmt));
1363 else if (code == COND_EXPR)
1364 extract_range_from_cond_expr (vr, stmt);
1365 else if (TREE_CODE_CLASS (code)tree_code_type[(int) (code)] == tcc_comparison)
1366 extract_range_from_comparison (vr, stmt);
1367 else if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS
1368 && is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
1369 vr->set (gimple_assign_rhs1 (stmt));
1370 else
1371 vr->set_varying (TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1371, __FUNCTION__))->typed.type)
);
1372
1373 if (vr->varying_p ())
1374 extract_range_basic (vr, stmt);
1375}
1376
1377/* Given two numeric value ranges VR0, VR1 and a comparison code COMP:
1378
1379 - Return BOOLEAN_TRUE_NODE if VR0 COMP VR1 always returns true for
1380 all the values in the ranges.
1381
1382 - Return BOOLEAN_FALSE_NODE if the comparison always returns false.
1383
1384 - Return NULL_TREE if it is not always possible to determine the
1385 value of the comparison.
1386
1387 Also set *STRICT_OVERFLOW_P to indicate whether comparision evaluation
1388 assumed signed overflow is undefined. */
1389
1390
1391static tree
1392compare_ranges (enum tree_code comp, const value_range_equiv *vr0,
1393 const value_range_equiv *vr1, bool *strict_overflow_p)
1394{
1395 /* VARYING or UNDEFINED ranges cannot be compared. */
1396 if (vr0->varying_p ()
1397 || vr0->undefined_p ()
1398 || vr1->varying_p ()
1399 || vr1->undefined_p ())
1400 return NULL_TREE(tree) __null;
1401
1402 /* Anti-ranges need to be handled separately. */
1403 if (vr0->kind () == VR_ANTI_RANGE || vr1->kind () == VR_ANTI_RANGE)
1404 {
1405 /* If both are anti-ranges, then we cannot compute any
1406 comparison. */
1407 if (vr0->kind () == VR_ANTI_RANGE && vr1->kind () == VR_ANTI_RANGE)
1408 return NULL_TREE(tree) __null;
1409
1410 /* These comparisons are never statically computable. */
1411 if (comp == GT_EXPR
1412 || comp == GE_EXPR
1413 || comp == LT_EXPR
1414 || comp == LE_EXPR)
1415 return NULL_TREE(tree) __null;
1416
1417 /* Equality can be computed only between a range and an
1418 anti-range. ~[VAL1, VAL2] == [VAL1, VAL2] is always false. */
1419 if (vr0->kind () == VR_RANGE)
1420 /* To simplify processing, make VR0 the anti-range. */
1421 std::swap (vr0, vr1);
1422
1423 gcc_assert (comp == NE_EXPR || comp == EQ_EXPR)((void)(!(comp == NE_EXPR || comp == EQ_EXPR) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1423, __FUNCTION__), 0 : 0))
;
1424
1425 if (compare_values_warnv (vr0->min (), vr1->min (), strict_overflow_p) == 0
1426 && compare_values_warnv (vr0->max (), vr1->max (), strict_overflow_p) == 0)
1427 return (comp == NE_EXPR) ? boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE] : boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1428
1429 return NULL_TREE(tree) __null;
1430 }
1431
1432 /* Simplify processing. If COMP is GT_EXPR or GE_EXPR, switch the
1433 operands around and change the comparison code. */
1434 if (comp == GT_EXPR || comp == GE_EXPR)
1435 {
1436 comp = (comp == GT_EXPR) ? LT_EXPR : LE_EXPR;
1437 std::swap (vr0, vr1);
1438 }
1439
1440 if (comp == EQ_EXPR)
1441 {
1442 /* Equality may only be computed if both ranges represent
1443 exactly one value. */
1444 if (compare_values_warnv (vr0->min (), vr0->max (), strict_overflow_p) == 0
1445 && compare_values_warnv (vr1->min (), vr1->max (), strict_overflow_p) == 0)
1446 {
1447 int cmp_min = compare_values_warnv (vr0->min (), vr1->min (),
1448 strict_overflow_p);
1449 int cmp_max = compare_values_warnv (vr0->max (), vr1->max (),
1450 strict_overflow_p);
1451 if (cmp_min == 0 && cmp_max == 0)
1452 return boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
1453 else if (cmp_min != -2 && cmp_max != -2)
1454 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1455 }
1456 /* If [V0_MIN, V1_MAX] < [V1_MIN, V1_MAX] then V0 != V1. */
1457 else if (compare_values_warnv (vr0->min (), vr1->max (),
1458 strict_overflow_p) == 1
1459 || compare_values_warnv (vr1->min (), vr0->max (),
1460 strict_overflow_p) == 1)
1461 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1462
1463 return NULL_TREE(tree) __null;
1464 }
1465 else if (comp == NE_EXPR)
1466 {
1467 int cmp1, cmp2;
1468
1469 /* If VR0 is completely to the left or completely to the right
1470 of VR1, they are always different. Notice that we need to
1471 make sure that both comparisons yield similar results to
1472 avoid comparing values that cannot be compared at
1473 compile-time. */
1474 cmp1 = compare_values_warnv (vr0->max (), vr1->min (), strict_overflow_p);
1475 cmp2 = compare_values_warnv (vr0->min (), vr1->max (), strict_overflow_p);
1476 if ((cmp1 == -1 && cmp2 == -1) || (cmp1 == 1 && cmp2 == 1))
1477 return boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
1478
1479 /* If VR0 and VR1 represent a single value and are identical,
1480 return false. */
1481 else if (compare_values_warnv (vr0->min (), vr0->max (),
1482 strict_overflow_p) == 0
1483 && compare_values_warnv (vr1->min (), vr1->max (),
1484 strict_overflow_p) == 0
1485 && compare_values_warnv (vr0->min (), vr1->min (),
1486 strict_overflow_p) == 0
1487 && compare_values_warnv (vr0->max (), vr1->max (),
1488 strict_overflow_p) == 0)
1489 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1490
1491 /* Otherwise, they may or may not be different. */
1492 else
1493 return NULL_TREE(tree) __null;
1494 }
1495 else if (comp == LT_EXPR || comp == LE_EXPR)
1496 {
1497 int tst;
1498
1499 /* If VR0 is to the left of VR1, return true. */
1500 tst = compare_values_warnv (vr0->max (), vr1->min (), strict_overflow_p);
1501 if ((comp == LT_EXPR && tst == -1)
1502 || (comp == LE_EXPR && (tst == -1 || tst == 0)))
1503 return boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
1504
1505 /* If VR0 is to the right of VR1, return false. */
1506 tst = compare_values_warnv (vr0->min (), vr1->max (), strict_overflow_p);
1507 if ((comp == LT_EXPR && (tst == 0 || tst == 1))
1508 || (comp == LE_EXPR && tst == 1))
1509 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1510
1511 /* Otherwise, we don't know. */
1512 return NULL_TREE(tree) __null;
1513 }
1514
1515 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1515, __FUNCTION__))
;
1516}
1517
1518/* Given a value range VR, a value VAL and a comparison code COMP, return
1519 BOOLEAN_TRUE_NODE if VR COMP VAL always returns true for all the
1520 values in VR. Return BOOLEAN_FALSE_NODE if the comparison
1521 always returns false. Return NULL_TREE if it is not always
1522 possible to determine the value of the comparison. Also set
1523 *STRICT_OVERFLOW_P to indicate whether comparision evaluation
1524 assumed signed overflow is undefined. */
1525
1526static tree
1527compare_range_with_value (enum tree_code comp, const value_range *vr,
1528 tree val, bool *strict_overflow_p)
1529{
1530 if (vr->varying_p () || vr->undefined_p ())
1531 return NULL_TREE(tree) __null;
1532
1533 /* Anti-ranges need to be handled separately. */
1534 if (vr->kind () == VR_ANTI_RANGE)
1535 {
1536 /* For anti-ranges, the only predicates that we can compute at
1537 compile time are equality and inequality. */
1538 if (comp == GT_EXPR
1539 || comp == GE_EXPR
1540 || comp == LT_EXPR
1541 || comp == LE_EXPR)
1542 return NULL_TREE(tree) __null;
1543
1544 /* ~[VAL_1, VAL_2] OP VAL is known if VAL_1 <= VAL <= VAL_2. */
1545 if (!vr->may_contain_p (val))
1546 return (comp == NE_EXPR) ? boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE] : boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1547
1548 return NULL_TREE(tree) __null;
1549 }
1550
1551 if (comp == EQ_EXPR)
1552 {
1553 /* EQ_EXPR may only be computed if VR represents exactly
1554 one value. */
1555 if (compare_values_warnv (vr->min (), vr->max (), strict_overflow_p) == 0)
1556 {
1557 int cmp = compare_values_warnv (vr->min (), val, strict_overflow_p);
1558 if (cmp == 0)
1559 return boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
1560 else if (cmp == -1 || cmp == 1 || cmp == 2)
1561 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1562 }
1563 else if (compare_values_warnv (val, vr->min (), strict_overflow_p) == -1
1564 || compare_values_warnv (vr->max (), val, strict_overflow_p) == -1)
1565 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1566
1567 return NULL_TREE(tree) __null;
1568 }
1569 else if (comp == NE_EXPR)
1570 {
1571 /* If VAL is not inside VR, then they are always different. */
1572 if (compare_values_warnv (vr->max (), val, strict_overflow_p) == -1
1573 || compare_values_warnv (vr->min (), val, strict_overflow_p) == 1)
1574 return boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
1575
1576 /* If VR represents exactly one value equal to VAL, then return
1577 false. */
1578 if (compare_values_warnv (vr->min (), vr->max (), strict_overflow_p) == 0
1579 && compare_values_warnv (vr->min (), val, strict_overflow_p) == 0)
1580 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1581
1582 /* Otherwise, they may or may not be different. */
1583 return NULL_TREE(tree) __null;
1584 }
1585 else if (comp == LT_EXPR || comp == LE_EXPR)
1586 {
1587 int tst;
1588
1589 /* If VR is to the left of VAL, return true. */
1590 tst = compare_values_warnv (vr->max (), val, strict_overflow_p);
1591 if ((comp == LT_EXPR && tst == -1)
1592 || (comp == LE_EXPR && (tst == -1 || tst == 0)))
1593 return boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
1594
1595 /* If VR is to the right of VAL, return false. */
1596 tst = compare_values_warnv (vr->min (), val, strict_overflow_p);
1597 if ((comp == LT_EXPR && (tst == 0 || tst == 1))
1598 || (comp == LE_EXPR && tst == 1))
1599 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1600
1601 /* Otherwise, we don't know. */
1602 return NULL_TREE(tree) __null;
1603 }
1604 else if (comp == GT_EXPR || comp == GE_EXPR)
1605 {
1606 int tst;
1607
1608 /* If VR is to the right of VAL, return true. */
1609 tst = compare_values_warnv (vr->min (), val, strict_overflow_p);
1610 if ((comp == GT_EXPR && tst == 1)
1611 || (comp == GE_EXPR && (tst == 0 || tst == 1)))
1612 return boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
1613
1614 /* If VR is to the left of VAL, return false. */
1615 tst = compare_values_warnv (vr->max (), val, strict_overflow_p);
1616 if ((comp == GT_EXPR && (tst == -1 || tst == 0))
1617 || (comp == GE_EXPR && tst == -1))
1618 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
1619
1620 /* Otherwise, we don't know. */
1621 return NULL_TREE(tree) __null;
1622 }
1623
1624 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1624, __FUNCTION__))
;
1625}
1626
1627/* Given a VAR in STMT within LOOP, determine the bounds of the
1628 variable and store it in MIN/MAX and return TRUE. If no bounds
1629 could be determined, return FALSE. */
1630
1631bool
1632bounds_of_var_in_loop (tree *min, tree *max, range_query *query,
1633 class loop *loop, gimple *stmt, tree var)
1634{
1635 tree init, step, chrec, tmin, tmax, type = TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1635, __FUNCTION__))->typed.type)
;
1636 enum ev_direction dir;
1637
1638 chrec = instantiate_parameters (loop, analyze_scalar_evolution (loop, var));
1639
1640 /* Like in PR19590, scev can return a constant function. */
1641 if (is_gimple_min_invariant (chrec))
1642 {
1643 *min = *max = chrec;
1644 goto fix_overflow;
1645 }
1646
1647 if (TREE_CODE (chrec)((enum tree_code) (chrec)->base.code) != POLYNOMIAL_CHREC)
1648 return false;
1649
1650 init = initial_condition_in_loop_num (chrec, loop->num);
1651 step = evolution_part_in_loop_num (chrec, loop->num);
1652
1653 /* If INIT is an SSA with a singleton range, set INIT to said
1654 singleton, otherwise leave INIT alone. */
1655 if (TREE_CODE (init)((enum tree_code) (init)->base.code) == SSA_NAME)
1656 query->get_value_range (init, stmt)->singleton_p (&init);
1657 /* Likewise for step. */
1658 if (TREE_CODE (step)((enum tree_code) (step)->base.code) == SSA_NAME)
1659 query->get_value_range (step, stmt)->singleton_p (&step);
1660
1661 /* If STEP is symbolic, we can't know whether INIT will be the
1662 minimum or maximum value in the range. Also, unless INIT is
1663 a simple expression, compare_values and possibly other functions
1664 in tree-vrp won't be able to handle it. */
1665 if (step == NULL_TREE(tree) __null
1666 || !is_gimple_min_invariant (step)
1667 || !valid_value_p (init))
1668 return false;
1669
1670 dir = scev_direction (chrec);
1671 if (/* Do not adjust ranges if we do not know whether the iv increases
1672 or decreases, ... */
1673 dir == EV_DIR_UNKNOWN
1674 /* ... or if it may wrap. */
1675 || scev_probably_wraps_p (NULL_TREE(tree) __null, init, step, stmt,
1676 get_chrec_loop (chrec), true))
1677 return false;
1678
1679 if (POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE)
|| !TYPE_MIN_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1679, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
)
1680 tmin = lower_bound_in_type (type, type);
1681 else
1682 tmin = TYPE_MIN_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1682, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
;
1683 if (POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE)
|| !TYPE_MAX_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1683, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
)
1684 tmax = upper_bound_in_type (type, type);
1685 else
1686 tmax = TYPE_MAX_VALUE (type)((tree_check5 ((type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1686, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
;
1687
1688 /* Try to use estimated number of iterations for the loop to constrain the
1689 final value in the evolution. */
1690 if (TREE_CODE (step)((enum tree_code) (step)->base.code) == INTEGER_CST
1691 && is_gimple_val (init)
1692 && (TREE_CODE (init)((enum tree_code) (init)->base.code) != SSA_NAME
1693 || query->get_value_range (init, stmt)->kind () == VR_RANGE))
1694 {
1695 widest_int nit;
1696
1697 /* We are only entering here for loop header PHI nodes, so using
1698 the number of latch executions is the correct thing to use. */
1699 if (max_loop_iterations (loop, &nit))
1700 {
1701 signop sgn = TYPE_SIGN (TREE_TYPE (step))((signop) ((tree_class_check ((((contains_struct_check ((step
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1701, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1701, __FUNCTION__))->base.u.bits.unsigned_flag))
;
1702 wi::overflow_type overflow;
1703
1704 widest_int wtmp = wi::mul (wi::to_widest (step), nit, sgn,
1705 &overflow);
1706 /* If the multiplication overflowed we can't do a meaningful
1707 adjustment. Likewise if the result doesn't fit in the type
1708 of the induction variable. For a signed type we have to
1709 check whether the result has the expected signedness which
1710 is that of the step as number of iterations is unsigned. */
1711 if (!overflow
1712 && wi::fits_to_tree_p (wtmp, TREE_TYPE (init)((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1712, __FUNCTION__))->typed.type)
)
1713 && (sgn == UNSIGNED
1714 || wi::gts_p (wtmp, 0) == wi::gts_p (wi::to_wide (step), 0)))
1715 {
1716 value_range maxvr, vr0, vr1;
1717 if (TREE_CODE (init)((enum tree_code) (init)->base.code) == SSA_NAME)
1718 vr0 = *(query->get_value_range (init, stmt));
1719 else if (is_gimple_min_invariant (init))
1720 vr0.set (init);
1721 else
1722 vr0.set_varying (TREE_TYPE (init)((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1722, __FUNCTION__))->typed.type)
);
1723 tree tem = wide_int_to_tree (TREE_TYPE (init)((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1723, __FUNCTION__))->typed.type)
, wtmp);
1724 vr1.set (tem, tem);
1725 range_fold_binary_expr (&maxvr, PLUS_EXPR,
1726 TREE_TYPE (init)((contains_struct_check ((init), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1726, __FUNCTION__))->typed.type)
, &vr0, &vr1);
1727
1728 /* Likewise if the addition did. */
1729 if (maxvr.kind () == VR_RANGE)
1730 {
1731 value_range initvr;
1732
1733 if (TREE_CODE (init)((enum tree_code) (init)->base.code) == SSA_NAME)
1734 initvr = *(query->get_value_range (init, stmt));
1735 else if (is_gimple_min_invariant (init))
1736 initvr.set (init);
1737 else
1738 return false;
1739
1740 /* Check if init + nit * step overflows. Though we checked
1741 scev {init, step}_loop doesn't wrap, it is not enough
1742 because the loop may exit immediately. Overflow could
1743 happen in the plus expression in this case. */
1744 if ((dir == EV_DIR_DECREASES
1745 && compare_values (maxvr.min (), initvr.min ()) != -1)
1746 || (dir == EV_DIR_GROWS
1747 && compare_values (maxvr.max (), initvr.max ()) != 1))
1748 return false;
1749
1750 tmin = maxvr.min ();
1751 tmax = maxvr.max ();
1752 }
1753 }
1754 }
1755 }
1756
1757 *min = tmin;
1758 *max = tmax;
1759 if (dir == EV_DIR_DECREASES)
1760 *max = init;
1761 else
1762 *min = init;
1763
1764 fix_overflow:
1765 /* Even for valid range info, sometimes overflow flag will leak in.
1766 As GIMPLE IL should have no constants with TREE_OVERFLOW set, we
1767 drop them. */
1768 if (TREE_OVERFLOW_P (*min)((tree_code_type[(int) (((enum tree_code) (*min)->base.code
))] == tcc_constant) && ((tree_class_check ((*min), (
tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1768, __FUNCTION__))->base.public_flag))
)
1769 *min = drop_tree_overflow (*min);
1770 if (TREE_OVERFLOW_P (*max)((tree_code_type[(int) (((enum tree_code) (*max)->base.code
))] == tcc_constant) && ((tree_class_check ((*max), (
tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1770, __FUNCTION__))->base.public_flag))
)
1771 *max = drop_tree_overflow (*max);
1772
1773 gcc_checking_assert (compare_values (*min, *max) != 1)((void)(!(compare_values (*min, *max) != 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1773, __FUNCTION__), 0 : 0))
;
1774 return true;
1775}
1776
1777/* Given a range VR, a LOOP and a variable VAR, determine whether it
1778 would be profitable to adjust VR using scalar evolution information
1779 for VAR. If so, update VR with the new limits. */
1780
1781void
1782vr_values::adjust_range_with_scev (value_range_equiv *vr, class loop *loop,
1783 gimple *stmt, tree var)
1784{
1785 tree min, max;
1786 if (bounds_of_var_in_loop (&min, &max, this, loop, stmt, var))
1787 {
1788 if (vr->undefined_p () || vr->varying_p ())
1789 {
1790 /* For VARYING or UNDEFINED ranges, just about anything we get
1791 from scalar evolutions should be better. */
1792 vr->update (min, max);
1793 }
1794 else if (vr->kind () == VR_RANGE)
1795 {
1796 /* Start with the input range... */
1797 tree vrmin = vr->min ();
1798 tree vrmax = vr->max ();
1799
1800 /* ...and narrow it down with what we got from SCEV. */
1801 if (compare_values (min, vrmin) == 1)
1802 vrmin = min;
1803 if (compare_values (max, vrmax) == -1)
1804 vrmax = max;
1805
1806 vr->update (vrmin, vrmax);
1807 }
1808 else if (vr->kind () == VR_ANTI_RANGE)
1809 {
1810 /* ?? As an enhancement, if VR, MIN, and MAX are constants, one
1811 could just intersect VR with a range of [MIN,MAX]. */
1812 }
1813 }
1814}
1815
1816/* Dump value ranges of all SSA_NAMEs to FILE. */
1817
1818void
1819vr_values::dump_all_value_ranges (FILE *file)
1820{
1821 size_t i;
1822
1823 for (i = 0; i < num_vr_values; i++)
1824 {
1825 if (vr_value[i] && ssa_name (i)((*(cfun + 0)->gimple_df->ssa_names)[(i)]))
1826 {
1827 print_generic_expr (file, ssa_name (i)((*(cfun + 0)->gimple_df->ssa_names)[(i)]));
1828 fprintf (file, ": ");
1829 dump_value_range (file, vr_value[i]);
1830 fprintf (file, "\n");
1831 }
1832 }
1833
1834 fprintf (file, "\n");
1835}
1836
1837/* Initialize VRP lattice. */
1838
1839vr_values::vr_values () : simplifier (this)
1840{
1841 values_propagated = false;
1842 num_vr_values = num_ssa_names(vec_safe_length ((cfun + 0)->gimple_df->ssa_names)) * 2;
1843 vr_value = XCNEWVEC (value_range_equiv *, num_vr_values)((value_range_equiv * *) xcalloc ((num_vr_values), sizeof (value_range_equiv
*)))
;
1844 vr_phi_edge_counts = XCNEWVEC (int, num_ssa_names)((int *) xcalloc (((vec_safe_length ((cfun + 0)->gimple_df
->ssa_names))), sizeof (int)))
;
1845 bitmap_obstack_initialize (&vrp_equiv_obstack);
1846}
1847
1848/* Free VRP lattice. */
1849
1850vr_values::~vr_values ()
1851{
1852 /* Free allocated memory. */
1853 free (vr_value);
1854 free (vr_phi_edge_counts);
1855 bitmap_obstack_release (&vrp_equiv_obstack);
1856
1857 /* So that we can distinguish between VRP data being available
1858 and not available. */
1859 vr_value = NULL__null;
1860 vr_phi_edge_counts = NULL__null;
1861}
1862
1863
1864/* A hack. */
1865static class vr_values *x_vr_values;
1866
1867/* Return the singleton value-range for NAME or NAME. */
1868
1869static inline tree
1870vrp_valueize (tree name)
1871{
1872 if (TREE_CODE (name)((enum tree_code) (name)->base.code) == SSA_NAME)
1873 {
1874 const value_range_equiv *vr = x_vr_values->get_value_range (name);
1875 if (vr->kind () == VR_RANGE
1876 && (TREE_CODE (vr->min ())((enum tree_code) (vr->min ())->base.code) == SSA_NAME
1877 || is_gimple_min_invariant (vr->min ()))
1878 && vrp_operand_equal_p (vr->min (), vr->max ()))
1879 return vr->min ();
1880 }
1881 return name;
1882}
1883
1884/* Return the singleton value-range for NAME if that is a constant
1885 but signal to not follow SSA edges. */
1886
1887static inline tree
1888vrp_valueize_1 (tree name)
1889{
1890 if (TREE_CODE (name)((enum tree_code) (name)->base.code) == SSA_NAME)
1891 {
1892 /* If the definition may be simulated again we cannot follow
1893 this SSA edge as the SSA propagator does not necessarily
1894 re-visit the use. */
1895 gimple *def_stmt = SSA_NAME_DEF_STMT (name)(tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1895, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
;
1896 if (!gimple_nop_p (def_stmt)
1897 && prop_simulate_again_p (def_stmt))
1898 return NULL_TREE(tree) __null;
1899 const value_range_equiv *vr = x_vr_values->get_value_range (name);
1900 tree singleton;
1901 if (vr->singleton_p (&singleton))
1902 return singleton;
1903 }
1904 return name;
1905}
1906
1907/* Given STMT, an assignment or call, return its LHS if the type
1908 of the LHS is suitable for VRP analysis, else return NULL_TREE. */
1909
1910tree
1911get_output_for_vrp (gimple *stmt)
1912{
1913 if (!is_gimple_assign (stmt) && !is_gimple_call (stmt))
1914 return NULL_TREE(tree) __null;
1915
1916 /* We only keep track of ranges in integral and pointer types. */
1917 tree lhs = gimple_get_lhs (stmt);
1918 if (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == SSA_NAME
1919 && ((INTEGRAL_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1919, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1919, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1919, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
1920 /* It is valid to have NULL MIN/MAX values on a type. See
1921 build_range_type. */
1922 && TYPE_MIN_VALUE (TREE_TYPE (lhs))((tree_check5 ((((contains_struct_check ((lhs), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1922, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1922, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
1923 && TYPE_MAX_VALUE (TREE_TYPE (lhs))((tree_check5 ((((contains_struct_check ((lhs), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1923, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1923, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
)
1924 || POINTER_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1924, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1924, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
))
1925 return lhs;
1926
1927 return NULL_TREE(tree) __null;
1928}
1929
1930/* Visit assignment STMT. If it produces an interesting range, record
1931 the range in VR and set LHS to OUTPUT_P. */
1932
1933void
1934vr_values::vrp_visit_assignment_or_call (gimple *stmt, tree *output_p,
1935 value_range_equiv *vr)
1936{
1937 tree lhs = get_output_for_vrp (stmt);
1938 *output_p = lhs;
1939
1940 /* We only keep track of ranges in integral and pointer types. */
1941 if (lhs)
1942 {
1943 enum gimple_code code = gimple_code (stmt);
1944
1945 /* Try folding the statement to a constant first. */
1946 x_vr_values = this;
1947 tree tem = gimple_fold_stmt_to_constant_1 (stmt, vrp_valueize,
1948 vrp_valueize_1);
1949 x_vr_values = NULL__null;
1950 if (tem)
1951 {
1952 if (TREE_CODE (tem)((enum tree_code) (tem)->base.code) == SSA_NAME
1953 && (SSA_NAME_IS_DEFAULT_DEF (tem)(tree_check ((tem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1953, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
1954 || ! prop_simulate_again_p (SSA_NAME_DEF_STMT (tem)(tree_check ((tem), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 1954, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
)))
1955 {
1956 extract_range_from_ssa_name (vr, tem);
1957 return;
1958 }
1959 else if (is_gimple_min_invariant (tem))
1960 {
1961 vr->set (tem);
1962 return;
1963 }
1964 }
1965 /* Then dispatch to value-range extracting functions. */
1966 if (code == GIMPLE_CALL)
1967 extract_range_basic (vr, stmt);
1968 else
1969 extract_range_from_assignment (vr, as_a <gassign *> (stmt));
1970 }
1971}
1972
1973/* Helper that gets the value range of the SSA_NAME with version I
1974 or a symbolic range containing the SSA_NAME only if the value range
1975 is varying or undefined. Uses TEM as storage for the alternate range. */
1976
1977const value_range_equiv *
1978simplify_using_ranges::get_vr_for_comparison (int i, value_range_equiv *tem)
1979{
1980 /* Shallow-copy equiv bitmap. */
1981 const value_range_equiv *vr = query->get_value_range (ssa_name (i)((*(cfun + 0)->gimple_df->ssa_names)[(i)]));
1982
1983 /* If name N_i does not have a valid range, use N_i as its own
1984 range. This allows us to compare against names that may
1985 have N_i in their ranges. */
1986 if (vr->varying_p () || vr->undefined_p ())
1987 {
1988 tem->set (ssa_name (i)((*(cfun + 0)->gimple_df->ssa_names)[(i)]));
1989 return tem;
1990 }
1991
1992 return vr;
1993}
1994
1995/* Compare all the value ranges for names equivalent to VAR with VAL
1996 using comparison code COMP. Return the same value returned by
1997 compare_range_with_value, including the setting of
1998 *STRICT_OVERFLOW_P. */
1999
2000tree
2001simplify_using_ranges::compare_name_with_value
2002 (enum tree_code comp, tree var, tree val,
2003 bool *strict_overflow_p, bool use_equiv_p)
2004{
2005 /* Get the set of equivalences for VAR. */
2006 bitmap e = query->get_value_range (var)->equiv ();
2007
2008 /* Start at -1. Set it to 0 if we do a comparison without relying
2009 on overflow, or 1 if all comparisons rely on overflow. */
2010 int used_strict_overflow = -1;
2011
2012 /* Compare vars' value range with val. */
2013 value_range_equiv tem_vr;
2014 const value_range_equiv *equiv_vr
2015 = get_vr_for_comparison (SSA_NAME_VERSION (var)(tree_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2015, __FUNCTION__, (SSA_NAME)))->base.u.version
, &tem_vr);
2016 bool sop = false;
2017 tree retval = compare_range_with_value (comp, equiv_vr, val, &sop);
2018 if (retval)
2019 used_strict_overflow = sop ? 1 : 0;
2020
2021 /* If the equiv set is empty we have done all work we need to do. */
2022 if (e == NULL__null)
2023 {
2024 if (retval && used_strict_overflow > 0)
2025 *strict_overflow_p = true;
2026 return retval;
2027 }
2028
2029 unsigned i;
2030 bitmap_iterator bi;
2031 EXECUTE_IF_SET_IN_BITMAP (e, 0, i, bi)for (bmp_iter_set_init (&(bi), (e), (0), &(i)); bmp_iter_set
(&(bi), &(i)); bmp_iter_next (&(bi), &(i)))
2032 {
2033 tree name = ssa_name (i)((*(cfun + 0)->gimple_df->ssa_names)[(i)]);
2034 if (!name)
2035 continue;
2036
2037 if (!use_equiv_p
2038 && !SSA_NAME_IS_DEFAULT_DEF (name)(tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2038, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
2039 && prop_simulate_again_p (SSA_NAME_DEF_STMT (name)(tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2039, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
))
2040 continue;
2041
2042 equiv_vr = get_vr_for_comparison (i, &tem_vr);
2043 sop = false;
2044 tree t = compare_range_with_value (comp, equiv_vr, val, &sop);
2045 if (t)
2046 {
2047 /* If we get different answers from different members
2048 of the equivalence set this check must be in a dead
2049 code region. Folding it to a trap representation
2050 would be correct here. For now just return don't-know. */
2051 if (retval != NULL__null
2052 && t != retval)
2053 {
2054 retval = NULL_TREE(tree) __null;
2055 break;
2056 }
2057 retval = t;
2058
2059 if (!sop)
2060 used_strict_overflow = 0;
2061 else if (used_strict_overflow < 0)
2062 used_strict_overflow = 1;
2063 }
2064 }
2065
2066 if (retval && used_strict_overflow > 0)
2067 *strict_overflow_p = true;
2068
2069 return retval;
2070}
2071
2072
2073/* Given a comparison code COMP and names N1 and N2, compare all the
2074 ranges equivalent to N1 against all the ranges equivalent to N2
2075 to determine the value of N1 COMP N2. Return the same value
2076 returned by compare_ranges. Set *STRICT_OVERFLOW_P to indicate
2077 whether we relied on undefined signed overflow in the comparison. */
2078
2079
2080tree
2081simplify_using_ranges::compare_names (enum tree_code comp, tree n1, tree n2,
2082 bool *strict_overflow_p)
2083{
2084 /* Compare the ranges of every name equivalent to N1 against the
2085 ranges of every name equivalent to N2. */
2086 bitmap e1 = query->get_value_range (n1)->equiv ();
2087 bitmap e2 = query->get_value_range (n2)->equiv ();
2088
2089 /* Use the fake bitmaps if e1 or e2 are not available. */
2090 static bitmap s_e1 = NULL__null, s_e2 = NULL__null;
2091 static bitmap_obstack *s_obstack = NULL__null;
2092 if (s_obstack == NULL__null)
2093 {
2094 s_obstack = XNEW (bitmap_obstack)((bitmap_obstack *) xmalloc (sizeof (bitmap_obstack)));
2095 bitmap_obstack_initialize (s_obstack);
2096 s_e1 = BITMAP_ALLOCbitmap_alloc (s_obstack);
2097 s_e2 = BITMAP_ALLOCbitmap_alloc (s_obstack);
2098 }
2099 if (e1 == NULL__null)
2100 e1 = s_e1;
2101 if (e2 == NULL__null)
2102 e2 = s_e2;
2103
2104 /* Add N1 and N2 to their own set of equivalences to avoid
2105 duplicating the body of the loop just to check N1 and N2
2106 ranges. */
2107 bitmap_set_bit (e1, SSA_NAME_VERSION (n1)(tree_check ((n1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2107, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2108 bitmap_set_bit (e2, SSA_NAME_VERSION (n2)(tree_check ((n2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2108, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2109
2110 /* If the equivalence sets have a common intersection, then the two
2111 names can be compared without checking their ranges. */
2112 if (bitmap_intersect_p (e1, e2))
2113 {
2114 bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)(tree_check ((n1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2114, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2115 bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)(tree_check ((n2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2115, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2116
2117 return (comp == EQ_EXPR || comp == GE_EXPR || comp == LE_EXPR)
2118 ? boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE]
2119 : boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
2120 }
2121
2122 /* Start at -1. Set it to 0 if we do a comparison without relying
2123 on overflow, or 1 if all comparisons rely on overflow. */
2124 int used_strict_overflow = -1;
2125
2126 /* Otherwise, compare all the equivalent ranges. First, add N1 and
2127 N2 to their own set of equivalences to avoid duplicating the body
2128 of the loop just to check N1 and N2 ranges. */
2129 bitmap_iterator bi1;
2130 unsigned i1;
2131 EXECUTE_IF_SET_IN_BITMAP (e1, 0, i1, bi1)for (bmp_iter_set_init (&(bi1), (e1), (0), &(i1)); bmp_iter_set
(&(bi1), &(i1)); bmp_iter_next (&(bi1), &(i1
)))
2132 {
2133 if (!ssa_name (i1)((*(cfun + 0)->gimple_df->ssa_names)[(i1)]))
2134 continue;
2135
2136 value_range_equiv tem_vr1;
2137 const value_range_equiv *vr1 = get_vr_for_comparison (i1, &tem_vr1);
2138
2139 tree t = NULL_TREE(tree) __null, retval = NULL_TREE(tree) __null;
2140 bitmap_iterator bi2;
2141 unsigned i2;
2142 EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2)for (bmp_iter_set_init (&(bi2), (e2), (0), &(i2)); bmp_iter_set
(&(bi2), &(i2)); bmp_iter_next (&(bi2), &(i2
)))
2143 {
2144 if (!ssa_name (i2)((*(cfun + 0)->gimple_df->ssa_names)[(i2)]))
2145 continue;
2146
2147 bool sop = false;
2148
2149 value_range_equiv tem_vr2;
2150 const value_range_equiv *vr2 = get_vr_for_comparison (i2, &tem_vr2);
2151
2152 t = compare_ranges (comp, vr1, vr2, &sop);
2153 if (t)
2154 {
2155 /* If we get different answers from different members
2156 of the equivalence set this check must be in a dead
2157 code region. Folding it to a trap representation
2158 would be correct here. For now just return don't-know. */
2159 if (retval != NULL__null && t != retval)
2160 {
2161 bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)(tree_check ((n1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2161, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2162 bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)(tree_check ((n2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2162, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2163 return NULL_TREE(tree) __null;
2164 }
2165 retval = t;
2166
2167 if (!sop)
2168 used_strict_overflow = 0;
2169 else if (used_strict_overflow < 0)
2170 used_strict_overflow = 1;
2171 }
2172 }
2173
2174 if (retval)
2175 {
2176 bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)(tree_check ((n1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2176, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2177 bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)(tree_check ((n2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2177, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2178 if (used_strict_overflow > 0)
2179 *strict_overflow_p = true;
2180 return retval;
2181 }
2182 }
2183
2184 /* None of the equivalent ranges are useful in computing this
2185 comparison. */
2186 bitmap_clear_bit (e1, SSA_NAME_VERSION (n1)(tree_check ((n1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2186, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2187 bitmap_clear_bit (e2, SSA_NAME_VERSION (n2)(tree_check ((n2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2187, __FUNCTION__, (SSA_NAME)))->base.u.version
);
2188 return NULL_TREE(tree) __null;
2189}
2190
2191/* Helper function for vrp_evaluate_conditional_warnv & other
2192 optimizers. */
2193
2194tree
2195simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops_using_ranges
2196 (enum tree_code code, tree op0, tree op1, bool * strict_overflow_p)
2197{
2198 const value_range_equiv *vr0, *vr1;
2199 vr0 = (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME) ? query->get_value_range (op0) : NULL__null;
2200 vr1 = (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME) ? query->get_value_range (op1) : NULL__null;
2201
2202 tree res = NULL_TREE(tree) __null;
2203 if (vr0 && vr1)
2204 res = compare_ranges (code, vr0, vr1, strict_overflow_p);
2205 if (!res && vr0)
2206 res = compare_range_with_value (code, vr0, op1, strict_overflow_p);
2207 if (!res && vr1)
2208 res = (compare_range_with_value
2209 (swap_tree_comparison (code), vr1, op0, strict_overflow_p));
2210 return res;
2211}
2212
2213/* Helper function for vrp_evaluate_conditional_warnv. */
2214
2215tree
2216simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops
2217 (gimple *stmt,
2218 enum tree_code code,
2219 tree op0, tree op1,
2220 bool use_equiv_p,
2221 bool *strict_overflow_p,
2222 bool *only_ranges)
2223{
2224 tree ret;
2225 if (only_ranges)
2226 *only_ranges = true;
2227
2228 /* We only deal with integral and pointer types. */
2229 if (!INTEGRAL_TYPE_P (TREE_TYPE (op0))(((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2229, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2229, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2229, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
2230 && !POINTER_TYPE_P (TREE_TYPE (op0))(((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2230, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2230, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
)
2231 return NULL_TREE(tree) __null;
2232
2233 /* If OP0 CODE OP1 is an overflow comparison, if it can be expressed
2234 as a simple equality test, then prefer that over its current form
2235 for evaluation.
2236
2237 An overflow test which collapses to an equality test can always be
2238 expressed as a comparison of one argument against zero. Overflow
2239 occurs when the chosen argument is zero and does not occur if the
2240 chosen argument is not zero. */
2241 tree x;
2242 if (overflow_comparison_p (code, op0, op1, use_equiv_p, &x))
2243 {
2244 wide_int max = wi::max_value (TYPE_PRECISION (TREE_TYPE (op0))((tree_class_check ((((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2244, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2244, __FUNCTION__))->type_common.precision)
, UNSIGNED);
2245 /* B = A - 1; if (A < B) -> B = A - 1; if (A == 0)
2246 B = A - 1; if (A > B) -> B = A - 1; if (A != 0)
2247 B = A + 1; if (B < A) -> B = A + 1; if (B == 0)
2248 B = A + 1; if (B > A) -> B = A + 1; if (B != 0) */
2249 if (integer_zerop (x))
2250 {
2251 op1 = x;
2252 code = (code == LT_EXPR || code == LE_EXPR) ? EQ_EXPR : NE_EXPR;
2253 }
2254 /* B = A + 1; if (A > B) -> B = A + 1; if (B == 0)
2255 B = A + 1; if (A < B) -> B = A + 1; if (B != 0)
2256 B = A - 1; if (B > A) -> B = A - 1; if (A == 0)
2257 B = A - 1; if (B < A) -> B = A - 1; if (A != 0) */
2258 else if (wi::to_wide (x) == max - 1)
2259 {
2260 op0 = op1;
2261 op1 = wide_int_to_tree (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2261, __FUNCTION__))->typed.type)
, 0);
2262 code = (code == GT_EXPR || code == GE_EXPR) ? EQ_EXPR : NE_EXPR;
2263 }
2264 else
2265 {
2266 value_range vro, vri;
2267 if (code == GT_EXPR || code == GE_EXPR)
2268 {
2269 vro.set (TYPE_MIN_VALUE (TREE_TYPE (op0))((tree_check5 ((((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2269, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2269, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
, x, VR_ANTI_RANGE);
2270 vri.set (TYPE_MIN_VALUE (TREE_TYPE (op0))((tree_check5 ((((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2270, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2270, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
, x);
2271 }
2272 else if (code == LT_EXPR || code == LE_EXPR)
2273 {
2274 vro.set (TYPE_MIN_VALUE (TREE_TYPE (op0))((tree_check5 ((((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2274, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2274, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
, x);
2275 vri.set (TYPE_MIN_VALUE (TREE_TYPE (op0))((tree_check5 ((((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2275, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2275, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
, x, VR_ANTI_RANGE);
2276 }
2277 else
2278 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2278, __FUNCTION__))
;
2279 const value_range_equiv *vr0 = query->get_value_range (op0, stmt);
2280 /* If vro, the range for OP0 to pass the overflow test, has
2281 no intersection with *vr0, OP0's known range, then the
2282 overflow test can't pass, so return the node for false.
2283 If it is the inverted range, vri, that has no
2284 intersection, then the overflow test must pass, so return
2285 the node for true. In other cases, we could proceed with
2286 a simplified condition comparing OP0 and X, with LE_EXPR
2287 for previously LE_ or LT_EXPR and GT_EXPR otherwise, but
2288 the comments next to the enclosing if suggest it's not
2289 generally profitable to do so. */
2290 vro.intersect (vr0);
2291 if (vro.undefined_p ())
2292 return boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
2293 vri.intersect (vr0);
2294 if (vri.undefined_p ())
2295 return boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
2296 }
2297 }
2298
2299 if ((ret = vrp_evaluate_conditional_warnv_with_ops_using_ranges
2300 (code, op0, op1, strict_overflow_p)))
2301 return ret;
2302 if (only_ranges)
2303 *only_ranges = false;
2304 /* Do not use compare_names during propagation, it's quadratic. */
2305 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME && TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME
2306 && use_equiv_p)
2307 return compare_names (code, op0, op1, strict_overflow_p);
2308 else if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME)
2309 return compare_name_with_value (code, op0, op1,
2310 strict_overflow_p, use_equiv_p);
2311 else if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME)
2312 return compare_name_with_value (swap_tree_comparison (code), op1, op0,
2313 strict_overflow_p, use_equiv_p);
2314 return NULL_TREE(tree) __null;
2315}
2316
2317/* Given (CODE OP0 OP1) within STMT, try to simplify it based on value range
2318 information. Return NULL if the conditional cannot be evaluated.
2319 The ranges of all the names equivalent with the operands in COND
2320 will be used when trying to compute the value. If the result is
2321 based on undefined signed overflow, issue a warning if
2322 appropriate. */
2323
2324tree
2325simplify_using_ranges::vrp_evaluate_conditional (tree_code code, tree op0,
2326 tree op1, gimple *stmt)
2327{
2328 bool sop;
2329 tree ret;
2330 bool only_ranges;
2331
2332 /* Some passes and foldings leak constants with overflow flag set
2333 into the IL. Avoid doing wrong things with these and bail out. */
2334 if ((TREE_CODE (op0)((enum tree_code) (op0)->base.code) == INTEGER_CST
2335 && TREE_OVERFLOW (op0)((tree_class_check ((op0), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2335, __FUNCTION__))->base.public_flag)
)
2336 || (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == INTEGER_CST
2337 && TREE_OVERFLOW (op1)((tree_class_check ((op1), (tcc_constant), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2337, __FUNCTION__))->base.public_flag)
))
2338 return NULL_TREE(tree) __null;
2339
2340 sop = false;
2341 ret = vrp_evaluate_conditional_warnv_with_ops (stmt, code, op0, op1, true,
2342 &sop, &only_ranges);
2343
2344 if (ret && sop)
2345 {
2346 enum warn_strict_overflow_code wc;
2347 const char* warnmsg;
2348
2349 if (is_gimple_min_invariant (ret))
2350 {
2351 wc = WARN_STRICT_OVERFLOW_CONDITIONAL;
2352 warnmsg = G_("assuming signed overflow does not occur when ""assuming signed overflow does not occur when " "simplifying conditional to constant"
2353 "simplifying conditional to constant")"assuming signed overflow does not occur when " "simplifying conditional to constant";
2354 }
2355 else
2356 {
2357 wc = WARN_STRICT_OVERFLOW_COMPARISON;
2358 warnmsg = G_("assuming signed overflow does not occur when ""assuming signed overflow does not occur when " "simplifying conditional"
2359 "simplifying conditional")"assuming signed overflow does not occur when " "simplifying conditional";
2360 }
2361
2362 if (issue_strict_overflow_warning (wc)(global_options.x_warn_strict_overflow >= (int) (wc)))
2363 {
2364 location_t location;
2365
2366 if (!gimple_has_location (stmt))
2367 location = input_location;
2368 else
2369 location = gimple_location (stmt);
2370 warning_at (location, OPT_Wstrict_overflow, "%s", warnmsg);
2371 }
2372 }
2373
2374 if (warn_type_limitsglobal_options.x_warn_type_limits
2375 && ret && only_ranges
2376 && TREE_CODE_CLASS (code)tree_code_type[(int) (code)] == tcc_comparison
2377 && TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME)
2378 {
2379 /* If the comparison is being folded and the operand on the LHS
2380 is being compared against a constant value that is outside of
2381 the natural range of OP0's type, then the predicate will
2382 always fold regardless of the value of OP0. If -Wtype-limits
2383 was specified, emit a warning. */
2384 tree type = TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2384, __FUNCTION__))->typed.type)
;
2385 const value_range_equiv *vr0 = query->get_value_range (op0, stmt);
2386
2387 if (vr0->varying_p ()
2388 && INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
tree_code) (type)->base.code) == INTEGER_TYPE)
2389 && is_gimple_min_invariant (op1))
2390 {
2391 location_t location;
2392
2393 if (!gimple_has_location (stmt))
2394 location = input_location;
2395 else
2396 location = gimple_location (stmt);
2397
2398 warning_at (location, OPT_Wtype_limits,
2399 integer_zerop (ret)
2400 ? G_("comparison always false ""comparison always false " "due to limited range of data type"
2401 "due to limited range of data type")"comparison always false " "due to limited range of data type"
2402 : G_("comparison always true ""comparison always true " "due to limited range of data type"
2403 "due to limited range of data type")"comparison always true " "due to limited range of data type");
2404 }
2405 }
2406
2407 return ret;
2408}
2409
2410
2411/* Visit conditional statement STMT. If we can determine which edge
2412 will be taken out of STMT's basic block, record it in
2413 *TAKEN_EDGE_P. Otherwise, set *TAKEN_EDGE_P to NULL. */
2414
2415void
2416simplify_using_ranges::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p)
2417{
2418 tree val;
2419
2420 *taken_edge_p = NULL__null;
2421
2422 if (dump_file && (dump_flags & TDF_DETAILS))
2423 {
2424 tree use;
2425 ssa_op_iter i;
2426
2427 fprintf (dump_file, "\nVisiting conditional with predicate: ");
2428 print_gimple_stmt (dump_file, stmt, 0);
2429 fprintf (dump_file, "\nWith known ranges\n");
2430
2431 FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)for (use = op_iter_init_tree (&(i), stmt, 0x01); !op_iter_done
(&(i)); (void) (use = op_iter_next_tree (&(i))))
2432 {
2433 fprintf (dump_file, "\t");
2434 print_generic_expr (dump_file, use);
2435 fprintf (dump_file, ": ");
2436 dump_value_range (dump_file, query->get_value_range (use, stmt));
2437 }
2438
2439 fprintf (dump_file, "\n");
2440 }
2441
2442 /* Compute the value of the predicate COND by checking the known
2443 ranges of each of its operands.
2444
2445 Note that we cannot evaluate all the equivalent ranges here
2446 because those ranges may not yet be final and with the current
2447 propagation strategy, we cannot determine when the value ranges
2448 of the names in the equivalence set have changed.
2449
2450 For instance, given the following code fragment
2451
2452 i_5 = PHI <8, i_13>
2453 ...
2454 i_14 = ASSERT_EXPR <i_5, i_5 != 0>
2455 if (i_14 == 1)
2456 ...
2457
2458 Assume that on the first visit to i_14, i_5 has the temporary
2459 range [8, 8] because the second argument to the PHI function is
2460 not yet executable. We derive the range ~[0, 0] for i_14 and the
2461 equivalence set { i_5 }. So, when we visit 'if (i_14 == 1)' for
2462 the first time, since i_14 is equivalent to the range [8, 8], we
2463 determine that the predicate is always false.
2464
2465 On the next round of propagation, i_13 is determined to be
2466 VARYING, which causes i_5 to drop down to VARYING. So, another
2467 visit to i_14 is scheduled. In this second visit, we compute the
2468 exact same range and equivalence set for i_14, namely ~[0, 0] and
2469 { i_5 }. But we did not have the previous range for i_5
2470 registered, so vrp_visit_assignment thinks that the range for
2471 i_14 has not changed. Therefore, the predicate 'if (i_14 == 1)'
2472 is not visited again, which stops propagation from visiting
2473 statements in the THEN clause of that if().
2474
2475 To properly fix this we would need to keep the previous range
2476 value for the names in the equivalence set. This way we would've
2477 discovered that from one visit to the other i_5 changed from
2478 range [8, 8] to VR_VARYING.
2479
2480 However, fixing this apparent limitation may not be worth the
2481 additional checking. Testing on several code bases (GCC, DLV,
2482 MICO, TRAMP3D and SPEC2000) showed that doing this results in
2483 4 more predicates folded in SPEC. */
2484
2485 bool sop;
2486 val = vrp_evaluate_conditional_warnv_with_ops (stmt,
2487 gimple_cond_code (stmt),
2488 gimple_cond_lhs (stmt),
2489 gimple_cond_rhs (stmt),
2490 false, &sop, NULL__null);
2491 if (val)
2492 *taken_edge_p = find_taken_edge (gimple_bb (stmt), val);
2493
2494 if (dump_file && (dump_flags & TDF_DETAILS))
2495 {
2496 fprintf (dump_file, "\nPredicate evaluates to: ");
2497 if (val == NULL_TREE(tree) __null)
2498 fprintf (dump_file, "DON'T KNOW\n");
2499 else
2500 print_generic_stmt (dump_file, val);
2501 }
2502}
2503
2504/* Searches the case label vector VEC for the ranges of CASE_LABELs that are
2505 used in range VR. The indices are placed in MIN_IDX1, MAX_IDX, MIN_IDX2 and
2506 MAX_IDX2. If the ranges of CASE_LABELs are empty then MAX_IDX1 < MIN_IDX1.
2507 Returns true if the default label is not needed. */
2508
2509static bool
2510find_case_label_ranges (gswitch *stmt, const value_range *vr,
2511 size_t *min_idx1, size_t *max_idx1,
2512 size_t *min_idx2, size_t *max_idx2)
2513{
2514 size_t i, j, k, l;
2515 unsigned int n = gimple_switch_num_labels (stmt);
2516 bool take_default;
2517 tree case_low, case_high;
2518 tree min = vr->min (), max = vr->max ();
2519
2520 gcc_checking_assert (!vr->varying_p () && !vr->undefined_p ())((void)(!(!vr->varying_p () && !vr->undefined_p
()) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2520, __FUNCTION__), 0 : 0))
;
2521
2522 take_default = !find_case_label_range (stmt, min, max, &i, &j);
2523
2524 /* Set second range to empty. */
2525 *min_idx2 = 1;
2526 *max_idx2 = 0;
2527
2528 if (vr->kind () == VR_RANGE)
2529 {
2530 *min_idx1 = i;
2531 *max_idx1 = j;
2532 return !take_default;
2533 }
2534
2535 /* Set first range to all case labels. */
2536 *min_idx1 = 1;
2537 *max_idx1 = n - 1;
2538
2539 if (i > j)
2540 return false;
2541
2542 /* Make sure all the values of case labels [i , j] are contained in
2543 range [MIN, MAX]. */
2544 case_low = CASE_LOW (gimple_switch_label (stmt, i))(*((const_cast<tree*> (tree_operand_check (((tree_check
((gimple_switch_label (stmt, i)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2544, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2544, __FUNCTION__)))))
;
2545 case_high = CASE_HIGH (gimple_switch_label (stmt, j))(*((const_cast<tree*> (tree_operand_check (((tree_check
((gimple_switch_label (stmt, j)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2545, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2545, __FUNCTION__)))))
;
2546 if (tree_int_cst_compare (case_low, min) < 0)
2547 i += 1;
2548 if (case_high != NULL_TREE(tree) __null
2549 && tree_int_cst_compare (max, case_high) < 0)
2550 j -= 1;
2551
2552 if (i > j)
2553 return false;
2554
2555 /* If the range spans case labels [i, j], the corresponding anti-range spans
2556 the labels [1, i - 1] and [j + 1, n - 1]. */
2557 k = j + 1;
2558 l = n - 1;
2559 if (k > l)
2560 {
2561 k = 1;
2562 l = 0;
2563 }
2564
2565 j = i - 1;
2566 i = 1;
2567 if (i > j)
2568 {
2569 i = k;
2570 j = l;
2571 k = 1;
2572 l = 0;
2573 }
2574
2575 *min_idx1 = i;
2576 *max_idx1 = j;
2577 *min_idx2 = k;
2578 *max_idx2 = l;
2579 return false;
2580}
2581
2582/* Visit switch statement STMT. If we can determine which edge
2583 will be taken out of STMT's basic block, record it in
2584 *TAKEN_EDGE_P. Otherwise, *TAKEN_EDGE_P set to NULL. */
2585
2586void
2587vr_values::vrp_visit_switch_stmt (gswitch *stmt, edge *taken_edge_p)
2588{
2589 tree op, val;
2590 const value_range_equiv *vr;
2591 size_t i = 0, j = 0, k, l;
2592 bool take_default;
2593
2594 *taken_edge_p = NULL__null;
2595 op = gimple_switch_index (stmt);
2596 if (TREE_CODE (op)((enum tree_code) (op)->base.code) != SSA_NAME)
2597 return;
2598
2599 vr = get_value_range (op);
2600 if (dump_file && (dump_flags & TDF_DETAILS))
2601 {
2602 fprintf (dump_file, "\nVisiting switch expression with operand ");
2603 print_generic_expr (dump_file, op);
2604 fprintf (dump_file, " with known range ");
2605 dump_value_range (dump_file, vr);
2606 fprintf (dump_file, "\n");
2607 }
2608
2609 if (vr->undefined_p ()
2610 || vr->varying_p ()
2611 || vr->symbolic_p ())
2612 return;
2613
2614 /* Find the single edge that is taken from the switch expression. */
2615 take_default = !find_case_label_ranges (stmt, vr, &i, &j, &k, &l);
2616
2617 /* Check if the range spans no CASE_LABEL. If so, we only reach the default
2618 label */
2619 if (j < i)
2620 {
2621 gcc_assert (take_default)((void)(!(take_default) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2621, __FUNCTION__), 0 : 0))
;
2622 val = gimple_switch_default_label (stmt);
2623 }
2624 else
2625 {
2626 /* Check if labels with index i to j and maybe the default label
2627 are all reaching the same label. */
2628
2629 val = gimple_switch_label (stmt, i);
2630 if (take_default
2631 && CASE_LABEL (gimple_switch_default_label (stmt))(*((const_cast<tree*> (tree_operand_check (((tree_check
((gimple_switch_default_label (stmt)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2631, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2631, __FUNCTION__)))))
2632 != CASE_LABEL (val)(*((const_cast<tree*> (tree_operand_check (((tree_check
((val), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2632, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2632, __FUNCTION__)))))
)
2633 {
2634 if (dump_file && (dump_flags & TDF_DETAILS))
2635 fprintf (dump_file, " not a single destination for this "
2636 "range\n");
2637 return;
2638 }
2639 for (++i; i <= j; ++i)
2640 {
2641 if (CASE_LABEL (gimple_switch_label (stmt, i))(*((const_cast<tree*> (tree_operand_check (((tree_check
((gimple_switch_label (stmt, i)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2641, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2641, __FUNCTION__)))))
!= CASE_LABEL (val)(*((const_cast<tree*> (tree_operand_check (((tree_check
((val), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2641, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2641, __FUNCTION__)))))
)
2642 {
2643 if (dump_file && (dump_flags & TDF_DETAILS))
2644 fprintf (dump_file, " not a single destination for this "
2645 "range\n");
2646 return;
2647 }
2648 }
2649 for (; k <= l; ++k)
2650 {
2651 if (CASE_LABEL (gimple_switch_label (stmt, k))(*((const_cast<tree*> (tree_operand_check (((tree_check
((gimple_switch_label (stmt, k)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2651, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2651, __FUNCTION__)))))
!= CASE_LABEL (val)(*((const_cast<tree*> (tree_operand_check (((tree_check
((val), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2651, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2651, __FUNCTION__)))))
)
2652 {
2653 if (dump_file && (dump_flags & TDF_DETAILS))
2654 fprintf (dump_file, " not a single destination for this "
2655 "range\n");
2656 return;
2657 }
2658 }
2659 }
2660
2661 *taken_edge_p = find_edge (gimple_bb (stmt),
2662 label_to_block (cfun(cfun + 0), CASE_LABEL (val)(*((const_cast<tree*> (tree_operand_check (((tree_check
((val), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2662, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2662, __FUNCTION__)))))
));
2663
2664 if (dump_file && (dump_flags & TDF_DETAILS))
2665 {
2666 fprintf (dump_file, " will take edge to ");
2667 print_generic_stmt (dump_file, CASE_LABEL (val)(*((const_cast<tree*> (tree_operand_check (((tree_check
((val), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2667, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2667, __FUNCTION__)))))
);
2668 }
2669}
2670
2671
2672/* Evaluate statement STMT. If the statement produces a useful range,
2673 set VR and corepsponding OUTPUT_P.
2674
2675 If STMT is a conditional branch and we can determine its truth
2676 value, the taken edge is recorded in *TAKEN_EDGE_P. */
2677
2678void
2679vr_values::extract_range_from_stmt (gimple *stmt, edge *taken_edge_p,
2680 tree *output_p, value_range_equiv *vr)
2681{
2682
2683 if (dump_file && (dump_flags & TDF_DETAILS))
2684 {
2685 fprintf (dump_file, "\nextract_range_from_stmt visiting:\n");
2686 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
2687 }
2688
2689 if (!stmt_interesting_for_vrp (stmt))
2690 gcc_assert (stmt_ends_bb_p (stmt))((void)(!(stmt_ends_bb_p (stmt)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2690, __FUNCTION__), 0 : 0))
;
2691 else if (is_gimple_assign (stmt) || is_gimple_call (stmt))
2692 vrp_visit_assignment_or_call (stmt, output_p, vr);
2693 else if (gimple_code (stmt) == GIMPLE_COND)
2694 simplifier.vrp_visit_cond_stmt (as_a <gcond *> (stmt), taken_edge_p);
2695 else if (gimple_code (stmt) == GIMPLE_SWITCH)
2696 vrp_visit_switch_stmt (as_a <gswitch *> (stmt), taken_edge_p);
2697}
2698
2699/* Visit all arguments for PHI node PHI that flow through executable
2700 edges. If a valid value range can be derived from all the incoming
2701 value ranges, set a new range in VR_RESULT. */
2702
2703void
2704vr_values::extract_range_from_phi_node (gphi *phi,
2705 value_range_equiv *vr_result)
2706{
2707 tree lhs = PHI_RESULT (phi)get_def_from_ptr (gimple_phi_result_ptr (phi));
2708 const value_range_equiv *lhs_vr = get_value_range (lhs);
2709 bool first = true;
2710 int old_edges;
2711 class loop *l;
2712
2713 if (dump_file && (dump_flags & TDF_DETAILS))
2714 {
2715 fprintf (dump_file, "\nVisiting PHI node: ");
2716 print_gimple_stmt (dump_file, phi, 0, dump_flags);
2717 }
2718
2719 bool may_simulate_backedge_again = false;
2720 int edges = 0;
2721 for (size_t i = 0; i < gimple_phi_num_args (phi); i++)
2722 {
2723 edge e = gimple_phi_arg_edge (phi, i);
2724
2725 if (dump_file && (dump_flags & TDF_DETAILS))
2726 {
2727 fprintf (dump_file,
2728 " Argument #%d (%d -> %d %sexecutable)\n",
2729 (int) i, e->src->index, e->dest->index,
2730 (e->flags & EDGE_EXECUTABLE) ? "" : "not ");
2731 }
2732
2733 if (e->flags & EDGE_EXECUTABLE)
2734 {
2735 value_range_equiv vr_arg_tem;
2736 const value_range_equiv *vr_arg = &vr_arg_tem;
2737
2738 ++edges;
2739
2740 tree arg = PHI_ARG_DEF (phi, i)gimple_phi_arg_def ((phi), (i));
2741 if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME)
2742 {
2743 /* See if we are eventually going to change one of the args. */
2744 gimple *def_stmt = SSA_NAME_DEF_STMT (arg)(tree_check ((arg), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2744, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
;
2745 if (! gimple_nop_p (def_stmt)
2746 && prop_simulate_again_p (def_stmt)
2747 && e->flags & EDGE_DFS_BACK)
2748 may_simulate_backedge_again = true;
2749
2750 const value_range_equiv *vr_arg_ = get_value_range (arg);
2751 /* Do not allow equivalences or symbolic ranges to leak in from
2752 backedges. That creates invalid equivalencies.
2753 See PR53465 and PR54767. */
2754 if (e->flags & EDGE_DFS_BACK)
2755 {
2756 if (!vr_arg_->varying_p () && !vr_arg_->undefined_p ())
2757 {
2758 vr_arg_tem.set (vr_arg_->min (), vr_arg_->max (), NULL__null,
2759 vr_arg_->kind ());
2760 if (vr_arg_tem.symbolic_p ())
2761 vr_arg_tem.set_varying (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2761, __FUNCTION__))->typed.type)
);
2762 }
2763 else
2764 vr_arg = vr_arg_;
2765 }
2766 /* If the non-backedge arguments range is VR_VARYING then
2767 we can still try recording a simple equivalence. */
2768 else if (vr_arg_->varying_p ())
2769 vr_arg_tem.set (arg);
2770 else
2771 vr_arg = vr_arg_;
2772 }
2773 else
2774 {
2775 if (TREE_OVERFLOW_P (arg)((tree_code_type[(int) (((enum tree_code) (arg)->base.code
))] == tcc_constant) && ((tree_class_check ((arg), (tcc_constant
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2775, __FUNCTION__))->base.public_flag))
)
2776 arg = drop_tree_overflow (arg);
2777
2778 vr_arg_tem.set (arg);
2779 }
2780
2781 if (dump_file && (dump_flags & TDF_DETAILS))
2782 {
2783 fprintf (dump_file, "\t");
2784 print_generic_expr (dump_file, arg, dump_flags);
2785 fprintf (dump_file, ": ");
2786 dump_value_range (dump_file, vr_arg);
2787 fprintf (dump_file, "\n");
2788 }
2789
2790 if (first)
2791 vr_result->deep_copy (vr_arg);
2792 else
2793 vr_result->union_ (vr_arg);
2794 first = false;
2795
2796 if (vr_result->varying_p ())
2797 break;
2798 }
2799 }
2800
2801 if (vr_result->varying_p ())
2802 goto varying;
2803 else if (vr_result->undefined_p ())
2804 goto update_range;
2805
2806 old_edges = vr_phi_edge_counts[SSA_NAME_VERSION (lhs)(tree_check ((lhs), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2806, __FUNCTION__, (SSA_NAME)))->base.u.version
];
2807 vr_phi_edge_counts[SSA_NAME_VERSION (lhs)(tree_check ((lhs), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2807, __FUNCTION__, (SSA_NAME)))->base.u.version
] = edges;
2808
2809 /* To prevent infinite iterations in the algorithm, derive ranges
2810 when the new value is slightly bigger or smaller than the
2811 previous one. We don't do this if we have seen a new executable
2812 edge; this helps us avoid an infinity for conditionals
2813 which are not in a loop. If the old value-range was VR_UNDEFINED
2814 use the updated range and iterate one more time. If we will not
2815 simulate this PHI again via the backedge allow us to iterate. */
2816 if (edges > 0
2817 && gimple_phi_num_args (phi) > 1
2818 && edges == old_edges
2819 && !lhs_vr->undefined_p ()
2820 && may_simulate_backedge_again)
2821 {
2822 /* Compare old and new ranges, fall back to varying if the
2823 values are not comparable. */
2824 int cmp_min = compare_values (lhs_vr->min (), vr_result->min ());
2825 if (cmp_min == -2)
2826 goto varying;
2827 int cmp_max = compare_values (lhs_vr->max (), vr_result->max ());
2828 if (cmp_max == -2)
2829 goto varying;
2830
2831 /* For non VR_RANGE or for pointers fall back to varying if
2832 the range changed. */
2833 if ((lhs_vr->kind () != VR_RANGE || vr_result->kind () != VR_RANGE
2834 || POINTER_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2834, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2834, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
)
2835 && (cmp_min != 0 || cmp_max != 0))
2836 goto varying;
2837
2838 /* If the new minimum is larger than the previous one
2839 retain the old value. If the new minimum value is smaller
2840 than the previous one and not -INF go all the way to -INF + 1.
2841 In the first case, to avoid infinite bouncing between different
2842 minimums, and in the other case to avoid iterating millions of
2843 times to reach -INF. Going to -INF + 1 also lets the following
2844 iteration compute whether there will be any overflow, at the
2845 expense of one additional iteration. */
2846 tree new_min = vr_result->min ();
2847 tree new_max = vr_result->max ();
2848 if (cmp_min < 0)
2849 new_min = lhs_vr->min ();
2850 else if (cmp_min > 0
2851 && (TREE_CODE (vr_result->min ())((enum tree_code) (vr_result->min ())->base.code) != INTEGER_CST
2852 || tree_int_cst_lt (vrp_val_min (vr_result->type ()),
2853 vr_result->min ())))
2854 new_min = int_const_binop (PLUS_EXPR,
2855 vrp_val_min (vr_result->type ()),
2856 build_int_cst (vr_result->type (), 1));
2857
2858 /* Similarly for the maximum value. */
2859 if (cmp_max > 0)
2860 new_max = lhs_vr->max ();
2861 else if (cmp_max < 0
2862 && (TREE_CODE (vr_result->max ())((enum tree_code) (vr_result->max ())->base.code) != INTEGER_CST
2863 || tree_int_cst_lt (vr_result->max (),
2864 vrp_val_max (vr_result->type ()))))
2865 new_max = int_const_binop (MINUS_EXPR,
2866 vrp_val_max (vr_result->type ()),
2867 build_int_cst (vr_result->type (), 1));
2868
2869 vr_result->update (new_min, new_max, vr_result->kind ());
2870
2871 /* If we dropped either bound to +-INF then if this is a loop
2872 PHI node SCEV may known more about its value-range. */
2873 if (cmp_min > 0 || cmp_min < 0
2874 || cmp_max < 0 || cmp_max > 0)
2875 goto scev_check;
2876
2877 goto infinite_check;
2878 }
2879
2880 goto update_range;
2881
2882varying:
2883 vr_result->set_varying (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2883, __FUNCTION__))->typed.type)
);
2884
2885scev_check:
2886 /* If this is a loop PHI node SCEV may known more about its value-range.
2887 scev_check can be reached from two paths, one is a fall through from above
2888 "varying" label, the other is direct goto from code block which tries to
2889 avoid infinite simulation. */
2890 if (scev_initialized_p ()
2891 && (l = loop_containing_stmt (phi))
2892 && l->header == gimple_bb (phi))
2893 adjust_range_with_scev (vr_result, l, phi, lhs);
2894
2895infinite_check:
2896 /* If we will end up with a (-INF, +INF) range, set it to
2897 VARYING. Same if the previous max value was invalid for
2898 the type and we end up with vr_result.min > vr_result.max. */
2899 if ((!vr_result->varying_p () && !vr_result->undefined_p ())
2900 && !((vrp_val_is_max (vr_result->max ()) && vrp_val_is_min (vr_result->min ()))
2901 || compare_values (vr_result->min (), vr_result->max ()) > 0))
2902 ;
2903 else
2904 vr_result->set_varying (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2904, __FUNCTION__))->typed.type)
);
2905
2906 /* If the new range is different than the previous value, keep
2907 iterating. */
2908update_range:
2909 return;
2910}
2911
2912/* Simplify boolean operations if the source is known
2913 to be already a boolean. */
2914bool
2915simplify_using_ranges::simplify_truth_ops_using_ranges
2916 (gimple_stmt_iterator *gsi,
2917 gimple *stmt)
2918{
2919 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
2920 tree lhs, op0, op1;
2921 bool need_conversion;
2922
2923 /* We handle only !=/== case here. */
2924 gcc_assert (rhs_code == EQ_EXPR || rhs_code == NE_EXPR)((void)(!(rhs_code == EQ_EXPR || rhs_code == NE_EXPR) ? fancy_abort
("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2924, __FUNCTION__), 0 : 0))
;
2925
2926 op0 = gimple_assign_rhs1 (stmt);
2927 if (!op_with_boolean_value_range_p (op0))
2928 return false;
2929
2930 op1 = gimple_assign_rhs2 (stmt);
2931 if (!op_with_boolean_value_range_p (op1))
2932 return false;
2933
2934 /* Reduce number of cases to handle to NE_EXPR. As there is no
2935 BIT_XNOR_EXPR we cannot replace A == B with a single statement. */
2936 if (rhs_code == EQ_EXPR)
2937 {
2938 if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == INTEGER_CST)
2939 op1 = int_const_binop (BIT_XOR_EXPR, op1,
2940 build_int_cst (TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2940, __FUNCTION__))->typed.type)
, 1));
2941 else
2942 return false;
2943 }
2944
2945 lhs = gimple_assign_lhs (stmt);
2946 need_conversion
2947 = !useless_type_conversion_p (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2947, __FUNCTION__))->typed.type)
, TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2947, __FUNCTION__))->typed.type)
);
2948
2949 /* Make sure to not sign-extend a 1-bit 1 when converting the result. */
2950 if (need_conversion
2951 && !TYPE_UNSIGNED (TREE_TYPE (op0))((tree_class_check ((((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2951, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2951, __FUNCTION__))->base.u.bits.unsigned_flag)
2952 && TYPE_PRECISION (TREE_TYPE (op0))((tree_class_check ((((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2952, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2952, __FUNCTION__))->type_common.precision)
== 1
2953 && TYPE_PRECISION (TREE_TYPE (lhs))((tree_class_check ((((contains_struct_check ((lhs), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2953, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2953, __FUNCTION__))->type_common.precision)
> 1)
2954 return false;
2955
2956 /* For A != 0 we can substitute A itself. */
2957 if (integer_zerop (op1))
2958 gimple_assign_set_rhs_with_ops (gsi,
2959 need_conversion
2960 ? NOP_EXPR : TREE_CODE (op0)((enum tree_code) (op0)->base.code), op0);
2961 /* For A != B we substitute A ^ B. Either with conversion. */
2962 else if (need_conversion)
2963 {
2964 tree tem = make_ssa_name (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2964, __FUNCTION__))->typed.type)
);
2965 gassign *newop
2966 = gimple_build_assign (tem, BIT_XOR_EXPR, op0, op1);
2967 gsi_insert_before (gsi, newop, GSI_SAME_STMT);
2968 if (INTEGRAL_TYPE_P (TREE_TYPE (tem))(((enum tree_code) (((contains_struct_check ((tem), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2968, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((tem), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2968, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((tem), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2968, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
2969 && TYPE_PRECISION (TREE_TYPE (tem))((tree_class_check ((((contains_struct_check ((tem), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2969, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2969, __FUNCTION__))->type_common.precision)
> 1)
2970 set_range_info (tem, VR_RANGE,
2971 wi::zero (TYPE_PRECISION (TREE_TYPE (tem))((tree_class_check ((((contains_struct_check ((tem), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2971, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2971, __FUNCTION__))->type_common.precision)
),
2972 wi::one (TYPE_PRECISION (TREE_TYPE (tem))((tree_class_check ((((contains_struct_check ((tem), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2972, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 2972, __FUNCTION__))->type_common.precision)
));
2973 gimple_assign_set_rhs_with_ops (gsi, NOP_EXPR, tem);
2974 }
2975 /* Or without. */
2976 else
2977 gimple_assign_set_rhs_with_ops (gsi, BIT_XOR_EXPR, op0, op1);
2978 update_stmt (gsi_stmt (*gsi));
2979 fold_stmt (gsi, follow_single_use_edges);
2980
2981 return true;
2982}
2983
2984/* Simplify a division or modulo operator to a right shift or bitwise and
2985 if the first operand is unsigned or is greater than zero and the second
2986 operand is an exact power of two. For TRUNC_MOD_EXPR op0 % op1 with
2987 constant op1 (op1min = op1) or with op1 in [op1min, op1max] range,
2988 optimize it into just op0 if op0's range is known to be a subset of
2989 [-op1min + 1, op1min - 1] for signed and [0, op1min - 1] for unsigned
2990 modulo. */
2991
2992bool
2993simplify_using_ranges::simplify_div_or_mod_using_ranges
2994 (gimple_stmt_iterator *gsi,
2995 gimple *stmt)
2996{
2997 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
2998 tree val = NULL__null;
2999 tree op0 = gimple_assign_rhs1 (stmt);
3000 tree op1 = gimple_assign_rhs2 (stmt);
3001 tree op0min = NULL_TREE(tree) __null, op0max = NULL_TREE(tree) __null;
3002 tree op1min = op1;
3003 const value_range *vr = NULL__null;
3004
3005 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == INTEGER_CST)
3006 {
3007 op0min = op0;
3008 op0max = op0;
3009 }
3010 else
3011 {
3012 vr = query->get_value_range (op0, stmt);
3013 if (range_int_cst_p (vr))
3014 {
3015 op0min = vr->min ();
3016 op0max = vr->max ();
3017 }
3018 }
3019
3020 if (rhs_code == TRUNC_MOD_EXPR
3021 && TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME)
3022 {
3023 const value_range_equiv *vr1 = query->get_value_range (op1, stmt);
3024 if (range_int_cst_p (vr1))
3025 op1min = vr1->min ();
3026 }
3027 if (rhs_code == TRUNC_MOD_EXPR
3028 && TREE_CODE (op1min)((enum tree_code) (op1min)->base.code) == INTEGER_CST
3029 && tree_int_cst_sgn (op1min) == 1
3030 && op0max
3031 && tree_int_cst_lt (op0max, op1min))
3032 {
3033 if (TYPE_UNSIGNED (TREE_TYPE (op0))((tree_class_check ((((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3033, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3033, __FUNCTION__))->base.u.bits.unsigned_flag)
3034 || tree_int_cst_sgn (op0min) >= 0
3035 || tree_int_cst_lt (fold_unary (NEGATE_EXPR, TREE_TYPE (op1min), op1min)fold_unary_loc (((location_t) 0), NEGATE_EXPR, ((contains_struct_check
((op1min), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3035, __FUNCTION__))->typed.type), op1min)
,
3036 op0min))
3037 {
3038 /* If op0 already has the range op0 % op1 has,
3039 then TRUNC_MOD_EXPR won't change anything. */
3040 gimple_assign_set_rhs_from_tree (gsi, op0);
3041 return true;
3042 }
3043 }
3044
3045 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) != SSA_NAME)
3046 return false;
3047
3048 if (!integer_pow2p (op1))
3049 {
3050 /* X % -Y can be only optimized into X % Y either if
3051 X is not INT_MIN, or Y is not -1. Fold it now, as after
3052 remove_range_assertions the range info might be not available
3053 anymore. */
3054 if (rhs_code == TRUNC_MOD_EXPR
3055 && fold_stmt (gsi, follow_single_use_edges))
3056 return true;
3057 return false;
3058 }
3059
3060 if (TYPE_UNSIGNED (TREE_TYPE (op0))((tree_class_check ((((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3060, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3060, __FUNCTION__))->base.u.bits.unsigned_flag)
)
3061 val = integer_one_nodeglobal_trees[TI_INTEGER_ONE];
3062 else
3063 {
3064 bool sop = false;
3065
3066 val = compare_range_with_value (GE_EXPR, vr, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO], &sop);
3067
3068 if (val
3069 && sop
3070 && integer_onep (val)
3071 && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)(global_options.x_warn_strict_overflow >= (int) (WARN_STRICT_OVERFLOW_MISC
))
)
3072 {
3073 location_t location;
3074
3075 if (!gimple_has_location (stmt))
3076 location = input_location;
3077 else
3078 location = gimple_location (stmt);
3079 warning_at (location, OPT_Wstrict_overflow,
3080 "assuming signed overflow does not occur when "
3081 "simplifying %</%> or %<%%%> to %<>>%> or %<&%>");
3082 }
3083 }
3084
3085 if (val && integer_onep (val))
3086 {
3087 tree t;
3088
3089 if (rhs_code == TRUNC_DIV_EXPR)
3090 {
3091 t = build_int_cst (integer_type_nodeinteger_types[itk_int], tree_log2 (op1));
3092 gimple_assign_set_rhs_code (stmt, RSHIFT_EXPR);
3093 gimple_assign_set_rhs1 (stmt, op0);
3094 gimple_assign_set_rhs2 (stmt, t);
3095 }
3096 else
3097 {
3098 t = build_int_cst (TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3098, __FUNCTION__))->typed.type)
, 1);
3099 t = int_const_binop (MINUS_EXPR, op1, t);
3100 t = fold_convert (TREE_TYPE (op0), t)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3100, __FUNCTION__))->typed.type), t)
;
3101
3102 gimple_assign_set_rhs_code (stmt, BIT_AND_EXPR);
3103 gimple_assign_set_rhs1 (stmt, op0);
3104 gimple_assign_set_rhs2 (stmt, t);
3105 }
3106
3107 update_stmt (stmt);
3108 fold_stmt (gsi, follow_single_use_edges);
3109 return true;
3110 }
3111
3112 return false;
3113}
3114
3115/* Simplify a min or max if the ranges of the two operands are
3116 disjoint. Return true if we do simplify. */
3117
3118bool
3119simplify_using_ranges::simplify_min_or_max_using_ranges
3120 (gimple_stmt_iterator *gsi,
3121 gimple *stmt)
3122{
3123 tree op0 = gimple_assign_rhs1 (stmt);
3124 tree op1 = gimple_assign_rhs2 (stmt);
3125 bool sop = false;
3126 tree val;
3127
3128 val = (vrp_evaluate_conditional_warnv_with_ops_using_ranges
3129 (LE_EXPR, op0, op1, &sop));
3130 if (!val)
3131 {
3132 sop = false;
3133 val = (vrp_evaluate_conditional_warnv_with_ops_using_ranges
3134 (LT_EXPR, op0, op1, &sop));
3135 }
3136
3137 if (val)
3138 {
3139 if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)(global_options.x_warn_strict_overflow >= (int) (WARN_STRICT_OVERFLOW_MISC
))
)
3140 {
3141 location_t location;
3142
3143 if (!gimple_has_location (stmt))
3144 location = input_location;
3145 else
3146 location = gimple_location (stmt);
3147 warning_at (location, OPT_Wstrict_overflow,
3148 "assuming signed overflow does not occur when "
3149 "simplifying %<min/max (X,Y)%> to %<X%> or %<Y%>");
3150 }
3151
3152 /* VAL == TRUE -> OP0 < or <= op1
3153 VAL == FALSE -> OP0 > or >= op1. */
3154 tree res = ((gimple_assign_rhs_code (stmt) == MAX_EXPR)
3155 == integer_zerop (val)) ? op0 : op1;
3156 gimple_assign_set_rhs_from_tree (gsi, res);
3157 return true;
3158 }
3159
3160 return false;
3161}
3162
3163/* If the operand to an ABS_EXPR is >= 0, then eliminate the
3164 ABS_EXPR. If the operand is <= 0, then simplify the
3165 ABS_EXPR into a NEGATE_EXPR. */
3166
3167bool
3168simplify_using_ranges::simplify_abs_using_ranges (gimple_stmt_iterator *gsi,
3169 gimple *stmt)
3170{
3171 tree op = gimple_assign_rhs1 (stmt);
3172 const value_range *vr = query->get_value_range (op, stmt);
3173
3174 if (vr)
3175 {
3176 tree val = NULL__null;
3177 bool sop = false;
3178
3179 val = compare_range_with_value (LE_EXPR, vr, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO], &sop);
3180 if (!val)
3181 {
3182 /* The range is neither <= 0 nor > 0. Now see if it is
3183 either < 0 or >= 0. */
3184 sop = false;
3185 val = compare_range_with_value (LT_EXPR, vr, integer_zero_nodeglobal_trees[TI_INTEGER_ZERO],
3186 &sop);
3187 }
3188
3189 if (val)
3190 {
3191 if (sop && issue_strict_overflow_warning (WARN_STRICT_OVERFLOW_MISC)(global_options.x_warn_strict_overflow >= (int) (WARN_STRICT_OVERFLOW_MISC
))
)
3192 {
3193 location_t location;
3194
3195 if (!gimple_has_location (stmt))
3196 location = input_location;
3197 else
3198 location = gimple_location (stmt);
3199 warning_at (location, OPT_Wstrict_overflow,
3200 "assuming signed overflow does not occur when "
3201 "simplifying %<abs (X)%> to %<X%> or %<-X%>");
3202 }
3203
3204 gimple_assign_set_rhs1 (stmt, op);
3205 if (integer_zerop (val))
3206 gimple_assign_set_rhs_code (stmt, SSA_NAME);
3207 else
3208 gimple_assign_set_rhs_code (stmt, NEGATE_EXPR);
3209 update_stmt (stmt);
3210 fold_stmt (gsi, follow_single_use_edges);
3211 return true;
3212 }
3213 }
3214
3215 return false;
3216}
3217
3218/* value_range wrapper for wi_set_zero_nonzero_bits.
3219
3220 Return TRUE if VR was a constant range and we were able to compute
3221 the bit masks. */
3222
3223static bool
3224vr_set_zero_nonzero_bits (const tree expr_type,
3225 const value_range *vr,
3226 wide_int *may_be_nonzero,
3227 wide_int *must_be_nonzero)
3228{
3229 if (range_int_cst_p (vr))
3230 {
3231 wi_set_zero_nonzero_bits (expr_type,
3232 wi::to_wide (vr->min ()),
3233 wi::to_wide (vr->max ()),
3234 *may_be_nonzero, *must_be_nonzero);
3235 return true;
3236 }
3237 *may_be_nonzero = wi::minus_one (TYPE_PRECISION (expr_type)((tree_class_check ((expr_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3237, __FUNCTION__))->type_common.precision)
);
3238 *must_be_nonzero = wi::zero (TYPE_PRECISION (expr_type)((tree_class_check ((expr_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3238, __FUNCTION__))->type_common.precision)
);
3239 return false;
3240}
3241
3242/* Optimize away redundant BIT_AND_EXPR and BIT_IOR_EXPR.
3243 If all the bits that are being cleared by & are already
3244 known to be zero from VR, or all the bits that are being
3245 set by | are already known to be one from VR, the bit
3246 operation is redundant. */
3247
3248bool
3249simplify_using_ranges::simplify_bit_ops_using_ranges
3250 (gimple_stmt_iterator *gsi,
3251 gimple *stmt)
3252{
3253 tree op0 = gimple_assign_rhs1 (stmt);
3254 tree op1 = gimple_assign_rhs2 (stmt);
3255 tree op = NULL_TREE(tree) __null;
3256 value_range vr0, vr1;
3257 wide_int may_be_nonzero0, may_be_nonzero1;
3258 wide_int must_be_nonzero0, must_be_nonzero1;
3259 wide_int mask;
3260
3261 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME)
3262 vr0 = *(query->get_value_range (op0, stmt));
3263 else if (is_gimple_min_invariant (op0))
3264 vr0.set (op0);
3265 else
3266 return false;
3267
3268 if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME)
3269 vr1 = *(query->get_value_range (op1, stmt));
3270 else if (is_gimple_min_invariant (op1))
3271 vr1.set (op1);
3272 else
3273 return false;
3274
3275 if (!vr_set_zero_nonzero_bits (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3275, __FUNCTION__))->typed.type)
, &vr0, &may_be_nonzero0,
3276 &must_be_nonzero0))
3277 return false;
3278 if (!vr_set_zero_nonzero_bits (TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3278, __FUNCTION__))->typed.type)
, &vr1, &may_be_nonzero1,
3279 &must_be_nonzero1))
3280 return false;
3281
3282 switch (gimple_assign_rhs_code (stmt))
3283 {
3284 case BIT_AND_EXPR:
3285 mask = wi::bit_and_not (may_be_nonzero0, must_be_nonzero1);
3286 if (mask == 0)
3287 {
3288 op = op0;
3289 break;
3290 }
3291 mask = wi::bit_and_not (may_be_nonzero1, must_be_nonzero0);
3292 if (mask == 0)
3293 {
3294 op = op1;
3295 break;
3296 }
3297 break;
3298 case BIT_IOR_EXPR:
3299 mask = wi::bit_and_not (may_be_nonzero0, must_be_nonzero1);
3300 if (mask == 0)
3301 {
3302 op = op1;
3303 break;
3304 }
3305 mask = wi::bit_and_not (may_be_nonzero1, must_be_nonzero0);
3306 if (mask == 0)
3307 {
3308 op = op0;
3309 break;
3310 }
3311 break;
3312 default:
3313 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3313, __FUNCTION__))
;
3314 }
3315
3316 if (op == NULL_TREE(tree) __null)
3317 return false;
3318
3319 gimple_assign_set_rhs_with_ops (gsi, TREE_CODE (op)((enum tree_code) (op)->base.code), op);
3320 update_stmt (gsi_stmt (*gsi));
3321 return true;
3322}
3323
3324/* We are comparing trees OP0 and OP1 using COND_CODE. OP0 has
3325 a known value range VR.
3326
3327 If there is one and only one value which will satisfy the
3328 conditional, then return that value. Else return NULL.
3329
3330 If signed overflow must be undefined for the value to satisfy
3331 the conditional, then set *STRICT_OVERFLOW_P to true. */
3332
3333static tree
3334test_for_singularity (enum tree_code cond_code, tree op0,
3335 tree op1, const value_range *vr)
3336{
3337 tree min = NULL__null;
3338 tree max = NULL__null;
3339
3340 /* Extract minimum/maximum values which satisfy the conditional as it was
3341 written. */
3342 if (cond_code == LE_EXPR || cond_code == LT_EXPR)
3343 {
3344 min = TYPE_MIN_VALUE (TREE_TYPE (op0))((tree_check5 ((((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3344, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3344, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
)
;
3345
3346 max = op1;
3347 if (cond_code == LT_EXPR)
3348 {
3349 tree one = build_int_cst (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3349, __FUNCTION__))->typed.type)
, 1);
3350 max = fold_build2 (MINUS_EXPR, TREE_TYPE (op0), max, one)fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3350, __FUNCTION__))->typed.type), max, one )
;
3351 /* Signal to compare_values_warnv this expr doesn't overflow. */
3352 if (EXPR_P (max)((tree_code_type[(int) (((enum tree_code) (max)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (max)->base.code))]) <= tcc_expression)
)
3353 TREE_NO_WARNING (max)((max)->base.nowarning_flag) = 1;
3354 }
3355 }
3356 else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
3357 {
3358 max = TYPE_MAX_VALUE (TREE_TYPE (op0))((tree_check5 ((((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3358, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3358, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.maxval
)
;
3359
3360 min = op1;
3361 if (cond_code == GT_EXPR)
3362 {
3363 tree one = build_int_cst (TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3363, __FUNCTION__))->typed.type)
, 1);
3364 min = fold_build2 (PLUS_EXPR, TREE_TYPE (op0), min, one)fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3364, __FUNCTION__))->typed.type), min, one )
;
3365 /* Signal to compare_values_warnv this expr doesn't overflow. */
3366 if (EXPR_P (min)((tree_code_type[(int) (((enum tree_code) (min)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (min)->base.code))]) <= tcc_expression)
)
3367 TREE_NO_WARNING (min)((min)->base.nowarning_flag) = 1;
3368 }
3369 }
3370
3371 /* Now refine the minimum and maximum values using any
3372 value range information we have for op0. */
3373 if (min && max)
3374 {
3375 tree type = TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3375, __FUNCTION__))->typed.type)
;
3376 tree tmin = wide_int_to_tree (type, vr->lower_bound ());
3377 tree tmax = wide_int_to_tree (type, vr->upper_bound ());
3378 if (compare_values (tmin, min) == 1)
3379 min = tmin;
3380 if (compare_values (tmax, max) == -1)
3381 max = tmax;
3382
3383 /* If the new min/max values have converged to a single value,
3384 then there is only one value which can satisfy the condition,
3385 return that value. */
3386 if (operand_equal_p (min, max, 0) && is_gimple_min_invariant (min))
3387 return min;
3388 }
3389 return NULL__null;
3390}
3391
3392/* Return whether the value range *VR fits in an integer type specified
3393 by PRECISION and UNSIGNED_P. */
3394
3395bool
3396range_fits_type_p (const value_range *vr,
3397 unsigned dest_precision, signop dest_sgn)
3398{
3399 tree src_type;
3400 unsigned src_precision;
3401 widest_int tem;
3402 signop src_sgn;
3403
3404 /* We can only handle integral and pointer types. */
3405 src_type = vr->type ();
3406 if (!INTEGRAL_TYPE_P (src_type)(((enum tree_code) (src_type)->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (src_type)->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (src_type)->base.code) == INTEGER_TYPE
)
3407 && !POINTER_TYPE_P (src_type)(((enum tree_code) (src_type)->base.code) == POINTER_TYPE ||
((enum tree_code) (src_type)->base.code) == REFERENCE_TYPE
)
)
3408 return false;
3409
3410 /* An extension is fine unless VR is SIGNED and dest_sgn is UNSIGNED,
3411 and so is an identity transform. */
3412 src_precision = TYPE_PRECISION (vr->type ())((tree_class_check ((vr->type ()), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3412, __FUNCTION__))->type_common.precision)
;
3413 src_sgn = TYPE_SIGN (src_type)((signop) ((tree_class_check ((src_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3413, __FUNCTION__))->base.u.bits.unsigned_flag))
;
3414 if ((src_precision < dest_precision
3415 && !(dest_sgn == UNSIGNED && src_sgn == SIGNED))
3416 || (src_precision == dest_precision && src_sgn == dest_sgn))
3417 return true;
3418
3419 /* Now we can only handle ranges with constant bounds. */
3420 if (!range_int_cst_p (vr))
3421 return false;
3422
3423 /* For sign changes, the MSB of the wide_int has to be clear.
3424 An unsigned value with its MSB set cannot be represented by
3425 a signed wide_int, while a negative value cannot be represented
3426 by an unsigned wide_int. */
3427 if (src_sgn != dest_sgn
3428 && (wi::lts_p (wi::to_wide (vr->min ()), 0)
3429 || wi::lts_p (wi::to_wide (vr->max ()), 0)))
3430 return false;
3431
3432 /* Then we can perform the conversion on both ends and compare
3433 the result for equality. */
3434 tem = wi::ext (wi::to_widest (vr->min ()), dest_precision, dest_sgn);
3435 if (tem != wi::to_widest (vr->min ()))
3436 return false;
3437 tem = wi::ext (wi::to_widest (vr->max ()), dest_precision, dest_sgn);
3438 if (tem != wi::to_widest (vr->max ()))
3439 return false;
3440
3441 return true;
3442}
3443
3444/* If COND can be folded entirely as TRUE or FALSE, rewrite the
3445 conditional as such, and return TRUE. */
3446
3447bool
3448simplify_using_ranges::fold_cond (gcond *cond)
3449{
3450 /* ?? vrp_folder::fold_predicate_in() is a superset of this. At
3451 some point we should merge all variants of this code. */
3452 edge taken_edge;
3453 vrp_visit_cond_stmt (cond, &taken_edge);
3454
3455 int_range_max r;
3456 if (query->range_of_stmt (r, cond) && r.singleton_p ())
3457 {
3458 // COND has already been folded if arguments are constant.
3459 if (TREE_CODE (gimple_cond_lhs (cond))((enum tree_code) (gimple_cond_lhs (cond))->base.code) != SSA_NAME
3460 && TREE_CODE (gimple_cond_rhs (cond))((enum tree_code) (gimple_cond_rhs (cond))->base.code) != SSA_NAME)
3461 return false;
3462
3463 if (r.zero_p ())
3464 {
3465 gcc_checking_assert (!taken_edge((void)(!(!taken_edge || taken_edge->flags & EDGE_FALSE_VALUE
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3466, __FUNCTION__), 0 : 0))
3466 || taken_edge->flags & EDGE_FALSE_VALUE)((void)(!(!taken_edge || taken_edge->flags & EDGE_FALSE_VALUE
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3466, __FUNCTION__), 0 : 0))
;
3467 if (dump_file && (dump_flags & TDF_DETAILS) && !taken_edge)
3468 fprintf (dump_file, "\nPredicate evaluates to: 0\n");
3469 gimple_cond_make_false (cond);
3470 }
3471 else
3472 {
3473 gcc_checking_assert (!taken_edge((void)(!(!taken_edge || taken_edge->flags & EDGE_TRUE_VALUE
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3474, __FUNCTION__), 0 : 0))
3474 || taken_edge->flags & EDGE_TRUE_VALUE)((void)(!(!taken_edge || taken_edge->flags & EDGE_TRUE_VALUE
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3474, __FUNCTION__), 0 : 0))
;
3475 if (dump_file && (dump_flags & TDF_DETAILS) && !taken_edge)
3476 fprintf (dump_file, "\nPredicate evaluates to: 1\n");
3477 gimple_cond_make_true (cond);
3478 }
3479 update_stmt (cond);
3480 return true;
3481 }
3482
3483 if (taken_edge)
3484 {
3485 if (taken_edge->flags & EDGE_TRUE_VALUE)
3486 gimple_cond_make_true (cond);
3487 else if (taken_edge->flags & EDGE_FALSE_VALUE)
3488 gimple_cond_make_false (cond);
3489 else
3490 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3490, __FUNCTION__))
;
3491 update_stmt (cond);
3492 return true;
3493 }
3494 return false;
3495}
3496
3497/* Simplify a conditional using a relational operator to an equality
3498 test if the range information indicates only one value can satisfy
3499 the original conditional. */
3500
3501bool
3502simplify_using_ranges::simplify_cond_using_ranges_1 (gcond *stmt)
3503{
3504 tree op0 = gimple_cond_lhs (stmt);
3505 tree op1 = gimple_cond_rhs (stmt);
3506 enum tree_code cond_code = gimple_cond_code (stmt);
3507
3508 if (fold_cond (stmt))
3509 return true;
3510
3511 if (cond_code != NE_EXPR
3512 && cond_code != EQ_EXPR
3513 && TREE_CODE (op0)((enum tree_code) (op0)->base.code) == SSA_NAME
3514 && INTEGRAL_TYPE_P (TREE_TYPE (op0))(((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3514, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3514, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3514, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
3515 && is_gimple_min_invariant (op1))
3516 {
3517 const value_range *vr = query->get_value_range (op0, stmt);
3518
3519 /* If we have range information for OP0, then we might be
3520 able to simplify this conditional. */
3521 if (!vr->undefined_p () && !vr->varying_p ())
3522 {
3523 tree new_tree = test_for_singularity (cond_code, op0, op1, vr);
3524 if (new_tree)
3525 {
3526 if (dump_file)
3527 {
3528 fprintf (dump_file, "Simplified relational ");
3529 print_gimple_stmt (dump_file, stmt, 0);
3530 fprintf (dump_file, " into ");
3531 }
3532
3533 gimple_cond_set_code (stmt, EQ_EXPR);
3534 gimple_cond_set_lhs (stmt, op0);
3535 gimple_cond_set_rhs (stmt, new_tree);
3536
3537 update_stmt (stmt);
3538
3539 if (dump_file)
3540 {
3541 print_gimple_stmt (dump_file, stmt, 0);
3542 fprintf (dump_file, "\n");
3543 }
3544
3545 return true;
3546 }
3547
3548 /* Try again after inverting the condition. We only deal
3549 with integral types here, so no need to worry about
3550 issues with inverting FP comparisons. */
3551 new_tree = test_for_singularity
3552 (invert_tree_comparison (cond_code, false),
3553 op0, op1, vr);
3554 if (new_tree)
3555 {
3556 if (dump_file)
3557 {
3558 fprintf (dump_file, "Simplified relational ");
3559 print_gimple_stmt (dump_file, stmt, 0);
3560 fprintf (dump_file, " into ");
3561 }
3562
3563 gimple_cond_set_code (stmt, NE_EXPR);
3564 gimple_cond_set_lhs (stmt, op0);
3565 gimple_cond_set_rhs (stmt, new_tree);
3566
3567 update_stmt (stmt);
3568
3569 if (dump_file)
3570 {
3571 print_gimple_stmt (dump_file, stmt, 0);
3572 fprintf (dump_file, "\n");
3573 }
3574
3575 return true;
3576 }
3577 }
3578 }
3579 return false;
3580}
3581
3582/* Simplify a switch statement using the value range of the switch
3583 argument. */
3584
3585bool
3586simplify_using_ranges::simplify_switch_using_ranges (gswitch *stmt)
3587{
3588 tree op = gimple_switch_index (stmt);
3589 const value_range *vr = NULL__null;
3590 bool take_default;
3591 edge e;
3592 edge_iterator ei;
3593 size_t i = 0, j = 0, n, n2;
3594 tree vec2;
3595 switch_update su;
3596 size_t k = 1, l = 0;
3597
3598 if (TREE_CODE (op)((enum tree_code) (op)->base.code) == SSA_NAME)
3599 {
3600 vr = query->get_value_range (op, stmt);
3601
3602 /* We can only handle integer ranges. */
3603 if (vr->varying_p ()
3604 || vr->undefined_p ()
3605 || vr->symbolic_p ())
3606 return false;
3607
3608 /* Find case label for min/max of the value range. */
3609 take_default = !find_case_label_ranges (stmt, vr, &i, &j, &k, &l);
3610 }
3611 else if (TREE_CODE (op)((enum tree_code) (op)->base.code) == INTEGER_CST)
3612 {
3613 take_default = !find_case_label_index (stmt, 1, op, &i);
3614 if (take_default)
3615 {
3616 i = 1;
3617 j = 0;
3618 }
3619 else
3620 {
3621 j = i;
3622 }
3623 }
3624 else
3625 return false;
3626
3627 n = gimple_switch_num_labels (stmt);
3628
3629 /* We can truncate the case label ranges that partially overlap with OP's
3630 value range. */
3631 size_t min_idx = 1, max_idx = 0;
3632 if (vr != NULL__null)
3633 find_case_label_range (stmt, vr->min (), vr->max (), &min_idx, &max_idx);
3634 if (min_idx <= max_idx)
3635 {
3636 tree min_label = gimple_switch_label (stmt, min_idx);
3637 tree max_label = gimple_switch_label (stmt, max_idx);
3638
3639 /* Avoid changing the type of the case labels when truncating. */
3640 tree case_label_type = TREE_TYPE (CASE_LOW (min_label))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
(((tree_check ((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3640, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3640, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3640, __FUNCTION__))->typed.type)
;
3641 tree vr_min = fold_convert (case_label_type, vr->min ())fold_convert_loc (((location_t) 0), case_label_type, vr->min
())
;
3642 tree vr_max = fold_convert (case_label_type, vr->max ())fold_convert_loc (((location_t) 0), case_label_type, vr->max
())
;
3643
3644 if (vr->kind () == VR_RANGE)
3645 {
3646 /* If OP's value range is [2,8] and the low label range is
3647 0 ... 3, truncate the label's range to 2 .. 3. */
3648 if (tree_int_cst_compare (CASE_LOW (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3648, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3648, __FUNCTION__)))))
, vr_min) < 0
3649 && CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3649, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3649, __FUNCTION__)))))
!= NULL_TREE(tree) __null
3650 && tree_int_cst_compare (CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3650, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3650, __FUNCTION__)))))
, vr_min) >= 0)
3651 CASE_LOW (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3651, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3651, __FUNCTION__)))))
= vr_min;
3652
3653 /* If OP's value range is [2,8] and the high label range is
3654 7 ... 10, truncate the label's range to 7 .. 8. */
3655 if (tree_int_cst_compare (CASE_LOW (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3655, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3655, __FUNCTION__)))))
, vr_max) <= 0
3656 && CASE_HIGH (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3656, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3656, __FUNCTION__)))))
!= NULL_TREE(tree) __null
3657 && tree_int_cst_compare (CASE_HIGH (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3657, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3657, __FUNCTION__)))))
, vr_max) > 0)
3658 CASE_HIGH (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3658, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3658, __FUNCTION__)))))
= vr_max;
3659 }
3660 else if (vr->kind () == VR_ANTI_RANGE)
3661 {
3662 tree one_cst = build_one_cst (case_label_type);
3663
3664 if (min_label == max_label)
3665 {
3666 /* If OP's value range is ~[7,8] and the label's range is
3667 7 ... 10, truncate the label's range to 9 ... 10. */
3668 if (tree_int_cst_compare (CASE_LOW (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3668, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3668, __FUNCTION__)))))
, vr_min) == 0
3669 && CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3669, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3669, __FUNCTION__)))))
!= NULL_TREE(tree) __null
3670 && tree_int_cst_compare (CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3670, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3670, __FUNCTION__)))))
, vr_max) > 0)
3671 CASE_LOW (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3671, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3671, __FUNCTION__)))))
3672 = int_const_binop (PLUS_EXPR, vr_max, one_cst);
3673
3674 /* If OP's value range is ~[7,8] and the label's range is
3675 5 ... 8, truncate the label's range to 5 ... 6. */
3676 if (tree_int_cst_compare (CASE_LOW (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3676, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3676, __FUNCTION__)))))
, vr_min) < 0
3677 && CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3677, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3677, __FUNCTION__)))))
!= NULL_TREE(tree) __null
3678 && tree_int_cst_compare (CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3678, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3678, __FUNCTION__)))))
, vr_max) == 0)
3679 CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3679, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3679, __FUNCTION__)))))
3680 = int_const_binop (MINUS_EXPR, vr_min, one_cst);
3681 }
3682 else
3683 {
3684 /* If OP's value range is ~[2,8] and the low label range is
3685 0 ... 3, truncate the label's range to 0 ... 1. */
3686 if (tree_int_cst_compare (CASE_LOW (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3686, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3686, __FUNCTION__)))))
, vr_min) < 0
3687 && CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3687, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3687, __FUNCTION__)))))
!= NULL_TREE(tree) __null
3688 && tree_int_cst_compare (CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3688, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3688, __FUNCTION__)))))
, vr_min) >= 0)
3689 CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3689, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3689, __FUNCTION__)))))
3690 = int_const_binop (MINUS_EXPR, vr_min, one_cst);
3691
3692 /* If OP's value range is ~[2,8] and the high label range is
3693 7 ... 10, truncate the label's range to 9 ... 10. */
3694 if (tree_int_cst_compare (CASE_LOW (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3694, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3694, __FUNCTION__)))))
, vr_max) <= 0
3695 && CASE_HIGH (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3695, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3695, __FUNCTION__)))))
!= NULL_TREE(tree) __null
3696 && tree_int_cst_compare (CASE_HIGH (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3696, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3696, __FUNCTION__)))))
, vr_max) > 0)
3697 CASE_LOW (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3697, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3697, __FUNCTION__)))))
3698 = int_const_binop (PLUS_EXPR, vr_max, one_cst);
3699 }
3700 }
3701
3702 /* Canonicalize singleton case ranges. */
3703 if (tree_int_cst_equal (CASE_LOW (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3703, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3703, __FUNCTION__)))))
, CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3703, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3703, __FUNCTION__)))))
))
3704 CASE_HIGH (min_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((min_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3704, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3704, __FUNCTION__)))))
= NULL_TREE(tree) __null;
3705 if (tree_int_cst_equal (CASE_LOW (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3705, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3705, __FUNCTION__)))))
, CASE_HIGH (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3705, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3705, __FUNCTION__)))))
))
3706 CASE_HIGH (max_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((max_label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3706, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3706, __FUNCTION__)))))
= NULL_TREE(tree) __null;
3707 }
3708
3709 /* We can also eliminate case labels that lie completely outside OP's value
3710 range. */
3711
3712 /* Bail out if this is just all edges taken. */
3713 if (i == 1
3714 && j == n - 1
3715 && take_default)
3716 return false;
3717
3718 /* Build a new vector of taken case labels. */
3719 vec2 = make_tree_vec (j - i + 1 + l - k + 1 + (int)take_default);
3720 n2 = 0;
3721
3722 /* Add the default edge, if necessary. */
3723 if (take_default)
3724 TREE_VEC_ELT (vec2, n2++)(*((const_cast<tree *> (tree_vec_elt_check ((vec2), (n2
++), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3724, __FUNCTION__)))))
= gimple_switch_default_label (stmt);
3725
3726 for (; i <= j; ++i, ++n2)
3727 TREE_VEC_ELT (vec2, n2)(*((const_cast<tree *> (tree_vec_elt_check ((vec2), (n2
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3727, __FUNCTION__)))))
= gimple_switch_label (stmt, i);
3728
3729 for (; k <= l; ++k, ++n2)
3730 TREE_VEC_ELT (vec2, n2)(*((const_cast<tree *> (tree_vec_elt_check ((vec2), (n2
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3730, __FUNCTION__)))))
= gimple_switch_label (stmt, k);
3731
3732 /* Mark needed edges. */
3733 for (i = 0; i < n2; ++i)
3734 {
3735 e = find_edge (gimple_bb (stmt),
3736 label_to_block (cfun(cfun + 0),
3737 CASE_LABEL (TREE_VEC_ELT (vec2, i))(*((const_cast<tree*> (tree_operand_check (((tree_check
(((*((const_cast<tree *> (tree_vec_elt_check ((vec2), (
i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3737, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3737, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3737, __FUNCTION__)))))
));
3738 e->aux = (void *)-1;
3739 }
3740
3741 /* Queue not needed edges for later removal. */
3742 FOR_EACH_EDGE (e, ei, gimple_bb (stmt)->succs)for ((ei) = ei_start_1 (&((gimple_bb (stmt)->succs)));
ei_cond ((ei), &(e)); ei_next (&(ei)))
3743 {
3744 if (e->aux == (void *)-1)
3745 {
3746 e->aux = NULL__null;
3747 continue;
3748 }
3749
3750 if (dump_file && (dump_flags & TDF_DETAILS))
3751 {
3752 fprintf (dump_file, "removing unreachable case label\n");
3753 }
3754 to_remove_edges.safe_push (e);
3755 e->flags &= ~EDGE_EXECUTABLE;
3756 e->flags |= EDGE_IGNORE;
3757 }
3758
3759 /* And queue an update for the stmt. */
3760 su.stmt = stmt;
3761 su.vec = vec2;
3762 to_update_switch_stmts.safe_push (su);
3763 return true;
3764}
3765
3766void
3767simplify_using_ranges::cleanup_edges_and_switches (void)
3768{
3769 int i;
3770 edge e;
3771 switch_update *su;
3772
3773 /* Remove dead edges from SWITCH_EXPR optimization. This leaves the
3774 CFG in a broken state and requires a cfg_cleanup run. */
3775 FOR_EACH_VEC_ELT (to_remove_edges, i, e)for (i = 0; (to_remove_edges).iterate ((i), &(e)); ++(i))
3776 remove_edge (e);
3777
3778 /* Update SWITCH_EXPR case label vector. */
3779 FOR_EACH_VEC_ELT (to_update_switch_stmts, i, su)for (i = 0; (to_update_switch_stmts).iterate ((i), &(su))
; ++(i))
3780 {
3781 size_t j;
3782 size_t n = TREE_VEC_LENGTH (su->vec)((tree_check ((su->vec), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3782, __FUNCTION__, (TREE_VEC)))->base.u.length)
;
3783 tree label;
3784 gimple_switch_set_num_labels (su->stmt, n);
3785 for (j = 0; j < n; j++)
3786 gimple_switch_set_label (su->stmt, j, TREE_VEC_ELT (su->vec, j)(*((const_cast<tree *> (tree_vec_elt_check ((su->vec
), (j), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3786, __FUNCTION__)))))
);
3787 /* As we may have replaced the default label with a regular one
3788 make sure to make it a real default label again. This ensures
3789 optimal expansion. */
3790 label = gimple_switch_label (su->stmt, 0);
3791 CASE_LOW (label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3791, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3791, __FUNCTION__)))))
= NULL_TREE(tree) __null;
3792 CASE_HIGH (label)(*((const_cast<tree*> (tree_operand_check (((tree_check
((label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3792, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3792, __FUNCTION__)))))
= NULL_TREE(tree) __null;
3793 }
3794
3795 if (!to_remove_edges.is_empty ())
3796 {
3797 free_dominance_info (CDI_DOMINATORS);
3798 loops_state_set (LOOPS_NEED_FIXUP);
3799 }
3800
3801 to_remove_edges.release ();
3802 to_update_switch_stmts.release ();
3803}
3804
3805/* Simplify an integral conversion from an SSA name in STMT. */
3806
3807static bool
3808simplify_conversion_using_ranges (gimple_stmt_iterator *gsi, gimple *stmt)
3809{
3810 tree innerop, middleop, finaltype;
3811 gimple *def_stmt;
3812 signop inner_sgn, middle_sgn, final_sgn;
3813 unsigned inner_prec, middle_prec, final_prec;
3814 widest_int innermin, innermed, innermax, middlemin, middlemed, middlemax;
3815
3816 finaltype = TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3816, __FUNCTION__))->typed.type)
;
3817 if (!INTEGRAL_TYPE_P (finaltype)(((enum tree_code) (finaltype)->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (finaltype)->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (finaltype)->base.code) == INTEGER_TYPE
)
)
3818 return false;
3819 middleop = gimple_assign_rhs1 (stmt);
3820 def_stmt = SSA_NAME_DEF_STMT (middleop)(tree_check ((middleop), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3820, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt
;
3821 if (!is_gimple_assign (def_stmt)
3822 || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))((gimple_assign_rhs_code (def_stmt)) == NOP_EXPR || (gimple_assign_rhs_code
(def_stmt)) == CONVERT_EXPR)
)
3823 return false;
3824 innerop = gimple_assign_rhs1 (def_stmt);
3825 if (TREE_CODE (innerop)((enum tree_code) (innerop)->base.code) != SSA_NAME
3826 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (innerop)(tree_check ((innerop), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3826, __FUNCTION__, (SSA_NAME)))->base.asm_written_flag
)
3827 return false;
3828
3829 /* Get the value-range of the inner operand. Use get_range_info in
3830 case innerop was created during substitute-and-fold. */
3831 wide_int imin, imax;
3832 value_range vr;
3833 if (!INTEGRAL_TYPE_P (TREE_TYPE (innerop))(((enum tree_code) (((contains_struct_check ((innerop), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3833, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((innerop), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3833, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((innerop), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3833, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
)
3834 return false;
3835 get_range_info (innerop, vr);
3836 if (vr.undefined_p () || vr.varying_p ())
3837 return false;
3838 innermin = widest_int::from (vr.lower_bound (), TYPE_SIGN (TREE_TYPE (innerop))((signop) ((tree_class_check ((((contains_struct_check ((innerop
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3838, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3838, __FUNCTION__))->base.u.bits.unsigned_flag))
);
3839 innermax = widest_int::from (vr.upper_bound (), TYPE_SIGN (TREE_TYPE (innerop))((signop) ((tree_class_check ((((contains_struct_check ((innerop
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3839, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3839, __FUNCTION__))->base.u.bits.unsigned_flag))
);
3840
3841 /* Simulate the conversion chain to check if the result is equal if
3842 the middle conversion is removed. */
3843 inner_prec = TYPE_PRECISION (TREE_TYPE (innerop))((tree_class_check ((((contains_struct_check ((innerop), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3843, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3843, __FUNCTION__))->type_common.precision)
;
3844 middle_prec = TYPE_PRECISION (TREE_TYPE (middleop))((tree_class_check ((((contains_struct_check ((middleop), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3844, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3844, __FUNCTION__))->type_common.precision)
;
3845 final_prec = TYPE_PRECISION (finaltype)((tree_class_check ((finaltype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3845, __FUNCTION__))->type_common.precision)
;
3846
3847 /* If the first conversion is not injective, the second must not
3848 be widening. */
3849 if (wi::gtu_p (innermax - innermin,
3850 wi::mask <widest_int> (middle_prec, false))
3851 && middle_prec < final_prec)
3852 return false;
3853 /* We also want a medium value so that we can track the effect that
3854 narrowing conversions with sign change have. */
3855 inner_sgn = TYPE_SIGN (TREE_TYPE (innerop))((signop) ((tree_class_check ((((contains_struct_check ((innerop
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3855, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3855, __FUNCTION__))->base.u.bits.unsigned_flag))
;
3856 if (inner_sgn == UNSIGNED)
3857 innermed = wi::shifted_mask <widest_int> (1, inner_prec - 1, false);
3858 else
3859 innermed = 0;
3860 if (wi::cmp (innermin, innermed, inner_sgn) >= 0
3861 || wi::cmp (innermed, innermax, inner_sgn) >= 0)
3862 innermed = innermin;
3863
3864 middle_sgn = TYPE_SIGN (TREE_TYPE (middleop))((signop) ((tree_class_check ((((contains_struct_check ((middleop
), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3864, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3864, __FUNCTION__))->base.u.bits.unsigned_flag))
;
3865 middlemin = wi::ext (innermin, middle_prec, middle_sgn);
3866 middlemed = wi::ext (innermed, middle_prec, middle_sgn);
3867 middlemax = wi::ext (innermax, middle_prec, middle_sgn);
3868
3869 /* Require that the final conversion applied to both the original
3870 and the intermediate range produces the same result. */
3871 final_sgn = TYPE_SIGN (finaltype)((signop) ((tree_class_check ((finaltype), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3871, __FUNCTION__))->base.u.bits.unsigned_flag))
;
3872 if (wi::ext (middlemin, final_prec, final_sgn)
3873 != wi::ext (innermin, final_prec, final_sgn)
3874 || wi::ext (middlemed, final_prec, final_sgn)
3875 != wi::ext (innermed, final_prec, final_sgn)
3876 || wi::ext (middlemax, final_prec, final_sgn)
3877 != wi::ext (innermax, final_prec, final_sgn))
3878 return false;
3879
3880 gimple_assign_set_rhs1 (stmt, innerop);
3881 fold_stmt (gsi, follow_single_use_edges);
3882 return true;
3883}
3884
3885/* Simplify a conversion from integral SSA name to float in STMT. */
3886
3887bool
3888simplify_using_ranges::simplify_float_conversion_using_ranges
3889 (gimple_stmt_iterator *gsi,
3890 gimple *stmt)
3891{
3892 tree rhs1 = gimple_assign_rhs1 (stmt);
3893 const value_range *vr = query->get_value_range (rhs1, stmt);
3894 scalar_float_mode fltmode
3895 = SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt)))(as_a <scalar_float_mode> ((tree_class_check ((((contains_struct_check
((gimple_assign_lhs (stmt)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3895, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3895, __FUNCTION__))->type_common.mode))
;
3896 scalar_int_mode mode;
3897 tree tem;
3898 gassign *conv;
3899
3900 /* We can only handle constant ranges. */
3901 if (!range_int_cst_p (vr))
3902 return false;
3903
3904 /* First check if we can use a signed type in place of an unsigned. */
3905 scalar_int_mode rhs_mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (rhs1))(as_a <scalar_int_mode> ((tree_class_check ((((contains_struct_check
((rhs1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3905, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3905, __FUNCTION__))->type_common.mode))
;
3906 if (TYPE_UNSIGNED (TREE_TYPE (rhs1))((tree_class_check ((((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3906, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3906, __FUNCTION__))->base.u.bits.unsigned_flag)
3907 && can_float_p (fltmode, rhs_mode, 0) != CODE_FOR_nothing
3908 && range_fits_type_p (vr, TYPE_PRECISION (TREE_TYPE (rhs1))((tree_class_check ((((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3908, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3908, __FUNCTION__))->type_common.precision)
, SIGNED))
3909 mode = rhs_mode;
3910 /* If we can do the conversion in the current input mode do nothing. */
3911 else if (can_float_p (fltmode, rhs_mode,
3912 TYPE_UNSIGNED (TREE_TYPE (rhs1))((tree_class_check ((((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3912, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3912, __FUNCTION__))->base.u.bits.unsigned_flag)
) != CODE_FOR_nothing)
3913 return false;
3914 /* Otherwise search for a mode we can use, starting from the narrowest
3915 integer mode available. */
3916 else
3917 {
3918 mode = NARROWEST_INT_MODE(scalar_int_mode (scalar_int_mode::from_int (class_narrowest_mode
[MODE_INT])))
;
3919 for (;;)
3920 {
3921 /* If we cannot do a signed conversion to float from mode
3922 or if the value-range does not fit in the signed type
3923 try with a wider mode. */
3924 if (can_float_p (fltmode, mode, 0) != CODE_FOR_nothing
3925 && range_fits_type_p (vr, GET_MODE_PRECISION (mode), SIGNED))
3926 break;
3927
3928 /* But do not widen the input. Instead leave that to the
3929 optabs expansion code. */
3930 if (!GET_MODE_WIDER_MODE (mode).exists (&mode)
3931 || GET_MODE_PRECISION (mode) > TYPE_PRECISION (TREE_TYPE (rhs1))((tree_class_check ((((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3931, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3931, __FUNCTION__))->type_common.precision)
)
3932 return false;
3933 }
3934 }
3935
3936 /* It works, insert a truncation or sign-change before the
3937 float conversion. */
3938 tem = make_ssa_name (build_nonstandard_integer_type
3939 (GET_MODE_PRECISION (mode), 0));
3940 conv = gimple_build_assign (tem, NOP_EXPR, rhs1);
3941 gsi_insert_before (gsi, conv, GSI_SAME_STMT);
3942 gimple_assign_set_rhs1 (stmt, tem);
3943 fold_stmt (gsi, follow_single_use_edges);
3944
3945 return true;
3946}
3947
3948/* Simplify an internal fn call using ranges if possible. */
3949
3950bool
3951simplify_using_ranges::simplify_internal_call_using_ranges
3952 (gimple_stmt_iterator *gsi,
3953 gimple *stmt)
3954{
3955 enum tree_code subcode;
3956 bool is_ubsan = false;
3957 bool ovf = false;
3958 switch (gimple_call_internal_fn (stmt))
3959 {
3960 case IFN_UBSAN_CHECK_ADD:
3961 subcode = PLUS_EXPR;
3962 is_ubsan = true;
3963 break;
3964 case IFN_UBSAN_CHECK_SUB:
3965 subcode = MINUS_EXPR;
3966 is_ubsan = true;
3967 break;
3968 case IFN_UBSAN_CHECK_MUL:
3969 subcode = MULT_EXPR;
3970 is_ubsan = true;
3971 break;
3972 case IFN_ADD_OVERFLOW:
3973 subcode = PLUS_EXPR;
3974 break;
3975 case IFN_SUB_OVERFLOW:
3976 subcode = MINUS_EXPR;
3977 break;
3978 case IFN_MUL_OVERFLOW:
3979 subcode = MULT_EXPR;
3980 break;
3981 default:
3982 return false;
3983 }
3984
3985 tree op0 = gimple_call_arg (stmt, 0);
3986 tree op1 = gimple_call_arg (stmt, 1);
3987 tree type;
3988 if (is_ubsan)
3989 {
3990 type = TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3990, __FUNCTION__))->typed.type)
;
3991 if (VECTOR_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE))
3992 return false;
3993 }
3994 else if (gimple_call_lhs (stmt) == NULL_TREE(tree) __null)
3995 return false;
3996 else
3997 type = TREE_TYPE (TREE_TYPE (gimple_call_lhs (stmt)))((contains_struct_check ((((contains_struct_check ((gimple_call_lhs
(stmt)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3997, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 3997, __FUNCTION__))->typed.type)
;
3998 if (!check_for_binary_op_overflow (query, subcode, type, op0, op1, &ovf)
3999 || (is_ubsan && ovf))
4000 return false;
4001
4002 gimple *g;
4003 location_t loc = gimple_location (stmt);
4004 if (is_ubsan)
4005 g = gimple_build_assign (gimple_call_lhs (stmt), subcode, op0, op1);
4006 else
4007 {
4008 int prec = TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4008, __FUNCTION__))->type_common.precision)
;
4009 tree utype = type;
4010 if (ovf
4011 || !useless_type_conversion_p (type, TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4011, __FUNCTION__))->typed.type)
)
4012 || !useless_type_conversion_p (type, TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4012, __FUNCTION__))->typed.type)
))
4013 utype = build_nonstandard_integer_type (prec, 1);
4014 if (TREE_CODE (op0)((enum tree_code) (op0)->base.code) == INTEGER_CST)
4015 op0 = fold_convert (utype, op0)fold_convert_loc (((location_t) 0), utype, op0);
4016 else if (!useless_type_conversion_p (utype, TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4016, __FUNCTION__))->typed.type)
))
4017 {
4018 g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, op0);
4019 gimple_set_location (g, loc);
4020 gsi_insert_before (gsi, g, GSI_SAME_STMT);
4021 op0 = gimple_assign_lhs (g);
4022 }
4023 if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == INTEGER_CST)
4024 op1 = fold_convert (utype, op1)fold_convert_loc (((location_t) 0), utype, op1);
4025 else if (!useless_type_conversion_p (utype, TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4025, __FUNCTION__))->typed.type)
))
4026 {
4027 g = gimple_build_assign (make_ssa_name (utype), NOP_EXPR, op1);
4028 gimple_set_location (g, loc);
4029 gsi_insert_before (gsi, g, GSI_SAME_STMT);
4030 op1 = gimple_assign_lhs (g);
4031 }
4032 g = gimple_build_assign (make_ssa_name (utype), subcode, op0, op1);
4033 gimple_set_location (g, loc);
4034 gsi_insert_before (gsi, g, GSI_SAME_STMT);
4035 if (utype != type)
4036 {
4037 g = gimple_build_assign (make_ssa_name (type), NOP_EXPR,
4038 gimple_assign_lhs (g));
4039 gimple_set_location (g, loc);
4040 gsi_insert_before (gsi, g, GSI_SAME_STMT);
4041 }
4042 g = gimple_build_assign (gimple_call_lhs (stmt), COMPLEX_EXPR,
4043 gimple_assign_lhs (g),
4044 build_int_cst (type, ovf));
4045 }
4046 gimple_set_location (g, loc);
4047 gsi_replace (gsi, g, false);
4048 return true;
4049}
4050
4051/* Return true if VAR is a two-valued variable. Set a and b with the
4052 two-values when it is true. Return false otherwise. */
4053
4054bool
4055simplify_using_ranges::two_valued_val_range_p (tree var, tree *a, tree *b)
4056{
4057 value_range vr = *query->get_value_range (var);
4058 vr.normalize_symbolics ();
4059 if (vr.varying_p () || vr.undefined_p ())
4060 return false;
4061
4062 if ((vr.num_pairs () == 1 && vr.upper_bound () - vr.lower_bound () == 1)
4063 || (vr.num_pairs () == 2
4064 && vr.lower_bound (0) == vr.upper_bound (0)
4065 && vr.lower_bound (1) == vr.upper_bound (1)))
4066 {
4067 *a = wide_int_to_tree (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4067, __FUNCTION__))->typed.type)
, vr.lower_bound ());
4068 *b = wide_int_to_tree (TREE_TYPE (var)((contains_struct_check ((var), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4068, __FUNCTION__))->typed.type)
, vr.upper_bound ());
4069 return true;
4070 }
4071 return false;
4072}
4073
4074simplify_using_ranges::simplify_using_ranges (range_query *query)
4075 : query (query)
4076{
4077 to_remove_edges = vNULL;
4078 to_update_switch_stmts = vNULL;
4079}
4080
4081simplify_using_ranges::~simplify_using_ranges ()
4082{
4083 cleanup_edges_and_switches ();
4084}
4085
4086/* Simplify STMT using ranges if possible. */
4087
4088bool
4089simplify_using_ranges::simplify (gimple_stmt_iterator *gsi)
4090{
4091 gcc_checking_assert (query)((void)(!(query) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4091, __FUNCTION__), 0 : 0))
;
4092
4093 gimple *stmt = gsi_stmt (*gsi);
4094 if (is_gimple_assign (stmt))
4095 {
4096 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
4097 tree rhs1 = gimple_assign_rhs1 (stmt);
4098 tree rhs2 = gimple_assign_rhs2 (stmt);
4099 tree lhs = gimple_assign_lhs (stmt);
4100 tree val1 = NULL_TREE(tree) __null, val2 = NULL_TREE(tree) __null;
4101 use_operand_p use_p;
4102 gimple *use_stmt;
4103
4104 /* Convert:
4105 LHS = CST BINOP VAR
4106 Where VAR is two-valued and LHS is used in GIMPLE_COND only
4107 To:
4108 LHS = VAR == VAL1 ? (CST BINOP VAL1) : (CST BINOP VAL2)
4109
4110 Also handles:
4111 LHS = VAR BINOP CST
4112 Where VAR is two-valued and LHS is used in GIMPLE_COND only
4113 To:
4114 LHS = VAR == VAL1 ? (VAL1 BINOP CST) : (VAL2 BINOP CST) */
4115
4116 if (TREE_CODE_CLASS (rhs_code)tree_code_type[(int) (rhs_code)] == tcc_binary
4117 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))(((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4117, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4117, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4117, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
4118 && ((TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == INTEGER_CST
4119 && TREE_CODE (rhs2)((enum tree_code) (rhs2)->base.code) == SSA_NAME)
4120 || (TREE_CODE (rhs2)((enum tree_code) (rhs2)->base.code) == INTEGER_CST
4121 && TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME))
4122 && single_imm_use (lhs, &use_p, &use_stmt)
4123 && gimple_code (use_stmt) == GIMPLE_COND)
4124
4125 {
4126 tree new_rhs1 = NULL_TREE(tree) __null;
4127 tree new_rhs2 = NULL_TREE(tree) __null;
4128 tree cmp_var = NULL_TREE(tree) __null;
4129
4130 if (TREE_CODE (rhs2)((enum tree_code) (rhs2)->base.code) == SSA_NAME
4131 && two_valued_val_range_p (rhs2, &val1, &val2))
4132 {
4133 /* Optimize RHS1 OP [VAL1, VAL2]. */
4134 new_rhs1 = int_const_binop (rhs_code, rhs1, val1);
4135 new_rhs2 = int_const_binop (rhs_code, rhs1, val2);
4136 cmp_var = rhs2;
4137 }
4138 else if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME
4139 && two_valued_val_range_p (rhs1, &val1, &val2))
4140 {
4141 /* Optimize [VAL1, VAL2] OP RHS2. */
4142 new_rhs1 = int_const_binop (rhs_code, val1, rhs2);
4143 new_rhs2 = int_const_binop (rhs_code, val2, rhs2);
4144 cmp_var = rhs1;
4145 }
4146
4147 /* If we could not find two-vals or the optimzation is invalid as
4148 in divide by zero, new_rhs1 / new_rhs will be NULL_TREE. */
4149 if (new_rhs1 && new_rhs2)
4150 {
4151 tree cond = build2 (EQ_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], cmp_var, val1);
4152 gimple_assign_set_rhs_with_ops (gsi,
4153 COND_EXPR, cond,
4154 new_rhs1,
4155 new_rhs2);
4156 update_stmt (gsi_stmt (*gsi));
4157 fold_stmt (gsi, follow_single_use_edges);
4158 return true;
4159 }
4160 }
4161
4162 switch (rhs_code)
4163 {
4164 case EQ_EXPR:
4165 case NE_EXPR:
4166 /* Transform EQ_EXPR, NE_EXPR into BIT_XOR_EXPR or identity
4167 if the RHS is zero or one, and the LHS are known to be boolean
4168 values. */
4169 if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))(((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4169, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4169, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4169, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
)
4170 return simplify_truth_ops_using_ranges (gsi, stmt);
4171 break;
4172
4173 /* Transform TRUNC_DIV_EXPR and TRUNC_MOD_EXPR into RSHIFT_EXPR
4174 and BIT_AND_EXPR respectively if the first operand is greater
4175 than zero and the second operand is an exact power of two.
4176 Also optimize TRUNC_MOD_EXPR away if the second operand is
4177 constant and the first operand already has the right value
4178 range. */
4179 case TRUNC_DIV_EXPR:
4180 case TRUNC_MOD_EXPR:
4181 if ((TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME
4182 || TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == INTEGER_CST)
4183 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))(((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4183, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4183, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4183, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
)
4184 return simplify_div_or_mod_using_ranges (gsi, stmt);
4185 break;
4186
4187 /* Transform ABS (X) into X or -X as appropriate. */
4188 case ABS_EXPR:
4189 if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME
4190 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))(((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4190, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4190, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4190, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
)
4191 return simplify_abs_using_ranges (gsi, stmt);
4192 break;
4193
4194 case BIT_AND_EXPR:
4195 case BIT_IOR_EXPR:
4196 /* Optimize away BIT_AND_EXPR and BIT_IOR_EXPR
4197 if all the bits being cleared are already cleared or
4198 all the bits being set are already set. */
4199 if (INTEGRAL_TYPE_P (TREE_TYPE (rhs1))(((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4199, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4199, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4199, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
)
4200 return simplify_bit_ops_using_ranges (gsi, stmt);
4201 break;
4202
4203 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
4204 if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME
4205 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))(((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4205, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4205, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4205, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
)
4206 return simplify_conversion_using_ranges (gsi, stmt);
4207 break;
4208
4209 case FLOAT_EXPR:
4210 if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME
4211 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))(((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4211, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4211, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4211, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
)
4212 return simplify_float_conversion_using_ranges (gsi, stmt);
4213 break;
4214
4215 case MIN_EXPR:
4216 case MAX_EXPR:
4217 return simplify_min_or_max_using_ranges (gsi, stmt);
4218
4219 default:
4220 break;
4221 }
4222 }
4223 else if (gimple_code (stmt) == GIMPLE_COND)
4224 return simplify_cond_using_ranges_1 (as_a <gcond *> (stmt));
4225 else if (gimple_code (stmt) == GIMPLE_SWITCH)
4226 return simplify_switch_using_ranges (as_a <gswitch *> (stmt));
4227 else if (is_gimple_call (stmt)
4228 && gimple_call_internal_p (stmt))
4229 return simplify_internal_call_using_ranges (gsi, stmt);
4230
4231 return false;
4232}
4233
4234/* Set the lattice entry for VAR to VR. */
4235
4236void
4237vr_values::set_vr_value (tree var, value_range_equiv *vr)
4238{
4239 if (SSA_NAME_VERSION (var)(tree_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4239, __FUNCTION__, (SSA_NAME)))->base.u.version
>= num_vr_values)
4240 return;
4241 vr_value[SSA_NAME_VERSION (var)(tree_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4241, __FUNCTION__, (SSA_NAME)))->base.u.version
] = vr;
4242}
4243
4244/* Swap the lattice entry for VAR with VR and return the old entry. */
4245
4246value_range_equiv *
4247vr_values::swap_vr_value (tree var, value_range_equiv *vr)
4248{
4249 if (SSA_NAME_VERSION (var)(tree_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4249, __FUNCTION__, (SSA_NAME)))->base.u.version
>= num_vr_values)
4250 return NULL__null;
4251 std::swap (vr_value[SSA_NAME_VERSION (var)(tree_check ((var), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vr-values.c"
, 4251, __FUNCTION__, (SSA_NAME)))->base.u.version
], vr);
4252 return vr;
4253}