Bug Summary

File:objdir/gcc/generic-match.c
Warning:line 972, column 14
Value stored to 'type' during its initialization 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 generic-match.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 -Wno-unused -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-O3O6I2.plist -x c++ generic-match.c
1/* Generated automatically by the program `genmatch' from
2 a IL pattern matching and simplification description. */
3
4#include "generic-match-head.c"
5
6bool
7tree_nop_convert (tree t, tree *res_ops)
8{
9 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 9
, __FUNCTION__))->typed.type)
;
10 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 10, __FUNCTION__))->
base.side_effects_flag)
) return false;
11 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
12 {
13 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
14 {
15 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 15, __FUNCTION__)))))
;
16 {
17/* #line 105 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
18 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
19/* #line 105 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
20 if (tree_nop_conversion_p (type, TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 20, __FUNCTION__))->typed.type)
)
21)
22 {
23 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 103, __FILE__"generic-match.c", __LINE__23);
24 {
25 res_ops[0] = captures[0];
26 return true;
27 }
28next_after_fail1:;
29 }
30 }
31 break;
32 }
33 case VIEW_CONVERT_EXPR:
34 {
35 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 35, __FUNCTION__)))))
;
36 {
37/* #line 108 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
38 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
39/* #line 108 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
40 if (VECTOR_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE) && VECTOR_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 40, __FUNCTION__))->typed.type
))->base.code) == VECTOR_TYPE)
41 && known_eq (TYPE_VECTOR_SUBPARTS (type),(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS
(((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 42, __FUNCTION__))->typed.type))))
42 TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[0])))(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS
(((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 42, __FUNCTION__))->typed.type))))
43 && tree_nop_conversion_p (TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "generic-match.c"
, 43, __FUNCTION__))->typed.type)
, TREE_TYPE (TREE_TYPE (captures[0]))((contains_struct_check ((((contains_struct_check ((captures[
0]), (TS_TYPED), "generic-match.c", 43, __FUNCTION__))->typed
.type)), (TS_TYPED), "generic-match.c", 43, __FUNCTION__))->
typed.type)
)
44)
45 {
46 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 106, __FILE__"generic-match.c", __LINE__46);
47 {
48 res_ops[0] = captures[0];
49 return true;
50 }
51next_after_fail2:;
52 }
53 }
54 break;
55 }
56 default:;
57 }
58 return false;
59}
60
61bool
62tree_power_of_two_cand (tree t, tree *res_ops)
63{
64 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 64
, __FUNCTION__))->typed.type)
;
65 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 65, __FUNCTION__))->
base.side_effects_flag)
) return false;
66 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
67 {
68 case INTEGER_CST:
69 {
70 {
71/* #line 624 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
72 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
73 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 624, __FILE__"generic-match.c", __LINE__73);
74 {
75 res_ops[0] = captures[0];
76 return true;
77 }
78next_after_fail3:;
79 }
80 break;
81 }
82 case LSHIFT_EXPR:
83 {
84 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 84, __FUNCTION__)))))
;
85 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 85, __FUNCTION__)))))
;
86 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
87 {
88 case INTEGER_CST:
89 {
90 {
91/* #line 626 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
92 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
93 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 626, __FILE__"generic-match.c", __LINE__93);
94 {
95 res_ops[0] = captures[0];
96 return true;
97 }
98next_after_fail4:;
99 }
100 break;
101 }
102 default:;
103 }
104 break;
105 }
106 default:;
107 }
108 return false;
109}
110
111bool
112tree_negate_expr_p (tree t)
113{
114 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 114
, __FUNCTION__))->typed.type)
;
115 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 115, __FUNCTION__))
->base.side_effects_flag)
) return false;
116 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
117 {
118 case INTEGER_CST:
119 {
120 {
121/* #line 1422 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
122/* #line 1422 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
123 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)
124 && TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 124
, __FUNCTION__))->base.u.bits.unsigned_flag)
)
125 || (!TYPE_OVERFLOW_SANITIZED (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) &&
!((((enum tree_code) (type)->base.code) == POINTER_TYPE ||
((enum tree_code) (type)->base.code) == REFERENCE_TYPE) ?
global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((type), "generic-match.c", 125, __FUNCTION__))->base.u.bits
.unsigned_flag || global_options.x_flag_wrapv)) && (global_options
.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
126 && may_negate_without_overflow_p (t))
127)
128 {
129 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1421, __FILE__"generic-match.c", __LINE__129);
130 {
131 return true;
132 }
133next_after_fail5:;
134 }
135 }
136 break;
137 }
138 case FIXED_CST:
139 {
140 {
141/* #line 1427 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
142 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1427, __FILE__"generic-match.c", __LINE__142);
143 {
144 return true;
145 }
146next_after_fail6:;
147 }
148 break;
149 }
150 case NEGATE_EXPR:
151 {
152 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 152, __FUNCTION__)))))
;
153 {
154/* #line 1430 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
155 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
156/* #line 1430 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
157 if (!TYPE_OVERFLOW_SANITIZED (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) &&
!((((enum tree_code) (type)->base.code) == POINTER_TYPE ||
((enum tree_code) (type)->base.code) == REFERENCE_TYPE) ?
global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((type), "generic-match.c", 157, __FUNCTION__))->base.u.bits
.unsigned_flag || global_options.x_flag_wrapv)) && (global_options
.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
158)
159 {
160 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1429, __FILE__"generic-match.c", __LINE__160);
161 {
162 return true;
163 }
164next_after_fail7:;
165 }
166 }
167 break;
168 }
169 case REAL_CST:
170 {
171 {
172/* #line 1433 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
173/* #line 1433 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
174 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (t))real_isneg (&((*((tree_check ((t), "generic-match.c", 174
, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr))))
175)
176 {
177 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1432, __FILE__"generic-match.c", __LINE__177);
178 {
179 return true;
180 }
181next_after_fail8:;
182 }
183 }
184 break;
185 }
186 case VECTOR_CST:
187 {
188 {
189/* #line 1438 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
190/* #line 1438 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
191 if (FLOAT_TYPE_P (TREE_TYPE (type))((((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 191, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE) || ((((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 191, __FUNCTION__))->
typed.type))->base.code) == COMPLEX_TYPE || (((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "generic-match.c"
, 191, __FUNCTION__))->typed.type))->base.code) == VECTOR_TYPE
)) && (((enum tree_code) (((contains_struct_check (((
(contains_struct_check ((type), (TS_TYPED), "generic-match.c"
, 191, __FUNCTION__))->typed.type)), (TS_TYPED), "generic-match.c"
, 191, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
|| TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.c"
, 191, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
192)
193 {
194 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1437, __FILE__"generic-match.c", __LINE__194);
195 {
196 return true;
197 }
198next_after_fail9:;
199 }
200 }
201 break;
202 }
203 case MINUS_EXPR:
204 {
205 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 205, __FUNCTION__)))))
;
206 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 206, __FUNCTION__)))))
;
207 {
208/* #line 1441 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
209 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
210/* #line 1441 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
211 if ((ANY_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) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 211, __FUNCTION__))->typed.type))->
base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 211, __FUNCTION__))->
typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "generic-match.c"
, 211, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
&& TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.c"
, 211, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
)
212 || (FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 212, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
213 && !HONOR_SIGN_DEPENDENT_ROUNDING (type)
214 && !HONOR_SIGNED_ZEROS (type))
215)
216 {
217 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1440, __FILE__"generic-match.c", __LINE__217);
218 {
219 return true;
220 }
221next_after_fail10:;
222 }
223 }
224 break;
225 }
226 default:;
227 }
228 return false;
229}
230
231bool
232tree_truth_valued_p (tree t)
233{
234 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 234
, __FUNCTION__))->typed.type)
;
235 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 235, __FUNCTION__))
->base.side_effects_flag)
) return false;
236 {
237/* #line 1575 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
238 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
239/* #line 1575 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
240 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)
&& TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 240
, __FUNCTION__))->type_common.precision)
== 1
241)
242 {
243 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1574, __FILE__"generic-match.c", __LINE__243);
244 {
245 return true;
246 }
247next_after_fail11:;
248 }
249 }
250 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
251 {
252 case LT_EXPR:
253 {
254 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 254, __FUNCTION__)))))
;
255 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 255, __FUNCTION__)))))
;
256 {
257/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
258 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
259 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__259);
260 {
261 return true;
262 }
263next_after_fail12:;
264 }
265 break;
266 }
267 case LE_EXPR:
268 {
269 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 269, __FUNCTION__)))))
;
270 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 270, __FUNCTION__)))))
;
271 {
272/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
273 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
274 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__274);
275 {
276 return true;
277 }
278next_after_fail13:;
279 }
280 break;
281 }
282 case EQ_EXPR:
283 {
284 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 284, __FUNCTION__)))))
;
285 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 285, __FUNCTION__)))))
;
286 {
287/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
288 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
289 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__289);
290 {
291 return true;
292 }
293next_after_fail14:;
294 }
295 break;
296 }
297 case NE_EXPR:
298 {
299 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 299, __FUNCTION__)))))
;
300 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 300, __FUNCTION__)))))
;
301 {
302/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
303 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
304 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__304);
305 {
306 return true;
307 }
308next_after_fail15:;
309 }
310 break;
311 }
312 case GE_EXPR:
313 {
314 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 314, __FUNCTION__)))))
;
315 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 315, __FUNCTION__)))))
;
316 {
317/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
318 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
319 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__319);
320 {
321 return true;
322 }
323next_after_fail16:;
324 }
325 break;
326 }
327 case GT_EXPR:
328 {
329 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 329, __FUNCTION__)))))
;
330 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 330, __FUNCTION__)))))
;
331 {
332/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
333 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
334 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__334);
335 {
336 return true;
337 }
338next_after_fail17:;
339 }
340 break;
341 }
342 case UNORDERED_EXPR:
343 {
344 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 344, __FUNCTION__)))))
;
345 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 345, __FUNCTION__)))))
;
346 {
347/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
348 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
349 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__349);
350 {
351 return true;
352 }
353next_after_fail18:;
354 }
355 break;
356 }
357 case ORDERED_EXPR:
358 {
359 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 359, __FUNCTION__)))))
;
360 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 360, __FUNCTION__)))))
;
361 {
362/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
363 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
364 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__364);
365 {
366 return true;
367 }
368next_after_fail19:;
369 }
370 break;
371 }
372 case UNLT_EXPR:
373 {
374 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 374, __FUNCTION__)))))
;
375 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 375, __FUNCTION__)))))
;
376 {
377/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
378 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
379 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__379);
380 {
381 return true;
382 }
383next_after_fail20:;
384 }
385 break;
386 }
387 case UNLE_EXPR:
388 {
389 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 389, __FUNCTION__)))))
;
390 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 390, __FUNCTION__)))))
;
391 {
392/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
393 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
394 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__394);
395 {
396 return true;
397 }
398next_after_fail21:;
399 }
400 break;
401 }
402 case UNGT_EXPR:
403 {
404 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 404, __FUNCTION__)))))
;
405 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 405, __FUNCTION__)))))
;
406 {
407/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
408 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
409 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__409);
410 {
411 return true;
412 }
413next_after_fail22:;
414 }
415 break;
416 }
417 case UNGE_EXPR:
418 {
419 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 419, __FUNCTION__)))))
;
420 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 420, __FUNCTION__)))))
;
421 {
422/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
423 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
424 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__424);
425 {
426 return true;
427 }
428next_after_fail23:;
429 }
430 break;
431 }
432 case UNEQ_EXPR:
433 {
434 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 434, __FUNCTION__)))))
;
435 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 435, __FUNCTION__)))))
;
436 {
437/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
438 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
439 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__439);
440 {
441 return true;
442 }
443next_after_fail24:;
444 }
445 break;
446 }
447 case LTGT_EXPR:
448 {
449 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 449, __FUNCTION__)))))
;
450 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 450, __FUNCTION__)))))
;
451 {
452/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
453 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
454 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__454);
455 {
456 return true;
457 }
458next_after_fail25:;
459 }
460 break;
461 }
462 case TRUTH_AND_EXPR:
463 {
464 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 464, __FUNCTION__)))))
;
465 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 465, __FUNCTION__)))))
;
466 {
467/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
468 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
469 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__469);
470 {
471 return true;
472 }
473next_after_fail26:;
474 }
475 break;
476 }
477 case TRUTH_ANDIF_EXPR:
478 {
479 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 479, __FUNCTION__)))))
;
480 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 480, __FUNCTION__)))))
;
481 {
482/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
483 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
484 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__484);
485 {
486 return true;
487 }
488next_after_fail27:;
489 }
490 break;
491 }
492 case TRUTH_OR_EXPR:
493 {
494 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 494, __FUNCTION__)))))
;
495 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 495, __FUNCTION__)))))
;
496 {
497/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
498 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
499 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__499);
500 {
501 return true;
502 }
503next_after_fail28:;
504 }
505 break;
506 }
507 case TRUTH_ORIF_EXPR:
508 {
509 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 509, __FUNCTION__)))))
;
510 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 510, __FUNCTION__)))))
;
511 {
512/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
513 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
514 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__514);
515 {
516 return true;
517 }
518next_after_fail29:;
519 }
520 break;
521 }
522 case TRUTH_XOR_EXPR:
523 {
524 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 524, __FUNCTION__)))))
;
525 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 525, __FUNCTION__)))))
;
526 {
527/* #line 1578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
528 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
529 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1578, __FILE__"generic-match.c", __LINE__529);
530 {
531 return true;
532 }
533next_after_fail30:;
534 }
535 break;
536 }
537 case TRUTH_NOT_EXPR:
538 {
539 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 539, __FUNCTION__)))))
;
540 {
541/* #line 1580 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
542 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
543 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1580, __FILE__"generic-match.c", __LINE__543);
544 {
545 return true;
546 }
547next_after_fail31:;
548 }
549 break;
550 }
551 default:;
552 }
553 return false;
554}
555
556bool
557tree_logical_inverted_value (tree t, tree *res_ops)
558{
559 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 559
, __FUNCTION__))->typed.type)
;
560 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 560, __FUNCTION__))
->base.side_effects_flag)
) return false;
561 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
562 {
563 case TRUTH_NOT_EXPR:
564 {
565 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 565, __FUNCTION__)))))
;
566 {
567/* #line 1582 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
568 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
569 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1582, __FILE__"generic-match.c", __LINE__569);
570 {
571 res_ops[0] = captures[0];
572 return true;
573 }
574next_after_fail32:;
575 }
576 break;
577 }
578 case BIT_NOT_EXPR:
579 {
580 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 580, __FUNCTION__)))))
;
581 if (tree_truth_valued_p (_p0))
582 {
583 {
584/* #line 1584 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
585 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
586 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1584, __FILE__"generic-match.c", __LINE__586);
587 {
588 res_ops[0] = captures[0];
589 return true;
590 }
591next_after_fail33:;
592 }
593 }
594 break;
595 }
596 case EQ_EXPR:
597 {
598 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 598, __FUNCTION__)))))
;
599 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 599, __FUNCTION__)))))
;
600 if (integer_zerop (_p1))
601 {
602 {
603/* #line 1586 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
604 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
605 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1586, __FILE__"generic-match.c", __LINE__605);
606 {
607 res_ops[0] = captures[0];
608 return true;
609 }
610next_after_fail34:;
611 }
612 }
613 break;
614 }
615 case NE_EXPR:
616 {
617 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 617, __FUNCTION__)))))
;
618 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 618, __FUNCTION__)))))
;
619 if (tree_truth_valued_p (_p0))
620 {
621 if (integer_truep (_p1))
622 {
623 {
624/* #line 1588 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
625 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
626 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1588, __FILE__"generic-match.c", __LINE__626);
627 {
628 res_ops[0] = captures[0];
629 return true;
630 }
631next_after_fail35:;
632 }
633 }
634 }
635 break;
636 }
637 case BIT_XOR_EXPR:
638 {
639 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 639, __FUNCTION__)))))
;
640 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 640, __FUNCTION__)))))
;
641 if (tree_truth_valued_p (_p0))
642 {
643 if (integer_truep (_p1))
644 {
645 {
646/* #line 1590 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
647 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
648 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1590, __FILE__"generic-match.c", __LINE__648);
649 {
650 res_ops[0] = captures[0];
651 return true;
652 }
653next_after_fail36:;
654 }
655 }
656 }
657 break;
658 }
659 default:;
660 }
661 return false;
662}
663
664bool
665tree_with_possible_nonzero_bits (tree t)
666{
667 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 667
, __FUNCTION__))->typed.type)
;
668 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 668, __FUNCTION__))
->base.side_effects_flag)
) return false;
669 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
670 {
671 case INTEGER_CST:
672 {
673 {
674/* #line 1929 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
675 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
676 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1929, __FILE__"generic-match.c", __LINE__676);
677 {
678 return true;
679 }
680next_after_fail37:;
681 }
682 break;
683 }
684 case SSA_NAME:
685 {
686 {
687/* #line 1932 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
688 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
689/* #line 1932 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
690 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 690, __FUNCTION__))->typed.type
))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 690, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 690, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
|| POINTER_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 690, __FUNCTION__))->typed.type
))->base.code) == POINTER_TYPE || ((enum tree_code) (((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 690, __FUNCTION__
))->typed.type))->base.code) == REFERENCE_TYPE)
691)
692 {
693 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1931, __FILE__"generic-match.c", __LINE__693);
694 {
695 return true;
696 }
697next_after_fail38:;
698 }
699 }
700 break;
701 }
702 default:;
703 }
704 return false;
705}
706
707bool
708tree_with_possible_nonzero_bits2 (tree t, tree *res_ops)
709{
710 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 710
, __FUNCTION__))->typed.type)
;
711 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 711, __FUNCTION__))
->base.side_effects_flag)
) return false;
712 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
713 {
714 case BIT_AND_EXPR:
715 {
716 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 716, __FUNCTION__)))))
;
717 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 717, __FUNCTION__)))))
;
718 if (tree_with_possible_nonzero_bits (_p0))
719 {
720 {
721/* #line 1936 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
722 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
723 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1936, __FILE__"generic-match.c", __LINE__723);
724 {
725 res_ops[0] = captures[0];
726 return true;
727 }
728next_after_fail39:;
729 }
730 }
731 if (tree_with_possible_nonzero_bits (_p1))
732 {
733 {
734/* #line 1936 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
735 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
736 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1936, __FILE__"generic-match.c", __LINE__736);
737 {
738 res_ops[0] = captures[0];
739 return true;
740 }
741next_after_fail40:;
742 }
743 }
744 break;
745 }
746 default:;
747 }
748if (tree_with_possible_nonzero_bits (t))
749 {
750 {
751/* #line 1934 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
752 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
753 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1934, __FILE__"generic-match.c", __LINE__753);
754 {
755 res_ops[0] = captures[0];
756 return true;
757 }
758next_after_fail41:;
759 }
760 }
761 return false;
762}
763
764bool
765tree_with_certain_nonzero_bits2 (tree t, tree *res_ops)
766{
767 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 767
, __FUNCTION__))->typed.type)
;
768 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 768, __FUNCTION__))
->base.side_effects_flag)
) return false;
769 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
770 {
771 case INTEGER_CST:
772 {
773 {
774/* #line 1941 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
775 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
776 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1941, __FILE__"generic-match.c", __LINE__776);
777 {
778 res_ops[0] = captures[0];
779 return true;
780 }
781next_after_fail42:;
782 }
783 break;
784 }
785 case BIT_IOR_EXPR:
786 {
787 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 787, __FUNCTION__)))))
;
788 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 788, __FUNCTION__)))))
;
789 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
790 {
791 case INTEGER_CST:
792 {
793 {
794/* #line 1943 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
795 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p1, _p0 };
796 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 1943, __FILE__"generic-match.c", __LINE__796);
797 {
798 res_ops[0] = captures[0];
799 return true;
800 }
801next_after_fail43:;
802 }
803 break;
804 }
805 default:;
806 }
807 break;
808 }
809 default:;
810 }
811 return false;
812}
813
814bool
815tree_min_value (tree t)
816{
817 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 817
, __FUNCTION__))->typed.type)
;
818 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 818, __FUNCTION__))
->base.side_effects_flag)
) return false;
819 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
820 {
821 case INTEGER_CST:
822 {
823 {
824/* #line 2089 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
825/* #line 2089 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
826 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)
827 && wi::eq_p (wi::to_wide (t), wi::min_value (type))
828)
829 {
830 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2088, __FILE__"generic-match.c", __LINE__830);
831 {
832 return true;
833 }
834next_after_fail44:;
835 }
836 }
837 break;
838 }
839 default:;
840 }
841 return false;
842}
843
844bool
845tree_max_value (tree t)
846{
847 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 847
, __FUNCTION__))->typed.type)
;
848 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 848, __FUNCTION__))
->base.side_effects_flag)
) return false;
849 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
850 {
851 case INTEGER_CST:
852 {
853 {
854/* #line 2094 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
855/* #line 2094 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
856 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)
857 && wi::eq_p (wi::to_wide (t), wi::max_value (type))
858)
859 {
860 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 2093, __FILE__"generic-match.c", __LINE__860);
861 {
862 return true;
863 }
864next_after_fail45:;
865 }
866 }
867 break;
868 }
869 default:;
870 }
871 return false;
872}
873
874bool
875tree_compositional_complex (tree t)
876{
877 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 877
, __FUNCTION__))->typed.type)
;
878 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 878, __FUNCTION__))
->base.side_effects_flag)
) return false;
879 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
880 {
881 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
882 {
883 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 883, __FUNCTION__)))))
;
884 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
885 {
886 case COMPLEX_EXPR:
887 {
888 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.c"
, 888, __FUNCTION__)))))
;
889 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.c"
, 889, __FUNCTION__)))))
;
890 {
891/* #line 3540 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
892 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q20, _q21 };
893 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 3540, __FILE__"generic-match.c", __LINE__893);
894 {
895 return true;
896 }
897next_after_fail46:;
898 }
899 break;
900 }
901 default:;
902 }
903 break;
904 }
905 case COMPLEX_EXPR:
906 {
907 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 907, __FUNCTION__)))))
;
908 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 908, __FUNCTION__)))))
;
909 {
910/* #line 3540 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
911 tree captures[2] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0, _p1 };
912 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 3540, __FILE__"generic-match.c", __LINE__912);
913 {
914 return true;
915 }
916next_after_fail47:;
917 }
918 break;
919 }
920 default:;
921 }
922 return false;
923}
924
925bool
926tree_double_value_p (tree t)
927{
928 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 928
, __FUNCTION__))->typed.type)
;
929 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 929, __FUNCTION__))
->base.side_effects_flag)
) return false;
930 {
931/* #line 5721 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
932 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
933/* #line 5721 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
934 if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 934, __FUNCTION__))->typed.type
)), (tcc_type), "generic-match.c", 934, __FUNCTION__))->type_common
.main_variant)
== double_type_nodeglobal_trees[TI_DOUBLE_TYPE]
935)
936 {
937 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 5720, __FILE__"generic-match.c", __LINE__937);
938 {
939 return true;
940 }
941next_after_fail48:;
942 }
943 }
944 return false;
945}
946
947bool
948tree_float_value_p (tree t)
949{
950 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 950
, __FUNCTION__))->typed.type)
;
951 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 951, __FUNCTION__))
->base.side_effects_flag)
) return false;
952 {
953/* #line 5742 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
954 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
955/* #line 5742 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
956 if (TYPE_MAIN_VARIANT (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 956, __FUNCTION__))->typed.type
)), (tcc_type), "generic-match.c", 956, __FUNCTION__))->type_common
.main_variant)
== float_type_nodeglobal_trees[TI_FLOAT_TYPE]
957)
958 {
959 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 5741, __FILE__"generic-match.c", __LINE__959);
960 {
961 return true;
962 }
963next_after_fail49:;
964 }
965 }
966 return false;
967}
968
969bool
970tree_vec_same_elem_p (tree t)
971{
972 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 972
, __FUNCTION__))->typed.type)
;
Value stored to 'type' during its initialization is never read
973 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 973, __FUNCTION__))
->base.side_effects_flag)
) return false;
974 {
975/* #line 6800 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
976 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { t };
977/* #line 6800 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
978 if (uniform_vector_p (captures[0])
979)
980 {
981 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 6799, __FILE__"generic-match.c", __LINE__981);
982 {
983 return true;
984 }
985next_after_fail50:;
986 }
987 }
988 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
989 {
990 case VEC_DUPLICATE_EXPR:
991 {
992 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 992, __FUNCTION__)))))
;
993 {
994/* #line 6803 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
995 tree captures[1] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _p0 };
996 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 6803, __FILE__"generic-match.c", __LINE__996);
997 {
998 return true;
999 }
1000next_after_fail51:;
1001 }
1002 break;
1003 }
1004 default:;
1005 }
1006 return false;
1007}
1008
1009bool
1010tree_ctz_table_index (tree t, tree *res_ops)
1011{
1012 const tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "generic-match.c", 1012
, __FUNCTION__))->typed.type)
;
1013 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 1013, __FUNCTION__)
)->base.side_effects_flag)
) return false;
1014 switch (TREE_CODE (t)((enum tree_code) (t)->base.code))
1015 {
1016 case RSHIFT_EXPR:
1017 {
1018 tree _p0 = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "generic-match.c"
, 1018, __FUNCTION__)))))
;
1019 tree _p1 = TREE_OPERAND (t, 1)(*((const_cast<tree*> (tree_operand_check ((t), (1), "generic-match.c"
, 1019, __FUNCTION__)))))
;
1020 switch (TREE_CODE (_p0)((enum tree_code) (_p0)->base.code))
1021 {
1022 case MULT_EXPR:
1023 {
1024 tree _q20 = TREE_OPERAND (_p0, 0)(*((const_cast<tree*> (tree_operand_check ((_p0), (0), "generic-match.c"
, 1024, __FUNCTION__)))))
;
1025 tree _q21 = TREE_OPERAND (_p0, 1)(*((const_cast<tree*> (tree_operand_check ((_p0), (1), "generic-match.c"
, 1025, __FUNCTION__)))))
;
1026 switch (TREE_CODE (_q20)((enum tree_code) (_q20)->base.code))
1027 {
1028 case BIT_AND_EXPR:
1029 {
1030 tree _q30 = TREE_OPERAND (_q20, 0)(*((const_cast<tree*> (tree_operand_check ((_q20), (0),
"generic-match.c", 1030, __FUNCTION__)))))
;
1031 tree _q31 = TREE_OPERAND (_q20, 1)(*((const_cast<tree*> (tree_operand_check ((_q20), (1),
"generic-match.c", 1031, __FUNCTION__)))))
;
1032 switch (TREE_CODE (_q30)((enum tree_code) (_q30)->base.code))
1033 {
1034 case NEGATE_EXPR:
1035 {
1036 tree _q40 = TREE_OPERAND (_q30, 0)(*((const_cast<tree*> (tree_operand_check ((_q30), (0),
"generic-match.c", 1036, __FUNCTION__)))))
;
1037 if ((_q31 == _q40 && ! TREE_SIDE_EFFECTS (_q31)((non_type_check ((_q31), "generic-match.c", 1037, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q31, _q40, 0) && types_match (_q31, _q40)))
1038 {
1039 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1040 {
1041 case INTEGER_CST:
1042 {
1043 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1044 {
1045 case INTEGER_CST:
1046 {
1047 {
1048/* #line 6814 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1049 tree captures[3] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q40, _q21, _p1 };
1050 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 6814, __FILE__"generic-match.c", __LINE__1050);
1051 {
1052 res_ops[0] = captures[0];
1053 res_ops[1] = captures[1];
1054 res_ops[2] = captures[2];
1055 return true;
1056 }
1057next_after_fail52:;
1058 }
1059 break;
1060 }
1061 default:;
1062 }
1063 break;
1064 }
1065 default:;
1066 }
1067 }
1068 break;
1069 }
1070 default:;
1071 }
1072 switch (TREE_CODE (_q31)((enum tree_code) (_q31)->base.code))
1073 {
1074 case NEGATE_EXPR:
1075 {
1076 tree _q50 = TREE_OPERAND (_q31, 0)(*((const_cast<tree*> (tree_operand_check ((_q31), (0),
"generic-match.c", 1076, __FUNCTION__)))))
;
1077 if ((_q50 == _q30 && ! TREE_SIDE_EFFECTS (_q50)((non_type_check ((_q50), "generic-match.c", 1077, __FUNCTION__
))->base.side_effects_flag)
) || (operand_equal_p (_q50, _q30, 0) && types_match (_q50, _q30)))
1078 {
1079 switch (TREE_CODE (_q21)((enum tree_code) (_q21)->base.code))
1080 {
1081 case INTEGER_CST:
1082 {
1083 switch (TREE_CODE (_p1)((enum tree_code) (_p1)->base.code))
1084 {
1085 case INTEGER_CST:
1086 {
1087 {
1088/* #line 6814 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1089 tree captures[3] ATTRIBUTE_UNUSED__attribute__ ((__unused__)) = { _q30, _q21, _p1 };
1090 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Matching expression %s:%d, %s:%d\n", "match.pd", 6814, __FILE__"generic-match.c", __LINE__1090);
1091 {
1092 res_ops[0] = captures[0];
1093 res_ops[1] = captures[1];
1094 res_ops[2] = captures[2];
1095 return true;
1096 }
1097next_after_fail53:;
1098 }
1099 break;
1100 }
1101 default:;
1102 }
1103 break;
1104 }
1105 default:;
1106 }
1107 }
1108 break;
1109 }
1110 default:;
1111 }
1112 break;
1113 }
1114 default:;
1115 }
1116 break;
1117 }
1118 default:;
1119 }
1120 break;
1121 }
1122 default:;
1123 }
1124 return false;
1125}
1126
1127static tree
1128generic_simplify_1 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1129 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1130, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (rbitop)rbitop __attribute__ ((__unused__)))
1131{
1132 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 1132, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail54;
1133 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail54;
1134 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1179, __FILE__"generic-match.c", __LINE__1134);
1135 {
1136 tree res_op0;
1137 res_op0 = captures[1];
1138 tree res_op1;
1139 res_op1 = captures[2];
1140 tree _r;
1141 _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
1142 return _r;
1143 }
1144next_after_fail54:;
1145 return NULL_TREE(tree) nullptr;
1146}
1147
1148static tree
1149generic_simplify_2 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1150 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1151)
1152{
1153 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail55;
1154 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1184, __FILE__"generic-match.c", __LINE__1154);
1155 {
1156 tree res_op0;
1157 res_op0 = captures[0];
1158 tree res_op1;
1159 res_op1 = captures[1];
1160 tree _r;
1161 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
1162 return _r;
1163 }
1164next_after_fail55:;
1165 return NULL_TREE(tree) nullptr;
1166}
1167
1168static tree
1169generic_simplify_3 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1170 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1171)
1172{
1173 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail56;
1174 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1189, __FILE__"generic-match.c", __LINE__1174);
1175 {
1176 tree res_op0;
1177 res_op0 = captures[0];
1178 tree res_op1;
1179 res_op1 = captures[1];
1180 tree _r;
1181 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1182 return _r;
1183 }
1184next_after_fail56:;
1185 return NULL_TREE(tree) nullptr;
1186}
1187
1188static tree
1189generic_simplify_4 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1190 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1191, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
1192{
1193/* #line 1300 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1194 if (tree_nop_conversion_p (type, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1194, __FUNCTION__))->typed.type)
)
1195 && tree_nop_conversion_p (type, TREE_TYPE (captures[4])((contains_struct_check ((captures[4]), (TS_TYPED), "generic-match.c"
, 1195, __FUNCTION__))->typed.type)
)
1196 && (wi::to_wide (captures[2]) & wi::to_wide (captures[5])) == 0
1197)
1198 {
1199 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 1199, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail57;
1200 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 1200, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail57;
1201 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail57;
1202 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1303, __FILE__"generic-match.c", __LINE__1202);
1203 {
1204 tree res_op0;
1205 {
1206 tree _o1[1], _r1;
1207 _o1[0] = captures[0];
1208 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1208, __FUNCTION__))->typed.type)
!= type)
1209 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1210 else
1211 _r1 = _o1[0];
1212 res_op0 = _r1;
1213 }
1214 tree res_op1;
1215 {
1216 tree _o1[1], _r1;
1217 _o1[0] = captures[3];
1218 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1218, __FUNCTION__))->typed.type)
!= type)
1219 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1220 else
1221 _r1 = _o1[0];
1222 res_op1 = _r1;
1223 }
1224 tree _r;
1225 _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
1226 return _r;
1227 }
1228next_after_fail57:;
1229 }
1230 return NULL_TREE(tree) nullptr;
1231}
1232
1233static tree
1234generic_simplify_5 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1235 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1236, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
1237{
1238/* #line 1880 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1239 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1239, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1239, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 1239, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1239, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[2]
), (TS_TYPED), "generic-match.c", 1239, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.c", 1239, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 1239, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[2]), (TS_TYPED), "generic-match.c", 1239, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 1239, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.c", 1239, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 1239, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
1240 && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1240, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1240, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1240, __FUNCTION__))->typed.type)), "generic-match.c", 1240
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
1241 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1241, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1241, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1241, __FUNCTION__))->typed.type)), "generic-match.c", 1241
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
)
1242 && (CONSTANT_CLASS_P (captures[2])(tree_code_type[(int) (((enum tree_code) (captures[2])->base
.code))] == tcc_constant)
|| (single_use (captures[1]) && single_use (captures[0])))
1243 && tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1243, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1243, __FUNCTION__))->typed.type)
)
1244 && tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1244, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 1244, __FUNCTION__))->typed.type)
)
1245)
1246 {
1247 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail58;
1248 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1886, __FILE__"generic-match.c", __LINE__1248);
1249 {
1250 tree res_op0;
1251 res_op0 = captures[2];
1252 tree res_op1;
1253 res_op1 = build_zero_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1253, __FUNCTION__))->typed.type)
);
1254 tree _r;
1255 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1256 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 1256, __FUNCTION__
))->base.side_effects_flag)
)
1257 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
1258 return _r;
1259 }
1260next_after_fail58:;
1261 }
1262 return NULL_TREE(tree) nullptr;
1263}
1264
1265static tree
1266generic_simplify_6 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1267 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1268, const combined_fn ARG_UNUSED (minmax)minmax __attribute__ ((__unused__)))
1269{
1270/* #line 2893 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1271 if (real_isnan (TREE_REAL_CST_PTR (captures[1])((tree_check ((captures[1]), "generic-match.c", 1271, __FUNCTION__
, (REAL_CST)))->real_cst.real_cst_ptr)
)
1272 && (!HONOR_SNANS (captures[1]) || !TREE_REAL_CST (captures[1])(*((tree_check ((captures[1]), "generic-match.c", 1272, __FUNCTION__
, (REAL_CST)))->real_cst.real_cst_ptr))
.signalling)
1273)
1274 {
1275 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail59;
1276 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2895, __FILE__"generic-match.c", __LINE__1276);
1277 {
1278 tree _r;
1279 _r = captures[0];
1280 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1280, __FUNCTION__
))->base.side_effects_flag)
)
1281 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1282 return _r;
1283 }
1284next_after_fail59:;
1285 }
1286 return NULL_TREE(tree) nullptr;
1287}
1288
1289static tree
1290generic_simplify_7 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1291 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1292, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
1293{
1294 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail60;
1295 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1197, __FILE__"generic-match.c", __LINE__1295);
1296 {
1297 tree res_op0;
1298 res_op0 = captures[0];
1299 tree res_op1;
1300 res_op1 = captures[1];
1301 tree _r;
1302 _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
1303 return _r;
1304 }
1305next_after_fail60:;
1306 return NULL_TREE(tree) nullptr;
1307}
1308
1309static tree
1310generic_simplify_8 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1311 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1312)
1313{
1314/* #line 3926 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1315 if (VECTOR_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE)
1316 && known_eq (TYPE_VECTOR_SUBPARTS (type),(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS
(((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 1317, __FUNCTION__))->typed.type))))
1317 TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[3])))(!maybe_ne (TYPE_VECTOR_SUBPARTS (type), TYPE_VECTOR_SUBPARTS
(((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 1317, __FUNCTION__))->typed.type))))
1318 && (TYPE_MODE (TREE_TYPE (type))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 1318, __FUNCTION__))
->typed.type)), (tcc_type), "generic-match.c", 1318, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 1318, __FUNCTION__))
->typed.type)) : (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 1318, __FUNCTION__))->typed.type))->
type_common.mode)
1319 == TYPE_MODE (TREE_TYPE (TREE_TYPE (captures[3])))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 1319, __FUNCTION__))->typed.type)), (TS_TYPED), "generic-match.c"
, 1319, __FUNCTION__))->typed.type)), (tcc_type), "generic-match.c"
, 1319, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((((contains_struct_check ((captures
[3]), (TS_TYPED), "generic-match.c", 1319, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 1319, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((((contains_struct_check
((captures[3]), (TS_TYPED), "generic-match.c", 1319, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 1319, __FUNCTION__
))->typed.type))->type_common.mode)
)
1320)
1321 {
1322 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail61;
1323 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3931, __FILE__"generic-match.c", __LINE__1323);
1324 {
1325 tree res_op0;
1326 res_op0 = captures[0];
1327 tree res_op1;
1328 {
1329 tree _o1[1], _r1;
1330 {
1331 tree _o2[3], _r2;
1332 _o2[0] = captures[2];
1333 {
1334 tree _o3[1], _r3;
1335 _o3[0] = captures[3];
1336 _r3 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 1336, __FUNCTION__))->typed.type)
, _o3[0]);
1337 _o2[1] = _r3;
1338 }
1339 _o2[2] = captures[4];
1340 _r2 = fold_build3_loc (loc, VEC_COND_EXPR, TREE_TYPE (_o2[1])((contains_struct_check ((_o2[1]), (TS_TYPED), "generic-match.c"
, 1340, __FUNCTION__))->typed.type)
, _o2[0], _o2[1], _o2[2]);
1341 _o1[0] = _r2;
1342 }
1343 _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
1344 res_op1 = _r1;
1345 }
1346 tree _r;
1347 _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
1348 return _r;
1349 }
1350next_after_fail61:;
1351 }
1352 return NULL_TREE(tree) nullptr;
1353}
1354
1355static tree
1356generic_simplify_9 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1357 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1358)
1359{
1360 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail62;
1361 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1202, __FILE__"generic-match.c", __LINE__1361);
1362 {
1363 tree res_op0;
1364 res_op0 = captures[0];
1365 tree res_op1;
1366 res_op1 = captures[1];
1367 tree _r;
1368 _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
1369 return _r;
1370 }
1371next_after_fail62:;
1372 return NULL_TREE(tree) nullptr;
1373}
1374
1375static tree
1376generic_simplify_10 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1377 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
1378, const combined_fn ARG_UNUSED (froms)froms __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (tos)tos __attribute__ ((__unused__)))
1379{
1380/* #line 5757 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1381 if (optimizeglobal_options.x_optimize && canonicalize_math_p ()
1382 && targetm.libc_has_function (function_c99_misc, NULL_TREE(tree) nullptr)
1383)
1384 {
1385 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail63;
1386 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5761, __FILE__"generic-match.c", __LINE__1386);
1387 {
1388 tree res_op0;
1389 {
1390 tree _o1[1], _r1;
1391 _o1[0] = captures[0];
1392 {
1393 _r1 = maybe_build_call_expr_loc (loc, tos, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1393, __FUNCTION__))->typed.type)
, 1, _o1[0]);
1394 if (!_r1)
1395 goto next_after_fail63;
1396 }
1397 res_op0 = _r1;
1398 }
1399 tree _r;
1400 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1401 return _r;
1402 }
1403next_after_fail63:;
1404 }
1405 return NULL_TREE(tree) nullptr;
1406}
1407
1408static tree
1409generic_simplify_11 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1410 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1411, const enum tree_code ARG_UNUSED (plusminus)plusminus __attribute__ ((__unused__)))
1412{
1413/* #line 2710 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1414 if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 1414, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
1415 && (!FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 1415, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
|| flag_associative_mathglobal_options.x_flag_associative_math)
1416)
1417 {
1418/* #line 2715 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1419 if (!ANY_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) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 1419, __FUNCTION__))->typed.type))->
base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 1419, __FUNCTION__))
->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "generic-match.c"
, 1419, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
1420 || TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.c"
, 1420, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
1421 || (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)
1422 && tree_expr_nonzero_p (captures[1])
1423 && expr_not_equal_to (captures[1], wi::minus_one (TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 1423
, __FUNCTION__))->type_common.precision)
)))
1424)
1425 {
1426/* #line 2720 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1427 if (single_use (captures[0]) || single_use (captures[3])
1428)
1429 {
1430 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail64;
1431 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2723, __FILE__"generic-match.c", __LINE__1431);
1432 {
1433 tree res_op0;
1434 {
1435 tree _o1[2], _r1;
1436 _o1[0] = captures[2];
1437 _o1[1] = captures[4];
1438 _r1 = fold_build2_loc (loc, plusminus, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1438, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1439 res_op0 = _r1;
1440 }
1441 tree res_op1;
1442 res_op1 = captures[1];
1443 tree _r;
1444 _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
1445 return _r;
1446 }
1447next_after_fail64:;
1448 }
1449 }
1450 }
1451 return NULL_TREE(tree) nullptr;
1452}
1453
1454static tree
1455generic_simplify_12 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1456 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1457, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
1458{
1459/* #line 886 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1460 if (~wi::to_wide (captures[1]) == wi::to_wide (captures[2])
1461)
1462 {
1463 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail65;
1464 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 887, __FILE__"generic-match.c", __LINE__1464);
1465 {
1466 tree res_op0;
1467 res_op0 = captures[0];
1468 tree res_op1;
1469 res_op1 = captures[2];
1470 tree _r;
1471 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
1472 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1472, __FUNCTION__
))->base.side_effects_flag)
)
1473 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1474 return _r;
1475 }
1476next_after_fail65:;
1477 }
1478 return NULL_TREE(tree) nullptr;
1479}
1480
1481static tree
1482generic_simplify_13 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1483 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1484, const enum tree_code ARG_UNUSED (eqne)eqne __attribute__ ((__unused__)))
1485{
1486/* #line 2103 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1487 if (eqne == EQ_EXPR
1488)
1489 {
1490 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 1490, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail66;
1491 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail66;
1492 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2104, __FILE__"generic-match.c", __LINE__1492);
1493 {
1494 tree _r;
1495 _r = constant_boolean_node (false, type);
1496 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 1496, __FUNCTION__
))->base.side_effects_flag)
)
1497 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
1498 return _r;
1499 }
1500next_after_fail66:;
1501 }
1502 else
1503 {
1504/* #line 2105 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1505 if (eqne == NE_EXPR
1506)
1507 {
1508 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 1508, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail67;
1509 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 1509, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail67;
1510 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail67;
1511 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2106, __FILE__"generic-match.c", __LINE__1511);
1512 {
1513 tree _r;
1514 _r = captures[0];
1515 return _r;
1516 }
1517next_after_fail67:;
1518 }
1519 }
1520 return NULL_TREE(tree) nullptr;
1521}
1522
1523static tree
1524generic_simplify_14 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1525 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1526, const combined_fn ARG_UNUSED (COS)COS __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (SIN)SIN __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (TAN)TAN __attribute__ ((__unused__)))
1527{
1528/* #line 5578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1529 if (flag_unsafe_math_optimizationsglobal_options.x_flag_unsafe_math_optimizations && canonicalize_math_p ()
1530)
1531 {
1532 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail68;
1533 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5608, __FILE__"generic-match.c", __LINE__1533);
1534 {
1535 tree res_op0;
1536 res_op0 = build_one_cst (type);
1537 tree res_op1;
1538 {
1539 tree _o1[1], _r1;
1540 _o1[0] = captures[1];
1541 {
1542 _r1 = maybe_build_call_expr_loc (loc, TAN, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1542, __FUNCTION__))->typed.type)
, 1, _o1[0]);
1543 if (!_r1)
1544 goto next_after_fail68;
1545 }
1546 res_op1 = _r1;
1547 }
1548 tree _r;
1549 _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
1550 return _r;
1551 }
1552next_after_fail68:;
1553 }
1554 return NULL_TREE(tree) nullptr;
1555}
1556
1557static tree
1558generic_simplify_15 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1559 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1560)
1561{
1562 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail69;
1563 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1221, __FILE__"generic-match.c", __LINE__1563);
1564 {
1565 tree res_op0;
1566 res_op0 = captures[1];
1567 tree res_op1;
1568 {
1569 tree _o1[1], _r1;
1570 _o1[0] = captures[2];
1571 _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1571, __FUNCTION__))->typed.type)
, _o1[0]);
1572 res_op1 = _r1;
1573 }
1574 tree _r;
1575 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1576 return _r;
1577 }
1578next_after_fail69:;
1579 return NULL_TREE(tree) nullptr;
1580}
1581
1582static tree
1583generic_simplify_16 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1584 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1585, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
1586{
1587/* #line 2989 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1588 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)
1589 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1589, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1589, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 1589, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1590 && TREE_CODE (TREE_TYPE (captures[2]))((enum tree_code) (((contains_struct_check ((captures[2]), (TS_TYPED
), "generic-match.c", 1590, __FUNCTION__))->typed.type))->
base.code)
!= BOOLEAN_TYPE
1591 && INTEGRAL_TYPE_P (TREE_TYPE (captures[3]))(((enum tree_code) (((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 1591, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 1591, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[3])
, (TS_TYPED), "generic-match.c", 1591, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1592 && (TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1592, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1592, __FUNCTION__))->
type_common.precision)
>= TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 1592
, __FUNCTION__))->type_common.precision)
1593 || !TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1593, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1593, __FUNCTION__))->
base.u.bits.unsigned_flag)
)
1594 && (
15950
1596 || !TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1596, __FUNCTION__
))->base.side_effects_flag)
)
1597)
1598 {
1599 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail70;
1600 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2996, __FILE__"generic-match.c", __LINE__1600);
1601 {
1602 tree res_op0;
1603 {
1604 tree _o1[2], _r1;
1605 _o1[0] = captures[4];
1606 _o1[1] = captures[5];
1607 _r1 = fold_build2_loc (loc, cmp, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], _o1[0], _o1[1]);
1608 res_op0 = _r1;
1609 }
1610 tree res_op1;
1611 res_op1 = captures[1];
1612 tree res_op2;
1613 res_op2 = captures[0];
1614 tree _r;
1615 _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
1616 return _r;
1617 }
1618next_after_fail70:;
1619 }
1620 return NULL_TREE(tree) nullptr;
1621}
1622
1623static tree
1624generic_simplify_17 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1625 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1626)
1627{
1628 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail71;
1629 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1236, __FILE__"generic-match.c", __LINE__1629);
1630 {
1631 tree res_op0;
1632 res_op0 = captures[0];
1633 tree res_op1;
1634 res_op1 = captures[1];
1635 tree _r;
1636 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
1637 return _r;
1638 }
1639next_after_fail71:;
1640 return NULL_TREE(tree) nullptr;
1641}
1642
1643static tree
1644generic_simplify_18 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1645 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1646)
1647{
1648 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail72;
1649 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1241, __FILE__"generic-match.c", __LINE__1649);
1650 {
1651 tree res_op0;
1652 res_op0 = captures[0];
1653 tree res_op1;
1654 res_op1 = captures[1];
1655 tree _r;
1656 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1657 return _r;
1658 }
1659next_after_fail72:;
1660 return NULL_TREE(tree) nullptr;
1661}
1662
1663static tree
1664generic_simplify_19 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1665 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1666, const combined_fn ARG_UNUSED (HYPOT)HYPOT __attribute__ ((__unused__)))
1667{
1668 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail73;
1669 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5533, __FILE__"generic-match.c", __LINE__1669);
1670 {
1671 tree res_op0;
1672 res_op0 = captures[0];
1673 tree _r;
1674 _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
1675 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1675, __FUNCTION__
))->base.side_effects_flag)
)
1676 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1677 return _r;
1678 }
1679next_after_fail73:;
1680 return NULL_TREE(tree) nullptr;
1681}
1682
1683static tree
1684generic_simplify_20 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1685 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1686)
1687{
1688 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail74;
1689 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1246, __FILE__"generic-match.c", __LINE__1689);
1690 {
1691 tree res_op0;
1692 {
1693 tree _o1[2], _r1;
1694 _o1[0] = captures[1];
1695 _o1[1] = captures[2];
1696 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1696, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1697 res_op0 = _r1;
1698 }
1699 tree _r;
1700 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
1701 return _r;
1702 }
1703next_after_fail74:;
1704 return NULL_TREE(tree) nullptr;
1705}
1706
1707static tree
1708generic_simplify_21 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1709 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1710)
1711{
1712 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 1712, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail75;
1713 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail75;
1714 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2129, __FILE__"generic-match.c", __LINE__1714);
1715 {
1716 tree _r;
1717 _r = captures[2];
1718 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1718, __FUNCTION__
))->base.side_effects_flag)
)
1719 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1720 return _r;
1721 }
1722next_after_fail75:;
1723 return NULL_TREE(tree) nullptr;
1724}
1725
1726static tree
1727generic_simplify_22 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1728 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1729)
1730{
1731 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail76;
1732 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1161, __FILE__"generic-match.c", __LINE__1732);
1733 {
1734 tree res_op0;
1735 {
1736 tree _o1[2], _r1;
1737 _o1[0] = captures[1];
1738 _o1[1] = captures[2];
1739 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1739, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1740 res_op0 = _r1;
1741 }
1742 tree _r;
1743 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
1744 return _r;
1745 }
1746next_after_fail76:;
1747 return NULL_TREE(tree) nullptr;
1748}
1749
1750static tree
1751generic_simplify_23 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1752 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1753, const enum tree_code ARG_UNUSED (shift)shift __attribute__ ((__unused__)))
1754{
1755/* #line 3170 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1756 if (tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1756, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1756, __FUNCTION__))->typed.type)
)
1757 && TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 1757
, __FUNCTION__))->type_common.precision)
<= HOST_BITS_PER_WIDE_INT64
1758 && tree_fits_uhwi_p (captures[4])
1759 && tree_to_uhwi (captures[4]) > 0
1760 && tree_to_uhwi (captures[4]) < TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 1760
, __FUNCTION__))->type_common.precision)
1761)
1762 {
1763 {
1764/* #line 3175 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1765 unsigned int shiftc = tree_to_uhwi (captures[4]);
1766 unsigned HOST_WIDE_INTlong mask = TREE_INT_CST_LOW (captures[5])((unsigned long) (*tree_int_cst_elt_check ((captures[5]), (0)
, "generic-match.c", 1766, __FUNCTION__)))
;
1767 unsigned HOST_WIDE_INTlong newmask, zerobits = 0;
1768 tree shift_type = TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1768, __FUNCTION__))->typed.type)
;
1769 unsigned int prec;
1770 if (shift == LSHIFT_EXPR)
1771 zerobits = ((HOST_WIDE_INT_1U1UL << shiftc) - 1);
1772 else if (shift == RSHIFT_EXPR
1773 && type_has_mode_precision_p (shift_type))
1774 {
1775 prec = TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1775, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1775, __FUNCTION__))->
type_common.precision)
;
1776 tree arg00 = captures[3];
1777 if (captures[2] != captures[3]
1778 && TYPE_UNSIGNED (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 1778, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1778, __FUNCTION__))->
base.u.bits.unsigned_flag)
)
1779 {
1780 tree inner_type = TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 1780, __FUNCTION__))->typed.type)
;
1781 if (type_has_mode_precision_p (inner_type)
1782 && TYPE_PRECISION (inner_type)((tree_class_check ((inner_type), (tcc_type), "generic-match.c"
, 1782, __FUNCTION__))->type_common.precision)
< prec)
1783 {
1784 prec = TYPE_PRECISION (inner_type)((tree_class_check ((inner_type), (tcc_type), "generic-match.c"
, 1784, __FUNCTION__))->type_common.precision)
;
1785 if (shiftc < prec)
1786 shift_type = inner_type;
1787 }
1788 }
1789 zerobits = HOST_WIDE_INT_M1U-1UL;
1790 if (shiftc < prec)
1791 {
1792 zerobits >>= HOST_BITS_PER_WIDE_INT64 - shiftc;
1793 zerobits <<= prec - shiftc;
1794 }
1795 if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1795, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1795, __FUNCTION__))->
base.u.bits.unsigned_flag)
1796 && prec == TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1796, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1796, __FUNCTION__))->
type_common.precision)
)
1797 {
1798 if ((mask & zerobits) == 0)
1799 shift_type = unsigned_type_for (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1799, __FUNCTION__))->typed.type)
);
1800 else
1801 zerobits = 0;
1802 }
1803 }
1804/* #line 3229 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1805 if ((mask & zerobits) == mask
1806)
1807 {
1808 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 1808, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail77;
1809 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 1809, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail77;
1810 if (TREE_SIDE_EFFECTS (captures[5])((non_type_check ((captures[5]), "generic-match.c", 1810, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail77;
1811 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail77;
1812 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3230, __FILE__"generic-match.c", __LINE__1812);
1813 {
1814 tree _r;
1815 _r = build_int_cst (type, 0);
1816 return _r;
1817 }
1818next_after_fail77:;
1819 }
1820 else
1821 {
1822 {
1823/* #line 3231 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1824 newmask = mask | zerobits;
1825/* #line 3232 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1826 if (newmask != mask && (newmask & (newmask + 1)) == 0
1827)
1828 {
1829 {
1830/* #line 3233 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1831 for (prec = BITS_PER_UNIT(8);
1832 prec < HOST_BITS_PER_WIDE_INT64; prec <<= 1)
1833 if (newmask == (HOST_WIDE_INT_1U1UL << prec) - 1)
1834 break;
1835/* #line 3242 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1836 if (prec < HOST_BITS_PER_WIDE_INT64
1837 || newmask == HOST_WIDE_INT_M1U-1UL
1838)
1839 {
1840 {
1841/* #line 3244 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1842 tree newmaskt = build_int_cst_type (TREE_TYPE (captures[5])((contains_struct_check ((captures[5]), (TS_TYPED), "generic-match.c"
, 1842, __FUNCTION__))->typed.type)
, newmask);
1843/* #line 3246 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1844 if (!tree_int_cst_equal (newmaskt, captures[5])
1845)
1846 {
1847/* #line 3247 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1848 if (shift_type != TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1848, __FUNCTION__))->typed.type)
1849)
1850 {
1851 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 1851, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail78;
1852 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 1852, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail78;
1853 if (TREE_SIDE_EFFECTS (captures[5])((non_type_check ((captures[5]), "generic-match.c", 1853, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail78;
1854 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail78;
1855 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3248, __FILE__"generic-match.c", __LINE__1855);
1856 {
1857 tree res_op0;
1858 {
1859 tree _o1[1], _r1;
1860 {
1861 tree _o2[2], _r2;
1862 {
1863 tree _o3[1], _r3;
1864 _o3[0] = captures[2];
1865 if (TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 1865, __FUNCTION__))->typed.type)
!= shift_type)
1866 _r3 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o3[0]);
1867 else
1868 _r3 = _o3[0];
1869 _o2[0] = _r3;
1870 }
1871 _o2[1] = captures[4];
1872 _r2 = fold_build2_loc (loc, shift, shift_type, _o2[0], _o2[1]);
1873 _o1[0] = _r2;
1874 }
1875 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1875, __FUNCTION__))->typed.type)
!= type)
1876 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1877 else
1878 _r1 = _o1[0];
1879 res_op0 = _r1;
1880 }
1881 tree res_op1;
1882 res_op1 = newmaskt;
1883 tree _r;
1884 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1885 return _r;
1886 }
1887next_after_fail78:;
1888 }
1889 else
1890 {
1891 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 1891, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail79;
1892 if (TREE_SIDE_EFFECTS (captures[5])((non_type_check ((captures[5]), "generic-match.c", 1892, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail79;
1893 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail79;
1894 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3249, __FILE__"generic-match.c", __LINE__1894);
1895 {
1896 tree res_op0;
1897 res_op0 = captures[0];
1898 tree res_op1;
1899 res_op1 = newmaskt;
1900 tree _r;
1901 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1902 return _r;
1903 }
1904next_after_fail79:;
1905 }
1906 }
1907 }
1908 }
1909 }
1910 }
1911 }
1912 }
1913 }
1914 }
1915 return NULL_TREE(tree) nullptr;
1916}
1917
1918static tree
1919generic_simplify_24 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1920 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1921, const combined_fn ARG_UNUSED (POW)POW __attribute__ ((__unused__)))
1922{
1923 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail80;
1924 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5538, __FILE__"generic-match.c", __LINE__1924);
1925 {
1926 tree _r;
1927 _r = captures[0];
1928 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1928, __FUNCTION__
))->base.side_effects_flag)
)
1929 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1930 return _r;
1931 }
1932next_after_fail80:;
1933 return NULL_TREE(tree) nullptr;
1934}
1935
1936static tree
1937generic_simplify_25 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1938 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1939, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)))
1940{
1941 {
1942/* #line 1014 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1943 tree pmop[2];
1944 tree utype = fold_bit_and_mask (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1944, __FUNCTION__))->typed.type)
, captures[4], NEGATE_EXPR, captures[1],
1945 bitop, captures[2], captures[3], NULL_TREE(tree) nullptr, ERROR_MARK,
1946 NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr, pmop);
1947/* #line 1019 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1948 if (utype
1949)
1950 {
1951 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1951, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail81;
1952 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 1952, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail81;
1953 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 1953, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail81;
1954 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 1954, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail81;
1955 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail81;
1956 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1020, __FILE__"generic-match.c", __LINE__1956);
1957 {
1958 tree res_op0;
1959 {
1960 tree _o1[2], _r1;
1961 {
1962 tree _o2[1], _r2;
1963 {
1964 tree _o3[1], _r3;
1965 _o3[0] = pmop[0];
1966 if (TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 1966, __FUNCTION__))->typed.type)
!= utype)
1967 _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1968 else
1969 _r3 = _o3[0];
1970 _o2[0] = _r3;
1971 }
1972 _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1972, __FUNCTION__))->typed.type)
, _o2[0]);
1973 _o1[0] = _r2;
1974 }
1975 {
1976 tree _o2[1], _r2;
1977 _o2[0] = captures[4];
1978 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1978, __FUNCTION__))->typed.type)
!= utype)
1979 _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1980 else
1981 _r2 = _o2[0];
1982 _o1[1] = _r2;
1983 }
1984 _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1984, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1985 res_op0 = _r1;
1986 }
1987 tree _r;
1988 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1989 return _r;
1990 }
1991next_after_fail81:;
1992 }
1993 }
1994 return NULL_TREE(tree) nullptr;
1995}
1996
1997static tree
1998generic_simplify_26 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1999 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2000, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2001{
2002/* #line 5017 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2003 if ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 2003, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2003, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 2003, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
2004 || POINTER_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 2004, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2004, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
2005 || VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 2005, __FUNCTION__))->typed.
type))->base.code) == VECTOR_TYPE) && ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.c", 2005, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 2005, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)
)
2006 && tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2006, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2006, __FUNCTION__))->typed.type)
)
2007)
2008 {
2009 {
2010/* #line 5021 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2011 tree cst = uniform_integer_cst_p (captures[2]);
2012 tree arg1_type = TREE_TYPE (cst)((contains_struct_check ((cst), (TS_TYPED), "generic-match.c"
, 2012, __FUNCTION__))->typed.type)
;
2013 unsigned int prec = TYPE_PRECISION (arg1_type)((tree_class_check ((arg1_type), (tcc_type), "generic-match.c"
, 2013, __FUNCTION__))->type_common.precision)
;
2014 wide_int max = wi::max_value (arg1_type);
2015 wide_int signed_max = wi::max_value (prec, SIGNED);
2016 wide_int min = wi::min_value (arg1_type);
2017/* #line 5031 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2018 if (wi::to_wide (cst) == max
2019)
2020 {
2021/* #line 5033 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2022 if (cmp == GT_EXPR
2023)
2024 {
2025 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail82;
2026 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5034, __FILE__"generic-match.c", __LINE__2026);
2027 {
2028 tree _r;
2029 _r = constant_boolean_node (false, type);
2030 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2030, __FUNCTION__
))->base.side_effects_flag)
)
2031 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2032 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2032, __FUNCTION__
))->base.side_effects_flag)
)
2033 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2034 return _r;
2035 }
2036next_after_fail82:;
2037 }
2038 else
2039 {
2040/* #line 5035 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2041 if (cmp == GE_EXPR
2042)
2043 {
2044 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail83;
2045 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5036, __FILE__"generic-match.c", __LINE__2045);
2046 {
2047 tree res_op0;
2048 res_op0 = captures[0];
2049 tree res_op1;
2050 res_op1 = captures[2];
2051 tree _r;
2052 _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2053 return _r;
2054 }
2055next_after_fail83:;
2056 }
2057 else
2058 {
2059/* #line 5037 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2060 if (cmp == LE_EXPR
2061)
2062 {
2063 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail84;
2064 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5038, __FILE__"generic-match.c", __LINE__2064);
2065 {
2066 tree _r;
2067 _r = constant_boolean_node (true, type);
2068 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2068, __FUNCTION__
))->base.side_effects_flag)
)
2069 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2070 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2070, __FUNCTION__
))->base.side_effects_flag)
)
2071 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2072 return _r;
2073 }
2074next_after_fail84:;
2075 }
2076 else
2077 {
2078/* #line 5039 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2079 if (cmp == LT_EXPR
2080)
2081 {
2082 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail85;
2083 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5040, __FILE__"generic-match.c", __LINE__2083);
2084 {
2085 tree res_op0;
2086 res_op0 = captures[0];
2087 tree res_op1;
2088 res_op1 = captures[2];
2089 tree _r;
2090 _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2091 return _r;
2092 }
2093next_after_fail85:;
2094 }
2095 }
2096 }
2097 }
2098 }
2099 else
2100 {
2101/* #line 5041 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2102 if (wi::to_wide (cst) == min
2103)
2104 {
2105/* #line 5043 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2106 if (cmp == LT_EXPR
2107)
2108 {
2109 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail86;
2110 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5044, __FILE__"generic-match.c", __LINE__2110);
2111 {
2112 tree _r;
2113 _r = constant_boolean_node (false, type);
2114 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2114, __FUNCTION__
))->base.side_effects_flag)
)
2115 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2116 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2116, __FUNCTION__
))->base.side_effects_flag)
)
2117 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2118 return _r;
2119 }
2120next_after_fail86:;
2121 }
2122 else
2123 {
2124/* #line 5045 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2125 if (cmp == LE_EXPR
2126)
2127 {
2128 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail87;
2129 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5046, __FILE__"generic-match.c", __LINE__2129);
2130 {
2131 tree res_op0;
2132 res_op0 = captures[0];
2133 tree res_op1;
2134 res_op1 = captures[2];
2135 tree _r;
2136 _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2137 return _r;
2138 }
2139next_after_fail87:;
2140 }
2141 else
2142 {
2143/* #line 5047 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2144 if (cmp == GE_EXPR
2145)
2146 {
2147 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail88;
2148 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5048, __FILE__"generic-match.c", __LINE__2148);
2149 {
2150 tree _r;
2151 _r = constant_boolean_node (true, type);
2152 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2152, __FUNCTION__
))->base.side_effects_flag)
)
2153 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2154 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2154, __FUNCTION__
))->base.side_effects_flag)
)
2155 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2156 return _r;
2157 }
2158next_after_fail88:;
2159 }
2160 else
2161 {
2162/* #line 5049 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2163 if (cmp == GT_EXPR
2164)
2165 {
2166 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail89;
2167 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5050, __FILE__"generic-match.c", __LINE__2167);
2168 {
2169 tree res_op0;
2170 res_op0 = captures[0];
2171 tree res_op1;
2172 res_op1 = captures[2];
2173 tree _r;
2174 _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2175 return _r;
2176 }
2177next_after_fail89:;
2178 }
2179 }
2180 }
2181 }
2182 }
2183 else
2184 {
2185/* #line 5051 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2186 if (wi::to_wide (cst) == max - 1
2187)
2188 {
2189/* #line 5053 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2190 if (cmp == GT_EXPR
2191)
2192 {
2193 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail90;
2194 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5054, __FILE__"generic-match.c", __LINE__2194);
2195 {
2196 tree res_op0;
2197 res_op0 = captures[0];
2198 tree res_op1;
2199 res_op1 = build_uniform_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2199, __FUNCTION__))->typed.type)
,
2200 wide_int_to_tree (TREE_TYPE (cst)((contains_struct_check ((cst), (TS_TYPED), "generic-match.c"
, 2200, __FUNCTION__))->typed.type)
,
2201 wi::to_wide (cst)
2202 + 1));
2203 tree _r;
2204 _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2205 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2205, __FUNCTION__
))->base.side_effects_flag)
)
2206 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2207 return _r;
2208 }
2209next_after_fail90:;
2210 }
2211 else
2212 {
2213/* #line 5058 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2214 if (cmp == LE_EXPR
2215)
2216 {
2217 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail91;
2218 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5059, __FILE__"generic-match.c", __LINE__2218);
2219 {
2220 tree res_op0;
2221 res_op0 = captures[0];
2222 tree res_op1;
2223 res_op1 = build_uniform_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2223, __FUNCTION__))->typed.type)
,
2224 wide_int_to_tree (TREE_TYPE (cst)((contains_struct_check ((cst), (TS_TYPED), "generic-match.c"
, 2224, __FUNCTION__))->typed.type)
,
2225 wi::to_wide (cst)
2226 + 1));
2227 tree _r;
2228 _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2229 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2229, __FUNCTION__
))->base.side_effects_flag)
)
2230 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2231 return _r;
2232 }
2233next_after_fail91:;
2234 }
2235 }
2236 }
2237 else
2238 {
2239/* #line 5063 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2240 if (wi::to_wide (cst) == min + 1
2241)
2242 {
2243/* #line 5065 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2244 if (cmp == GE_EXPR
2245)
2246 {
2247 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail92;
2248 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5066, __FILE__"generic-match.c", __LINE__2248);
2249 {
2250 tree res_op0;
2251 res_op0 = captures[0];
2252 tree res_op1;
2253 res_op1 = build_uniform_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2253, __FUNCTION__))->typed.type)
,
2254 wide_int_to_tree (TREE_TYPE (cst)((contains_struct_check ((cst), (TS_TYPED), "generic-match.c"
, 2254, __FUNCTION__))->typed.type)
,
2255 wi::to_wide (cst)
2256 - 1));
2257 tree _r;
2258 _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
2259 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2259, __FUNCTION__
))->base.side_effects_flag)
)
2260 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2261 return _r;
2262 }
2263next_after_fail92:;
2264 }
2265 else
2266 {
2267/* #line 5070 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2268 if (cmp == LT_EXPR
2269)
2270 {
2271 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail93;
2272 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5071, __FILE__"generic-match.c", __LINE__2272);
2273 {
2274 tree res_op0;
2275 res_op0 = captures[0];
2276 tree res_op1;
2277 res_op1 = build_uniform_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2277, __FUNCTION__))->typed.type)
,
2278 wide_int_to_tree (TREE_TYPE (cst)((contains_struct_check ((cst), (TS_TYPED), "generic-match.c"
, 2278, __FUNCTION__))->typed.type)
,
2279 wi::to_wide (cst)
2280 - 1));
2281 tree _r;
2282 _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
2283 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2283, __FUNCTION__
))->base.side_effects_flag)
)
2284 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2285 return _r;
2286 }
2287next_after_fail93:;
2288 }
2289 }
2290 }
2291 else
2292 {
2293/* #line 5075 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2294 if (wi::to_wide (cst) == signed_max
2295 && TYPE_UNSIGNED (arg1_type)((tree_class_check ((arg1_type), (tcc_type), "generic-match.c"
, 2295, __FUNCTION__))->base.u.bits.unsigned_flag)
2296 && prec == GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (arg1_type)(as_a <scalar_int_mode> ((tree_class_check ((arg1_type)
, (tcc_type), "generic-match.c", 2296, __FUNCTION__))->type_common
.mode))
)
2297 && INTEGRAL_TYPE_P (arg1_type)(((enum tree_code) (arg1_type)->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (arg1_type)->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (arg1_type)->base.code) == INTEGER_TYPE
)
2298)
2299 {
2300/* #line 5086 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2301 if (cmp == LE_EXPR || cmp == GT_EXPR
2302)
2303 {
2304 {
2305/* #line 5087 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2306 tree st = signed_type_for (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2306, __FUNCTION__))->typed.type)
);
2307/* #line 5089 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2308 if (cst == captures[2] && cmp == LE_EXPR
2309)
2310 {
2311 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail94;
2312 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5090, __FILE__"generic-match.c", __LINE__2312);
2313 {
2314 tree res_op0;
2315 {
2316 tree _o1[1], _r1;
2317 _o1[0] = captures[1];
2318 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2318, __FUNCTION__))->typed.type)
!= st)
2319 _r1 = fold_build1_loc (loc, NOP_EXPR, st, _o1[0]);
2320 else
2321 _r1 = _o1[0];
2322 res_op0 = _r1;
2323 }
2324 tree res_op1;
2325 res_op1 = build_zero_cst (st);
2326 tree _r;
2327 _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
2328 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2328, __FUNCTION__
))->base.side_effects_flag)
)
2329 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2330 return _r;
2331 }
2332next_after_fail94:;
2333 }
2334 else
2335 {
2336/* #line 5091 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2337 if (cst == captures[2] && cmp == GT_EXPR
2338)
2339 {
2340 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail95;
2341 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5092, __FILE__"generic-match.c", __LINE__2341);
2342 {
2343 tree res_op0;
2344 {
2345 tree _o1[1], _r1;
2346 _o1[0] = captures[1];
2347 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2347, __FUNCTION__))->typed.type)
!= st)
2348 _r1 = fold_build1_loc (loc, NOP_EXPR, st, _o1[0]);
2349 else
2350 _r1 = _o1[0];
2351 res_op0 = _r1;
2352 }
2353 tree res_op1;
2354 res_op1 = build_zero_cst (st);
2355 tree _r;
2356 _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2357 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2357, __FUNCTION__
))->base.side_effects_flag)
)
2358 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2359 return _r;
2360 }
2361next_after_fail95:;
2362 }
2363 else
2364 {
2365/* #line 5093 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2366 if (cmp == LE_EXPR
2367)
2368 {
2369 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail96;
2370 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5094, __FILE__"generic-match.c", __LINE__2370);
2371 {
2372 tree res_op0;
2373 {
2374 tree _o1[1], _r1;
2375 _o1[0] = captures[1];
2376 _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, st, _o1[0]);
2377 res_op0 = _r1;
2378 }
2379 tree res_op1;
2380 res_op1 = build_zero_cst (st);
2381 tree _r;
2382 _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
2383 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2383, __FUNCTION__
))->base.side_effects_flag)
)
2384 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2385 return _r;
2386 }
2387next_after_fail96:;
2388 }
2389 else
2390 {
2391/* #line 5095 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2392 if (cmp == GT_EXPR
2393)
2394 {
2395 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail97;
2396 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5096, __FILE__"generic-match.c", __LINE__2396);
2397 {
2398 tree res_op0;
2399 {
2400 tree _o1[1], _r1;
2401 _o1[0] = captures[1];
2402 _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, st, _o1[0]);
2403 res_op0 = _r1;
2404 }
2405 tree res_op1;
2406 res_op1 = build_zero_cst (st);
2407 tree _r;
2408 _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
2409 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2409, __FUNCTION__
))->base.side_effects_flag)
)
2410 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2411 return _r;
2412 }
2413next_after_fail97:;
2414 }
2415 }
2416 }
2417 }
2418 }
2419 }
2420 }
2421 }
2422 }
2423 }
2424 }
2425 }
2426 }
2427 return NULL_TREE(tree) nullptr;
2428}
2429
2430static tree
2431generic_simplify_27 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2432 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
2433, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
2434{
2435 {
2436/* #line 3799 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2437 tree from_type = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2437, __FUNCTION__))->typed.type)
, to_type = TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2437, __FUNCTION__))->typed.type)
;
2438/* #line 3800 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2439 if (types_match (from_type, to_type)
2440 || (TYPE_UNSIGNED (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.c"
, 2440, __FUNCTION__))->base.u.bits.unsigned_flag)
2441 && !TYPE_UNSIGNED (to_type)((tree_class_check ((to_type), (tcc_type), "generic-match.c",
2441, __FUNCTION__))->base.u.bits.unsigned_flag)
2442 && TYPE_PRECISION (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.c"
, 2442, __FUNCTION__))->type_common.precision)
== TYPE_PRECISION (to_type)((tree_class_check ((to_type), (tcc_type), "generic-match.c",
2442, __FUNCTION__))->type_common.precision)
2443 && integer_zerop (captures[1])
2444 && (cmp == LT_EXPR || cmp == GE_EXPR))
2445)
2446 {
2447 {
2448/* #line 3807 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2449 wi::overflow_type overflow = wi::OVF_NONE;
2450 enum tree_code code, cmp_code = cmp;
2451 wide_int real_c1;
2452 wide_int c1 = wi::to_wide (captures[1]);
2453 wide_int c2 = wi::to_wide (captures[2]);
2454 wide_int c3 = wi::to_wide (captures[3]);
2455 signop sgn = TYPE_SIGN (from_type)((signop) ((tree_class_check ((from_type), (tcc_type), "generic-match.c"
, 2455, __FUNCTION__))->base.u.bits.unsigned_flag))
;
2456 if (!types_match (from_type, to_type))
2457 {
2458 if (cmp_code == LT_EXPR)
2459 cmp_code = GT_EXPR;
2460 if (cmp_code == GE_EXPR)
2461 cmp_code = LE_EXPR;
2462 c1 = wi::max_value (to_type);
2463 }
2464 if (op == PLUS_EXPR)
2465 real_c1 = wi::sub (c3, c2, sgn, &overflow);
2466 else
2467 real_c1 = wi::add (c3, c2, sgn, &overflow);
2468 code = cmp_code;
2469 if (!overflow || !TYPE_OVERFLOW_UNDEFINED (from_type)((((enum tree_code) (from_type)->base.code) == POINTER_TYPE
|| ((enum tree_code) (from_type)->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((from_type), "generic-match.c", 2469, __FUNCTION__))->base
.u.bits.unsigned_flag && !global_options.x_flag_wrapv
&& !global_options.x_flag_trapv))
)
2470 {
2471 if (!wi::cmp (wi::sub (real_c1, 1, sgn, &overflow), c1, sgn)
2472 && !overflow)
2473 {
2474 if (cmp_code == LE_EXPR)
2475 code = LT_EXPR;
2476 if (cmp_code == GT_EXPR)
2477 code = GE_EXPR;
2478 }
2479 if (!wi::cmp (wi::add (real_c1, 1, sgn, &overflow), c1, sgn)
2480 && !overflow)
2481 {
2482 if (cmp_code == LT_EXPR)
2483 code = LE_EXPR;
2484 if (cmp_code == GE_EXPR)
2485 code = GT_EXPR;
2486 }
2487 if (code != cmp_code || !wi::cmp (real_c1, c1, sgn))
2488 {
2489 if (cmp_code == LT_EXPR || cmp_code == LE_EXPR)
2490 code = MIN_EXPR;
2491 if (cmp_code == GT_EXPR || cmp_code == GE_EXPR)
2492 code = MAX_EXPR;
2493 }
2494 }
2495/* #line 3871 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2496 if (code == MAX_EXPR
2497)
2498 {
2499 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2499, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail98;
2500 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2500, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail98;
2501 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2501, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail98;
2502 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 2502, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail98;
2503 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail98;
2504 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3872, __FILE__"generic-match.c", __LINE__2504);
2505 {
2506 tree res_op0;
2507 {
2508 tree _o1[2], _r1;
2509 _o1[0] = captures[0];
2510 _o1[1] = wide_int_to_tree (from_type, real_c1);
2511 _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2511, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
2512 res_op0 = _r1;
2513 }
2514 tree res_op1;
2515 res_op1 = wide_int_to_tree (from_type, c2);
2516 tree _r;
2517 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2518 return _r;
2519 }
2520next_after_fail98:;
2521 }
2522 else
2523 {
2524/* #line 3874 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2525 if (code == MIN_EXPR
2526)
2527 {
2528 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2528, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail99;
2529 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2529, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail99;
2530 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2530, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail99;
2531 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 2531, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail99;
2532 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail99;
2533 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3875, __FILE__"generic-match.c", __LINE__2533);
2534 {
2535 tree res_op0;
2536 {
2537 tree _o1[2], _r1;
2538 _o1[0] = captures[0];
2539 _o1[1] = wide_int_to_tree (from_type, real_c1);
2540 _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2540, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
2541 res_op0 = _r1;
2542 }
2543 tree res_op1;
2544 res_op1 = wide_int_to_tree (from_type, c2);
2545 tree _r;
2546 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2547 return _r;
2548 }
2549next_after_fail99:;
2550 }
2551 }
2552 }
2553 }
2554 }
2555 return NULL_TREE(tree) nullptr;
2556}
2557
2558static tree
2559generic_simplify_28 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2560 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
2561, const combined_fn ARG_UNUSED (SIGNBIT)SIGNBIT __attribute__ ((__unused__)))
2562{
2563 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail100;
2564 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6048, __FILE__"generic-match.c", __LINE__2564);
2565 {
2566 tree _r;
2567 _r = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];
2568 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2568, __FUNCTION__
))->base.side_effects_flag)
)
2569 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2570 return _r;
2571 }
2572next_after_fail100:;
2573 return NULL_TREE(tree) nullptr;
2574}
2575
2576static tree
2577generic_simplify_29 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2578 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
2579, const combined_fn ARG_UNUSED (fmas)fmas __attribute__ ((__unused__)))
2580{
2581/* #line 6244 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2582 if (canonicalize_math_after_vectorization_p ()
2583)
2584 {
2585 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail101;
2586 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6251, __FILE__"generic-match.c", __LINE__2586);
2587 {
2588 tree res_op0;
2589 res_op0 = captures[0];
2590 tree res_op1;
2591 res_op1 = captures[1];
2592 tree res_op2;
2593 res_op2 = captures[2];
2594 tree _r;
2595 _r = maybe_build_call_expr_loc (loc, CFN_FMS, type, 3, res_op0, res_op1, res_op2);
2596 if (!_r)
2597 goto next_after_fail101;
2598 return _r;
2599 }
2600next_after_fail101:;
2601 }
2602 return NULL_TREE(tree) nullptr;
2603}
2604
2605static tree
2606generic_simplify_30 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2607 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2608, const enum tree_code ARG_UNUSED (shift)shift __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (mod)mod __attribute__ ((__unused__)))
2609{
2610/* #line 632 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2611 if (integer_pow2p (captures[3]) && tree_int_cst_sgn (captures[3]) > 0
2612)
2613 {
2614 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 2614, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail102;
2615 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail102;
2616 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 633, __FILE__"generic-match.c", __LINE__2616);
2617 {
2618 tree res_op0;
2619 res_op0 = captures[0];
2620 tree res_op1;
2621 {
2622 tree _o1[2], _r1;
2623 _o1[0] = captures[1];
2624 {
2625 tree _o2[2], _r2;
2626 _o2[0] = captures[2];
2627 _o2[1] = build_int_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2627, __FUNCTION__))->typed.type)
,
2628 1);
2629 _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 2629, __FUNCTION__))->typed.type)
, _o2[0], _o2[1]);
2630 _o1[1] = _r2;
2631 }
2632 _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2632, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
2633 res_op1 = _r1;
2634 }
2635 tree _r;
2636 _r = fold_build2_loc (loc, shift, type, res_op0, res_op1);
2637 return _r;
2638 }
2639next_after_fail102:;
2640 }
2641 return NULL_TREE(tree) nullptr;
2642}
2643
2644static tree
2645generic_simplify_31 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2646 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2647, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2648{
2649/* #line 5172 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2650 if (single_use (captures[0])
2651 && ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 2651, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2651, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 2651, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2651, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[1]
), (TS_TYPED), "generic-match.c", 2651, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 2651, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 2651, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 2651, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 2651, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 2651, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 2651, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
2652 && TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 2652, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 2652, __FUNCTION__))->
base.u.bits.unsigned_flag)
2653)
2654 {
2655 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail103;
2656 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5175, __FILE__"generic-match.c", __LINE__2656);
2657 {
2658 tree res_op0;
2659 res_op0 = captures[2];
2660 tree res_op1;
2661 res_op1 = captures[1];
2662 tree _r;
2663 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2664 return _r;
2665 }
2666next_after_fail103:;
2667 }
2668 return NULL_TREE(tree) nullptr;
2669}
2670
2671static tree
2672generic_simplify_32 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2673 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2674, const combined_fn ARG_UNUSED (copysigns)copysigns __attribute__ ((__unused__)))
2675{
2676/* #line 774 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2677 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (captures[1]))real_isneg (&((*((tree_check ((captures[1]), "generic-match.c"
, 2677, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)))
2678)
2679 {
2680 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail104;
2681 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 775, __FILE__"generic-match.c", __LINE__2681);
2682 {
2683 tree res_op0;
2684 {
2685 tree _o1[1], _r1;
2686 _o1[0] = captures[0];
2687 _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2687, __FUNCTION__))->typed.type)
, _o1[0]);
2688 res_op0 = _r1;
2689 }
2690 tree _r;
2691 _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
2692 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2692, __FUNCTION__
))->base.side_effects_flag)
)
2693 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2694 return _r;
2695 }
2696next_after_fail104:;
2697 }
2698 else
2699 {
2700 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail105;
2701 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 776, __FILE__"generic-match.c", __LINE__2701);
2702 {
2703 tree res_op0;
2704 res_op0 = captures[0];
2705 tree _r;
2706 _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
2707 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2707, __FUNCTION__
))->base.side_effects_flag)
)
2708 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2709 return _r;
2710 }
2711next_after_fail105:;
2712 }
2713 return NULL_TREE(tree) nullptr;
2714}
2715
2716static tree
2717generic_simplify_33 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2718 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
2719, const combined_fn ARG_UNUSED (sins)sins __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (atans)atans __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (sqrts)sqrts __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (copysigns)copysigns __attribute__ ((__unused__)))
2720{
2721 {
2722/* #line 5463 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2723 REAL_VALUE_TYPEstruct real_value r_cst;
2724 build_sinatan_real (&r_cst, type);
2725 tree t_cst = build_real (type, r_cst);
2726 tree t_one = build_one_cst (type);
2727/* #line 5470 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2728 if (SCALAR_FLOAT_TYPE_P (type)(((enum tree_code) (type)->base.code) == REAL_TYPE)
2729)
2730 {
2731 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail106;
2732 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5471, __FILE__"generic-match.c", __LINE__2732);
2733 {
2734 if (! tree_invariant_p (captures[1])) goto next_after_fail106;
2735 tree res_op0;
2736 {
2737 tree _o1[2], _r1;
2738 {
2739 tree _o2[1], _r2;
2740 _o2[0] = unshare_expr (captures[1]);
2741 _r2 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 2741, __FUNCTION__))->typed.type)
, _o2[0]);
2742 _o1[0] = _r2;
2743 }
2744 _o1[1] = t_cst;
2745 _r1 = fold_build2_loc (loc, LT_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], _o1[0], _o1[1]);
2746 res_op0 = _r1;
2747 }
2748 tree res_op1;
2749 {
2750 tree _o1[2], _r1;
2751 _o1[0] = unshare_expr (captures[1]);
2752 {
2753 tree _o2[1], _r2;
2754 {
2755 tree _o3[2], _r3;
2756 {
2757 tree _o4[2], _r4;
2758 _o4[0] = unshare_expr (captures[1]);
2759 _o4[1] = unshare_expr (captures[1]);
2760 _r4 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o4[0])((contains_struct_check ((_o4[0]), (TS_TYPED), "generic-match.c"
, 2760, __FUNCTION__))->typed.type)
, _o4[0], _o4[1]);
2761 _o3[0] = _r4;
2762 }
2763 _o3[1] = t_one;
2764 _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 2764, __FUNCTION__))->typed.type)
, _o3[0], _o3[1]);
2765 _o2[0] = _r3;
2766 }
2767 {
2768 _r2 = maybe_build_call_expr_loc (loc, sqrts, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 2768, __FUNCTION__))->typed.type)
, 1, _o2[0]);
2769 if (!_r2)
2770 goto next_after_fail106;
2771 }
2772 _o1[1] = _r2;
2773 }
2774 _r1 = fold_build2_loc (loc, RDIV_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2774, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
2775 res_op1 = _r1;
2776 }
2777 tree res_op2;
2778 {
2779 tree _o1[2], _r1;
2780 _o1[0] = t_one;
2781 _o1[1] = captures[1];
2782 {
2783 _r1 = maybe_build_call_expr_loc (loc, copysigns, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2783, __FUNCTION__))->typed.type)
, 2, _o1[0], _o1[1]);
2784 if (!_r1)
2785 goto next_after_fail106;
2786 }
2787 res_op2 = _r1;
2788 }
2789 tree _r;
2790 _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
2791 return _r;
2792 }
2793next_after_fail106:;
2794 }
2795 }
2796 return NULL_TREE(tree) nullptr;
2797}
2798
2799static tree
2800generic_simplify_34 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2801 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2802, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2803{
2804/* #line 4758 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2805 if (tree_single_nonzero_warnv_p (captures[0], NULLnullptr)
2806)
2807 {
2808 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 2808, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail107;
2809 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail107;
2810 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4759, __FILE__"generic-match.c", __LINE__2810);
2811 {
2812 tree _r;
2813 _r = constant_boolean_node (cmp == NE_EXPR, type);
2814 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2814, __FUNCTION__
))->base.side_effects_flag)
)
2815 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2816 return _r;
2817 }
2818next_after_fail107:;
2819 }
2820 return NULL_TREE(tree) nullptr;
2821}
2822
2823static tree
2824generic_simplify_35 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2825 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2826, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2827{
2828/* #line 5220 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2829 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 2829, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2829, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 2829, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
2830 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 2830, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2830, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 2830, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
2831 && TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 2831, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 2831, __FUNCTION__))->
base.u.bits.unsigned_flag)
2832 && (TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 2832, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 2832, __FUNCTION__))->
type_common.precision)
2833 >= 2 * TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 2833, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 2833, __FUNCTION__))->
type_common.precision)
)
2834 && tree_fits_uhwi_p (captures[4])
2835 && tree_to_uhwi (captures[4]) == TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 2835, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 2835, __FUNCTION__))->
type_common.precision)
2836 && types_match (captures[2], captures[3])
2837 && type_has_mode_precision_p (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2837, __FUNCTION__))->typed.type)
)
2838 && (optab_handler (umulv4_optab, TYPE_MODE (TREE_TYPE (captures[2]))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[2]), (TS_TYPED), "generic-match.c", 2838, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.c", 2838, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[2]), (TS_TYPED), "generic-match.c", 2838, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 2838, __FUNCTION__))->typed
.type))->type_common.mode)
)
2839 != CODE_FOR_nothing)
2840)
2841 {
2842 {
2843/* #line 5231 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2844 tree t = TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2844, __FUNCTION__))->typed.type)
, cpx = build_complex_type (t);
2845 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 2845, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail108;
2846 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail108;
2847 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5232, __FILE__"generic-match.c", __LINE__2847);
2848 {
2849 tree res_op0;
2850 {
2851 tree _o1[1], _r1;
2852 {
2853 tree _o2[2], _r2;
2854 _o2[0] = captures[2];
2855 _o2[1] = captures[3];
2856 {
2857 _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
2858 if (!_r2)
2859 goto next_after_fail108;
2860 }
2861 _o1[0] = _r2;
2862 }
2863 _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0]))((contains_struct_check ((((contains_struct_check ((_o1[0]), (
TS_TYPED), "generic-match.c", 2863, __FUNCTION__))->typed.
type)), (TS_TYPED), "generic-match.c", 2863, __FUNCTION__))->
typed.type)
, _o1[0]);
2864 res_op0 = _r1;
2865 }
2866 tree res_op1;
2867 res_op1 = build_zero_cst (t);
2868 tree _r;
2869 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2870 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 2870, __FUNCTION__
))->base.side_effects_flag)
)
2871 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[4]), _r);
2872 return _r;
2873 }
2874next_after_fail108:;
2875 }
2876 }
2877 return NULL_TREE(tree) nullptr;
2878}
2879
2880static tree
2881generic_simplify_36 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2882 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2883, const combined_fn ARG_UNUSED (sq)sq __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2884{
2885/* #line 4253 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2886 if (flag_unsafe_math_optimizationsglobal_options.x_flag_unsafe_math_optimizations && ! flag_errno_mathglobal_options.x_flag_errno_math
2887)
2888 {
2889/* #line 4393 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2890 if (! HONOR_NANS (captures[0])
2891)
2892 {
2893 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail109;
2894 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4394, __FILE__"generic-match.c", __LINE__2894);
2895 {
2896 tree res_op0;
2897 res_op0 = captures[0];
2898 tree res_op1;
2899 res_op1 = captures[1];
2900 tree _r;
2901 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2902 return _r;
2903 }
2904next_after_fail109:;
2905 }
2906 }
2907 return NULL_TREE(tree) nullptr;
2908}
2909
2910static tree
2911generic_simplify_37 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2912 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2913, const combined_fn ARG_UNUSED (COPYSIGN_ALL)COPYSIGN_ALL __attribute__ ((__unused__)))
2914{
2915/* #line 296 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2916 if (!HONOR_NANS (type) && !HONOR_SIGNED_ZEROS (type)
2917)
2918 {
2919 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 2919, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail110;
2920 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail110;
2921 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 297, __FILE__"generic-match.c", __LINE__2921);
2922 {
2923 tree res_op0;
2924 {
2925 tree _o1[1], _r1;
2926 _o1[0] = captures[0];
2927 _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2927, __FUNCTION__))->typed.type)
, _o1[0]);
2928 res_op0 = _r1;
2929 }
2930 tree _r;
2931 _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
2932 return _r;
2933 }
2934next_after_fail110:;
2935 }
2936 return NULL_TREE(tree) nullptr;
2937}
2938
2939static tree
2940generic_simplify_38 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2941 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2942, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2943{
2944 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 2944, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail111;
2945 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail111;
2946 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4742, __FILE__"generic-match.c", __LINE__2946);
2947 {
2948 tree res_op0;
2949 res_op0 = captures[0];
2950 tree res_op1;
2951 res_op1 = captures[1];
2952 tree _r;
2953 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2954 return _r;
2955 }
2956next_after_fail111:;
2957 return NULL_TREE(tree) nullptr;
2958}
2959
2960static tree
2961generic_simplify_39 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2962 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2963, const enum tree_code ARG_UNUSED (shiftrotate)shiftrotate __attribute__ ((__unused__)))
2964{
2965 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 2965, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail112;
2966 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail112;
2967 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3062, __FILE__"generic-match.c", __LINE__2967);
2968 {
2969 tree res_op0;
2970 res_op0 = captures[0];
2971 tree _r;
2972 _r = non_lvalue_loc (loc, res_op0);
2973 return _r;
2974 }
2975next_after_fail112:;
2976 return NULL_TREE(tree) nullptr;
2977}
2978
2979static tree
2980generic_simplify_40 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2981 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2982, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2983{
2984 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail113;
2985 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4748, __FILE__"generic-match.c", __LINE__2985);
2986 {
2987 tree res_op0;
2988 res_op0 = captures[1];
2989 tree res_op1;
2990 res_op1 = build_zero_cst (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2990, __FUNCTION__))->typed.type)
);
2991 tree _r;
2992 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2993 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2993, __FUNCTION__
))->base.side_effects_flag)
)
2994 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2995 return _r;
2996 }
2997next_after_fail113:;
2998 return NULL_TREE(tree) nullptr;
2999}
3000
3001static tree
3002generic_simplify_41 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3003 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3004, const combined_fn ARG_UNUSED (TAN)TAN __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (COS)COS __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (SIN)SIN __attribute__ ((__unused__)))
3005{
3006/* #line 5578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3007 if (flag_unsafe_math_optimizationsglobal_options.x_flag_unsafe_math_optimizations && canonicalize_math_p ()
3008)
3009 {
3010 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail114;
3011 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5582, __FILE__"generic-match.c", __LINE__3011);
3012 {
3013 tree res_op0;
3014 res_op0 = captures[1];
3015 tree _r;
3016 _r = maybe_build_call_expr_loc (loc, SIN, type, 1, res_op0);
3017 if (!_r)
3018 goto next_after_fail114;
3019 return _r;
3020 }
3021next_after_fail114:;
3022 }
3023 return NULL_TREE(tree) nullptr;
3024}
3025
3026static tree
3027generic_simplify_42 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3028 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3029, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3030{
3031/* #line 1859 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3032 if (!TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 3032, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3032, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3032, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) && !((((enum tree_code
) (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3032, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3032, __FUNCTION__))->typed
.type))->base.code) == REFERENCE_TYPE) ? global_options.x_flag_wrapv_pointer
: ((any_integral_type_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 3032, __FUNCTION__))->
typed.type)), "generic-match.c", 3032, __FUNCTION__))->base
.u.bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
3033)
3034 {
3035 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail115;
3036 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1860, __FILE__"generic-match.c", __LINE__3036);
3037 {
3038 tree res_op0;
3039 res_op0 = captures[3];
3040 tree res_op1;
3041 res_op1 = captures[2];
3042 tree _r;
3043 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3044 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3044, __FUNCTION__
))->base.side_effects_flag)
)
3045 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3046 return _r;
3047 }
3048next_after_fail115:;
3049 }
3050 return NULL_TREE(tree) nullptr;
3051}
3052
3053static tree
3054generic_simplify_43 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3055 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3056)
3057{
3058/* #line 1413 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3059 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)
3060 && TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 3060
, __FUNCTION__))->base.u.bits.unsigned_flag)
3061 && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3061, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3061, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 3061, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
3062 && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3062, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3062, __FUNCTION__))->
base.u.bits.unsigned_flag)
3063)
3064 {
3065 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 3065, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail116;
3066 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail116;
3067 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1417, __FILE__"generic-match.c", __LINE__3067);
3068 {
3069 tree res_op0;
3070 res_op0 = captures[0];
3071 tree _r;
3072 _r = fold_build1_loc (loc, ABSU_EXPR, type, res_op0);
3073 return _r;
3074 }
3075next_after_fail116:;
3076 }
3077 return NULL_TREE(tree) nullptr;
3078}
3079
3080static tree
3081generic_simplify_44 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3082 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
3083, const combined_fn ARG_UNUSED (sinhs)sinhs __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (atanhs)atanhs __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (sqrts)sqrts __attribute__ ((__unused__)))
3084{
3085/* #line 5495 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3086 if (!flag_errno_mathglobal_options.x_flag_errno_math
3087)
3088 {
3089 {
3090/* #line 5502 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3091 tree t_one = build_one_cst (type);
3092 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail117;
3093 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5503, __FILE__"generic-match.c", __LINE__3093);
3094 {
3095 if (! tree_invariant_p (captures[1])) goto next_after_fail117;
3096 tree res_op0;
3097 res_op0 = unshare_expr (captures[1]);
3098 tree res_op1;
3099 {
3100 tree _o1[1], _r1;
3101 {
3102 tree _o2[2], _r2;
3103 {
3104 tree _o3[2], _r3;
3105 _o3[0] = t_one;
3106 _o3[1] = unshare_expr (captures[1]);
3107 _r3 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 3107, __FUNCTION__))->typed.type)
, _o3[0], _o3[1]);
3108 _o2[0] = _r3;
3109 }
3110 {
3111 tree _o3[2], _r3;
3112 _o3[0] = t_one;
3113 _o3[1] = captures[1];
3114 _r3 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 3114, __FUNCTION__))->typed.type)
, _o3[0], _o3[1]);
3115 _o2[1] = _r3;
3116 }
3117 _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3117, __FUNCTION__))->typed.type)
, _o2[0], _o2[1]);
3118 _o1[0] = _r2;
3119 }
3120 {
3121 _r1 = maybe_build_call_expr_loc (loc, sqrts, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3121, __FUNCTION__))->typed.type)
, 1, _o1[0]);
3122 if (!_r1)
3123 goto next_after_fail117;
3124 }
3125 res_op1 = _r1;
3126 }
3127 tree _r;
3128 _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
3129 return _r;
3130 }
3131next_after_fail117:;
3132 }
3133 }
3134 return NULL_TREE(tree) nullptr;
3135}
3136
3137static tree
3138generic_simplify_45 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3139 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3140, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (ncmp)ncmp __attribute__ ((__unused__)))
3141{
3142/* #line 4822 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3143 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 3143, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3143, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3143, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
3144 && type_has_mode_precision_p (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3144, __FUNCTION__))->typed.type)
)
3145 && element_precision (captures[0]) >= element_precision (captures[1])
3146 && wi::only_sign_bit_p (wi::to_wide (captures[2]), element_precision (captures[1]))
3147)
3148 {
3149 {
3150/* #line 4826 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3151 tree stype = signed_type_for (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3151, __FUNCTION__))->typed.type)
);
3152 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 3152, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail118;
3153 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail118;
3154 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4827, __FILE__"generic-match.c", __LINE__3154);
3155 {
3156 tree res_op0;
3157 {
3158 tree _o1[1], _r1;
3159 _o1[0] = captures[1];
3160 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3160, __FUNCTION__))->typed.type)
!= stype)
3161 _r1 = fold_build1_loc (loc, NOP_EXPR, stype, _o1[0]);
3162 else
3163 _r1 = _o1[0];
3164 res_op0 = _r1;
3165 }
3166 tree res_op1;
3167 res_op1 = build_zero_cst (stype);
3168 tree _r;
3169 _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
3170 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3170, __FUNCTION__
))->base.side_effects_flag)
)
3171 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
3172 return _r;
3173 }
3174next_after_fail118:;
3175 }
3176 }
3177 return NULL_TREE(tree) nullptr;
3178}
3179
3180static tree
3181generic_simplify_46 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3182 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3183, const enum tree_code ARG_UNUSED (div)div __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (mod)mod __attribute__ ((__unused__)))
3184{
3185 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail119;
3186 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3468, __FILE__"generic-match.c", __LINE__3186);
3187 {
3188 tree _r;
3189 _r = captures[0];
3190 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3190, __FUNCTION__
))->base.side_effects_flag)
)
3191 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3192 return _r;
3193 }
3194next_after_fail119:;
3195 return NULL_TREE(tree) nullptr;
3196}
3197
3198static tree
3199generic_simplify_47 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3200 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3201, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3202{
3203/* #line 4169 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3204 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (captures[1]))real_isnegzero (&((*((tree_check ((captures[1]), "generic-match.c"
, 3204, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)))
3205)
3206 {
3207 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail120;
3208 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4170, __FILE__"generic-match.c", __LINE__3208);
3209 {
3210 tree res_op0;
3211 res_op0 = captures[0];
3212 tree res_op1;
3213 res_op1 = build_real (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3213, __FUNCTION__))->typed.type)
, dconst0);
3214 tree _r;
3215 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
3216 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3216, __FUNCTION__
))->base.side_effects_flag)
)
3217 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3218 return _r;
3219 }
3220next_after_fail120:;
3221 }
3222 else
3223 {
3224/* #line 4172 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3225 if (REAL_VALUE_ISNAN (TREE_REAL_CST (captures[1]))real_isnan (&((*((tree_check ((captures[1]), "generic-match.c"
, 3225, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)))
3226 && ! HONOR_SNANS (captures[1])
3227)
3228 {
3229 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail121;
3230 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4174, __FILE__"generic-match.c", __LINE__3230);
3231 {
3232 tree _r;
3233 _r = constant_boolean_node (cmp == NE_EXPR, type);
3234 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3234, __FUNCTION__
))->base.side_effects_flag)
)
3235 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3236 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3236, __FUNCTION__
))->base.side_effects_flag)
)
3237 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3238 return _r;
3239 }
3240next_after_fail121:;
3241 }
3242 else
3243 {
3244/* #line 4176 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3245 if (REAL_VALUE_ISINF (TREE_REAL_CST (captures[1]))real_isinf (&((*((tree_check ((captures[1]), "generic-match.c"
, 3245, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)))
3246 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (captures[1])))((((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3246, __FUNCTION__))->typed.type)), (tcc_type), "generic-match.c"
, 3246, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3246, __FUNCTION__))->typed.type)) : (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 3246, __FUNCTION__
))->typed.type))->type_common.mode)]) == MODE_FLOAT || (
(enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3246, __FUNCTION__))->typed.type)), (tcc_type), "generic-match.c"
, 3246, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3246, __FUNCTION__))->typed.type)) : (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 3246, __FUNCTION__
))->typed.type))->type_common.mode)]) == MODE_DECIMAL_FLOAT
|| ((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3246, __FUNCTION__))->typed.type)), (tcc_type), "generic-match.c"
, 3246, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3246, __FUNCTION__))->typed.type)) : (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 3246, __FUNCTION__
))->typed.type))->type_common.mode)]) == MODE_COMPLEX_FLOAT
|| ((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3246, __FUNCTION__))->typed.type)), (tcc_type), "generic-match.c"
, 3246, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3246, __FUNCTION__))->typed.type)) : (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 3246, __FUNCTION__
))->typed.type))->type_common.mode)]) == MODE_VECTOR_FLOAT
) && ((real_format_for_mode[(((enum mode_class) mode_class
[as_a <scalar_float_mode> ((mode_to_inner (((((enum tree_code
) ((tree_class_check ((((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3246, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.c", 3246, __FUNCTION__)))
->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 3246, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3246, __FUNCTION__))->typed
.type))->type_common.mode))))]) == MODE_DECIMAL_FLOAT) ? (
((as_a <scalar_float_mode> ((mode_to_inner (((((enum tree_code
) ((tree_class_check ((((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3246, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.c", 3246, __FUNCTION__)))
->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 3246, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3246, __FUNCTION__))->typed
.type))->type_common.mode))))) - MIN_MODE_DECIMAL_FLOAT) +
(MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1)) : ((enum mode_class) mode_class
[as_a <scalar_float_mode> ((mode_to_inner (((((enum tree_code
) ((tree_class_check ((((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3246, __FUNCTION__))->typed
.type)), (tcc_type), "generic-match.c", 3246, __FUNCTION__)))
->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 3246, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3246, __FUNCTION__))->typed
.type))->type_common.mode))))]) == MODE_FLOAT ? ((as_a <
scalar_float_mode> ((mode_to_inner (((((enum tree_code) ((
tree_class_check ((((contains_struct_check ((captures[1]), (TS_TYPED
), "generic-match.c", 3246, __FUNCTION__))->typed.type)), (
tcc_type), "generic-match.c", 3246, __FUNCTION__)))->base.
code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 3246, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3246, __FUNCTION__))->typed
.type))->type_common.mode))))) - MIN_MODE_FLOAT) : ((fancy_abort
("generic-match.c", 3246, __FUNCTION__)), 0)]))->has_inf)
3247)
3248 {
3249 {
3250/* #line 4178 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3251 REAL_VALUE_TYPEstruct real_value max;
3252 enum tree_code code = cmp;
3253 bool neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (captures[1]))real_isneg (&((*((tree_check ((captures[1]), "generic-match.c"
, 3253, __FUNCTION__, (REAL_CST)))->real_cst.real_cst_ptr)
)))
;
3254 if (neg)
3255 code = swap_tree_comparison (code);
3256/* #line 4188 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3257 if (code == GT_EXPR
3258 && !(HONOR_NANS (captures[0]) && flag_trapping_mathglobal_options.x_flag_trapping_math)
3259)
3260 {
3261 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail122;
3262 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4190, __FILE__"generic-match.c", __LINE__3262);
3263 {
3264 tree _r;
3265 _r = constant_boolean_node (false, type);
3266 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3266, __FUNCTION__
))->base.side_effects_flag)
)
3267 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3268 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3268, __FUNCTION__
))->base.side_effects_flag)
)
3269 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3270 return _r;
3271 }
3272next_after_fail122:;
3273 }
3274 else
3275 {
3276/* #line 4191 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3277 if (code == LE_EXPR
3278)
3279 {
3280/* #line 4193 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3281 if (! HONOR_NANS (captures[0])
3282)
3283 {
3284 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail123;
3285 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4194, __FILE__"generic-match.c", __LINE__3285);
3286 {
3287 tree _r;
3288 _r = constant_boolean_node (true, type);
3289 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3289, __FUNCTION__
))->base.side_effects_flag)
)
3290 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3291 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3291, __FUNCTION__
))->base.side_effects_flag)
)
3292 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3293 return _r;
3294 }
3295next_after_fail123:;
3296 }
3297 else
3298 {
3299/* #line 4197 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3300 if (!flag_trapping_mathglobal_options.x_flag_trapping_math
3301)
3302 {
3303 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail124;
3304 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4198, __FILE__"generic-match.c", __LINE__3304);
3305 {
3306 if (! tree_invariant_p (captures[0])) goto next_after_fail124;
3307 tree res_op0;
3308 res_op0 = unshare_expr (captures[0]);
3309 tree res_op1;
3310 res_op1 = captures[0];
3311 tree _r;
3312 _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
3313 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3313, __FUNCTION__
))->base.side_effects_flag)
)
3314 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3315 return _r;
3316 }
3317next_after_fail124:;
3318 }
3319 }
3320 }
3321 else
3322 {
3323/* #line 4201 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3324 if ((code == EQ_EXPR && !(HONOR_NANS (captures[0]) && flag_trapping_mathglobal_options.x_flag_trapping_math))
3325 || code == GE_EXPR
3326)
3327 {
3328 {
3329/* #line 4203 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3330 real_maxval (&max, neg, TYPE_MODE (TREE_TYPE (captures[0]))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 3330, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.c", 3330, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 3330, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 3330, __FUNCTION__))->typed
.type))->type_common.mode)
);
3331/* #line 4204 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3332 if (neg
3333)
3334 {
3335 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail125;
3336 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4205, __FILE__"generic-match.c", __LINE__3336);
3337 {
3338 tree res_op0;
3339 res_op0 = captures[0];
3340 tree res_op1;
3341 res_op1 = build_real (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3341, __FUNCTION__))->typed.type)
, max);
3342 tree _r;
3343 _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
3344 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3344, __FUNCTION__
))->base.side_effects_flag)
)
3345 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3346 return _r;
3347 }
3348next_after_fail125:;
3349 }
3350 else
3351 {
3352 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail126;
3353 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4206, __FILE__"generic-match.c", __LINE__3353);
3354 {
3355 tree res_op0;
3356 res_op0 = captures[0];
3357 tree res_op1;
3358 res_op1 = build_real (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3358, __FUNCTION__))->typed.type)
, max);
3359 tree _r;
3360 _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
3361 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3361, __FUNCTION__
))->base.side_effects_flag)
)
3362 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3363 return _r;
3364 }
3365next_after_fail126:;
3366 }
3367 }
3368 }
3369 else
3370 {
3371/* #line 4208 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3372 if (code == LT_EXPR
3373)
3374 {
3375 {
3376/* #line 4209 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3377 real_maxval (&max, neg, TYPE_MODE (TREE_TYPE (captures[0]))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 3377, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.c", 3377, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 3377, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 3377, __FUNCTION__))->typed
.type))->type_common.mode)
);
3378/* #line 4210 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3379 if (neg
3380)
3381 {
3382 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail127;
3383 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4211, __FILE__"generic-match.c", __LINE__3383);
3384 {
3385 tree res_op0;
3386 res_op0 = captures[0];
3387 tree res_op1;
3388 res_op1 = build_real (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3388, __FUNCTION__))->typed.type)
, max);
3389 tree _r;
3390 _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
3391 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3391, __FUNCTION__
))->base.side_effects_flag)
)
3392 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3393 return _r;
3394 }
3395next_after_fail127:;
3396 }
3397 else
3398 {
3399 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail128;
3400 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4212, __FILE__"generic-match.c", __LINE__3400);
3401 {
3402 tree res_op0;
3403 res_op0 = captures[0];
3404 tree res_op1;
3405 res_op1 = build_real (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3405, __FUNCTION__))->typed.type)
, max);
3406 tree _r;
3407 _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
3408 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3408, __FUNCTION__
))->base.side_effects_flag)
)
3409 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3410 return _r;
3411 }
3412next_after_fail128:;
3413 }
3414 }
3415 }
3416 else
3417 {
3418/* #line 4215 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3419 if (code == NE_EXPR
3420)
3421 {
3422 {
3423/* #line 4216 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3424 real_maxval (&max, neg, TYPE_MODE (TREE_TYPE (captures[0]))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 3424, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.c", 3424, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 3424, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 3424, __FUNCTION__))->typed
.type))->type_common.mode)
);
3425/* #line 4217 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3426 if (! HONOR_NANS (captures[0])
3427)
3428 {
3429/* #line 4218 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3430 if (neg
3431)
3432 {
3433 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail129;
3434 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4219, __FILE__"generic-match.c", __LINE__3434);
3435 {
3436 tree res_op0;
3437 res_op0 = captures[0];
3438 tree res_op1;
3439 res_op1 = build_real (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3439, __FUNCTION__))->typed.type)
, max);
3440 tree _r;
3441 _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
3442 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3442, __FUNCTION__
))->base.side_effects_flag)
)
3443 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3444 return _r;
3445 }
3446next_after_fail129:;
3447 }
3448 else
3449 {
3450 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail130;
3451 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4220, __FILE__"generic-match.c", __LINE__3451);
3452 {
3453 tree res_op0;
3454 res_op0 = captures[0];
3455 tree res_op1;
3456 res_op1 = build_real (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3456, __FUNCTION__))->typed.type)
, max);
3457 tree _r;
3458 _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
3459 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3459, __FUNCTION__
))->base.side_effects_flag)
)
3460 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3461 return _r;
3462 }
3463next_after_fail130:;
3464 }
3465 }
3466 else
3467 {
3468/* #line 4221 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3469 if (neg
3470)
3471 {
3472 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail131;
3473 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4222, __FILE__"generic-match.c", __LINE__3473);
3474 {
3475 tree res_op0;
3476 res_op0 = captures[0];
3477 tree res_op1;
3478 res_op1 = build_real (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3478, __FUNCTION__))->typed.type)
, max);
3479 tree _r;
3480 _r = fold_build2_loc (loc, UNGE_EXPR, type, res_op0, res_op1);
3481 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3481, __FUNCTION__
))->base.side_effects_flag)
)
3482 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3483 return _r;
3484 }
3485next_after_fail131:;
3486 }
3487 else
3488 {
3489 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail132;
3490 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4223, __FILE__"generic-match.c", __LINE__3490);
3491 {
3492 tree res_op0;
3493 res_op0 = captures[0];
3494 tree res_op1;
3495 res_op1 = build_real (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3495, __FUNCTION__))->typed.type)
, max);
3496 tree _r;
3497 _r = fold_build2_loc (loc, UNLE_EXPR, type, res_op0, res_op1);
3498 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3498, __FUNCTION__
))->base.side_effects_flag)
)
3499 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3500 return _r;
3501 }
3502next_after_fail132:;
3503 }
3504 }
3505 }
3506 }
3507 }
3508 }
3509 }
3510 }
3511 }
3512 }
3513 }
3514 }
3515 return NULL_TREE(tree) nullptr;
3516}
3517
3518static tree
3519generic_simplify_48 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3520 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3521)
3522{
3523/* #line 1650 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3524 if (tree_nop_conversion_p (type, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3524, __FUNCTION__))->typed.type)
)
3525)
3526 {
3527 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail133;
3528 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1651, __FILE__"generic-match.c", __LINE__3528);
3529 {
3530 tree res_op0;
3531 {
3532 tree _o1[2], _r1;
3533 {
3534 tree _o2[1], _r2;
3535 _o2[0] = captures[2];
3536 _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o2[0]);
3537 _o1[0] = _r2;
3538 }
3539 _o1[1] = captures[3];
3540 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3540, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3541 res_op0 = _r1;
3542 }
3543 tree _r;
3544 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
3545 return _r;
3546 }
3547next_after_fail133:;
3548 }
3549 return NULL_TREE(tree) nullptr;
3550}
3551
3552static tree
3553generic_simplify_49 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3554 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3555, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3556{
3557/* #line 1923 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3558 if (TREE_INT_CST_LOW (captures[1])((unsigned long) (*tree_int_cst_elt_check ((captures[1]), (0)
, "generic-match.c", 3558, __FUNCTION__)))
& 1
3559)
3560 {
3561 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail134;
3562 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1924, __FILE__"generic-match.c", __LINE__3562);
3563 {
3564 tree _r;
3565 _r = constant_boolean_node (cmp == NE_EXPR, type);
3566 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3566, __FUNCTION__
))->base.side_effects_flag)
)
3567 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3568 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3568, __FUNCTION__
))->base.side_effects_flag)
)
3569 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3570 return _r;
3571 }
3572next_after_fail134:;
3573 }
3574 return NULL_TREE(tree) nullptr;
3575}
3576
3577static tree
3578generic_simplify_50 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3579 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3580, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3581{
3582/* #line 1700 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3583 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 3583, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3583, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3583, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
3584 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3584, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3584, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3584, __FUNCTION__))->typed.type)), "generic-match.c", 3584
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
3585)
3586 {
3587/* #line 1702 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3588 if (tree_expr_nonnegative_p (captures[1]) && tree_expr_nonzero_p (captures[1])
3589)
3590 {
3591 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail135;
3592 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1703, __FILE__"generic-match.c", __LINE__3592);
3593 {
3594 tree res_op0;
3595 res_op0 = captures[0];
3596 tree res_op1;
3597 res_op1 = captures[2];
3598 tree _r;
3599 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
3600 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3600, __FUNCTION__
))->base.side_effects_flag)
)
3601 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3602 return _r;
3603 }
3604next_after_fail135:;
3605 }
3606 else
3607 {
3608/* #line 1704 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3609 if (TREE_CODE (captures[1])((enum tree_code) (captures[1])->base.code) == INTEGER_CST
3610 && wi::neg_p (wi::to_wide (captures[1]), TYPE_SIGN (TREE_TYPE (captures[1]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 3610, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.c", 3610, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
3611)
3612 {
3613 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail136;
3614 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1706, __FILE__"generic-match.c", __LINE__3614);
3615 {
3616 tree res_op0;
3617 res_op0 = captures[2];
3618 tree res_op1;
3619 res_op1 = captures[0];
3620 tree _r;
3621 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
3622 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3622, __FUNCTION__
))->base.side_effects_flag)
)
3623 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3624 return _r;
3625 }
3626next_after_fail136:;
3627 }
3628 }
3629 }
3630 return NULL_TREE(tree) nullptr;
3631}
3632
3633static tree
3634generic_simplify_51 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3635 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3636)
3637{
3638/* #line 3532 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3639 if (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) != INTEGER_CST
3640 && single_use (captures[0])
3641 && !integer_zerop (captures[2]) && !integer_minus_onep (captures[2])
3642)
3643 {
3644 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail137;
3645 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3535, __FILE__"generic-match.c", __LINE__3645);
3646 {
3647 tree res_op0;
3648 {
3649 tree _o1[2], _r1;
3650 _o1[0] = captures[1];
3651 _o1[1] = captures[3];
3652 _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3652, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3653 res_op0 = _r1;
3654 }
3655 tree res_op1;
3656 res_op1 = captures[2];
3657 tree _r;
3658 _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
3659 return _r;
3660 }
3661next_after_fail137:;
3662 }
3663 return NULL_TREE(tree) nullptr;
3664}
3665
3666static tree
3667generic_simplify_52 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3668 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3669)
3670{
3671/* #line 155 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3672 if (fold_real_zero_addition_p (type, captures[1], 0)
3673)
3674 {
3675 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail138;
3676 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 156, __FILE__"generic-match.c", __LINE__3676);
3677 {
3678 tree res_op0;
3679 res_op0 = captures[0];
3680 tree _r;
3681 _r = non_lvalue_loc (loc, res_op0);
3682 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3682, __FUNCTION__
))->base.side_effects_flag)
)
3683 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3684 return _r;
3685 }
3686next_after_fail138:;
3687 }
3688 return NULL_TREE(tree) nullptr;
3689}
3690
3691static tree
3692generic_simplify_53 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3693 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
3694, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3695{
3696/* #line 5907 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3697 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)
3698 && op != MULT_EXPR
3699 && op != RDIV_EXPR
3700 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 3700, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3700, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 3700, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
3701 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 3701, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3701, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 3701, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
3702 && type_has_mode_precision_p (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3702, __FUNCTION__))->typed.type)
)
3703 && type_has_mode_precision_p (TREE_TYPE (captures[4])((contains_struct_check ((captures[4]), (TS_TYPED), "generic-match.c"
, 3703, __FUNCTION__))->typed.type)
)
3704 && type_has_mode_precision_p (type)
3705 && TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 3705, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3705, __FUNCTION__))->
type_common.precision)
> TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 3705, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3705, __FUNCTION__))->
type_common.precision)
3706 && types_match (captures[2], type)
3707 && (types_match (captures[2], captures[4])
3708 || TREE_CODE (captures[4])((enum tree_code) (captures[4])->base.code) == INTEGER_CST)
3709)
3710 {
3711/* #line 5927 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3712 if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 3712, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3712, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3712, __FUNCTION__))->typed.type)), "generic-match.c", 3712
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
3713)
3714 {
3715 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail139;
3716 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5928, __FILE__"generic-match.c", __LINE__3716);
3717 {
3718 tree res_op0;
3719 res_op0 = captures[2];
3720 tree res_op1;
3721 {
3722 tree _o1[1], _r1;
3723 _o1[0] = captures[4];
3724 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3724, __FUNCTION__))->typed.type)
!= type)
3725 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3726 else
3727 _r1 = _o1[0];
3728 res_op1 = _r1;
3729 }
3730 tree _r;
3731 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3732 return _r;
3733 }
3734next_after_fail139:;
3735 }
3736 else
3737 {
3738 {
3739/* #line 5929 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3740 tree utype = unsigned_type_for (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3740, __FUNCTION__))->typed.type)
);
3741 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail140;
3742 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5930, __FILE__"generic-match.c", __LINE__3742);
3743 {
3744 tree res_op0;
3745 {
3746 tree _o1[2], _r1;
3747 {
3748 tree _o2[1], _r2;
3749 _o2[0] = captures[2];
3750 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3750, __FUNCTION__))->typed.type)
!= utype)
3751 _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3752 else
3753 _r2 = _o2[0];
3754 _o1[0] = _r2;
3755 }
3756 {
3757 tree _o2[1], _r2;
3758 _o2[0] = captures[4];
3759 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3759, __FUNCTION__))->typed.type)
!= utype)
3760 _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
3761 else
3762 _r2 = _o2[0];
3763 _o1[1] = _r2;
3764 }
3765 _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3765, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3766 res_op0 = _r1;
3767 }
3768 tree _r;
3769 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3770 return _r;
3771 }
3772next_after_fail140:;
3773 }
3774 }
3775 }
3776 else
3777 {
3778/* #line 5932 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3779 if (FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 3779, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
3780 && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3780, __FUNCTION__))->typed.
type))->base.code) == REAL_TYPE) && (((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 3780, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.c", 3780, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 3780, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 3780, __FUNCTION__))->typed
.type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
3781 == DECIMAL_FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) &&
(((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((type), (tcc_type), "generic-match.c", 3781, __FUNCTION__))
)->base.code) == VECTOR_TYPE) ? vector_type_mode (type) : (
type)->type_common.mode)]) == MODE_DECIMAL_FLOAT))
3782)
3783 {
3784 {
3785/* #line 5935 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3786 tree arg0 = strip_float_extensions (captures[2]);
3787 tree arg1 = strip_float_extensions (captures[4]);
3788 tree itype = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3788, __FUNCTION__))->typed.type)
;
3789 tree ty1 = TREE_TYPE (arg0)((contains_struct_check ((arg0), (TS_TYPED), "generic-match.c"
, 3789, __FUNCTION__))->typed.type)
;
3790 tree ty2 = TREE_TYPE (arg1)((contains_struct_check ((arg1), (TS_TYPED), "generic-match.c"
, 3790, __FUNCTION__))->typed.type)
;
3791 enum tree_code code = TREE_CODE (itype)((enum tree_code) (itype)->base.code);
3792/* #line 5941 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3793 if (FLOAT_TYPE_P (ty1)((((enum tree_code) (ty1)->base.code) == REAL_TYPE) || (((
(enum tree_code) (ty1)->base.code) == COMPLEX_TYPE || (((enum
tree_code) (ty1)->base.code) == VECTOR_TYPE)) && (
((enum tree_code) (((contains_struct_check ((ty1), (TS_TYPED)
, "generic-match.c", 3793, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
3794 && FLOAT_TYPE_P (ty2)((((enum tree_code) (ty2)->base.code) == REAL_TYPE) || (((
(enum tree_code) (ty2)->base.code) == COMPLEX_TYPE || (((enum
tree_code) (ty2)->base.code) == VECTOR_TYPE)) && (
((enum tree_code) (((contains_struct_check ((ty2), (TS_TYPED)
, "generic-match.c", 3794, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
3795)
3796 {
3797 {
3798/* #line 5943 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3799 tree newtype = type;
3800 if (TYPE_MODE (ty1)((((enum tree_code) ((tree_class_check ((ty1), (tcc_type), "generic-match.c"
, 3800, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty1) : (ty1)->type_common.mode)
== SDmode(scalar_float_mode ((scalar_float_mode::from_int) E_SDmode))
3801 || TYPE_MODE (ty2)((((enum tree_code) ((tree_class_check ((ty2), (tcc_type), "generic-match.c"
, 3801, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty2) : (ty2)->type_common.mode)
== SDmode(scalar_float_mode ((scalar_float_mode::from_int) E_SDmode))
3802 || TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 3802, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
== SDmode(scalar_float_mode ((scalar_float_mode::from_int) E_SDmode)))
3803 newtype = dfloat32_type_nodeglobal_trees[TI_DFLOAT32_TYPE];
3804 if (TYPE_MODE (ty1)((((enum tree_code) ((tree_class_check ((ty1), (tcc_type), "generic-match.c"
, 3804, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty1) : (ty1)->type_common.mode)
== DDmode(scalar_float_mode ((scalar_float_mode::from_int) E_DDmode))
3805 || TYPE_MODE (ty2)((((enum tree_code) ((tree_class_check ((ty2), (tcc_type), "generic-match.c"
, 3805, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty2) : (ty2)->type_common.mode)
== DDmode(scalar_float_mode ((scalar_float_mode::from_int) E_DDmode))
3806 || TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 3806, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
== DDmode(scalar_float_mode ((scalar_float_mode::from_int) E_DDmode)))
3807 newtype = dfloat64_type_nodeglobal_trees[TI_DFLOAT64_TYPE];
3808 if (TYPE_MODE (ty1)((((enum tree_code) ((tree_class_check ((ty1), (tcc_type), "generic-match.c"
, 3808, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty1) : (ty1)->type_common.mode)
== TDmode(scalar_float_mode ((scalar_float_mode::from_int) E_TDmode))
3809 || TYPE_MODE (ty2)((((enum tree_code) ((tree_class_check ((ty2), (tcc_type), "generic-match.c"
, 3809, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty2) : (ty2)->type_common.mode)
== TDmode(scalar_float_mode ((scalar_float_mode::from_int) E_TDmode))
3810 || TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 3810, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
== TDmode(scalar_float_mode ((scalar_float_mode::from_int) E_TDmode)))
3811 newtype = dfloat128_type_nodeglobal_trees[TI_DFLOAT128_TYPE];
3812/* #line 5956 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3813 if ((newtype == dfloat32_type_nodeglobal_trees[TI_DFLOAT32_TYPE]
3814 || newtype == dfloat64_type_nodeglobal_trees[TI_DFLOAT64_TYPE]
3815 || newtype == dfloat128_type_nodeglobal_trees[TI_DFLOAT128_TYPE])
3816 && newtype == type
3817 && types_match (newtype, type)
3818)
3819 {
3820 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3820, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail141;
3821 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 3821, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail141;
3822 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail141;
3823 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5961, __FILE__"generic-match.c", __LINE__3823);
3824 {
3825 tree res_op0;
3826 {
3827 tree _o1[1], _r1;
3828 _o1[0] = captures[2];
3829 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3829, __FUNCTION__))->typed.type)
!= newtype)
3830 _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
3831 else
3832 _r1 = _o1[0];
3833 res_op0 = _r1;
3834 }
3835 tree res_op1;
3836 {
3837 tree _o1[1], _r1;
3838 _o1[0] = captures[4];
3839 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3839, __FUNCTION__))->typed.type)
!= newtype)
3840 _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
3841 else
3842 _r1 = _o1[0];
3843 res_op1 = _r1;
3844 }
3845 tree _r;
3846 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3847 return _r;
3848 }
3849next_after_fail141:;
3850 }
3851 else
3852 {
3853 {
3854/* #line 5962 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3855 if (TYPE_PRECISION (ty1)((tree_class_check ((ty1), (tcc_type), "generic-match.c", 3855
, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.c",
3855, __FUNCTION__))->type_common.precision)
)
3856 newtype = ty1;
3857 if (TYPE_PRECISION (ty2)((tree_class_check ((ty2), (tcc_type), "generic-match.c", 3857
, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.c",
3857, __FUNCTION__))->type_common.precision)
)
3858 newtype = ty2;
3859/* #line 5987 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3860 if (TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.c",
3860, __FUNCTION__))->type_common.precision)
< TYPE_PRECISION (itype)((tree_class_check ((itype), (tcc_type), "generic-match.c", 3860
, __FUNCTION__))->type_common.precision)
3861 && (flag_unsafe_math_optimizationsglobal_options.x_flag_unsafe_math_optimizations
3862 || (TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.c",
3862, __FUNCTION__))->type_common.precision)
== TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 3862
, __FUNCTION__))->type_common.precision)
3863 && real_can_shorten_arithmetic (TYPE_MODE (itype)((((enum tree_code) ((tree_class_check ((itype), (tcc_type), "generic-match.c"
, 3863, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(itype) : (itype)->type_common.mode)
,
3864 TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 3864, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
)
3865 && !excess_precision_type (newtype)))
3866 && !types_match (itype, newtype)
3867)
3868 {
3869 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3869, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail142;
3870 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 3870, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail142;
3871 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail142;
3872 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5994, __FILE__"generic-match.c", __LINE__3872);
3873 {
3874 tree res_op0;
3875 {
3876 tree _o1[2], _r1;
3877 {
3878 tree _o2[1], _r2;
3879 _o2[0] = captures[2];
3880 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3880, __FUNCTION__))->typed.type)
!= newtype)
3881 _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
3882 else
3883 _r2 = _o2[0];
3884 _o1[0] = _r2;
3885 }
3886 {
3887 tree _o2[1], _r2;
3888 _o2[0] = captures[4];
3889 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3889, __FUNCTION__))->typed.type)
!= newtype)
3890 _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
3891 else
3892 _r2 = _o2[0];
3893 _o1[1] = _r2;
3894 }
3895 _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3895, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3896 res_op0 = _r1;
3897 }
3898 tree _r;
3899 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3900 return _r;
3901 }
3902next_after_fail142:;
3903 }
3904 }
3905 }
3906 }
3907 }
3908 }
3909 }
3910 }
3911 return NULL_TREE(tree) nullptr;
3912}
3913
3914static tree
3915generic_simplify_54 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3916 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3917, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
3918{
3919 {
3920/* #line 3102 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3921 unsigned int prec = element_precision (type);
3922/* #line 3103 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3923 if (wi::ge_p (wi::to_wide (captures[1]), 0, TYPE_SIGN (TREE_TYPE (captures[1]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 3923, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.c", 3923, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
3924 && wi::lt_p (wi::to_wide (captures[1]), prec, TYPE_SIGN (TREE_TYPE (captures[1]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 3924, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.c", 3924, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
3925 && wi::ge_p (wi::to_wide (captures[2]), 0, TYPE_SIGN (TREE_TYPE (captures[2]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.c", 3925, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.c", 3925, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
3926 && wi::lt_p (wi::to_wide (captures[2]), prec, TYPE_SIGN (TREE_TYPE (captures[2]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.c", 3926, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.c", 3926, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
3927)
3928 {
3929 {
3930/* #line 3107 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3931 unsigned int low = (tree_to_uhwi (captures[1])
3932 + tree_to_uhwi (captures[2]));
3933/* #line 3111 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3934 if (low >= prec
3935)
3936 {
3937/* #line 3112 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3938 if (op == LROTATE_EXPR || op == RROTATE_EXPR
3939)
3940 {
3941 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3941, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail143;
3942 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3942, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail143;
3943 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail143;
3944 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3113, __FILE__"generic-match.c", __LINE__3944);
3945 {
3946 tree res_op0;
3947 res_op0 = captures[0];
3948 tree res_op1;
3949 res_op1 = build_int_cst (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3949, __FUNCTION__))->typed.type)
, low % prec);
3950 tree _r;
3951 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3952 return _r;
3953 }
3954next_after_fail143:;
3955 }
3956 else
3957 {
3958/* #line 3114 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3959 if (TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 3959
, __FUNCTION__))->base.u.bits.unsigned_flag)
|| op == LSHIFT_EXPR
3960)
3961 {
3962 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3962, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail144;
3963 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3963, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail144;
3964 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail144;
3965 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3115, __FILE__"generic-match.c", __LINE__3965);
3966 {
3967 tree _r;
3968 _r = build_zero_cst (type);
3969 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3969, __FUNCTION__
))->base.side_effects_flag)
)
3970 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3971 return _r;
3972 }
3973next_after_fail144:;
3974 }
3975 else
3976 {
3977 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3977, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail145;
3978 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3978, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail145;
3979 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail145;
3980 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3116, __FILE__"generic-match.c", __LINE__3980);
3981 {
3982 tree res_op0;
3983 res_op0 = captures[0];
3984 tree res_op1;
3985 res_op1 = build_int_cst (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3985, __FUNCTION__))->typed.type)
, prec - 1);
3986 tree _r;
3987 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3988 return _r;
3989 }
3990next_after_fail145:;
3991 }
3992 }
3993 }
3994 else
3995 {
3996 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3996, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail146;
3997 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3997, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail146;
3998 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail146;
3999 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3117, __FILE__"generic-match.c", __LINE__3999);
4000 {
4001 tree res_op0;
4002 res_op0 = captures[0];
4003 tree res_op1;
4004 res_op1 = build_int_cst (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4004, __FUNCTION__))->typed.type)
, low);
4005 tree _r;
4006 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
4007 return _r;
4008 }
4009next_after_fail146:;
4010 }
4011 }
4012 }
4013 }
4014 return NULL_TREE(tree) nullptr;
4015}
4016
4017static tree
4018generic_simplify_55 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4019 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4020, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (icmp)icmp __attribute__ ((__unused__)))
4021{
4022 {
4023/* #line 3134 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4024 int c1 = wi::clz (wi::to_wide (captures[0]));
4025 int c2 = wi::clz (wi::to_wide (captures[2]));
4026/* #line 3136 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4027 if (c1 < c2
4028)
4029 {
4030 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4030, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail147;
4031 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 4031, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail147;
4032 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4032, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail147;
4033 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail147;
4034 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3137, __FILE__"generic-match.c", __LINE__4034);
4035 {
4036 tree _r;
4037 _r = constant_boolean_node (cmp == NE_EXPR ? false : true, type);
4038 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4038, __FUNCTION__
))->base.side_effects_flag)
)
4039 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4040 return _r;
4041 }
4042next_after_fail147:;
4043 }
4044 else
4045 {
4046 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4046, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail148;
4047 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 4047, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail148;
4048 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4048, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail148;
4049 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail148;
4050 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3138, __FILE__"generic-match.c", __LINE__4050);
4051 {
4052 tree res_op0;
4053 res_op0 = captures[1];
4054 tree res_op1;
4055 res_op1 = build_int_cst (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4055, __FUNCTION__))->typed.type)
, c1 - c2);
4056 tree _r;
4057 _r = fold_build2_loc (loc, icmp, type, res_op0, res_op1);
4058 return _r;
4059 }
4060next_after_fail148:;
4061 }
4062 }
4063 return NULL_TREE(tree) nullptr;
4064}
4065
4066static tree
4067generic_simplify_56 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4068 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4069, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (out)out __attribute__ ((__unused__)))
4070{
4071/* #line 5153 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4072 if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4072, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4072, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4072, __FUNCTION__))->typed.type)), "generic-match.c", 4072
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
4073 && types_match (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 4073, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4073, __FUNCTION__))->typed.type)
)
4074 && tree_nop_conversion_p (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4074, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 4074, __FUNCTION__))->typed.type)
)
4075 && wi::to_wide (captures[4]) != 0
4076 && single_use (captures[1])
4077)
4078 {
4079 {
4080/* #line 5158 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4081 unsigned int prec = TYPE_PRECISION (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 4081, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4081, __FUNCTION__))->
type_common.precision)
;
4082 signop sign = TYPE_SIGN (TREE_TYPE (captures[3]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[3]), (TS_TYPED), "generic-match.c", 4082, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.c", 4082, __FUNCTION__
))->base.u.bits.unsigned_flag))
;
4083 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 4083, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail149;
4084 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail149;
4085 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5162, __FILE__"generic-match.c", __LINE__4085);
4086 {
4087 tree res_op0;
4088 res_op0 = captures[3];
4089 tree res_op1;
4090 res_op1 = wide_int_to_tree (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 4090, __FUNCTION__))->typed.type)
,
4091 wi::max_value (prec, sign)
4092 - wi::to_wide (captures[4]));
4093 tree _r;
4094 _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
4095 return _r;
4096 }
4097next_after_fail149:;
4098 }
4099 }
4100 return NULL_TREE(tree) nullptr;
4101}
4102
4103static tree
4104generic_simplify_57 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4105 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4106, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (scmp)scmp __attribute__ ((__unused__)))
4107{
4108/* #line 4621 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4109 if (FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4109, __FUNCTION__))->typed.
type))->base.code) == REAL_TYPE) || ((((enum tree_code) ((
(contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4109, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.c", 4109, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 4109, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 4109, __FUNCTION__
))->typed.type))->base.code) == REAL_TYPE)))
4110 || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4110, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4110, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 4110, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4110, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.c", 4110, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 4110, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 4110, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 4110, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 4110, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 4110, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 4110, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
4111 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4111, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4111, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4111, __FUNCTION__))->typed.type)), "generic-match.c", 4111
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
)
4112)
4113 {
4114 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail150;
4115 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4624, __FILE__"generic-match.c", __LINE__4115);
4116 {
4117 tree res_op0;
4118 res_op0 = captures[0];
4119 tree res_op1;
4120 res_op1 = captures[1];
4121 tree _r;
4122 _r = fold_build2_loc (loc, scmp, type, res_op0, res_op1);
4123 return _r;
4124 }
4125next_after_fail150:;
4126 }
4127 return NULL_TREE(tree) nullptr;
4128}
4129
4130static tree
4131generic_simplify_58 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4132 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4133)
4134{
4135/* #line 2295 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4136 if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 4136, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
4137)
4138 {
4139/* #line 2353 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4140 if ((!FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 4140, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
|| flag_associative_mathglobal_options.x_flag_associative_math)
4141 && !FIXED_POINT_TYPE_P (type)(((enum tree_code) (type)->base.code) == FIXED_POINT_TYPE)
4142)
4143 {
4144/* #line 2551 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4145 if (tree_nop_conversion_p (type, TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4145, __FUNCTION__))->typed.type)
)
4146)
4147 {
4148 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4148, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail151;
4149 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail151;
4150 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2552, __FILE__"generic-match.c", __LINE__4150);
4151 {
4152 tree res_op0;
4153 {
4154 tree _o1[1], _r1;
4155 _o1[0] = captures[0];
4156 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4156, __FUNCTION__))->typed.type)
!= type)
4157 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4158 else
4159 _r1 = _o1[0];
4160 res_op0 = _r1;
4161 }
4162 tree _r;
4163 _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
4164 return _r;
4165 }
4166next_after_fail151:;
4167 }
4168 }
4169 }
4170 return NULL_TREE(tree) nullptr;
4171}
4172
4173static tree
4174generic_simplify_59 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4175 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4176, const enum tree_code ARG_UNUSED (opo)opo __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (opi)opi __attribute__ ((__unused__)))
4177{
4178 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail152;
4179 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1329, __FILE__"generic-match.c", __LINE__4179);
4180 {
4181 tree res_op0;
4182 {
4183 tree _o1[1], _r1;
4184 _o1[0] = captures[1];
4185 _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4185, __FUNCTION__))->typed.type)
, _o1[0]);
4186 res_op0 = _r1;
4187 }
4188 tree res_op1;
4189 res_op1 = captures[2];
4190 tree _r;
4191 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
4192 return _r;
4193 }
4194next_after_fail152:;
4195 return NULL_TREE(tree) nullptr;
4196}
4197
4198static tree
4199generic_simplify_60 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4200 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4201, const enum tree_code ARG_UNUSED (sgncmp)sgncmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (ncmp)ncmp __attribute__ ((__unused__)))
4202{
4203/* #line 4775 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4204 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4204, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4204, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 4204, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4204, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.c", 4204, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 4204, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 4204, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 4204, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 4204, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 4204, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 4204, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
4205 && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4205, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4205, __FUNCTION__))->
base.u.bits.unsigned_flag)
4206 && types_match (captures[0], captures[2])
4207)
4208 {
4209 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4209, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail153;
4210 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail153;
4211 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4778, __FILE__"generic-match.c", __LINE__4211);
4212 {
4213 tree res_op0;
4214 {
4215 tree _o1[2], _r1;
4216 _o1[0] = captures[0];
4217 _o1[1] = captures[2];
4218 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4218, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
4219 res_op0 = _r1;
4220 }
4221 tree res_op1;
4222 res_op1 = captures[1];
4223 tree _r;
4224 _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
4225 return _r;
4226 }
4227next_after_fail153:;
4228 }
4229 return NULL_TREE(tree) nullptr;
4230}
4231
4232static tree
4233generic_simplify_61 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4234 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4235, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4236{
4237/* #line 1844 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4238 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4238, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4238, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 4238, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4238, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[1]
), (TS_TYPED), "generic-match.c", 4238, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 4238, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 4238, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 4238, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 4238, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 4238, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 4238, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
4239 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4239, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4239, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4239, __FUNCTION__))->typed.type)), "generic-match.c", 4239
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
4240)
4241 {
4242 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail154;
4243 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1846, __FILE__"generic-match.c", __LINE__4243);
4244 {
4245 tree res_op0;
4246 res_op0 = captures[2];
4247 tree res_op1;
4248 res_op1 = captures[1];
4249 tree _r;
4250 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
4251 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 4251, __FUNCTION__
))->base.side_effects_flag)
)
4252 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4253 return _r;
4254 }
4255next_after_fail154:;
4256 }
4257 return NULL_TREE(tree) nullptr;
4258}
4259
4260static tree
4261generic_simplify_62 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4262 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4263)
4264{
4265 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4265, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail155;
4266 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail155;
4267 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4568, __FILE__"generic-match.c", __LINE__4267);
4268 {
4269 tree _r;
4270 _r = captures[1];
4271 return _r;
4272 }
4273next_after_fail155:;
4274 return NULL_TREE(tree) nullptr;
4275}
4276
4277static tree
4278generic_simplify_63 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4279 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4280)
4281{
4282/* #line 2295 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4283 if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 4283, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
4284)
4285 {
4286/* #line 2353 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4287 if ((!FLOAT_TYPE_P (type)((((enum tree_code) (type)->base.code) == REAL_TYPE) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 4287, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
|| flag_associative_mathglobal_options.x_flag_associative_math)
4288 && !FIXED_POINT_TYPE_P (type)(((enum tree_code) (type)->base.code) == FIXED_POINT_TYPE)
4289)
4290 {
4291/* #line 2545 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4292 if (!TYPE_OVERFLOW_TRAPS (type)(!(any_integral_type_check ((type), "generic-match.c", 4292, __FUNCTION__
))->base.u.bits.unsigned_flag && global_options.x_flag_trapv
)
4293)
4294 {
4295 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail156;
4296 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2546, __FILE__"generic-match.c", __LINE__4296);
4297 {
4298 tree _r;
4299 _r = build_all_ones_cst (type);
4300 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 4300, __FUNCTION__
))->base.side_effects_flag)
)
4301 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4302 return _r;
4303 }
4304next_after_fail156:;
4305 }
4306 }
4307 }
4308 return NULL_TREE(tree) nullptr;
4309}
4310
4311static tree
4312generic_simplify_64 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4313 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4314, const enum tree_code ARG_UNUSED (test1)test1 __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (test2)test2 __attribute__ ((__unused__)))
4315{
4316/* #line 4584 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4317 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4317, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4317, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 4317, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4318 || VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4318, __FUNCTION__))->typed.
type))->base.code) == VECTOR_TYPE) && ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 4318, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 4318, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)
4319)
4320 {
4321 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail157;
4322 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4586, __FILE__"generic-match.c", __LINE__4322);
4323 {
4324 tree _r;
4325 _r = constant_boolean_node (false, type);
4326 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 4326, __FUNCTION__
))->base.side_effects_flag)
)
4327 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4328 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4328, __FUNCTION__
))->base.side_effects_flag)
)
4329 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4330 return _r;
4331 }
4332next_after_fail157:;
4333 }
4334 return NULL_TREE(tree) nullptr;
4335}
4336
4337static tree
4338generic_simplify_65 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4339 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4340, const combined_fn ARG_UNUSED (SIN)SIN __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (TAN)TAN __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (COS)COS __attribute__ ((__unused__)))
4341{
4342/* #line 5578 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4343 if (flag_unsafe_math_optimizationsglobal_options.x_flag_unsafe_math_optimizations && canonicalize_math_p ()
4344)
4345 {
4346/* #line 5613 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4347 if (! HONOR_NANS (captures[1])
4348 && ! HONOR_INFINITIES (captures[1])
4349)
4350 {
4351 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail158;
4352 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5615, __FILE__"generic-match.c", __LINE__4352);
4353 {
4354 tree res_op0;
4355 res_op0 = captures[1];
4356 tree _r;
4357 _r = maybe_build_call_expr_loc (loc, COS, type, 1, res_op0);
4358 if (!_r)
4359 goto next_after_fail158;
4360 return _r;
4361 }
4362next_after_fail158:;
4363 }
4364 }
4365 return NULL_TREE(tree) nullptr;
4366}
4367
4368static tree
4369generic_simplify_66 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4370 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4371, const enum tree_code ARG_UNUSED (eqne)eqne __attribute__ ((__unused__)))
4372{
4373/* #line 2115 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4374 if (eqne == EQ_EXPR
4375)
4376 {
4377 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 4377, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail159;
4378 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail159;
4379 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2116, __FILE__"generic-match.c", __LINE__4379);
4380 {
4381 tree _r;
4382 _r = constant_boolean_node (false, type);
4383 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4383, __FUNCTION__
))->base.side_effects_flag)
)
4384 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4385 return _r;
4386 }
4387next_after_fail159:;
4388 }
4389 else
4390 {
4391/* #line 2117 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4392 if (eqne == NE_EXPR
4393)
4394 {
4395 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 4395, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail160;
4396 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4396, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail160;
4397 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail160;
4398 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2118, __FILE__"generic-match.c", __LINE__4398);
4399 {
4400 tree _r;
4401 _r = captures[0];
4402 return _r;
4403 }
4404next_after_fail160:;
4405 }
4406 }
4407 return NULL_TREE(tree) nullptr;
4408}
4409
4410static tree
4411generic_simplify_67 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4412 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4413, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4414{
4415/* #line 1669 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4416 if (0
4417 || !TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4417, __FUNCTION__
))->base.side_effects_flag)
4418)
4419 {
4420 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail161;
4421 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1670, __FILE__"generic-match.c", __LINE__4421);
4422 {
4423 tree res_op0;
4424 {
4425 tree _o1[2], _r1;
4426 _o1[0] = captures[0];
4427 _o1[1] = captures[1];
4428 _r1 = fold_build2_loc (loc, cmp, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], _o1[0], _o1[1]);
4429 res_op0 = _r1;
4430 }
4431 tree res_op1;
4432 res_op1 = captures[2];
4433 tree res_op2;
4434 res_op2 = build_zero_cst (type);
4435 tree _r;
4436 _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
4437 return _r;
4438 }
4439next_after_fail161:;
4440 }
4441 return NULL_TREE(tree) nullptr;
4442}
4443
4444static tree
4445generic_simplify_68 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4446 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4447)
4448{
4449 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail162;
4450 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1355, __FILE__"generic-match.c", __LINE__4450);
4451 {
4452 tree res_op0;
4453 res_op0 = captures[0];
4454 tree _r;
4455 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4456 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4456, __FUNCTION__
))->base.side_effects_flag)
)
4457 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4458 return _r;
4459 }
4460next_after_fail162:;
4461 return NULL_TREE(tree) nullptr;
4462}
4463
4464static tree
4465generic_simplify_69 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4466 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4467)
4468{
4469 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail163;
4470 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1251, __FILE__"generic-match.c", __LINE__4470);
4471 {
4472 tree res_op0;
4473 res_op0 = captures[0];
4474 tree res_op1;
4475 res_op1 = captures[1];
4476 tree _r;
4477 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
4478 return _r;
4479 }
4480next_after_fail163:;
4481 return NULL_TREE(tree) nullptr;
4482}
4483
4484static tree
4485generic_simplify_70 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4486 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4487)
4488{
4489/* #line 2295 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4490 if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 4490, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
4491)
4492 {
4493/* #line 2315 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4494 if (tree_nop_conversion_p (type, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4494, __FUNCTION__))->typed.type)
)
4495 && !TYPE_OVERFLOW_SANITIZED (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) &&
!((((enum tree_code) (type)->base.code) == POINTER_TYPE ||
((enum tree_code) (type)->base.code) == REFERENCE_TYPE) ?
global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((type), "generic-match.c", 4495, __FUNCTION__))->base.u.
bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
4496)
4497 {
4498 {
4499/* #line 2317 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4500 tree t1 = type;
4501 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)
4502 && TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.c"
, 4502, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
!= TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4502, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4502, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? global_options.x_flag_wrapv_pointer : ((any_integral_type_check
((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4502, __FUNCTION__))->typed.type)), "generic-match.c", 4502
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
)
4503 t1 = TYPE_OVERFLOW_WRAPS (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((type), "generic-match.c"
, 4503, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
? type : TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4503, __FUNCTION__))->typed.type)
;
4504 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail164;
4505 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2324, __FILE__"generic-match.c", __LINE__4505);
4506 {
4507 tree res_op0;
4508 {
4509 tree _o1[2], _r1;
4510 {
4511 tree _o2[1], _r2;
4512 _o2[0] = captures[0];
4513 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 4513, __FUNCTION__))->typed.type)
!= t1)
4514 _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
4515 else
4516 _r2 = _o2[0];
4517 _o1[0] = _r2;
4518 }
4519 {
4520 tree _o2[1], _r2;
4521 _o2[0] = captures[1];
4522 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 4522, __FUNCTION__))->typed.type)
!= t1)
4523 _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
4524 else
4525 _r2 = _o2[0];
4526 _o1[1] = _r2;
4527 }
4528 _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4528, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
4529 res_op0 = _r1;
4530 }
4531 tree _r;
4532 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4533 return _r;
4534 }
4535next_after_fail164:;
4536 }
4537 }
4538 }
4539 return NULL_TREE(tree) nullptr;
4540}
4541
4542static tree
4543generic_simplify_71 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4544 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4545, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (out)out __attribute__ ((__unused__)))
4546{
4547/* #line 5209 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4548 if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 4548, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4548, __FUNCTION__))->
base.u.bits.unsigned_flag)
&& !VECTOR_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 4548, __FUNCTION__))->typed.
type))->base.code) == VECTOR_TYPE)
4549)
4550 {
4551 {
4552/* #line 5210 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4553 tree t = TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4553, __FUNCTION__))->typed.type)
, cpx = build_complex_type (t);
4554 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 4554, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail165;
4555 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail165;
4556 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5211, __FILE__"generic-match.c", __LINE__4556);
4557 {
4558 tree res_op0;
4559 {
4560 tree _o1[1], _r1;
4561 {
4562 tree _o2[2], _r2;
4563 _o2[0] = captures[2];
4564 _o2[1] = captures[1];
4565 {
4566 _r2 = maybe_build_call_expr_loc (loc, CFN_MUL_OVERFLOW, cpx, 2, _o2[0], _o2[1]);
4567 if (!_r2)
4568 goto next_after_fail165;
4569 }
4570 _o1[0] = _r2;
4571 }
4572 _r1 = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0]))((contains_struct_check ((((contains_struct_check ((_o1[0]), (
TS_TYPED), "generic-match.c", 4572, __FUNCTION__))->typed.
type)), (TS_TYPED), "generic-match.c", 4572, __FUNCTION__))->
typed.type)
, _o1[0]);
4573 res_op0 = _r1;
4574 }
4575 tree res_op1;
4576 res_op1 = build_zero_cst (t);
4577 tree _r;
4578 _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
4579 return _r;
4580 }
4581next_after_fail165:;
4582 }
4583 }
4584 return NULL_TREE(tree) nullptr;
4585}
4586
4587static tree
4588generic_simplify_72 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4589 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4590, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4591{
4592 {
4593/* #line 4855 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4594 poly_int64 off0, off1;
4595 tree base0 = get_addr_base_and_unit_offset (TREE_OPERAND (captures[1], 0)(*((const_cast<tree*> (tree_operand_check ((captures[1]
), (0), "generic-match.c", 4595, __FUNCTION__)))))
, &off0);
4596 tree base1 = get_addr_base_and_unit_offset (TREE_OPERAND (captures[2], 0)(*((const_cast<tree*> (tree_operand_check ((captures[2]
), (0), "generic-match.c", 4596, __FUNCTION__)))))
, &off1);
4597 if (base0 && TREE_CODE (base0)((enum tree_code) (base0)->base.code) == MEM_REF)
4598 {
4599 off0 += mem_ref_offset (base0).force_shwi ();
4600 base0 = TREE_OPERAND (base0, 0)(*((const_cast<tree*> (tree_operand_check ((base0), (0)
, "generic-match.c", 4600, __FUNCTION__)))))
;
4601 }
4602 if (base1 && TREE_CODE (base1)((enum tree_code) (base1)->base.code) == MEM_REF)
4603 {
4604 off1 += mem_ref_offset (base1).force_shwi ();
4605 base1 = TREE_OPERAND (base1, 0)(*((const_cast<tree*> (tree_operand_check ((base1), (0)
, "generic-match.c", 4605, __FUNCTION__)))))
;
4606 }
4607/* #line 4871 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4608 if (base0 && base1
4609)
4610 {
4611 {
4612/* #line 4872 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4613 int equal = 2;
4614 if (
46151
4616 && ((VAR_P (base0)(((enum tree_code) (base0)->base.code) == VAR_DECL) && DECL_HAS_VALUE_EXPR_P (base0)((tree_check3 ((base0), "generic-match.c", 4616, __FUNCTION__
, (VAR_DECL), (PARM_DECL), (RESULT_DECL))) ->decl_common.decl_flag_2
)
)
4617 || (VAR_P (base1)(((enum tree_code) (base1)->base.code) == VAR_DECL) && DECL_HAS_VALUE_EXPR_P (base1)((tree_check3 ((base1), "generic-match.c", 4617, __FUNCTION__
, (VAR_DECL), (PARM_DECL), (RESULT_DECL))) ->decl_common.decl_flag_2
)
)))
4618 ;
4619 else if (decl_in_symtab_p (base0)
4620 && decl_in_symtab_p (base1))
4621 equal = symtab_node::get_create (base0)
4622 ->equal_address_to (symtab_node::get_create (base1));
4623 else if ((DECL_P (base0)(tree_code_type[(int) (((enum tree_code) (base0)->base.code
))] == tcc_declaration)
4624 || TREE_CODE (base0)((enum tree_code) (base0)->base.code) == SSA_NAME
4625 || TREE_CODE (base0)((enum tree_code) (base0)->base.code) == STRING_CST)
4626 && (DECL_P (base1)(tree_code_type[(int) (((enum tree_code) (base1)->base.code
))] == tcc_declaration)
4627 || TREE_CODE (base1)((enum tree_code) (base1)->base.code) == SSA_NAME
4628 || TREE_CODE (base1)((enum tree_code) (base1)->base.code) == STRING_CST))
4629 equal = (base0 == base1);
4630 if (equal == 0)
4631 {
4632 HOST_WIDE_INTlong ioff0 = -1, ioff1 = -1;
4633 off0.is_constant (&ioff0);
4634 off1.is_constant (&ioff1);
4635 if ((DECL_P (base0)(tree_code_type[(int) (((enum tree_code) (base0)->base.code
))] == tcc_declaration)
&& TREE_CODE (base1)((enum tree_code) (base1)->base.code) == STRING_CST)
4636 || (TREE_CODE (base0)((enum tree_code) (base0)->base.code) == STRING_CST && DECL_P (base1)(tree_code_type[(int) (((enum tree_code) (base1)->base.code
))] == tcc_declaration)
)
4637 || (TREE_CODE (base0)((enum tree_code) (base0)->base.code) == STRING_CST
4638 && TREE_CODE (base1)((enum tree_code) (base1)->base.code) == STRING_CST
4639 && ioff0 >= 0 && ioff1 >= 0
4640 && ioff0 < TREE_STRING_LENGTH (base0)((tree_check ((base0), "generic-match.c", 4640, __FUNCTION__,
(STRING_CST)))->string.length)
4641 && ioff1 < TREE_STRING_LENGTH (base1)((tree_check ((base1), "generic-match.c", 4641, __FUNCTION__,
(STRING_CST)))->string.length)
4642 && strncmp (TREE_STRING_POINTER (base0)((const char *)((tree_check ((base0), "generic-match.c", 4642
, __FUNCTION__, (STRING_CST)))->string.str))
+ ioff0,
4643 TREE_STRING_POINTER (base1)((const char *)((tree_check ((base1), "generic-match.c", 4643
, __FUNCTION__, (STRING_CST)))->string.str))
+ ioff1,
4644 MIN (TREE_STRING_LENGTH (base0) - ioff0,((((tree_check ((base0), "generic-match.c", 4644, __FUNCTION__
, (STRING_CST)))->string.length) - ioff0) < (((tree_check
((base1), "generic-match.c", 4645, __FUNCTION__, (STRING_CST
)))->string.length) - ioff1) ? (((tree_check ((base0), "generic-match.c"
, 4644, __FUNCTION__, (STRING_CST)))->string.length) - ioff0
) : (((tree_check ((base1), "generic-match.c", 4645, __FUNCTION__
, (STRING_CST)))->string.length) - ioff1))
4645 TREE_STRING_LENGTH (base1) - ioff1)((((tree_check ((base0), "generic-match.c", 4644, __FUNCTION__
, (STRING_CST)))->string.length) - ioff0) < (((tree_check
((base1), "generic-match.c", 4645, __FUNCTION__, (STRING_CST
)))->string.length) - ioff1) ? (((tree_check ((base0), "generic-match.c"
, 4644, __FUNCTION__, (STRING_CST)))->string.length) - ioff0
) : (((tree_check ((base1), "generic-match.c", 4645, __FUNCTION__
, (STRING_CST)))->string.length) - ioff1))
) != 0))
4646 ;
4647 else if (!DECL_P (base0)(tree_code_type[(int) (((enum tree_code) (base0)->base.code
))] == tcc_declaration)
|| !DECL_P (base1)(tree_code_type[(int) (((enum tree_code) (base1)->base.code
))] == tcc_declaration)
)
4648 equal = 2;
4649 else if (cmp != EQ_EXPR && cmp != NE_EXPR)
4650 equal = 2;
4651 else if (!INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4651, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4651, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 4651, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
)
4652 ;
4653 else if (is_global_var (base0) != is_global_var (base1))
4654 ;
4655 else
4656 {
4657 tree sz0 = DECL_SIZE_UNIT (base0)((contains_struct_check ((base0), (TS_DECL_COMMON), "generic-match.c"
, 4657, __FUNCTION__))->decl_common.size_unit)
;
4658 tree sz1 = DECL_SIZE_UNIT (base1)((contains_struct_check ((base1), (TS_DECL_COMMON), "generic-match.c"
, 4658, __FUNCTION__))->decl_common.size_unit)
;
4659 if (!tree_fits_poly_int64_p (sz0)
4660 || !tree_fits_poly_int64_p (sz1))
4661 equal = 2;
4662 else
4663 {
4664 poly_int64 size0 = tree_to_poly_int64 (sz0);
4665 poly_int64 size1 = tree_to_poly_int64 (sz1);
4666 if (maybe_eq (off0, 0) && maybe_eq (off1, size1))
4667 equal = 2;
4668 else if (maybe_eq (off1, 0) && maybe_eq (off0, size0))
4669 equal = 2;
4670 if (equal == 2
4671 && known_eq (off0, off1)(!maybe_ne (off0, off1))
4672 && (known_ne (off0, 0)(!maybe_eq (off0, 0))
4673 || (known_ne (size0, 0)(!maybe_eq (size0, 0)) && known_ne (size1, 0)(!maybe_eq (size1, 0)))))
4674 equal = 0;
4675 }
4676 }
4677 }
4678/* #line 4957 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4679 if (equal == 1
4680 && (cmp == EQ_EXPR || cmp == NE_EXPR
4681 || known_eq (off0, off1)(!maybe_ne (off0, off1))
4682 || TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4682, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4682, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4682, __FUNCTION__))->typed.type)), "generic-match.c", 4682
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
4683 || (POINTER_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4683, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4683, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
4684 && (DECL_P (base0)(tree_code_type[(int) (((enum tree_code) (base0)->base.code
))] == tcc_declaration)
|| TREE_CODE (base0)((enum tree_code) (base0)->base.code) == STRING_CST)))
4685)
4686 {
4687/* #line 4966 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4688 if (cmp == EQ_EXPR && (known_eq (off0, off1)(!maybe_ne (off0, off1)) || known_ne (off0, off1)(!maybe_eq (off0, off1)))
4689)
4690 {
4691 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4691, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail166;
4692 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4692, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail166;
4693 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail166;
4694 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4967, __FILE__"generic-match.c", __LINE__4694);
4695 {
4696 tree _r;
4697 _r = constant_boolean_node (known_eq (off0, off1)(!maybe_ne (off0, off1)), type);
4698 return _r;
4699 }
4700next_after_fail166:;
4701 }
4702 else
4703 {
4704/* #line 4968 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4705 if (cmp == NE_EXPR && (known_eq (off0, off1)(!maybe_ne (off0, off1)) || known_ne (off0, off1)(!maybe_eq (off0, off1)))
4706)
4707 {
4708 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4708, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail167;
4709 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4709, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail167;
4710 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail167;
4711 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4969, __FILE__"generic-match.c", __LINE__4711);
4712 {
4713 tree _r;
4714 _r = constant_boolean_node (known_ne (off0, off1)(!maybe_eq (off0, off1)), type);
4715 return _r;
4716 }
4717next_after_fail167:;
4718 }
4719 else
4720 {
4721/* #line 4970 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4722 if (cmp == LT_EXPR && (known_lt (off0, off1)(!maybe_le (off1, off0)) || known_ge (off0, off1)(!maybe_lt (off0, off1)))
4723)
4724 {
4725 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4725, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail168;
4726 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4726, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail168;
4727 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail168;
4728 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4971, __FILE__"generic-match.c", __LINE__4728);
4729 {
4730 tree _r;
4731 _r = constant_boolean_node (known_lt (off0, off1)(!maybe_le (off1, off0)), type);
4732 return _r;
4733 }
4734next_after_fail168:;
4735 }
4736 else
4737 {
4738/* #line 4972 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4739 if (cmp == LE_EXPR && (known_le (off0, off1)(!maybe_lt (off1, off0)) || known_gt (off0, off1)(!maybe_le (off0, off1)))
4740)
4741 {
4742 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4742, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail169;
4743 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4743, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail169;
4744 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail169;
4745 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4973, __FILE__"generic-match.c", __LINE__4745);
4746 {
4747 tree _r;
4748 _r = constant_boolean_node (known_le (off0, off1)(!maybe_lt (off1, off0)), type);
4749 return _r;
4750 }
4751next_after_fail169:;
4752 }
4753 else
4754 {
4755/* #line 4974 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4756 if (cmp == GE_EXPR && (known_ge (off0, off1)(!maybe_lt (off0, off1)) || known_lt (off0, off1)(!maybe_le (off1, off0)))
4757)
4758 {
4759 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4759, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail170;
4760 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4760, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail170;
4761 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail170;
4762 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4975, __FILE__"generic-match.c", __LINE__4762);
4763 {
4764 tree _r;
4765 _r = constant_boolean_node (known_ge (off0, off1)(!maybe_lt (off0, off1)), type);
4766 return _r;
4767 }
4768next_after_fail170:;
4769 }
4770 else
4771 {
4772/* #line 4976 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4773 if (cmp == GT_EXPR && (known_gt (off0, off1)(!maybe_le (off0, off1)) || known_le (off0, off1)(!maybe_lt (off1, off0)))
4774)
4775 {
4776 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4776, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail171;
4777 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4777, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail171;
4778 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail171;
4779 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4977, __FILE__"generic-match.c", __LINE__4779);
4780 {
4781 tree _r;
4782 _r = constant_boolean_node (known_gt (off0, off1)(!maybe_le (off0, off1)), type);
4783 return _r;
4784 }
4785next_after_fail171:;
4786 }
4787 }
4788 }
4789 }
4790 }
4791 }
4792 }
4793 else
4794 {
4795/* #line 4978 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4796 if (equal == 0
4797)
4798 {
4799/* #line 4980 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4800 if (cmp == EQ_EXPR
4801)
4802 {
4803 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4803, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail172;
4804 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4804, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail172;
4805 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail172;
4806 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4981, __FILE__"generic-match.c", __LINE__4806);
4807 {
4808 tree _r;
4809 _r = constant_boolean_node (false, type);
4810 return _r;
4811 }
4812next_after_fail172:;
4813 }
4814 else
4815 {
4816/* #line 4982 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4817 if (cmp == NE_EXPR
4818)
4819 {
4820 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4820, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail173;
4821 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4821, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail173;
4822 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail173;
4823 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4983, __FILE__"generic-match.c", __LINE__4823);
4824 {
4825 tree _r;
4826 _r = constant_boolean_node (true, type);
4827 return _r;
4828 }
4829next_after_fail173:;
4830 }
4831 }
4832 }
4833 }
4834 }
4835 }
4836 }
4837 return NULL_TREE(tree) nullptr;
4838}
4839
4840static tree
4841generic_simplify_73 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4842 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4843, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4844{
4845 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4845, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail174;
4846 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail174;
4847 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 309, __FILE__"generic-match.c", __LINE__4847);
4848 {
4849 tree res_op0;
4850 res_op0 = captures[0];
4851 tree _r;
4852 _r = non_lvalue_loc (loc, res_op0);
4853 return _r;
4854 }
4855next_after_fail174:;
4856 return NULL_TREE(tree) nullptr;
4857}
4858
4859static tree
4860generic_simplify_74 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4861 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
4862, const enum tree_code ARG_UNUSED (rotate)rotate __attribute__ ((__unused__)))
4863{
4864/* #line 3278 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4865 if ((element_precision (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4865, __FUNCTION__))->typed.type)
)
4866 <= element_precision (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 4866, __FUNCTION__))->typed.type)
)
4867 || !TYPE_UNSIGNED (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 4867, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4867, __FUNCTION__))->
base.u.bits.unsigned_flag)
)
4868 && (element_precision (type) <= element_precision (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4868, __FUNCTION__))->typed.type)
)
4869 || !TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 4869, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4869, __FUNCTION__))->
base.u.bits.unsigned_flag)
)
4870)
4871 {
4872 {
4873/* #line 3283 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4874 tree rotate_type = TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4874, __FUNCTION__))->typed.type)
;
4875 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail175;
4876 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3285, __FILE__"generic-match.c", __LINE__4876);
4877 {
4878 tree res_op0;
4879 {
4880 tree _o1[2], _r1;
4881 {
4882 tree _o2[1], _r2;
4883 _o2[0] = captures[3];
4884 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 4884, __FUNCTION__))->typed.type)
!= rotate_type)
4885 _r2 = fold_build1_loc (loc, NOP_EXPR, rotate_type, _o2[0]);
4886 else
4887 _r2 = _o2[0];
4888 _o1[0] = _r2;
4889 }
4890 _o1[1] = captures[4];
4891 _r1 = fold_build2_loc (loc, rotate, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4891, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
4892 res_op0 = _r1;
4893 }
4894 tree _r;
4895 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4896 return _r;
4897 }
4898next_after_fail175:;
4899 }
4900 }
4901 return NULL_TREE(tree) nullptr;
4902}
4903
4904static tree
4905generic_simplify_75 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4906 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4907, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (acmp)acmp __attribute__ ((__unused__)))
4908{
4909 {
4910/* #line 3963 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4911 tree cst = uniform_integer_cst_p (captures[1]);
4912/* #line 3964 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4913 if (tree_int_cst_sgn (cst) == 1
4914)
4915 {
4916 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail176;
4917 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3965, __FILE__"generic-match.c", __LINE__4917);
4918 {
4919 tree res_op0;
4920 res_op0 = captures[0];
4921 tree res_op1;
4922 res_op1 = build_uniform_cst (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4922, __FUNCTION__))->typed.type)
,
4923 wide_int_to_tree (TREE_TYPE (cst)((contains_struct_check ((cst), (TS_TYPED), "generic-match.c"
, 4923, __FUNCTION__))->typed.type)
,
4924 wi::to_wide (cst) - 1));
4925 tree _r;
4926 _r = fold_build2_loc (loc, acmp, type, res_op0, res_op1);
4927 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4927, __FUNCTION__
))->base.side_effects_flag)
)
4928 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4929 return _r;
4930 }
4931next_after_fail176:;
4932 }
4933 }
4934 return NULL_TREE(tree) nullptr;
4935}
4936
4937static tree
4938generic_simplify_76 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4939 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4940, const enum tree_code ARG_UNUSED (mod)mod __attribute__ ((__unused__)))
4941{
4942/* #line 570 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4943 if (ANY_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) || ((
((enum tree_code) (type)->base.code) == COMPLEX_TYPE || ((
(enum tree_code) (type)->base.code) == VECTOR_TYPE)) &&
(((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 4943, __FUNCTION__))->typed.type))->
base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 4943, __FUNCTION__))
->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "generic-match.c"
, 4943, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
4944 && TYPE_OVERFLOW_UNDEFINED (type)((((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE) ? !
global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((type), "generic-match.c", 4944, __FUNCTION__))->base.u.
bits.unsigned_flag && !global_options.x_flag_wrapv &&
!global_options.x_flag_trapv))
4945 && wi::multiple_of_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
4946 TYPE_SIGN (type)((signop) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 4946, __FUNCTION__))->base.u.bits.unsigned_flag))
)
4947)
4948 {
4949 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail177;
4950 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 574, __FILE__"generic-match.c", __LINE__4950);
4951 {
4952 tree _r;
4953 _r = build_zero_cst (type);
4954 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 4954, __FUNCTION__
))->base.side_effects_flag)
)
4955 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4956 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4956, __FUNCTION__
))->base.side_effects_flag)
)
4957 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4958 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4958, __FUNCTION__
))->base.side_effects_flag)
)
4959 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4960 return _r;
4961 }
4962next_after_fail177:;
4963 }
4964 return NULL_TREE(tree) nullptr;
4965}
4966
4967static tree
4968generic_simplify_77 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4969 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4970, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (ffs)ffs __attribute__ ((__unused__)))
4971{
4972 {
4973/* #line 6464 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4974 int prec = TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4974, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4974, __FUNCTION__))->
type_common.precision)
;
4975/* #line 6466 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4976 if (integer_zerop (captures[2])
4977)
4978 {
4979 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail178;
4980 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6467, __FILE__"generic-match.c", __LINE__4980);
4981 {
4982 tree res_op0;
4983 res_op0 = captures[1];
4984 tree res_op1;
4985 res_op1 = build_zero_cst (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4985, __FUNCTION__))->typed.type)
);
4986 tree _r;
4987 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4988 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4988, __FUNCTION__
))->base.side_effects_flag)
)
4989 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
4990 return _r;
4991 }
4992next_after_fail178:;
4993 }
4994 else
4995 {
4996/* #line 6468 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4997 if (tree_int_cst_sgn (captures[2]) < 0 || wi::to_widest (captures[2]) > prec
4998)
4999 {
5000 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail179;
5001 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6469, __FILE__"generic-match.c", __LINE__5001);
5002 {
5003 tree _r;
5004 _r = constant_boolean_node (cmp == NE_EXPR ? true : false, type);
5005 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 5005, __FUNCTION__
))->base.side_effects_flag)
)
5006 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5007 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 5007, __FUNCTION__
))->base.side_effects_flag)
)
5008 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
5009 return _r;
5010 }
5011next_after_fail179:;
5012 }
5013 else
5014 {
5015/* #line 6470 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5016 if (single_use (captures[0])
5017)
5018 {
5019 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 5019, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail180;
5020 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail180;
5021 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6471, __FILE__"generic-match.c", __LINE__5021);
5022 {
5023 tree res_op0;
5024 {
5025 tree _o1[2], _r1;
5026 _o1[0] = captures[1];
5027 _o1[1] = wide_int_to_tree (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 5027, __FUNCTION__))->typed.type)
,
5028 wi::mask (tree_to_uhwi (captures[2]),
5029 false, prec));
5030 _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 5030, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
5031 res_op0 = _r1;
5032 }
5033 tree res_op1;
5034 res_op1 = wide_int_to_tree (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 5034, __FUNCTION__))->typed.type)
,
5035 wi::shifted_mask (tree_to_uhwi (captures[2]) - 1, 1,
5036 false, prec));
5037 tree _r;
5038 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
5039 return _r;
5040 }
5041next_after_fail180:;
5042 }
5043 }
5044 }
5045 }
5046 return NULL_TREE(tree) nullptr;
5047}
5048
5049static tree
5050generic_simplify_78 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
5051 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
5052, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
5053{
5054/* #line 1032 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5055 if (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 5055, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 5055, __FUNCTION__))->
base.u.bits.unsigned_flag)
5056)
5057 {
5058 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail181;
5059 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1033, __FILE__"generic-match.c", __LINE__5059);
5060 {
5061 tree _r;
5062 _r = constant_boolean_node (cmp == GT_EXPR, type);
5063 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 5063, __FUNCTION__
))->base.side_effects_flag)
)
5064 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
5065 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 5065, __FUNCTION__
))->base.side_effects_flag)
)
5066 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5067 return _r;
5068 }
5069next_after_fail181:;
5070 }
5071 return NULL_TREE(tree) nullptr;
5072}
5073
5074static tree
5075generic_simplify_79 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
5076 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
5077, const enum tree_code ARG_UNUSED (shiftrotate)shiftrotate __attribute__ ((__unused__)))
5078{
5079 {
5080/* #line 3071 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5081 tree tem = uniform_vector_p (captures[1]);
5082/* #line 3072 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5083 if (tem
5084)
5085 {
5086 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail182;
5087 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3073, __FILE__"generic-match.c", __LINE__5087);
5088 {
5089 tree res_op0;
5090 res_op0 = captures[0];
5091 tree res_op1;
5092 res_op1 = tem;
5093 tree _r;
5094 _r = fold_build2_loc (loc, shiftrotate, type, res_op0, res_op1);
5095 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 5095, __FUNCTION__
))->base.side_effects_flag)
)
5096 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5097 return _r;
5098 }
5099next_after_fail182:;
5100 }
5101 }
5102 return NULL_TREE(tree) nullptr;
5103}
5104
5105static tree
5106generic_simplify_80 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
5107 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
5108, const enum tree_code ARG_UNUSED (div)div __attribute__ ((__unused__)))
5109{
5110/* #line 363 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5111 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)
&& ssa_name_has_boolean_range (captures[1])
5112)
5113 {
5114 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail183;
5115 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 364, __FILE__"generic-match.c", __LINE__5115);
5116 {
5117 tree _r;
5118 _r = captures[0];
5119 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 5119, __FUNCTION__
))->base.side_effects_flag)
)
5120 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
5121 return _r;
5122 }
5123next_after_fail183:;
5124 }
5125 return NULL_TREE(tree) nullptr;
5126}
5127
5128static tree
5129generic_simplify_81 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
5130 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
5131, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
5132{
5133/* #line 1880 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5134 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 5134, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 5134, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 5134, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 5134, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[2]
), (TS_TYPED), "generic-match.c", 5134, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.c", 5134, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 5134, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[2]), (TS_TYPED), "generic-match.c", 5134, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 5134, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.c", 5134, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 5134, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
5135 && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 5135, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 5135, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) ? !global_options.x_flag_wrapv_pointer : (!(any_integral_type_check
((((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 5135, __FUNCTION__))->typed.type)), "generic-match.c", 5135
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
5136 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 5136, __FUNCTION