Bug Summary

File:objdir/gcc/generic-match.c
Warning:line 667, 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 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/13.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../include/c++/11/backward -internal-isystem /usr/lib64/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/11/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -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 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-11-20-133755-20252-1/report-WItxAZ.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 147 "/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 147 "/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", 145, __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 150 "/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 150 "/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", 148, __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 654 "/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", 654, __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 656 "/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", 656, __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 1512 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
122/* #line 1512 "/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", 1511, __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 1517 "/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", 1517, __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 1520 "/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 1520 "/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", 1519, __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 1523 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
173/* #line 1523 "/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", 1522, __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 1528 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
190/* #line 1528 "/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", 1527, __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 1531 "/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 1531 "/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", 1530, __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 1702 "/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 1702 "/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", 1701, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1705 "/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", 1705, __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 1707 "/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", 1707, __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 1709 "/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", 1709, __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 1711 "/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", 1711, __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 1713 "/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", 1713, __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 1715 "/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", 1715, __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 1717 "/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", 1717, __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)
;
Value stored to 'type' during its initialization is never read
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 2056 "/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", 2056, __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 2059 "/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 2059 "/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", 2058, __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 2063 "/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", 2063, __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 2063 "/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", 2063, __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 2061 "/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", 2061, __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 2068 "/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", 2068, __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 2070 "/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", 2070, __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 2231 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
825/* #line 2231 "/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", 2230, __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 2236 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
855/* #line 2236 "/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", 2235, __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 3838 "/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", 3838, __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 3838 "/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", 3838, __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 6267 "/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 6267 "/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", 6266, __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 6288 "/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 6288 "/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", 6287, __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)
;
973 if (TREE_SIDE_EFFECTS (t)((non_type_check ((t), "generic-match.c", 973, __FUNCTION__))
->base.side_effects_flag)
) return false;
974 {
975/* #line 7560 "/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 7560 "/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", 7559, __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 7563 "/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", 7563, __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 7574 "/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", 7574, __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 7574 "/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", 7574, __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)
1131{
1132 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail54;
1133 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6493, __FILE__"generic-match.c", __LINE__1133);
1134 {
1135 tree _r;
1136 _r = captures[0];
1137 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1137, __FUNCTION__
))->base.side_effects_flag)
)
1138 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1139 return _r;
1140 }
1141next_after_fail54:;
1142 return NULL_TREE(tree) nullptr;
1143}
1144
1145static tree
1146generic_simplify_2 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1147 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1148)
1149{
1150/* #line 853 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1151 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", 1151, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
1152 && tree_nop_conversion_p (type, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1152, __FUNCTION__))->typed.type)
)
1153)
1154 {
1155 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail55;
1156 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 855, __FILE__"generic-match.c", __LINE__1156);
1157 {
1158 tree res_op0;
1159 res_op0 = captures[0];
1160 tree res_op1;
1161 res_op1 = captures[2];
1162 tree _r;
1163 _r = fold_build2_loc (loc, LSHIFT_EXPR, type, res_op0, res_op1);
1164 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1164, __FUNCTION__
))->base.side_effects_flag)
)
1165 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1166 return _r;
1167 }
1168next_after_fail55:;
1169 }
1170 return NULL_TREE(tree) nullptr;
1171}
1172
1173static tree
1174generic_simplify_3 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1175 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
1176, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
1177{
1178/* #line 6525 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1179 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)
1180 && op != MULT_EXPR
1181 && op != RDIV_EXPR
1182 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1182, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1182, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 1182, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1183 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 1183, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1183, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 1183, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1184 && type_has_mode_precision_p (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1184, __FUNCTION__))->typed.type)
)
1185 && type_has_mode_precision_p (TREE_TYPE (captures[4])((contains_struct_check ((captures[4]), (TS_TYPED), "generic-match.c"
, 1185, __FUNCTION__))->typed.type)
)
1186 && type_has_mode_precision_p (type)
1187 && TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 1187, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1187, __FUNCTION__))->
type_common.precision)
> TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1187, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1187, __FUNCTION__))->
type_common.precision)
1188 && types_match (captures[2], type)
1189 && (types_match (captures[2], captures[4])
1190 || poly_int_tree_p (captures[3]))
1191)
1192 {
1193/* #line 6545 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1194 if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1194, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1194, __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"
, 1194, __FUNCTION__))->typed.type)), "generic-match.c", 1194
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
1195)
1196 {
1197 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail56;
1198 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6546, __FILE__"generic-match.c", __LINE__1198);
1199 {
1200 tree res_op0;
1201 res_op0 = captures[2];
1202 tree res_op1;
1203 {
1204 tree _o1[1], _r1;
1205 _o1[0] = captures[4];
1206 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1206, __FUNCTION__))->typed.type)
!= type)
1207 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1208 else
1209 _r1 = _o1[0];
1210 res_op1 = _r1;
1211 }
1212 tree _r;
1213 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1214 return _r;
1215 }
1216next_after_fail56:;
1217 }
1218 else
1219 {
1220 {
1221/* #line 6547 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1222 tree utype = unsigned_type_for (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1222, __FUNCTION__))->typed.type)
);
1223 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail57;
1224 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6548, __FILE__"generic-match.c", __LINE__1224);
1225 {
1226 tree res_op0;
1227 {
1228 tree _o1[2], _r1;
1229 {
1230 tree _o2[1], _r2;
1231 _o2[0] = captures[2];
1232 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1232, __FUNCTION__))->typed.type)
!= utype)
1233 _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1234 else
1235 _r2 = _o2[0];
1236 _o1[0] = _r2;
1237 }
1238 {
1239 tree _o2[1], _r2;
1240 _o2[0] = captures[4];
1241 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1241, __FUNCTION__))->typed.type)
!= utype)
1242 _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1243 else
1244 _r2 = _o2[0];
1245 _o1[1] = _r2;
1246 }
1247 _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1247, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1248 res_op0 = _r1;
1249 }
1250 tree _r;
1251 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1252 return _r;
1253 }
1254next_after_fail57:;
1255 }
1256 }
1257 }
1258 else
1259 {
1260/* #line 6550 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1261 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", 1261, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
1262 && DECIMAL_FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 1262, __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", 1262, __FUNCTION__
))->typed.type)), (tcc_type), "generic-match.c", 1262, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 1262, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 1262, __FUNCTION__))->typed
.type))->type_common.mode)]) == MODE_DECIMAL_FLOAT))
1263 == 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", 1263, __FUNCTION__))
)->base.code) == VECTOR_TYPE) ? vector_type_mode (type) : (
type)->type_common.mode)]) == MODE_DECIMAL_FLOAT))
1264)
1265 {
1266 {
1267/* #line 6553 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1268 tree arg0 = strip_float_extensions (captures[2]);
1269 tree arg1 = strip_float_extensions (captures[4]);
1270 tree itype = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1270, __FUNCTION__))->typed.type)
;
1271 tree ty1 = TREE_TYPE (arg0)((contains_struct_check ((arg0), (TS_TYPED), "generic-match.c"
, 1271, __FUNCTION__))->typed.type)
;
1272 tree ty2 = TREE_TYPE (arg1)((contains_struct_check ((arg1), (TS_TYPED), "generic-match.c"
, 1272, __FUNCTION__))->typed.type)
;
1273 enum tree_code code = TREE_CODE (itype)((enum tree_code) (itype)->base.code);
1274/* #line 6559 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1275 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", 1275, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
1276 && 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", 1276, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
1277)
1278 {
1279 {
1280/* #line 6561 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1281 tree newtype = type;
1282 if (TYPE_MODE (ty1)((((enum tree_code) ((tree_class_check ((ty1), (tcc_type), "generic-match.c"
, 1282, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty1) : (ty1)->type_common.mode)
== SDmode(scalar_float_mode ((scalar_float_mode::from_int) E_SDmode))
1283 || TYPE_MODE (ty2)((((enum tree_code) ((tree_class_check ((ty2), (tcc_type), "generic-match.c"
, 1283, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty2) : (ty2)->type_common.mode)
== SDmode(scalar_float_mode ((scalar_float_mode::from_int) E_SDmode))
1284 || TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 1284, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
== SDmode(scalar_float_mode ((scalar_float_mode::from_int) E_SDmode)))
1285 newtype = dfloat32_type_nodeglobal_trees[TI_DFLOAT32_TYPE];
1286 if (TYPE_MODE (ty1)((((enum tree_code) ((tree_class_check ((ty1), (tcc_type), "generic-match.c"
, 1286, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty1) : (ty1)->type_common.mode)
== DDmode(scalar_float_mode ((scalar_float_mode::from_int) E_DDmode))
1287 || TYPE_MODE (ty2)((((enum tree_code) ((tree_class_check ((ty2), (tcc_type), "generic-match.c"
, 1287, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty2) : (ty2)->type_common.mode)
== DDmode(scalar_float_mode ((scalar_float_mode::from_int) E_DDmode))
1288 || TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 1288, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
== DDmode(scalar_float_mode ((scalar_float_mode::from_int) E_DDmode)))
1289 newtype = dfloat64_type_nodeglobal_trees[TI_DFLOAT64_TYPE];
1290 if (TYPE_MODE (ty1)((((enum tree_code) ((tree_class_check ((ty1), (tcc_type), "generic-match.c"
, 1290, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty1) : (ty1)->type_common.mode)
== TDmode(scalar_float_mode ((scalar_float_mode::from_int) E_TDmode))
1291 || TYPE_MODE (ty2)((((enum tree_code) ((tree_class_check ((ty2), (tcc_type), "generic-match.c"
, 1291, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(ty2) : (ty2)->type_common.mode)
== TDmode(scalar_float_mode ((scalar_float_mode::from_int) E_TDmode))
1292 || TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 1292, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
== TDmode(scalar_float_mode ((scalar_float_mode::from_int) E_TDmode)))
1293 newtype = dfloat128_type_nodeglobal_trees[TI_DFLOAT128_TYPE];
1294/* #line 6574 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1295 if ((newtype == dfloat32_type_nodeglobal_trees[TI_DFLOAT32_TYPE]
1296 || newtype == dfloat64_type_nodeglobal_trees[TI_DFLOAT64_TYPE]
1297 || newtype == dfloat128_type_nodeglobal_trees[TI_DFLOAT128_TYPE])
1298 && newtype == type
1299 && types_match (newtype, type)
1300)
1301 {
1302 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 1302, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail58;
1303 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 1303, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail58;
1304 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail58;
1305 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6579, __FILE__"generic-match.c", __LINE__1305);
1306 {
1307 tree res_op0;
1308 {
1309 tree _o1[1], _r1;
1310 _o1[0] = captures[2];
1311 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1311, __FUNCTION__))->typed.type)
!= newtype)
1312 _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
1313 else
1314 _r1 = _o1[0];
1315 res_op0 = _r1;
1316 }
1317 tree res_op1;
1318 {
1319 tree _o1[1], _r1;
1320 _o1[0] = captures[4];
1321 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1321, __FUNCTION__))->typed.type)
!= newtype)
1322 _r1 = fold_build1_loc (loc, NOP_EXPR, newtype, _o1[0]);
1323 else
1324 _r1 = _o1[0];
1325 res_op1 = _r1;
1326 }
1327 tree _r;
1328 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1329 return _r;
1330 }
1331next_after_fail58:;
1332 }
1333 else
1334 {
1335 {
1336/* #line 6580 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1337 if (TYPE_PRECISION (ty1)((tree_class_check ((ty1), (tcc_type), "generic-match.c", 1337
, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.c",
1337, __FUNCTION__))->type_common.precision)
)
1338 newtype = ty1;
1339 if (TYPE_PRECISION (ty2)((tree_class_check ((ty2), (tcc_type), "generic-match.c", 1339
, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.c",
1339, __FUNCTION__))->type_common.precision)
)
1340 newtype = ty2;
1341/* #line 6605 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1342 if (TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.c",
1342, __FUNCTION__))->type_common.precision)
< TYPE_PRECISION (itype)((tree_class_check ((itype), (tcc_type), "generic-match.c", 1342
, __FUNCTION__))->type_common.precision)
1343 && (flag_unsafe_math_optimizationsglobal_options.x_flag_unsafe_math_optimizations
1344 || (TYPE_PRECISION (newtype)((tree_class_check ((newtype), (tcc_type), "generic-match.c",
1344, __FUNCTION__))->type_common.precision)
== TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 1344
, __FUNCTION__))->type_common.precision)
1345 && real_can_shorten_arithmetic (TYPE_MODE (itype)((((enum tree_code) ((tree_class_check ((itype), (tcc_type), "generic-match.c"
, 1345, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(itype) : (itype)->type_common.mode)
,
1346 TYPE_MODE (type)((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 1346, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)
)
1347 && !excess_precision_type (newtype)))
1348 && !types_match (itype, newtype)
1349)
1350 {
1351 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 1351, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail59;
1352 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 1352, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail59;
1353 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail59;
1354 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6612, __FILE__"generic-match.c", __LINE__1354);
1355 {
1356 tree res_op0;
1357 {
1358 tree _o1[2], _r1;
1359 {
1360 tree _o2[1], _r2;
1361 _o2[0] = captures[2];
1362 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1362, __FUNCTION__))->typed.type)
!= newtype)
1363 _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
1364 else
1365 _r2 = _o2[0];
1366 _o1[0] = _r2;
1367 }
1368 {
1369 tree _o2[1], _r2;
1370 _o2[0] = captures[4];
1371 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1371, __FUNCTION__))->typed.type)
!= newtype)
1372 _r2 = fold_build1_loc (loc, NOP_EXPR, newtype, _o2[0]);
1373 else
1374 _r2 = _o2[0];
1375 _o1[1] = _r2;
1376 }
1377 _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1377, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1378 res_op0 = _r1;
1379 }
1380 tree _r;
1381 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1382 return _r;
1383 }
1384next_after_fail59:;
1385 }
1386 }
1387 }
1388 }
1389 }
1390 }
1391 }
1392 }
1393 return NULL_TREE(tree) nullptr;
1394}
1395
1396static tree
1397generic_simplify_4 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1398 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1399, const enum tree_code ARG_UNUSED (shift)shift __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (mod)mod __attribute__ ((__unused__)))
1400{
1401/* #line 662 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1402 if (integer_pow2p (captures[3]) && tree_int_cst_sgn (captures[3]) > 0
1403)
1404 {
1405 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 1405, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail60;
1406 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail60;
1407 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 663, __FILE__"generic-match.c", __LINE__1407);
1408 {
1409 tree res_op0;
1410 res_op0 = captures[0];
1411 tree res_op1;
1412 {
1413 tree _o1[2], _r1;
1414 _o1[0] = captures[1];
1415 {
1416 tree _o2[2], _r2;
1417 _o2[0] = captures[2];
1418 _o2[1] = build_int_cst (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1418, __FUNCTION__))->typed.type)
,
1419 1);
1420 _r2 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1420, __FUNCTION__))->typed.type)
, _o2[0], _o2[1]);
1421 _o1[1] = _r2;
1422 }
1423 _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1423, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1424 res_op1 = _r1;
1425 }
1426 tree _r;
1427 _r = fold_build2_loc (loc, shift, type, res_op0, res_op1);
1428 return _r;
1429 }
1430next_after_fail60:;
1431 }
1432 return NULL_TREE(tree) nullptr;
1433}
1434
1435static tree
1436generic_simplify_5 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1437 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
1438)
1439{
1440 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail61;
1441 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__1441);
1442 {
1443 tree res_op0;
1444 res_op0 = captures[0];
1445 tree res_op1;
1446 res_op1 = captures[1];
1447 tree _r;
1448 _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
1449 return _r;
1450 }
1451next_after_fail61:;
1452 return NULL_TREE(tree) nullptr;
1453}
1454
1455static tree
1456generic_simplify_6 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1457 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1458)
1459{
1460/* #line 1348 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1461 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", 1461, __FUNCTION__))->base.u.
bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
&& !TYPE_OVERFLOW_TRAPS (type)(!(any_integral_type_check ((type), "generic-match.c", 1461, __FUNCTION__
))->base.u.bits.unsigned_flag && global_options.x_flag_trapv
)
1462 && !TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 1462, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
&& !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 1462, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1462, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 1462, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) && !((((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1462, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 1462, __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", 1462, __FUNCTION__))->
typed.type)), "generic-match.c", 1462, __FUNCTION__))->base
.u.bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
1463 && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (captures[0]))(!(any_integral_type_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 1463, __FUNCTION__))->
typed.type)), "generic-match.c", 1463, __FUNCTION__))->base
.u.bits.unsigned_flag && global_options.x_flag_trapv)
1464 && !TYPE_SATURATING (TREE_TYPE (captures[0]))((tree_not_check4 ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 1464, __FUNCTION__))->typed.
type)), "generic-match.c", 1464, __FUNCTION__, (RECORD_TYPE),
(UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE)))->base.u.bits
.saturating_flag)
1465)
1466 {
1467 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 1467, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail62;
1468 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail62;
1469 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1352, __FILE__"generic-match.c", __LINE__1469);
1470 {
1471 tree res_op0;
1472 {
1473 tree _o1[1], _r1;
1474 {
1475 tree _o2[2], _r2;
1476 _o2[0] = captures[1];
1477 _o2[1] = captures[2];
1478 _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1478, __FUNCTION__))->typed.type)
, _o2[0], _o2[1]);
1479 _o1[0] = _r2;
1480 }
1481 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1481, __FUNCTION__))->typed.type)
!= type)
1482 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1483 else
1484 _r1 = _o1[0];
1485 res_op0 = _r1;
1486 }
1487 tree _r;
1488 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
1489 return _r;
1490 }
1491next_after_fail62:;
1492 }
1493 return NULL_TREE(tree) nullptr;
1494}
1495
1496static tree
1497generic_simplify_7 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1498 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1499, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
1500{
1501 {
1502/* #line 1081 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1503 tree pmop[2];
1504 tree utype = fold_bit_and_mask (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1504, __FUNCTION__))->typed.type)
, captures[5], op, captures[1], ERROR_MARK,
1505 NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr, captures[2], bitop, captures[3],
1506 captures[4], pmop);
1507/* #line 1086 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1508 if (utype
1509)
1510 {
1511 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1511, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail63;
1512 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 1512, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail63;
1513 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 1513, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail63;
1514 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 1514, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail63;
1515 if (TREE_SIDE_EFFECTS (captures[5])((non_type_check ((captures[5]), "generic-match.c", 1515, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail63;
1516 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail63;
1517 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1087, __FILE__"generic-match.c", __LINE__1517);
1518 {
1519 tree res_op0;
1520 {
1521 tree _o1[2], _r1;
1522 {
1523 tree _o2[2], _r2;
1524 {
1525 tree _o3[1], _r3;
1526 _o3[0] = pmop[0];
1527 if (TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 1527, __FUNCTION__))->typed.type)
!= utype)
1528 _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1529 else
1530 _r3 = _o3[0];
1531 _o2[0] = _r3;
1532 }
1533 {
1534 tree _o3[1], _r3;
1535 _o3[0] = pmop[1];
1536 if (TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 1536, __FUNCTION__))->typed.type)
!= utype)
1537 _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
1538 else
1539 _r3 = _o3[0];
1540 _o2[1] = _r3;
1541 }
1542 _r2 = fold_build2_loc (loc, op, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1542, __FUNCTION__))->typed.type)
, _o2[0], _o2[1]);
1543 _o1[0] = _r2;
1544 }
1545 {
1546 tree _o2[1], _r2;
1547 _o2[0] = captures[5];
1548 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1548, __FUNCTION__))->typed.type)
!= utype)
1549 _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
1550 else
1551 _r2 = _o2[0];
1552 _o1[1] = _r2;
1553 }
1554 _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1554, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1555 res_op0 = _r1;
1556 }
1557 tree _r;
1558 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1559 return _r;
1560 }
1561next_after_fail63:;
1562 }
1563 }
1564 return NULL_TREE(tree) nullptr;
1565}
1566
1567static tree
1568generic_simplify_8 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1569 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1570, const combined_fn ARG_UNUSED (TAN)TAN __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (SIN)SIN __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (COS)COS __attribute__ ((__unused__)))
1571{
1572/* #line 6124 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1573 if (flag_unsafe_math_optimizationsglobal_options.x_flag_unsafe_math_optimizations && canonicalize_math_p ()
1574)
1575 {
1576/* #line 6166 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1577 if (! HONOR_NANS (captures[1])
1578 && ! HONOR_INFINITIES (captures[1])
1579)
1580 {
1581 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail64;
1582 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6168, __FILE__"generic-match.c", __LINE__1582);
1583 {
1584 tree res_op0;
1585 res_op0 = build_one_cst (type);
1586 tree res_op1;
1587 {
1588 tree _o1[1], _r1;
1589 _o1[0] = captures[1];
1590 {
1591 _r1 = maybe_build_call_expr_loc (loc, COS, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1591, __FUNCTION__))->typed.type)
, 1, _o1[0]);
1592 if (!_r1)
1593 goto next_after_fail64;
1594 }
1595 res_op1 = _r1;
1596 }
1597 tree _r;
1598 _r = fold_build2_loc (loc, RDIV_EXPR, type, res_op0, res_op1);
1599 return _r;
1600 }
1601next_after_fail64:;
1602 }
1603 }
1604 return NULL_TREE(tree) nullptr;
1605}
1606
1607static tree
1608generic_simplify_9 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1609 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1610, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
1611{
1612/* #line 950 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1613 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 1613, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1613, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 1613, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1614 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1614, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1614, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 1614, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1615 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 1615, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1615, __FUNCTION__))->
type_common.precision)
== TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 1615, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1615, __FUNCTION__))->
type_common.precision)
1616)
1617 {
1618 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 1618, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail65;
1619 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail65;
1620 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 953, __FILE__"generic-match.c", __LINE__1620);
1621 {
1622 tree res_op0;
1623 {
1624 tree _o1[2], _r1;
1625 _o1[0] = captures[0];
1626 {
1627 tree _o2[1], _r2;
1628 _o2[0] = captures[2];
1629 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1629, __FUNCTION__))->typed.type)
!= TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1629, __FUNCTION__))->typed.type)
)
1630 _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1630, __FUNCTION__))->typed.type)
, _o2[0]);
1631 else
1632 _r2 = _o2[0];
1633 _o1[1] = _r2;
1634 }
1635 _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1635, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1636 res_op0 = _r1;
1637 }
1638 tree res_op1;
1639 res_op1 = captures[1];
1640 tree _r;
1641 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
1642 return _r;
1643 }
1644next_after_fail65:;
1645 }
1646 return NULL_TREE(tree) nullptr;
1647}
1648
1649static tree
1650generic_simplify_10 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1651 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1652, const combined_fn ARG_UNUSED (FMAX_ALL)FMAX_ALL __attribute__ ((__unused__)))
1653{
1654/* #line 3146 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1655 if (flag_finite_math_onlyglobal_options.x_flag_finite_math_only
1656)
1657 {
1658 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail66;
1659 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3152, __FILE__"generic-match.c", __LINE__1659);
1660 {
1661 tree res_op0;
1662 res_op0 = captures[0];
1663 tree res_op1;
1664 res_op1 = captures[1];
1665 tree _r;
1666 _r = fold_build2_loc (loc, MAX_EXPR, type, res_op0, res_op1);
1667 return _r;
1668 }
1669next_after_fail66:;
1670 }
1671 return NULL_TREE(tree) nullptr;
1672}
1673
1674static tree
1675generic_simplify_11 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1676 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1677, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
1678{
1679/* #line 1928 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1680 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 1680, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1680, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 1680, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1680, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.c", 1680, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 1680, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 1680, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 1680, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 1680, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 1680, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 1680, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
1681 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 1681, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 1681, __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"
, 1681, __FUNCTION__))->typed.type)), "generic-match.c", 1681
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
1682)
1683 {
1684 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail67;
1685 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1930, __FILE__"generic-match.c", __LINE__1685);
1686 {
1687 tree res_op0;
1688 res_op0 = captures[0];
1689 tree res_op1;
1690 res_op1 = captures[2];
1691 tree _r;
1692 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
1693 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 1693, __FUNCTION__
))->base.side_effects_flag)
)
1694 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
1695 return _r;
1696 }
1697next_after_fail67:;
1698 }
1699 return NULL_TREE(tree) nullptr;
1700}
1701
1702static tree
1703generic_simplify_12 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1704 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1705)
1706{
1707/* #line 2451 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1708 if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 1708, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
1709)
1710 {
1711/* #line 2458 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1712 if (tree_nop_conversion_p (type, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1712, __FUNCTION__))->typed.type)
)
1713 && !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", 1713, __FUNCTION__))->base.u.
bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
1714)
1715 {
1716 {
1717/* #line 2460 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1718 tree t1 = type;
1719 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)
1720 && 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"
, 1720, __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", 1720, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1720, __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"
, 1720, __FUNCTION__))->typed.type)), "generic-match.c", 1720
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
)
1721 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"
, 1721, __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"
, 1721, __FUNCTION__))->typed.type)
;
1722 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail68;
1723 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2467, __FILE__"generic-match.c", __LINE__1723);
1724 {
1725 tree res_op0;
1726 {
1727 tree _o1[2], _r1;
1728 {
1729 tree _o2[1], _r2;
1730 _o2[0] = captures[0];
1731 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1731, __FUNCTION__))->typed.type)
!= t1)
1732 _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
1733 else
1734 _r2 = _o2[0];
1735 _o1[0] = _r2;
1736 }
1737 {
1738 tree _o2[1], _r2;
1739 _o2[0] = captures[1];
1740 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1740, __FUNCTION__))->typed.type)
!= t1)
1741 _r2 = fold_build1_loc (loc, NOP_EXPR, t1, _o2[0]);
1742 else
1743 _r2 = _o2[0];
1744 _o1[1] = _r2;
1745 }
1746 _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1746, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1747 res_op0 = _r1;
1748 }
1749 tree _r;
1750 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1751 return _r;
1752 }
1753next_after_fail68:;
1754 }
1755 }
1756 }
1757 return NULL_TREE(tree) nullptr;
1758}
1759
1760static tree
1761generic_simplify_13 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1762 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1763, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
1764{
1765/* #line 4582 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1766 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 1766, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1766, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 1766, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
1767 && !TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 1767, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 1767, __FUNCTION__))->
base.u.bits.unsigned_flag)
1768 && types_match (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1768, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 1768, __FUNCTION__))->typed.type)
)
1769)
1770 {
1771 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 1771, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail69;
1772 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 1772, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail69;
1773 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail69;
1774 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4585, __FILE__"generic-match.c", __LINE__1774);
1775 {
1776 tree res_op0;
1777 {
1778 tree _o1[2], _r1;
1779 _o1[0] = captures[1];
1780 _o1[1] = captures[3];
1781 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1781, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1782 res_op0 = _r1;
1783 }
1784 tree res_op1;
1785 res_op1 = build_zero_cst (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1785, __FUNCTION__))->typed.type)
);
1786 tree _r;
1787 _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
1788 return _r;
1789 }
1790next_after_fail69:;
1791 }
1792 return NULL_TREE(tree) nullptr;
1793}
1794
1795static tree
1796generic_simplify_14 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1797 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1798, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
1799{
1800/* #line 3005 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1801 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)
1802 && tree_int_cst_sgn (captures[2]) > 0
1803 && tree_int_cst_sgn (captures[4]) > 0
1804 && (tree_nonzero_bits (captures[0]) & tree_nonzero_bits (captures[3])) == 0
1805)
1806 {
1807 {
1808/* #line 3009 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1809 tree t = type;
1810 if (!TYPE_OVERFLOW_WRAPS (t)((((enum tree_code) (t)->base.code) == POINTER_TYPE || ((enum
tree_code) (t)->base.code) == REFERENCE_TYPE) ? global_options
.x_flag_wrapv_pointer : ((any_integral_type_check ((t), "generic-match.c"
, 1810, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
)
1811 t = unsigned_type_for (t);
1812 wide_int wone = wi::one (TYPE_PRECISION (t)((tree_class_check ((t), (tcc_type), "generic-match.c", 1812,
__FUNCTION__))->type_common.precision)
);
1813 wide_int c = wi::add (wi::lshift (wone, wi::to_wide (captures[2])),
1814 wi::lshift (wone, wi::to_wide (captures[4])));
1815 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 1815, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail70;
1816 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 1816, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail70;
1817 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail70;
1818 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3015, __FILE__"generic-match.c", __LINE__1818);
1819 {
1820 tree res_op0;
1821 {
1822 tree _o1[2], _r1;
1823 {
1824 tree _o2[1], _r2;
1825 _o2[0] = captures[1];
1826 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 1826, __FUNCTION__))->typed.type)
!= t)
1827 _r2 = fold_build1_loc (loc, NOP_EXPR, t, _o2[0]);
1828 else
1829 _r2 = _o2[0];
1830 _o1[0] = _r2;
1831 }
1832 _o1[1] = wide_int_to_tree (t,c);
1833 _r1 = fold_build2_loc (loc, MULT_EXPR, t, _o1[0], _o1[1]);
1834 res_op0 = _r1;
1835 }
1836 tree _r;
1837 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
1838 return _r;
1839 }
1840next_after_fail70:;
1841 }
1842 }
1843 return NULL_TREE(tree) nullptr;
1844}
1845
1846static tree
1847generic_simplify_15 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1848 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
1849, const combined_fn ARG_UNUSED (bswap)bswap __attribute__ ((__unused__)))
1850{
1851 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail71;
1852 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3890, __FILE__"generic-match.c", __LINE__1852);
1853 {
1854 tree res_op0;
1855 res_op0 = captures[0];
1856 tree _r;
1857 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
1858 return _r;
1859 }
1860next_after_fail71:;
1861 return NULL_TREE(tree) nullptr;
1862}
1863
1864static tree
1865generic_simplify_16 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1866 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1867, const combined_fn ARG_UNUSED (COPYSIGN_ALL)COPYSIGN_ALL __attribute__ ((__unused__)))
1868{
1869/* #line 320 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1870 if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
1871)
1872 {
1873 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 1873, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail72;
1874 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail72;
1875 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 321, __FILE__"generic-match.c", __LINE__1875);
1876 {
1877 tree res_op0;
1878 res_op0 = captures[0];
1879 tree _r;
1880 _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
1881 return _r;
1882 }
1883next_after_fail72:;
1884 }
1885 return NULL_TREE(tree) nullptr;
1886}
1887
1888static tree
1889generic_simplify_17 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1890 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1891)
1892{
1893/* #line 1460 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1894 if (tree_nop_conversion_p (type, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 1894, __FUNCTION__))->typed.type)
)
1895 && tree_nop_conversion_p (type, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 1895, __FUNCTION__))->typed.type)
)
1896)
1897 {
1898 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail73;
1899 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1462, __FILE__"generic-match.c", __LINE__1899);
1900 {
1901 tree res_op0;
1902 {
1903 tree _o1[1], _r1;
1904 _o1[0] = captures[1];
1905 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1905, __FUNCTION__))->typed.type)
!= type)
1906 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1907 else
1908 _r1 = _o1[0];
1909 res_op0 = _r1;
1910 }
1911 tree res_op1;
1912 {
1913 tree _o1[1], _r1;
1914 _o1[0] = captures[2];
1915 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1915, __FUNCTION__))->typed.type)
!= type)
1916 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
1917 else
1918 _r1 = _o1[0];
1919 res_op1 = _r1;
1920 }
1921 tree _r;
1922 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
1923 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 1923, __FUNCTION__
))->base.side_effects_flag)
)
1924 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
1925 return _r;
1926 }
1927next_after_fail73:;
1928 }
1929 return NULL_TREE(tree) nullptr;
1930}
1931
1932static tree
1933generic_simplify_18 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1934 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1935)
1936{
1937/* #line 3053 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
1938 if (TREE_CODE (type)((enum tree_code) (type)->base.code) != COMPLEX_TYPE
1939 && (! 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", 1939, __FUNCTION__))->typed.type))->
base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 1939, __FUNCTION__))
->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "generic-match.c"
, 1939, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
1940 || 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", 1940, __FUNCTION__))->base.u.
bits.unsigned_flag && !global_options.x_flag_wrapv &&
!global_options.x_flag_trapv))
)
1941)
1942 {
1943 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail74;
1944 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3056, __FILE__"generic-match.c", __LINE__1944);
1945 {
1946 tree res_op0;
1947 {
1948 tree _o1[1], _r1;
1949 _o1[0] = captures[0];
1950 _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1950, __FUNCTION__))->typed.type)
, _o1[0]);
1951 res_op0 = _r1;
1952 }
1953 tree _r;
1954 _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
1955 return _r;
1956 }
1957next_after_fail74:;
1958 }
1959 return NULL_TREE(tree) nullptr;
1960}
1961
1962static tree
1963generic_simplify_19 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1964 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1965)
1966{
1967 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail75;
1968 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1229, __FILE__"generic-match.c", __LINE__1968);
1969 {
1970 if (! tree_invariant_p (captures[2])) goto next_after_fail75;
1971 tree res_op0;
1972 {
1973 tree _o1[2], _r1;
1974 _o1[0] = captures[0];
1975 _o1[1] = unshare_expr (captures[2]);
1976 _r1 = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1976, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
1977 res_op0 = _r1;
1978 }
1979 tree res_op1;
1980 {
1981 tree _o1[1], _r1;
1982 _o1[0] = captures[2];
1983 _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 1983, __FUNCTION__))->typed.type)
, _o1[0]);
1984 res_op1 = _r1;
1985 }
1986 tree _r;
1987 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
1988 return _r;
1989 }
1990next_after_fail75:;
1991 return NULL_TREE(tree) nullptr;
1992}
1993
1994static tree
1995generic_simplify_20 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
1996 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
1997, const combined_fn ARG_UNUSED (HYPOT)HYPOT __attribute__ ((__unused__)))
1998{
1999/* #line 6124 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2000 if (flag_unsafe_math_optimizationsglobal_options.x_flag_unsafe_math_optimizations && canonicalize_math_p ()
2001)
2002 {
2003 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail76;
2004 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6244, __FILE__"generic-match.c", __LINE__2004);
2005 {
2006 tree res_op0;
2007 {
2008 tree _o1[1], _r1;
2009 _o1[0] = captures[0];
2010 _r1 = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2010, __FUNCTION__))->typed.type)
, _o1[0]);
2011 res_op0 = _r1;
2012 }
2013 tree res_op1;
2014 res_op1 = build_real_truncate (type, dconst_sqrt2 ()(*dconst_sqrt2_ptr ()));
2015 tree _r;
2016 _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
2017 return _r;
2018 }
2019next_after_fail76:;
2020 }
2021 return NULL_TREE(tree) nullptr;
2022}
2023
2024static tree
2025generic_simplify_21 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2026 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2027, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2028{
2029 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail77;
2030 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4678, __FILE__"generic-match.c", __LINE__2030);
2031 {
2032 tree _r;
2033 _r = constant_boolean_node (cmp == NE_EXPR, type);
2034 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2034, __FUNCTION__
))->base.side_effects_flag)
)
2035 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2036 return _r;
2037 }
2038next_after_fail77:;
2039 return NULL_TREE(tree) nullptr;
2040}
2041
2042static tree
2043generic_simplify_22 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2044 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2045, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)))
2046{
2047 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail78;
2048 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__2048);
2049 {
2050 tree res_op0;
2051 res_op0 = captures[0];
2052 tree res_op1;
2053 {
2054 tree _o1[1], _r1;
2055 _o1[0] = captures[2];
2056 _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2056, __FUNCTION__))->typed.type)
, _o1[0]);
2057 res_op1 = _r1;
2058 }
2059 tree _r;
2060 _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
2061 return _r;
2062 }
2063next_after_fail78:;
2064 return NULL_TREE(tree) nullptr;
2065}
2066
2067static tree
2068generic_simplify_23 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2069 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2070)
2071{
2072 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 2072, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail79;
2073 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail79;
2074 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5140, __FILE__"generic-match.c", __LINE__2074);
2075 {
2076 tree _r;
2077 _r = captures[1];
2078 return _r;
2079 }
2080next_after_fail79:;
2081 return NULL_TREE(tree) nullptr;
2082}
2083
2084static tree
2085generic_simplify_24 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2086 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2087)
2088{
2089/* #line 1777 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2090 if (tree_nop_conversion_p (type, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2090, __FUNCTION__))->typed.type)
)
2091)
2092 {
2093 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail80;
2094 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1778, __FILE__"generic-match.c", __LINE__2094);
2095 {
2096 tree res_op0;
2097 {
2098 tree _o1[2], _r1;
2099 {
2100 tree _o2[1], _r2;
2101 _o2[0] = captures[2];
2102 _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o2[0]);
2103 _o1[0] = _r2;
2104 }
2105 _o1[1] = captures[3];
2106 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2106, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
2107 res_op0 = _r1;
2108 }
2109 tree _r;
2110 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
2111 return _r;
2112 }
2113next_after_fail80:;
2114 }
2115 return NULL_TREE(tree) nullptr;
2116}
2117
2118static tree
2119generic_simplify_25 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2120 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2121, const enum tree_code ARG_UNUSED (div)div __attribute__ ((__unused__)))
2122{
2123/* #line 393 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2124 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])
2125)
2126 {
2127 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail81;
2128 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 394, __FILE__"generic-match.c", __LINE__2128);
2129 {
2130 tree _r;
2131 _r = captures[0];
2132 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2132, __FUNCTION__
))->base.side_effects_flag)
)
2133 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2134 return _r;
2135 }
2136next_after_fail81:;
2137 }
2138 return NULL_TREE(tree) nullptr;
2139}
2140
2141static tree
2142generic_simplify_26 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2143 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2144, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (ncmp)ncmp __attribute__ ((__unused__)))
2145{
2146/* #line 5379 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2147 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 2147, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2147, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 2147, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2147, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.c", 2147, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 2147, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 2147, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 2147, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 2147, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 2147, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 2147, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
2148 && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 2148, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 2148, __FUNCTION__))->
base.u.bits.unsigned_flag)
2149 && types_match (captures[0], captures[2])
2150)
2151 {
2152 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 2152, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail82;
2153 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail82;
2154 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5382, __FILE__"generic-match.c", __LINE__2154);
2155 {
2156 tree res_op0;
2157 {
2158 tree _o1[2], _r1;
2159 _o1[0] = captures[0];
2160 _o1[1] = captures[2];
2161 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2161, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
2162 res_op0 = _r1;
2163 }
2164 tree res_op1;
2165 res_op1 = captures[1];
2166 tree _r;
2167 _r = fold_build2_loc (loc, ncmp, type, res_op0, res_op1);
2168 return _r;
2169 }
2170next_after_fail82:;
2171 }
2172 return NULL_TREE(tree) nullptr;
2173}
2174
2175static tree
2176generic_simplify_27 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2177 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2178, const enum tree_code ARG_UNUSED (test1)test1 __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (test2)test2 __attribute__ ((__unused__)))
2179{
2180/* #line 5156 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2181 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 2181, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2181, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 2181, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
2182 || VECTOR_INTEGER_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 2182, __FUNCTION__))->typed.
type))->base.code) == VECTOR_TYPE) && ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 2182, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 2182, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)
2183)
2184 {
2185 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail83;
2186 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5158, __FILE__"generic-match.c", __LINE__2186);
2187 {
2188 tree _r;
2189 _r = constant_boolean_node (false, type);
2190 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2190, __FUNCTION__
))->base.side_effects_flag)
)
2191 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2192 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2192, __FUNCTION__
))->base.side_effects_flag)
)
2193 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2194 return _r;
2195 }
2196next_after_fail83:;
2197 }
2198 return NULL_TREE(tree) nullptr;
2199}
2200
2201static tree
2202generic_simplify_28 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2203 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2204)
2205{
2206 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail84;
2207 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__2207);
2208 {
2209 tree res_op0;
2210 res_op0 = captures[0];
2211 tree _r;
2212 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
2213 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2213, __FUNCTION__
))->base.side_effects_flag)
)
2214 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2215 return _r;
2216 }
2217next_after_fail84:;
2218 return NULL_TREE(tree) nullptr;
2219}
2220
2221static tree
2222generic_simplify_29 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2223 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2224)
2225{
2226/* #line 4487 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2227 if (VECTOR_TYPE_P (type)(((enum tree_code) (type)->base.code) == VECTOR_TYPE)
2228 && 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"
, 2229, __FUNCTION__))->typed.type))))
2229 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"
, 2229, __FUNCTION__))->typed.type))))
2230 && (TYPE_MODE (TREE_TYPE (type))((((enum tree_code) ((tree_class_check ((((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 2230, __FUNCTION__))
->typed.type)), (tcc_type), "generic-match.c", 2230, __FUNCTION__
)))->base.code) == VECTOR_TYPE) ? vector_type_mode (((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 2230, __FUNCTION__))
->typed.type)) : (((contains_struct_check ((type), (TS_TYPED
), "generic-match.c", 2230, __FUNCTION__))->typed.type))->
type_common.mode)
2231 == 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"
, 2231, __FUNCTION__))->typed.type)), (TS_TYPED), "generic-match.c"
, 2231, __FUNCTION__))->typed.type)), (tcc_type), "generic-match.c"
, 2231, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(((contains_struct_check ((((contains_struct_check ((captures
[3]), (TS_TYPED), "generic-match.c", 2231, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 2231, __FUNCTION__
))->typed.type)) : (((contains_struct_check ((((contains_struct_check
((captures[3]), (TS_TYPED), "generic-match.c", 2231, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 2231, __FUNCTION__
))->typed.type))->type_common.mode)
)
2232)
2233 {
2234 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail85;
2235 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4492, __FILE__"generic-match.c", __LINE__2235);
2236 {
2237 tree res_op0;
2238 res_op0 = captures[0];
2239 tree res_op1;
2240 {
2241 tree _o1[1], _r1;
2242 {
2243 tree _o2[3], _r2;
2244 _o2[0] = captures[2];
2245 {
2246 tree _o3[1], _r3;
2247 _o3[0] = captures[3];
2248 _r3 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 2248, __FUNCTION__))->typed.type)
, _o3[0]);
2249 _o2[1] = _r3;
2250 }
2251 _o2[2] = captures[4];
2252 _r2 = fold_build3_loc (loc, VEC_COND_EXPR, TREE_TYPE (_o2[1])((contains_struct_check ((_o2[1]), (TS_TYPED), "generic-match.c"
, 2252, __FUNCTION__))->typed.type)
, _o2[0], _o2[1], _o2[2]);
2253 _o1[0] = _r2;
2254 }
2255 _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
2256 res_op1 = _r1;
2257 }
2258 tree _r;
2259 _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
2260 return _r;
2261 }
2262next_after_fail85:;
2263 }
2264 return NULL_TREE(tree) nullptr;
2265}
2266
2267static tree
2268generic_simplify_30 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2269 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2270, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)))
2271{
2272 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail86;
2273 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1167, __FILE__"generic-match.c", __LINE__2273);
2274 {
2275 tree res_op0;
2276 res_op0 = captures[0];
2277 tree _r;
2278 _r = non_lvalue_loc (loc, res_op0);
2279 return _r;
2280 }
2281next_after_fail86:;
2282 return NULL_TREE(tree) nullptr;
2283}
2284
2285static tree
2286generic_simplify_31 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2287 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2288)
2289{
2290 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail87;
2291 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__2291);
2292 {
2293 tree res_op0;
2294 {
2295 tree _o1[2], _r1;
2296 _o1[0] = captures[1];
2297 _o1[1] = captures[2];
2298 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2298, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
2299 res_op0 = _r1;
2300 }
2301 tree _r;
2302 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
2303 return _r;
2304 }
2305next_after_fail87:;
2306 return NULL_TREE(tree) nullptr;
2307}
2308
2309static tree
2310generic_simplify_32 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2311 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2312)
2313{
2314 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail88;
2315 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1256, __FILE__"generic-match.c", __LINE__2315);
2316 {
2317 tree res_op0;
2318 res_op0 = captures[1];
2319 tree res_op1;
2320 {
2321 tree _o1[1], _r1;
2322 _o1[0] = captures[2];
2323 _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2323, __FUNCTION__))->typed.type)
, _o1[0]);
2324 res_op1 = _r1;
2325 }
2326 tree _r;
2327 _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
2328 return _r;
2329 }
2330next_after_fail88:;
2331 return NULL_TREE(tree) nullptr;
2332}
2333
2334static tree
2335generic_simplify_33 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2336 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2337)
2338{
2339/* #line 2451 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2340 if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 2340, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
2341)
2342 {
2343/* #line 2509 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2344 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", 2344, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
|| flag_associative_mathglobal_options.x_flag_associative_math)
2345 && !FIXED_POINT_TYPE_P (type)(((enum tree_code) (type)->base.code) == FIXED_POINT_TYPE)
2346)
2347 {
2348/* #line 2766 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2349 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)
2350 && 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", 2350, __FUNCTION__))->base.u.
bits.unsigned_flag && !global_options.x_flag_wrapv &&
!global_options.x_flag_trapv))
2351 && element_precision (type) <= element_precision (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2351, __FUNCTION__))->typed.type)
)
2352)
2353 {
2354 {
2355/* #line 2769 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2356 tree utype = unsigned_type_for (type);
2357 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail89;
2358 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2770, __FILE__"generic-match.c", __LINE__2358);
2359 {
2360 tree res_op0;
2361 {
2362 tree _o1[1], _r1;
2363 {
2364 tree _o2[1], _r2;
2365 _o2[0] = captures[1];
2366 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 2366, __FUNCTION__))->typed.type)
!= utype)
2367 _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
2368 else
2369 _r2 = _o2[0];
2370 _o1[0] = _r2;
2371 }
2372 _r1 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2372, __FUNCTION__))->typed.type)
, _o1[0]);
2373 res_op0 = _r1;
2374 }
2375 tree _r;
2376 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
2377 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2377, __FUNCTION__
))->base.side_effects_flag)
)
2378 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2379 return _r;
2380 }
2381next_after_fail89:;
2382 }
2383 }
2384 else
2385 {
2386/* #line 2771 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2387 if (element_precision (type) <= element_precision (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2387, __FUNCTION__))->typed.type)
)
2388 || (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 2388, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2388, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 2388, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
2389 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 2389, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2389, __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"
, 2389, __FUNCTION__))->typed.type)), "generic-match.c", 2389
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
)
2390)
2391 {
2392 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail90;
2393 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2781, __FILE__"generic-match.c", __LINE__2393);
2394 {
2395 tree res_op0;
2396 {
2397 tree _o1[1], _r1;
2398 _o1[0] = captures[1];
2399 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2399, __FUNCTION__))->typed.type)
!= type)
2400 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2401 else
2402 _r1 = _o1[0];
2403 res_op0 = _r1;
2404 }
2405 tree _r;
2406 _r = fold_build1_loc (loc, NEGATE_EXPR, type, res_op0);
2407 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2407, __FUNCTION__
))->base.side_effects_flag)
)
2408 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2409 return _r;
2410 }
2411next_after_fail90:;
2412 }
2413 }
2414 }
2415 }
2416 return NULL_TREE(tree) nullptr;
2417}
2418
2419static tree
2420generic_simplify_34 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2421 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2422)
2423{
2424 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail91;
2425 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1261, __FILE__"generic-match.c", __LINE__2425);
2426 {
2427 tree res_op0;
2428 {
2429 tree _o1[2], _r1;
2430 _o1[0] = captures[1];
2431 _o1[1] = captures[2];
2432 _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2432, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
2433 res_op0 = _r1;
2434 }
2435 tree _r;
2436 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
2437 return _r;
2438 }
2439next_after_fail91:;
2440 return NULL_TREE(tree) nullptr;
2441}
2442
2443static tree
2444generic_simplify_35 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2445 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2446, const enum tree_code ARG_UNUSED (eqne)eqne __attribute__ ((__unused__)))
2447{
2448/* #line 2257 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2449 if (eqne == EQ_EXPR
2450)
2451 {
2452 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 2452, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail92;
2453 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail92;
2454 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2258, __FILE__"generic-match.c", __LINE__2454);
2455 {
2456 tree _r;
2457 _r = constant_boolean_node (false, type);
2458 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2458, __FUNCTION__
))->base.side_effects_flag)
)
2459 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2460 return _r;
2461 }
2462next_after_fail92:;
2463 }
2464 else
2465 {
2466/* #line 2259 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2467 if (eqne == NE_EXPR
2468)
2469 {
2470 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 2470, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail93;
2471 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 2471, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail93;
2472 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail93;
2473 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2260, __FILE__"generic-match.c", __LINE__2473);
2474 {
2475 tree _r;
2476 _r = captures[0];
2477 return _r;
2478 }
2479next_after_fail93:;
2480 }
2481 }
2482 return NULL_TREE(tree) nullptr;
2483}
2484
2485static tree
2486generic_simplify_36 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2487 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2488, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (rbitop)rbitop __attribute__ ((__unused__)))
2489{
2490 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 2490, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail94;
2491 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail94;
2492 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1269, __FILE__"generic-match.c", __LINE__2492);
2493 {
2494 tree res_op0;
2495 res_op0 = captures[1];
2496 tree res_op1;
2497 res_op1 = captures[2];
2498 tree _r;
2499 _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
2500 return _r;
2501 }
2502next_after_fail94:;
2503 return NULL_TREE(tree) nullptr;
2504}
2505
2506static tree
2507generic_simplify_37 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2508 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2509, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2510{
2511/* #line 2050 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2512 if (TREE_INT_CST_LOW (captures[1])((unsigned long) (*tree_int_cst_elt_check ((captures[1]), (0)
, "generic-match.c", 2512, __FUNCTION__)))
& 1
2513)
2514 {
2515 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail95;
2516 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2051, __FILE__"generic-match.c", __LINE__2516);
2517 {
2518 tree _r;
2519 _r = constant_boolean_node (cmp == NE_EXPR, type);
2520 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2520, __FUNCTION__
))->base.side_effects_flag)
)
2521 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2522 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2522, __FUNCTION__
))->base.side_effects_flag)
)
2523 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2524 return _r;
2525 }
2526next_after_fail95:;
2527 }
2528 return NULL_TREE(tree) nullptr;
2529}
2530
2531static tree
2532generic_simplify_38 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2533 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2534, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2535{
2536/* #line 1827 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2537 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 2537, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2537, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 2537, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
2538 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 2538, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2538, __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"
, 2538, __FUNCTION__))->typed.type)), "generic-match.c", 2538
, __FUNCTION__))->base.u.bits.unsigned_flag && !global_options
.x_flag_wrapv && !global_options.x_flag_trapv))
2539)
2540 {
2541/* #line 1829 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2542 if (tree_expr_nonnegative_p (captures[1]) && tree_expr_nonzero_p (captures[1])
2543)
2544 {
2545 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail96;
2546 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1830, __FILE__"generic-match.c", __LINE__2546);
2547 {
2548 tree res_op0;
2549 res_op0 = captures[0];
2550 tree res_op1;
2551 res_op1 = captures[2];
2552 tree _r;
2553 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2554 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2554, __FUNCTION__
))->base.side_effects_flag)
)
2555 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2556 return _r;
2557 }
2558next_after_fail96:;
2559 }
2560 else
2561 {
2562/* #line 1831 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2563 if (TREE_CODE (captures[1])((enum tree_code) (captures[1])->base.code) == INTEGER_CST
2564 && 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", 2564, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.c", 2564, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
2565)
2566 {
2567 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail97;
2568 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1833, __FILE__"generic-match.c", __LINE__2568);
2569 {
2570 tree res_op0;
2571 res_op0 = captures[2];
2572 tree res_op1;
2573 res_op1 = captures[0];
2574 tree _r;
2575 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2576 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 2576, __FUNCTION__
))->base.side_effects_flag)
)
2577 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
2578 return _r;
2579 }
2580next_after_fail97:;
2581 }
2582 }
2583 }
2584 return NULL_TREE(tree) nullptr;
2585}
2586
2587static tree
2588generic_simplify_39 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2589 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2590)
2591{
2592 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail98;
2593 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1274, __FILE__"generic-match.c", __LINE__2593);
2594 {
2595 tree res_op0;
2596 res_op0 = captures[0];
2597 tree res_op1;
2598 res_op1 = captures[1];
2599 tree _r;
2600 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
2601 return _r;
2602 }
2603next_after_fail98:;
2604 return NULL_TREE(tree) nullptr;
2605}
2606
2607static tree
2608generic_simplify_40 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2609 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2610, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (out)out __attribute__ ((__unused__)))
2611{
2612/* #line 5682 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2613 if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 2613, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2613, __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"
, 2613, __FUNCTION__))->typed.type)), "generic-match.c", 2613
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
2614 && types_match (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 2614, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2614, __FUNCTION__))->typed.type)
)
2615 && tree_nop_conversion_p (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2615, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 2615, __FUNCTION__))->typed.type)
)
2616 && wi::to_wide (captures[4]) != 0
2617 && single_use (captures[1])
2618)
2619 {
2620 {
2621/* #line 5687 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2622 unsigned int prec = TYPE_PRECISION (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 2622, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 2622, __FUNCTION__))->
type_common.precision)
;
2623 signop sign = TYPE_SIGN (TREE_TYPE (captures[3]))((signop) ((tree_class_check ((((contains_struct_check ((captures
[3]), (TS_TYPED), "generic-match.c", 2623, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.c", 2623, __FUNCTION__
))->base.u.bits.unsigned_flag))
;
2624 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 2624, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail99;
2625 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail99;
2626 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5691, __FILE__"generic-match.c", __LINE__2626);
2627 {
2628 tree res_op0;
2629 res_op0 = captures[3];
2630 tree res_op1;
2631 res_op1 = wide_int_to_tree (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 2631, __FUNCTION__))->typed.type)
,
2632 wi::max_value (prec, sign)
2633 - wi::to_wide (captures[4]));
2634 tree _r;
2635 _r = fold_build2_loc (loc, out, type, res_op0, res_op1);
2636 return _r;
2637 }
2638next_after_fail99:;
2639 }
2640 }
2641 return NULL_TREE(tree) nullptr;
2642}
2643
2644static tree
2645generic_simplify_41 (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 (op)op __attribute__ ((__unused__)))
2648{
2649/* #line 2016 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2650 if (tree_nop_conversion_p (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 2650, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2650, __FUNCTION__))->typed.type)
)
2651 && tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2651, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 2651, __FUNCTION__))->typed.type)
)
2652 && (CONSTANT_CLASS_P (captures[3])(tree_code_type[(int) (((enum tree_code) (captures[3])->base
.code))] == tcc_constant)
|| (single_use (captures[1]) && single_use (captures[0])))
2653)
2654 {
2655 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail100;
2656 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2019, __FILE__"generic-match.c", __LINE__2656);
2657 {
2658 tree res_op0;
2659 res_op0 = captures[3];
2660 tree res_op1;
2661 res_op1 = build_zero_cst (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 2661, __FUNCTION__))->typed.type)
);
2662 tree _r;
2663 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2664 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 2664, __FUNCTION__
))->base.side_effects_flag)
)
2665 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[2]), _r);
2666 return _r;
2667 }
2668next_after_fail100:;
2669 }
2670 return NULL_TREE(tree) nullptr;
2671}
2672
2673static tree
2674generic_simplify_42 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2675 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2676, const enum tree_code ARG_UNUSED (mod)mod __attribute__ ((__unused__)))
2677{
2678/* #line 591 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2679 if (!integer_zerop (captures[0])
2680)
2681 {
2682 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail101;
2683 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 592, __FILE__"generic-match.c", __LINE__2683);
2684 {
2685 tree _r;
2686 _r = build_zero_cst (type);
2687 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2687, __FUNCTION__
))->base.side_effects_flag)
)
2688 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2689 return _r;
2690 }
2691next_after_fail101:;
2692 }
2693 return NULL_TREE(tree) nullptr;
2694}
2695
2696static tree
2697generic_simplify_43 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2698 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2699)
2700{
2701 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail102;
2702 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1279, __FILE__"generic-match.c", __LINE__2702);
2703 {
2704 tree res_op0;
2705 res_op0 = captures[0];
2706 tree res_op1;
2707 res_op1 = captures[1];
2708 tree _r;
2709 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2710 return _r;
2711 }
2712next_after_fail102:;
2713 return NULL_TREE(tree) nullptr;
2714}
2715
2716static tree
2717generic_simplify_44 (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 ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2719, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
2720{
2721 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail103;
2722 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1287, __FILE__"generic-match.c", __LINE__2722);
2723 {
2724 tree res_op0;
2725 res_op0 = captures[0];
2726 tree res_op1;
2727 res_op1 = captures[1];
2728 tree _r;
2729 _r = fold_build2_loc (loc, BIT_IOR_EXPR, type, res_op0, res_op1);
2730 return _r;
2731 }
2732next_after_fail103:;
2733 return NULL_TREE(tree) nullptr;
2734}
2735
2736static tree
2737generic_simplify_45 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2738 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2739, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (bswap)bswap __attribute__ ((__unused__)))
2740{
2741 {
2742/* #line 3898 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2743 tree ctype = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2743, __FUNCTION__))->typed.type)
;
2744 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail104;
2745 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3899, __FILE__"generic-match.c", __LINE__2745);
2746 {
2747 tree res_op0;
2748 {
2749 tree _o1[1], _r1;
2750 _o1[0] = captures[1];
2751 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2751, __FUNCTION__))->typed.type)
!= ctype)
2752 _r1 = fold_build1_loc (loc, NOP_EXPR, ctype, _o1[0]);
2753 else
2754 _r1 = _o1[0];
2755 res_op0 = _r1;
2756 }
2757 tree res_op1;
2758 {
2759 tree _o1[1], _r1;
2760 _o1[0] = captures[2];
2761 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2761, __FUNCTION__))->typed.type)
!= ctype)
2762 _r1 = fold_build1_loc (loc, NOP_EXPR, ctype, _o1[0]);
2763 else
2764 _r1 = _o1[0];
2765 res_op1 = _r1;
2766 }
2767 tree _r;
2768 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2769 return _r;
2770 }
2771next_after_fail104:;
2772 }
2773 return NULL_TREE(tree) nullptr;
2774}
2775
2776static tree
2777generic_simplify_46 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2778 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2779, const enum tree_code ARG_UNUSED (div)div __attribute__ ((__unused__)))
2780{
2781/* #line 400 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2782 if (!integer_zerop (captures[0]) && !ALL_FRACT_MODE_P (TYPE_MODE (type))((((enum mode_class) mode_class[((((enum tree_code) ((tree_class_check
((type), (tcc_type), "generic-match.c", 2782, __FUNCTION__))
)->base.code) == VECTOR_TYPE) ? vector_type_mode (type) : (
type)->type_common.mode)]) == MODE_FRACT || ((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((type), (
tcc_type), "generic-match.c", 2782, __FUNCTION__)))->base.
code) == VECTOR_TYPE) ? vector_type_mode (type) : (type)->
type_common.mode)]) == MODE_VECTOR_FRACT) || (((enum mode_class
) mode_class[((((enum tree_code) ((tree_class_check ((type), (
tcc_type), "generic-match.c", 2782, __FUNCTION__)))->base.
code) == VECTOR_TYPE) ? vector_type_mode (type) : (type)->
type_common.mode)]) == MODE_UFRACT || ((enum mode_class) mode_class
[((((enum tree_code) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 2782, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(type) : (type)->type_common.mode)]) == MODE_VECTOR_UFRACT
))
2783)
2784 {
2785 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail105;
2786 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 401, __FILE__"generic-match.c", __LINE__2786);
2787 {
2788 tree _r;
2789 _r = build_one_cst (type);
2790 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2790, __FUNCTION__
))->base.side_effects_flag)
)
2791 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2792 return _r;
2793 }
2794next_after_fail105:;
2795 }
2796 return NULL_TREE(tree) nullptr;
2797}
2798
2799static tree
2800generic_simplify_47 (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)
2803{
2804 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail106;
2805 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1292, __FILE__"generic-match.c", __LINE__2805);
2806 {
2807 tree res_op0;
2808 res_op0 = captures[0];
2809 tree res_op1;
2810 res_op1 = captures[1];
2811 tree _r;
2812 _r = fold_build2_loc (loc, PLUS_EXPR, type, res_op0, res_op1);
2813 return _r;
2814 }
2815next_after_fail106:;
2816 return NULL_TREE(tree) nullptr;
2817}
2818
2819static tree
2820generic_simplify_48 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2821 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2822, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
2823{
2824 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 2824, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail107;
2825 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail107;
2826 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1013, __FILE__"generic-match.c", __LINE__2826);
2827 {
2828 tree _r;
2829 _r = captures[0];
2830 return _r;
2831 }
2832next_after_fail107:;
2833 return NULL_TREE(tree) nullptr;
2834}
2835
2836static tree
2837generic_simplify_49 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2838 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2839, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
2840{
2841/* #line 5710 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2842 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 2842, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2842, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 2842, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 2842, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.c", 2842, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 2842, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 2842, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[0]), (TS_TYPED), "generic-match.c", 2842, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 2842, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 2842, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 2842, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
2843 && TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 2843, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 2843, __FUNCTION__))->
base.u.bits.unsigned_flag)
2844)
2845 {
2846 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 2846, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail108;
2847 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail108;
2848 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5712, __FILE__"generic-match.c", __LINE__2848);
2849 {
2850 tree res_op0;
2851 res_op0 = captures[1];
2852 tree res_op1;
2853 res_op1 = captures[0];
2854 tree _r;
2855 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
2856 return _r;
2857 }
2858next_after_fail108:;
2859 }
2860 return NULL_TREE(tree) nullptr;
2861}
2862
2863static tree
2864generic_simplify_50 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2865 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2866)
2867{
2868 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail109;
2869 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3038, __FILE__"generic-match.c", __LINE__2869);
2870 {
2871 tree _r;
2872 _r = captures[1];
2873 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 2873, __FUNCTION__
))->base.side_effects_flag)
)
2874 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
2875 return _r;
2876 }
2877next_after_fail109:;
2878 return NULL_TREE(tree) nullptr;
2879}
2880
2881static tree
2882generic_simplify_51 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2883 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2884, const combined_fn ARG_UNUSED (SINH)SINH __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (COSH)COSH __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (TANH)TANH __attribute__ ((__unused__)))
2885{
2886/* #line 6124 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2887 if (flag_unsafe_math_optimizationsglobal_options.x_flag_unsafe_math_optimizations && canonicalize_math_p ()
2888)
2889 {
2890 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail110;
2891 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6144, __FILE__"generic-match.c", __LINE__2891);
2892 {
2893 tree res_op0;
2894 res_op0 = captures[1];
2895 tree _r;
2896 _r = maybe_build_call_expr_loc (loc, TANH, type, 1, res_op0);
2897 if (!_r)
2898 goto next_after_fail110;
2899 return _r;
2900 }
2901next_after_fail110:;
2902 }
2903 return NULL_TREE(tree) nullptr;
2904}
2905
2906static tree
2907generic_simplify_52 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2908 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2909)
2910{
2911 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail111;
2912 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1311, __FILE__"generic-match.c", __LINE__2912);
2913 {
2914 tree res_op0;
2915 res_op0 = captures[1];
2916 tree res_op1;
2917 {
2918 tree _o1[1], _r1;
2919 _o1[0] = captures[2];
2920 _r1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2920, __FUNCTION__))->typed.type)
, _o1[0]);
2921 res_op1 = _r1;
2922 }
2923 tree _r;
2924 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
2925 return _r;
2926 }
2927next_after_fail111:;
2928 return NULL_TREE(tree) nullptr;
2929}
2930
2931static tree
2932generic_simplify_53 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
2933 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
2934, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
2935{
2936/* #line 1451 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2937 if (tree_nop_conversion_p (type, TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 2937, __FUNCTION__))->typed.type)
)
2938 && tree_nop_conversion_p (type, TREE_TYPE (captures[6])((contains_struct_check ((captures[6]), (TS_TYPED), "generic-match.c"
, 2938, __FUNCTION__))->typed.type)
)
2939)
2940 {
2941/* #line 1453 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2942 if (single_use (captures[4]) && single_use (captures[5])
2943)
2944 {
2945 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 2945, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail112;
2946 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail112;
2947 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1454, __FILE__"generic-match.c", __LINE__2947);
2948 {
2949 tree res_op0;
2950 res_op0 = captures[0];
2951 tree res_op1;
2952 {
2953 tree _o1[1], _r1;
2954 _o1[0] = captures[6];
2955 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2955, __FUNCTION__))->typed.type)
!= type)
2956 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2957 else
2958 _r1 = _o1[0];
2959 res_op1 = _r1;
2960 }
2961 tree _r;
2962 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2963 return _r;
2964 }
2965next_after_fail112:;
2966 }
2967 else
2968 {
2969/* #line 1455 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
2970 if (single_use (captures[0]) && single_use (captures[1])
2971)
2972 {
2973 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 2973, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail113;
2974 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail113;
2975 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1456, __FILE__"generic-match.c", __LINE__2975);
2976 {
2977 tree res_op0;
2978 {
2979 tree _o1[1], _r1;
2980 _o1[0] = captures[3];
2981 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 2981, __FUNCTION__))->typed.type)
!= type)
2982 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
2983 else
2984 _r1 = _o1[0];
2985 res_op0 = _r1;
2986 }
2987 tree res_op1;
2988 res_op1 = captures[4];
2989 tree _r;
2990 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
2991 return _r;
2992 }
2993next_after_fail113:;
2994 }
2995 }
2996 }
2997 return NULL_TREE(tree) nullptr;
2998}
2999
3000static tree
3001generic_simplify_54 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3002 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3003, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (cmp2)cmp2 __attribute__ ((__unused__)))
3004{
3005/* #line 5109 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3006 if (tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3006, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3006, __FUNCTION__))->typed.type)
)
3007 && TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 3007, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3007, __FUNCTION__))->
base.u.bits.unsigned_flag)
&& !TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3007, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3007, __FUNCTION__))->
base.u.bits.unsigned_flag)
3008 && wi::gt_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", 3008, __FUNCTION__))->
typed.type)), (tcc_type), "generic-match.c", 3008, __FUNCTION__
))->base.u.bits.unsigned_flag))
)
3009)
3010 {
3011 {
3012/* #line 5112 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3013 tree utype = TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3013, __FUNCTION__))->typed.type)
;
3014 wide_int denom = wi::to_wide (captures[1]);
3015 wide_int right = wi::to_wide (captures[2]);
3016 wide_int smax = wi::sdiv_trunc (wi::max_value (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3016, __FUNCTION__))->typed.type)
), denom);
3017 wide_int smin = wi::sdiv_trunc (wi::min_value (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3017, __FUNCTION__))->typed.type)
), denom);
3018 bool small = wi::leu_p (right, smax);
3019 bool large = wi::geu_p (right, smin);
3020/* #line 5122 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3021 if (small || large
3022)
3023 {
3024 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3024, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail114;
3025 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3025, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail114;
3026 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail114;
3027 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5123, __FILE__"generic-match.c", __LINE__3027);
3028 {
3029 tree res_op0;
3030 {
3031 tree _o1[1], _r1;
3032 _o1[0] = captures[0];
3033 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3033, __FUNCTION__))->typed.type)
!= utype)
3034 _r1 = fold_build1_loc (loc, NOP_EXPR, utype, _o1[0]);
3035 else
3036 _r1 = _o1[0];
3037 res_op0 = _r1;
3038 }
3039 tree res_op1;
3040 {
3041 tree _o1[2], _r1;
3042 _o1[0] = captures[2];
3043 {
3044 tree _o2[1], _r2;
3045 _o2[0] = captures[1];
3046 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3046, __FUNCTION__))->typed.type)
!= TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.c"
, 3046, __FUNCTION__))->typed.type)
)
3047 _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.c"
, 3047, __FUNCTION__))->typed.type)
, _o2[0]);
3048 else
3049 _r2 = _o2[0];
3050 _o1[1] = _r2;
3051 }
3052 _r1 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3052, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3053 res_op1 = _r1;
3054 }
3055 tree _r;
3056 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
3057 return _r;
3058 }
3059next_after_fail114:;
3060 }
3061 else
3062 {
3063 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3063, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail115;
3064 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3064, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail115;
3065 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail115;
3066 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5124, __FILE__"generic-match.c", __LINE__3066);
3067 {
3068 tree res_op0;
3069 res_op0 = captures[0];
3070 tree res_op1;
3071 res_op1 = build_zero_cst (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3071, __FUNCTION__))->typed.type)
);
3072 tree _r;
3073 _r = fold_build2_loc (loc, cmp2, type, res_op0, res_op1);
3074 return _r;
3075 }
3076next_after_fail115:;
3077 }
3078 }
3079 }
3080 return NULL_TREE(tree) nullptr;
3081}
3082
3083static tree
3084generic_simplify_55 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3085 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3086, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (rbitop)rbitop __attribute__ ((__unused__)))
3087{
3088 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail116;
3089 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1658, __FILE__"generic-match.c", __LINE__3089);
3090 {
3091 tree _r;
3092 _r = captures[0];
3093 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3093, __FUNCTION__
))->base.side_effects_flag)
)
3094 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3095 return _r;
3096 }
3097next_after_fail116:;
3098 return NULL_TREE(tree) nullptr;
3099}
3100
3101static tree
3102generic_simplify_56 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3103 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3104, const enum tree_code ARG_UNUSED (mod)mod __attribute__ ((__unused__)))
3105{
3106/* #line 585 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3107 if (!TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 3107
, __FUNCTION__))->base.u.bits.unsigned_flag)
3108)
3109 {
3110 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail117;
3111 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 586, __FILE__"generic-match.c", __LINE__3111);
3112 {
3113 tree _r;
3114 _r = build_zero_cst (type);
3115 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3115, __FUNCTION__
))->base.side_effects_flag)
)
3116 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3117 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3117, __FUNCTION__
))->base.side_effects_flag)
)
3118 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3119 return _r;
3120 }
3121next_after_fail117:;
3122 }
3123 return NULL_TREE(tree) nullptr;
3124}
3125
3126static tree
3127generic_simplify_57 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3128 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3129)
3130{
3131 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 3131, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail118;
3132 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail118;
3133 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2271, __FILE__"generic-match.c", __LINE__3133);
3134 {
3135 tree _r;
3136 _r = captures[2];
3137 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3137, __FUNCTION__
))->base.side_effects_flag)
)
3138 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3139 return _r;
3140 }
3141next_after_fail118:;
3142 return NULL_TREE(tree) nullptr;
3143}
3144
3145static tree
3146generic_simplify_58 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3147 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
3148)
3149{
3150/* #line 6879 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3151 if (canonicalize_math_after_vectorization_p ()
3152)
3153 {
3154 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail119;
3155 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6897, __FILE__"generic-match.c", __LINE__3155);
3156 {
3157 tree res_op0;
3158 res_op0 = captures[0];
3159 tree res_op1;
3160 res_op1 = captures[1];
3161 tree res_op2;
3162 res_op2 = captures[2];
3163 tree _r;
3164 _r = maybe_build_call_expr_loc (loc, CFN_FNMS, type, 3, res_op0, res_op1, res_op2);
3165 if (!_r)
3166 goto next_after_fail119;
3167 return _r;
3168 }
3169next_after_fail119:;
3170 }
3171 return NULL_TREE(tree) nullptr;
3172}
3173
3174static tree
3175generic_simplify_59 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3176 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
3177, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3178{
3179 {
3180/* #line 4217 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3181 tree from_type = TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3181, __FUNCTION__))->typed.type)
;
3182 tree c1_type = TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3182, __FUNCTION__))->typed.type)
, c2_type = TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3182, __FUNCTION__))->typed.type)
;
3183 enum tree_code code = ERROR_MARK;
3184 if (INTEGRAL_TYPE_P (from_type)(((enum tree_code) (from_type)->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (from_type)->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (from_type)->base.code) == INTEGER_TYPE
)
3185 && int_fits_type_p (captures[2], from_type)
3186 && (types_match (c1_type, from_type)
3187 || (TYPE_PRECISION (c1_type)((tree_class_check ((c1_type), (tcc_type), "generic-match.c",
3187, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.c"
, 3187, __FUNCTION__))->type_common.precision)
3188 && (TYPE_UNSIGNED (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.c"
, 3188, __FUNCTION__))->base.u.bits.unsigned_flag)
3189 || TYPE_SIGN (c1_type)((signop) ((tree_class_check ((c1_type), (tcc_type), "generic-match.c"
, 3189, __FUNCTION__))->base.u.bits.unsigned_flag))
== TYPE_SIGN (from_type)((signop) ((tree_class_check ((from_type), (tcc_type), "generic-match.c"
, 3189, __FUNCTION__))->base.u.bits.unsigned_flag))
)))
3190 && (types_match (c2_type, from_type)
3191 || (TYPE_PRECISION (c2_type)((tree_class_check ((c2_type), (tcc_type), "generic-match.c",
3191, __FUNCTION__))->type_common.precision)
> TYPE_PRECISION (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.c"
, 3191, __FUNCTION__))->type_common.precision)
3192 && (TYPE_UNSIGNED (from_type)((tree_class_check ((from_type), (tcc_type), "generic-match.c"
, 3192, __FUNCTION__))->base.u.bits.unsigned_flag)
3193 || TYPE_SIGN (c2_type)((signop) ((tree_class_check ((c2_type), (tcc_type), "generic-match.c"
, 3193, __FUNCTION__))->base.u.bits.unsigned_flag))
== TYPE_SIGN (from_type)((signop) ((tree_class_check ((from_type), (tcc_type), "generic-match.c"
, 3193, __FUNCTION__))->base.u.bits.unsigned_flag))
))))
3194 {
3195 if (cmp != EQ_EXPR)
3196 {
3197 if (wi::to_widest (captures[1]) == (wi::to_widest (captures[2]) - 1))
3198 {
3199 if (cmp == LE_EXPR)
3200 code = LT_EXPR;
3201 if (cmp == GT_EXPR)
3202 code = GE_EXPR;
3203 }
3204 if (wi::to_widest (captures[1]) == (wi::to_widest (captures[2]) + 1))
3205 {
3206 if (cmp == LT_EXPR)
3207 code = LE_EXPR;
3208 if (cmp == GE_EXPR)
3209 code = GT_EXPR;
3210 }
3211 if (code != ERROR_MARK
3212 || wi::to_widest (captures[2]) == wi::to_widest (captures[1]))
3213 {
3214 if (cmp == LT_EXPR || cmp == LE_EXPR)
3215 code = MIN_EXPR;
3216 if (cmp == GT_EXPR || cmp == GE_EXPR)
3217 code = MAX_EXPR;
3218 }
3219 }
3220 else if (int_fits_type_p (captures[1], from_type))
3221 code = EQ_EXPR;
3222 }
3223/* #line 4268 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3224 if (code == MAX_EXPR
3225)
3226 {
3227 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3227, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail120;
3228 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3228, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail120;
3229 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3229, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail120;
3230 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail120;
3231 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4269, __FILE__"generic-match.c", __LINE__3231);
3232 {
3233 tree res_op0;
3234 {
3235 tree _o1[2], _r1;
3236 _o1[0] = captures[0];
3237 {
3238 tree _o2[1], _r2;
3239 _o2[0] = captures[2];
3240 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3240, __FUNCTION__))->typed.type)
!= TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3240, __FUNCTION__))->typed.type)
)
3241 _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3241, __FUNCTION__))->typed.type)
, _o2[0]);
3242 else
3243 _r2 = _o2[0];
3244 _o1[1] = _r2;
3245 }
3246 _r1 = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3246, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3247 res_op0 = _r1;
3248 }
3249 tree _r;
3250 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3251 return _r;
3252 }
3253next_after_fail120:;
3254 }
3255 else
3256 {
3257/* #line 4270 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3258 if (code == MIN_EXPR
3259)
3260 {
3261 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3261, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail121;
3262 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3262, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail121;
3263 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3263, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail121;
3264 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail121;
3265 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4271, __FILE__"generic-match.c", __LINE__3265);
3266 {
3267 tree res_op0;
3268 {
3269 tree _o1[2], _r1;
3270 _o1[0] = captures[0];
3271 {
3272 tree _o2[1], _r2;
3273 _o2[0] = captures[2];
3274 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3274, __FUNCTION__))->typed.type)
!= TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3274, __FUNCTION__))->typed.type)
)
3275 _r2 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3275, __FUNCTION__))->typed.type)
, _o2[0]);
3276 else
3277 _r2 = _o2[0];
3278 _o1[1] = _r2;
3279 }
3280 _r1 = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3280, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3281 res_op0 = _r1;
3282 }
3283 tree _r;
3284 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3285 return _r;
3286 }
3287next_after_fail121:;
3288 }
3289 else
3290 {
3291/* #line 4272 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3292 if (code == EQ_EXPR
3293)
3294 {
3295 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3295, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail122;
3296 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3296, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail122;
3297 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3297, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail122;
3298 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail122;
3299 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4273, __FILE__"generic-match.c", __LINE__3299);
3300 {
3301 if (! tree_invariant_p (captures[1])) goto next_after_fail122;
3302 tree res_op0;
3303 {
3304 tree _o1[3], _r1;
3305 {
3306 tree _o2[2], _r2;
3307 _o2[0] = captures[0];
3308 {
3309 tree _o3[1], _r3;
3310 _o3[0] = unshare_expr (captures[1]);
3311 if (TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 3311, __FUNCTION__))->typed.type)
!= TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3311, __FUNCTION__))->typed.type)
)
3312 _r3 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3312, __FUNCTION__))->typed.type)
, _o3[0]);
3313 else
3314 _r3 = _o3[0];
3315 _o2[1] = _r3;
3316 }
3317 _r2 = fold_build2_loc (loc, EQ_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], _o2[0], _o2[1]);
3318 _o1[0] = _r2;
3319 }
3320 {
3321 tree _o2[1], _r2;
3322 _o2[0] = captures[1];
3323 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3323, __FUNCTION__))->typed.type)
!= from_type)
3324 _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
3325 else
3326 _r2 = _o2[0];
3327 _o1[1] = _r2;
3328 }
3329 {
3330 tree _o2[1], _r2;
3331 _o2[0] = captures[2];
3332 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3332, __FUNCTION__))->typed.type)
!= from_type)
3333 _r2 = fold_build1_loc (loc, NOP_EXPR, from_type, _o2[0]);
3334 else
3335 _r2 = _o2[0];
3336 _o1[2] = _r2;
3337 }
3338 _r1 = fold_build3_loc (loc, COND_EXPR, TREE_TYPE (_o1[1])((contains_struct_check ((_o1[1]), (TS_TYPED), "generic-match.c"
, 3338, __FUNCTION__))->typed.type)
, _o1[0], _o1[1], _o1[2]);
3339 res_op0 = _r1;
3340 }
3341 tree _r;
3342 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3343 return _r;
3344 }
3345next_after_fail122:;
3346 }
3347 }
3348 }
3349 }
3350 return NULL_TREE(tree) nullptr;
3351}
3352
3353static tree
3354generic_simplify_60 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3355 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3356)
3357{
3358 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail123;
3359 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1326, __FILE__"generic-match.c", __LINE__3359);
3360 {
3361 tree res_op0;
3362 res_op0 = captures[0];
3363 tree res_op1;
3364 res_op1 = captures[1];
3365 tree _r;
3366 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
3367 return _r;
3368 }
3369next_after_fail123:;
3370 return NULL_TREE(tree) nullptr;
3371}
3372
3373static tree
3374generic_simplify_61 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3375 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3376)
3377{
3378 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail124;
3379 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1331, __FILE__"generic-match.c", __LINE__3379);
3380 {
3381 tree res_op0;
3382 res_op0 = captures[0];
3383 tree res_op1;
3384 res_op1 = captures[1];
3385 tree _r;
3386 _r = fold_build2_loc (loc, BIT_AND_EXPR, type, res_op0, res_op1);
3387 return _r;
3388 }
3389next_after_fail124:;
3390 return NULL_TREE(tree) nullptr;
3391}
3392
3393static tree
3394generic_simplify_62 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3395 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3396, const enum tree_code ARG_UNUSED (code2)code2 __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (code1)code1 __attribute__ ((__unused__)))
3397{
3398 {
3399/* #line 2417 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3400 int cmp = tree_int_cst_compare (captures[2], captures[4]);
3401/* #line 2423 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3402 if ((code1 == LT_EXPR || code1 == LE_EXPR)
3403 && (code2 == LT_EXPR || code2 == LE_EXPR)
3404)
3405 {
3406/* #line 2425 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3407 if ((cmp < 0) || (cmp == 0 && code1 == LT_EXPR)
3408)
3409 {
3410 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 3410, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail125;
3411 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3411, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail125;
3412 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail125;
3413 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2426, __FILE__"generic-match.c", __LINE__3413);
3414 {
3415 tree _r;
3416 _r = captures[3];
3417 return _r;
3418 }
3419next_after_fail125:;
3420 }
3421 else
3422 {
3423 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 3423, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail126;
3424 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 3424, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail126;
3425 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail126;
3426 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2427, __FILE__"generic-match.c", __LINE__3426);
3427 {
3428 tree _r;
3429 _r = captures[0];
3430 return _r;
3431 }
3432next_after_fail126:;
3433 }
3434 }
3435 else
3436 {
3437/* #line 2429 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3438 if ((code1 == GT_EXPR || code1 == GE_EXPR)
3439 && (code2 == GT_EXPR || code2 == GE_EXPR)
3440)
3441 {
3442/* #line 2431 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3443 if ((cmp > 0) || (cmp == 0 && code1 == GT_EXPR)
3444)
3445 {
3446 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 3446, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail127;
3447 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3447, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail127;
3448 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail127;
3449 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2432, __FILE__"generic-match.c", __LINE__3449);
3450 {
3451 tree _r;
3452 _r = captures[3];
3453 return _r;
3454 }
3455next_after_fail127:;
3456 }
3457 else
3458 {
3459 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 3459, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail128;
3460 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 3460, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail128;
3461 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail128;
3462 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2433, __FILE__"generic-match.c", __LINE__3462);
3463 {
3464 tree _r;
3465 _r = captures[0];
3466 return _r;
3467 }
3468next_after_fail128:;
3469 }
3470 }
3471 else
3472 {
3473/* #line 2435 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3474 if (cmp == 0
3475 && ((code1 == LT_EXPR && code2 == GT_EXPR)
3476 || (code1 == GT_EXPR && code2 == LT_EXPR))
3477)
3478 {
3479 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3479, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail129;
3480 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 3480, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail129;
3481 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail129;
3482 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2438, __FILE__"generic-match.c", __LINE__3482);
3483 {
3484 tree res_op0;
3485 res_op0 = captures[1];
3486 tree res_op1;
3487 res_op1 = captures[4];
3488 tree _r;
3489 _r = fold_build2_loc (loc, NE_EXPR, type, res_op0, res_op1);
3490 return _r;
3491 }
3492next_after_fail129:;
3493 }
3494 else
3495 {
3496/* #line 2440 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3497 if (cmp >= 0
3498 && (code1 == LT_EXPR || code1 == LE_EXPR)
3499 && (code2 == GT_EXPR || code2 == GE_EXPR)
3500)
3501 {
3502 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3502, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail130;
3503 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 3503, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail130;
3504 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail130;
3505 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2443, __FILE__"generic-match.c", __LINE__3505);
3506 {
3507 tree _r;
3508 _r = constant_boolean_node (true, type);
3509 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3509, __FUNCTION__
))->base.side_effects_flag)
)
3510 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3511 return _r;
3512 }
3513next_after_fail130:;
3514 }
3515 else
3516 {
3517/* #line 2444 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3518 if (cmp <= 0
3519 && (code1 == GT_EXPR || code1 == GE_EXPR)
3520 && (code2 == LT_EXPR || code2 == LE_EXPR)
3521)
3522 {
3523 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 3523, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail131;
3524 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 3524, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail131;
3525 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail131;
3526 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2447, __FILE__"generic-match.c", __LINE__3526);
3527 {
3528 tree _r;
3529 _r = constant_boolean_node (true, type);
3530 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3530, __FUNCTION__
))->base.side_effects_flag)
)
3531 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3532 return _r;
3533 }
3534next_after_fail131:;
3535 }
3536 }
3537 }
3538 }
3539 }
3540 }
3541 return NULL_TREE(tree) nullptr;
3542}
3543
3544static tree
3545generic_simplify_63 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3546 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3547, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (acmp)acmp __attribute__ ((__unused__)))
3548{
3549 {
3550/* #line 4524 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3551 tree cst = uniform_integer_cst_p (captures[1]);
3552/* #line 4525 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3553 if (tree_int_cst_sgn (cst) == 1
3554)
3555 {
3556 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail132;
3557 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4526, __FILE__"generic-match.c", __LINE__3557);
3558 {
3559 tree res_op0;
3560 res_op0 = captures[0];
3561 tree res_op1;
3562 res_op1 = build_uniform_cst (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3562, __FUNCTION__))->typed.type)
,
3563 wide_int_to_tree (TREE_TYPE (cst)((contains_struct_check ((cst), (TS_TYPED), "generic-match.c"
, 3563, __FUNCTION__))->typed.type)
,
3564 wi::to_wide (cst) - 1));
3565 tree _r;
3566 _r = fold_build2_loc (loc, acmp, type, res_op0, res_op1);
3567 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3567, __FUNCTION__
))->base.side_effects_flag)
)
3568 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
3569 return _r;
3570 }
3571next_after_fail132:;
3572 }
3573 }
3574 return NULL_TREE(tree) nullptr;
3575}
3576
3577static tree
3578generic_simplify_64 (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 (op)op __attribute__ ((__unused__)))
3581{
3582/* #line 1971 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3583 if (ANY_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) || ((((enum tree_code
) (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 3583, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[1]
), (TS_TYPED), "generic-match.c", 3583, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 3583, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 3583, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 3583, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 3583, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 3583, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 3583, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
3584 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 3584, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (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[1]), (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 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail133;
3588 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1973, __FILE__"generic-match.c", __LINE__3588);
3589 {
3590 tree res_op0;
3591 res_op0 = captures[2];
3592 tree res_op1;
3593 res_op1 = captures[1];
3594 tree _r;
3595 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
3596 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3596, __FUNCTION__
))->base.side_effects_flag)
)
3597 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3598 return _r;
3599 }
3600next_after_fail133:;
3601 }
3602 return NULL_TREE(tree) nullptr;
3603}
3604
3605static tree
3606generic_simplify_65 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3607 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3608)
3609{
3610/* #line 2451 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3611 if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 3611, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
3612)
3613 {
3614/* #line 2509 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3615 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", 3615, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
|| flag_associative_mathglobal_options.x_flag_associative_math)
3616 && !FIXED_POINT_TYPE_P (type)(((enum tree_code) (type)->base.code) == FIXED_POINT_TYPE)
3617)
3618 {
3619/* #line 2550 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3620 if (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", 3620, __FUNCTION__))->base.u.
bits.unsigned_flag && !global_options.x_flag_wrapv &&
!global_options.x_flag_trapv))
3621 && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3621, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3621, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 3621, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) && !((((enum tree_code
) (((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3621, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 3621, __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", 3621, __FUNCTION__))->
typed.type)), "generic-match.c", 3621, __FUNCTION__))->base
.u.bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
3622)
3623 {
3624 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail134;
3625 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__3625);
3626 {
3627 tree res_op0;
3628 res_op0 = captures[2];
3629 tree res_op1;
3630 res_op1 = captures[1];
3631 tree _r;
3632 _r = fold_build2_loc (loc, POINTER_DIFF_EXPR, type, res_op0, res_op1);
3633 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3633, __FUNCTION__
))->base.side_effects_flag)
)
3634 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3635 return _r;
3636 }
3637next_after_fail134:;
3638 }
3639 }
3640 }
3641 return NULL_TREE(tree) nullptr;
3642}
3643
3644static tree
3645generic_simplify_66 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3646 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3647, const enum tree_code ARG_UNUSED (bit_op)bit_op __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (shift)shift __attribute__ ((__unused__)))
3648{
3649/* #line 3513 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3650 if (tree_nop_conversion_p (type, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3650, __FUNCTION__))->typed.type)
)
3651)
3652 {
3653 {
3654/* #line 3514 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3655 tree mask = int_const_binop (shift, fold_convert (type, captures[3])fold_convert_loc (((location_t) 0), type, captures[3]), captures[4]);
3656/* #line 3515 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3657 if (mask
3658)
3659 {
3660 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 3660, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail135;
3661 if (TREE_SIDE_EFFECTS (captures[4])((non_type_check ((captures[4]), "generic-match.c", 3661, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail135;
3662 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail135;
3663 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3516, __FILE__"generic-match.c", __LINE__3663);
3664 {
3665 tree res_op0;
3666 {
3667 tree _o1[2], _r1;
3668 {
3669 tree _o2[1], _r2;
3670 _o2[0] = captures[2];
3671 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3671, __FUNCTION__))->typed.type)
!= type)
3672 _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
3673 else
3674 _r2 = _o2[0];
3675 _o1[0] = _r2;
3676 }
3677 _o1[1] = captures[4];
3678 _r1 = fold_build2_loc (loc, shift, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3678, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3679 res_op0 = _r1;
3680 }
3681 tree res_op1;
3682 res_op1 = mask;
3683 tree _r;
3684 _r = fold_build2_loc (loc, bit_op, type, res_op0, res_op1);
3685 return _r;
3686 }
3687next_after_fail135:;
3688 }
3689 }
3690 }
3691 return NULL_TREE(tree) nullptr;
3692}
3693
3694static tree
3695generic_simplify_67 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3696 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3697)
3698{
3699 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail136;
3700 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1341, __FILE__"generic-match.c", __LINE__3700);
3701 {
3702 tree res_op0;
3703 res_op0 = captures[0];
3704 tree res_op1;
3705 res_op1 = captures[1];
3706 tree _r;
3707 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
3708 return _r;
3709 }
3710next_after_fail136:;
3711 return NULL_TREE(tree) nullptr;
3712}
3713
3714static tree
3715generic_simplify_68 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3716 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3717, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3718{
3719/* #line 5352 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3720 if (tree_single_nonzero_warnv_p (captures[0], NULLnullptr)
3721)
3722 {
3723 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 3723, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail137;
3724 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail137;
3725 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5353, __FILE__"generic-match.c", __LINE__3725);
3726 {
3727 tree _r;
3728 _r = constant_boolean_node (cmp == NE_EXPR, type);
3729 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 3729, __FUNCTION__
))->base.side_effects_flag)
)
3730 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
3731 return _r;
3732 }
3733next_after_fail137:;
3734 }
3735 return NULL_TREE(tree) nullptr;
3736}
3737
3738static tree
3739generic_simplify_69 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3740 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
3741)
3742{
3743/* #line 3521 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3744 if (!TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 3744, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3744, __FUNCTION__))->
base.u.bits.unsigned_flag)
3745 && (element_precision (TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3745, __FUNCTION__))->typed.type)
)
3746 <= element_precision (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 3746, __FUNCTION__))->typed.type)
)
3747 || !TYPE_UNSIGNED (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 3747, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3747, __FUNCTION__))->
base.u.bits.unsigned_flag)
)
3748)
3749 {
3750 {
3751/* #line 3525 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3752 tree shift_type = TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3752, __FUNCTION__))->typed.type)
;
3753 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail138;
3754 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3527, __FILE__"generic-match.c", __LINE__3754);
3755 {
3756 tree res_op0;
3757 {
3758 tree _o1[2], _r1;
3759 {
3760 tree _o2[1], _r2;
3761 _o2[0] = captures[3];
3762 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3762, __FUNCTION__))->typed.type)
!= shift_type)
3763 _r2 = fold_build1_loc (loc, NOP_EXPR, shift_type, _o2[0]);
3764 else
3765 _r2 = _o2[0];
3766 _o1[0] = _r2;
3767 }
3768 _o1[1] = captures[4];
3769 _r1 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3769, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3770 res_op0 = _r1;
3771 }
3772 tree _r;
3773 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3774 return _r;
3775 }
3776next_after_fail138:;
3777 }
3778 }
3779 return NULL_TREE(tree) nullptr;
3780}
3781
3782static tree
3783generic_simplify_70 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3784 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree ARG_UNUSED (_p2)_p2 __attribute__ ((__unused__)), tree *captures
3785, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3786{
3787/* #line 5412 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3788 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)
3789 && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3789, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3789, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 3789, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
3790 && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3790, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3790, __FUNCTION__))->
base.u.bits.unsigned_flag)
3791 && TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3791, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3791, __FUNCTION__))->
type_common.precision)
== TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 3791
, __FUNCTION__))->type_common.precision)
3792)
3793 {
3794 {
3795/* #line 5416 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3796 tree shifter = build_int_cst (integer_type_nodeinteger_types[itk_int], TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 3796
, __FUNCTION__))->type_common.precision)
- 1);
3797/* #line 5420 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3798 if (cmp == GE_EXPR
3799)
3800 {
3801 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 3801, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail139;
3802 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3802, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail139;
3803 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail139;
3804 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5421, __FILE__"generic-match.c", __LINE__3804);
3805 {
3806 tree res_op0;
3807 {
3808 tree _o1[1], _r1;
3809 {
3810 tree _o2[2], _r2;
3811 _o2[0] = captures[0];
3812 _o2[1] = shifter;
3813 _r2 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3813, __FUNCTION__))->typed.type)
, _o2[0], _o2[1]);
3814 _o1[0] = _r2;
3815 }
3816 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3816, __FUNCTION__))->typed.type)
!= type)
3817 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3818 else
3819 _r1 = _o1[0];
3820 res_op0 = _r1;
3821 }
3822 tree res_op1;
3823 res_op1 = captures[1];
3824 tree _r;
3825 _r = fold_build2_loc (loc, BIT_XOR_EXPR, type, res_op0, res_op1);
3826 return _r;
3827 }
3828next_after_fail139:;
3829 }
3830 else
3831 {
3832 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 3832, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail140;
3833 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 3833, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail140;
3834 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail140;
3835 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5422, __FILE__"generic-match.c", __LINE__3835);
3836 {
3837 tree res_op0;
3838 {
3839 tree _o1[2], _r1;
3840 {
3841 tree _o2[1], _r2;
3842 {
3843 tree _o3[2], _r3;
3844 _o3[0] = captures[0];
3845 _o3[1] = shifter;
3846 _r3 = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 3846, __FUNCTION__))->typed.type)
, _o3[0], _o3[1]);
3847 _o2[0] = _r3;
3848 }
3849 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3849, __FUNCTION__))->typed.type)
!= type)
3850 _r2 = fold_build1_loc (loc, NOP_EXPR, type, _o2[0]);
3851 else
3852 _r2 = _o2[0];
3853 _o1[0] = _r2;
3854 }
3855 _o1[1] = captures[1];
3856 _r1 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3856, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3857 res_op0 = _r1;
3858 }
3859 tree _r;
3860 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
3861 return _r;
3862 }
3863next_after_fail140:;
3864 }
3865 }
3866 }
3867 return NULL_TREE(tree) nullptr;
3868}
3869
3870static tree
3871generic_simplify_71 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3872 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3873)
3874{
3875/* #line 1499 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3876 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)
3877 && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3877, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3877, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 3877, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
3878 && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 3878, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 3878, __FUNCTION__))->
base.u.bits.unsigned_flag)
3879)
3880 {
3881/* #line 1502 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3882 if (TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 3882
, __FUNCTION__))->base.u.bits.unsigned_flag)
3883)
3884 {
3885 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 3885, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail141;
3886 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail141;
3887 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1503, __FILE__"generic-match.c", __LINE__3887);
3888 {
3889 tree res_op0;
3890 res_op0 = captures[0];
3891 tree _r;
3892 _r = fold_build1_loc (loc, ABSU_EXPR, type, res_op0);
3893 return _r;
3894 }
3895next_after_fail141:;
3896 }
3897 else
3898 {
3899 if (TREE_SIDE_EFFECTS (_p0)((non_type_check ((_p0), "generic-match.c", 3899, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail142;
3900 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail142;
3901 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1504, __FILE__"generic-match.c", __LINE__3901);
3902 {
3903 tree res_op0;
3904 res_op0 = captures[0];
3905 tree _r;
3906 _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
3907 return _r;
3908 }
3909next_after_fail142:;
3910 }
3911 }
3912 return NULL_TREE(tree) nullptr;
3913}
3914
3915static tree
3916generic_simplify_72 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3917 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3918)
3919{
3920/* #line 1366 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3921 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", 3921, __FUNCTION__))->base.u.
bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
&& !TYPE_OVERFLOW_TRAPS (type)(!(any_integral_type_check ((type), "generic-match.c", 3921, __FUNCTION__
))->base.u.bits.unsigned_flag && global_options.x_flag_trapv
)
3922 && !TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 3922, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
&& !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[2]))((((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 3922, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3922, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 3922, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) && !((((enum tree_code
) (((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 3922, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 3922, __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", 3922, __FUNCTION__))->
typed.type)), "generic-match.c", 3922, __FUNCTION__))->base
.u.bits.unsigned_flag || global_options.x_flag_wrapv)) &&
(global_options.x_flag_sanitize & SANITIZE_SI_OVERFLOW))
3923 && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (captures[2]))(!(any_integral_type_check ((((contains_struct_check ((captures
[2]), (TS_TYPED), "generic-match.c", 3923, __FUNCTION__))->
typed.type)), "generic-match.c", 3923, __FUNCTION__))->base
.u.bits.unsigned_flag && global_options.x_flag_trapv)
3924 && !TYPE_SATURATING (TREE_TYPE (captures[2]))((tree_not_check4 ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 3924, __FUNCTION__))->typed.
type)), "generic-match.c", 3924, __FUNCTION__, (RECORD_TYPE),
(UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE)))->base.u.bits
.saturating_flag)
3925)
3926 {
3927 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 3927, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail143;
3928 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail143;
3929 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1370, __FILE__"generic-match.c", __LINE__3929);
3930 {
3931 tree res_op0;
3932 {
3933 tree _o1[1], _r1;
3934 {
3935 tree _o2[2], _r2;
3936 _o2[0] = captures[0];
3937 _o2[1] = captures[1];
3938 _r2 = fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3938, __FUNCTION__))->typed.type)
, _o2[0], _o2[1]);
3939 _o1[0] = _r2;
3940 }
3941 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3941, __FUNCTION__))->typed.type)
!= type)
3942 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
3943 else
3944 _r1 = _o1[0];
3945 res_op0 = _r1;
3946 }
3947 tree _r;
3948 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
3949 return _r;
3950 }
3951next_after_fail143:;
3952 }
3953 return NULL_TREE(tree) nullptr;
3954}
3955
3956static tree
3957generic_simplify_73 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3958 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3959)
3960{
3961/* #line 1398 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
3962 if (tree_nop_conversion_p (type, TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 3962, __FUNCTION__))->typed.type)
)
3963)
3964 {
3965 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail144;
3966 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1399, __FILE__"generic-match.c", __LINE__3966);
3967 {
3968 tree res_op0;
3969 {
3970 tree _o1[2], _r1;
3971 _o1[0] = captures[1];
3972 {
3973 tree _o2[1], _r2;
3974 _o2[0] = captures[0];
3975 _r2 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 3975, __FUNCTION__))->typed.type)
, _o2[0]);
3976 _o1[1] = _r2;
3977 }
3978 _r1 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 3978, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
3979 res_op0 = _r1;
3980 }
3981 tree _r;
3982 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
3983 return _r;
3984 }
3985next_after_fail144:;
3986 }
3987 return NULL_TREE(tree) nullptr;
3988}
3989
3990static tree
3991generic_simplify_74 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
3992 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
3993, const enum tree_code ARG_UNUSED (minmax)minmax __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
3994{
3995 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail145;
3996 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3214, __FILE__"generic-match.c", __LINE__3996);
3997 {
3998 tree _r;
3999 _r = constant_boolean_node (cmp == GE_EXPR || cmp == LE_EXPR, type);
4000 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 4000, __FUNCTION__
))->base.side_effects_flag)
)
4001 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4002 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4002, __FUNCTION__
))->base.side_effects_flag)
)
4003 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4004 return _r;
4005 }
4006next_after_fail145:;
4007 return NULL_TREE(tree) nullptr;
4008}
4009
4010static tree
4011generic_simplify_75 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4012 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4013, const enum tree_code ARG_UNUSED (div)div __attribute__ ((__unused__)))
4014{
4015/* #line 703 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4016 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", 4016, __FUNCTION__))->typed.type))->
base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 4016, __FUNCTION__))
->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "generic-match.c"
, 4016, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
4017)
4018 {
4019/* #line 704 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4020 if (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", 4020, __FUNCTION__))->base.u.
bits.unsigned_flag && !global_options.x_flag_wrapv &&
!global_options.x_flag_trapv))
4021)
4022 {
4023 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail146;
4024 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 705, __FILE__"generic-match.c", __LINE__4024);
4025 {
4026 tree _r;
4027 _r = captures[0];
4028 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4028, __FUNCTION__
))->base.side_effects_flag)
)
4029 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4030 return _r;
4031 }
4032next_after_fail146:;
4033 }
4034 }
4035 return NULL_TREE(tree) nullptr;
4036}
4037
4038static tree
4039generic_simplify_76 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4040 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4041, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4042{
4043/* #line 1876 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4044 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4044, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4044, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 4044, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4045 && integer_nonzerop (captures[2])
4046 && !TREE_OVERFLOW (captures[2])((tree_class_check ((captures[2]), (tcc_constant), "generic-match.c"
, 4046, __FUNCTION__))->base.public_flag)
4047 && !TREE_OVERFLOW (captures[3])((tree_class_check ((captures[3]), (tcc_constant), "generic-match.c"
, 4047, __FUNCTION__))->base.public_flag)
4048)
4049 {
4050 {
4051/* #line 1880 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4052 tree lo, hi; bool neg_overflow;
4053 enum tree_code code = fold_div_compare (cmp, captures[2], captures[3], &lo, &hi,
4054 &neg_overflow);
4055/* #line 1884 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4056 if (code == LT_EXPR || code == GE_EXPR
4057)
4058 {
4059/* #line 1885 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4060 if (TREE_OVERFLOW (lo)((tree_class_check ((lo), (tcc_constant), "generic-match.c", 4060
, __FUNCTION__))->base.public_flag)
4061)
4062 {
4063 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4063, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail147;
4064 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4064, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail147;
4065 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail147;
4066 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__4066);
4067 {
4068 tree _r;
4069 _r = build_int_cst (type, (code == LT_EXPR) ^ neg_overflow);
4070 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4070, __FUNCTION__
))->base.side_effects_flag)
)
4071 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4072 return _r;
4073 }
4074next_after_fail147:;
4075 }
4076 else
4077 {
4078/* #line 1887 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4079 if (code == LT_EXPR
4080)
4081 {
4082 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4082, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail148;
4083 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4083, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail148;
4084 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail148;
4085 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1888, __FILE__"generic-match.c", __LINE__4085);
4086 {
4087 tree res_op0;
4088 res_op0 = captures[1];
4089 tree res_op1;
4090 res_op1 = lo;
4091 tree _r;
4092 _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
4093 return _r;
4094 }
4095next_after_fail148:;
4096 }
4097 else
4098 {
4099 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4099, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail149;
4100 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4100, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail149;
4101 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail149;
4102 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1889, __FILE__"generic-match.c", __LINE__4102);
4103 {
4104 tree res_op0;
4105 res_op0 = captures[1];
4106 tree res_op1;
4107 res_op1 = lo;
4108 tree _r;
4109 _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
4110 return _r;
4111 }
4112next_after_fail149:;
4113 }
4114 }
4115 }
4116 else
4117 {
4118/* #line 1890 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4119 if (code == LE_EXPR || code == GT_EXPR
4120)
4121 {
4122/* #line 1891 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4123 if (TREE_OVERFLOW (hi)((tree_class_check ((hi), (tcc_constant), "generic-match.c", 4123
, __FUNCTION__))->base.public_flag)
4124)
4125 {
4126 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4126, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail150;
4127 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4127, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail150;
4128 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail150;
4129 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1892, __FILE__"generic-match.c", __LINE__4129);
4130 {
4131 tree _r;
4132 _r = build_int_cst (type, (code == LE_EXPR) ^ neg_overflow);
4133 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4133, __FUNCTION__
))->base.side_effects_flag)
)
4134 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4135 return _r;
4136 }
4137next_after_fail150:;
4138 }
4139 else
4140 {
4141/* #line 1893 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4142 if (code == LE_EXPR
4143)
4144 {
4145 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4145, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail151;
4146 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4146, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail151;
4147 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail151;
4148 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1894, __FILE__"generic-match.c", __LINE__4148);
4149 {
4150 tree res_op0;
4151 res_op0 = captures[1];
4152 tree res_op1;
4153 res_op1 = hi;
4154 tree _r;
4155 _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
4156 return _r;
4157 }
4158next_after_fail151:;
4159 }
4160 else
4161 {
4162 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4162, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail152;
4163 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4163, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail152;
4164 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail152;
4165 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1895, __FILE__"generic-match.c", __LINE__4165);
4166 {
4167 tree res_op0;
4168 res_op0 = captures[1];
4169 tree res_op1;
4170 res_op1 = hi;
4171 tree _r;
4172 _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
4173 return _r;
4174 }
4175next_after_fail152:;
4176 }
4177 }
4178 }
4179 else
4180 {
4181/* #line 1896 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4182 if (!lo && !hi
4183)
4184 {
4185 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4185, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail153;
4186 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4186, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail153;
4187 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail153;
4188 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1897, __FILE__"generic-match.c", __LINE__4188);
4189 {
4190 tree _r;
4191 _r = build_int_cst (type, code == NE_EXPR);
4192 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4192, __FUNCTION__
))->base.side_effects_flag)
)
4193 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4194 return _r;
4195 }
4196next_after_fail153:;
4197 }
4198 else
4199 {
4200/* #line 1898 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4201 if (code == EQ_EXPR && !hi
4202)
4203 {
4204 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4204, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail154;
4205 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4205, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail154;
4206 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail154;
4207 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1899, __FILE__"generic-match.c", __LINE__4207);
4208 {
4209 tree res_op0;
4210 res_op0 = captures[1];
4211 tree res_op1;
4212 res_op1 = lo;
4213 tree _r;
4214 _r = fold_build2_loc (loc, GE_EXPR, type, res_op0, res_op1);
4215 return _r;
4216 }
4217next_after_fail154:;
4218 }
4219 else
4220 {
4221/* #line 1900 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4222 if (code == EQ_EXPR && !lo
4223)
4224 {
4225 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4225, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail155;
4226 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4226, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail155;
4227 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail155;
4228 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1901, __FILE__"generic-match.c", __LINE__4228);
4229 {
4230 tree res_op0;
4231 res_op0 = captures[1];
4232 tree res_op1;
4233 res_op1 = hi;
4234 tree _r;
4235 _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
4236 return _r;
4237 }
4238next_after_fail155:;
4239 }
4240 else
4241 {
4242/* #line 1902 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4243 if (code == NE_EXPR && !hi
4244)
4245 {
4246 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4246, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail156;
4247 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4247, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail156;
4248 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail156;
4249 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1903, __FILE__"generic-match.c", __LINE__4249);
4250 {
4251 tree res_op0;
4252 res_op0 = captures[1];
4253 tree res_op1;
4254 res_op1 = lo;
4255 tree _r;
4256 _r = fold_build2_loc (loc, LT_EXPR, type, res_op0, res_op1);
4257 return _r;
4258 }
4259next_after_fail156:;
4260 }
4261 else
4262 {
4263/* #line 1904 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4264 if (code == NE_EXPR && !lo
4265)
4266 {
4267 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4267, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail157;
4268 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4268, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail157;
4269 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail157;
4270 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1905, __FILE__"generic-match.c", __LINE__4270);
4271 {
4272 tree res_op0;
4273 res_op0 = captures[1];
4274 tree res_op1;
4275 res_op1 = hi;
4276 tree _r;
4277 _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
4278 return _r;
4279 }
4280next_after_fail157:;
4281 }
4282 else
4283 {
4284/* #line 1906 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4285 if (1
4286)
4287 {
4288 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4288, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail158;
4289 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4289, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail158;
4290 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4290, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail158;
4291 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail158;
4292 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1907, __FILE__"generic-match.c", __LINE__4292);
4293 {
4294 tree _r;
4295 _r = build_range_check (UNKNOWN_LOCATION((location_t) 0), type, captures[1], code == EQ_EXPR,
4296 lo, hi);
4297 return _r;
4298 }
4299next_after_fail158:;
4300 }
4301 else
4302 {
4303 {
4304/* #line 1909 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4305 tree etype = range_check_type (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4305, __FUNCTION__))->typed.type)
);
4306 if (etype)
4307 {
4308 hi = fold_convert (etype, hi)fold_convert_loc (((location_t) 0), etype, hi);
4309 lo = fold_convert (etype, lo)fold_convert_loc (((location_t) 0), etype, lo);
4310 hi = const_binop (MINUS_EXPR, etype, hi, lo);
4311 }
4312/* #line 1919 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4313 if (etype && hi && !TREE_OVERFLOW (hi)((tree_class_check ((hi), (tcc_constant), "generic-match.c", 4313
, __FUNCTION__))->base.public_flag)
4314)
4315 {
4316/* #line 1920 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4317 if (code == EQ_EXPR
4318)
4319 {
4320 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4320, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail159;
4321 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4321, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail159;
4322 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail159;
4323 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1921, __FILE__"generic-match.c", __LINE__4323);
4324 {
4325 tree res_op0;
4326 {
4327 tree _o1[2], _r1;
4328 {
4329 tree _o2[1], _r2;
4330 _o2[0] = captures[1];
4331 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 4331, __FUNCTION__))->typed.type)
!= etype)
4332 _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
4333 else
4334 _r2 = _o2[0];
4335 _o1[0] = _r2;
4336 }
4337 _o1[1] = lo;
4338 _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4338, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
4339 res_op0 = _r1;
4340 }
4341 tree res_op1;
4342 res_op1 = hi;
4343 tree _r;
4344 _r = fold_build2_loc (loc, LE_EXPR, type, res_op0, res_op1);
4345 return _r;
4346 }
4347next_after_fail159:;
4348 }
4349 else
4350 {
4351 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4351, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail160;
4352 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4352, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail160;
4353 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail160;
4354 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1922, __FILE__"generic-match.c", __LINE__4354);
4355 {
4356 tree res_op0;
4357 {
4358 tree _o1[2], _r1;
4359 {
4360 tree _o2[1], _r2;
4361 _o2[0] = captures[1];
4362 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 4362, __FUNCTION__))->typed.type)
!= etype)
4363 _r2 = fold_build1_loc (loc, NOP_EXPR, etype, _o2[0]);
4364 else
4365 _r2 = _o2[0];
4366 _o1[0] = _r2;
4367 }
4368 _o1[1] = lo;
4369 _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4369, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
4370 res_op0 = _r1;
4371 }
4372 tree res_op1;
4373 res_op1 = hi;
4374 tree _r;
4375 _r = fold_build2_loc (loc, GT_EXPR, type, res_op0, res_op1);
4376 return _r;
4377 }
4378next_after_fail160:;
4379 }
4380 }
4381 }
4382 }
4383 }
4384 }
4385 }
4386 }
4387 }
4388 }
4389 }
4390 }
4391 }
4392 return NULL_TREE(tree) nullptr;
4393}
4394
4395static tree
4396generic_simplify_77 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4397 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4398)
4399{
4400 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4400, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail161;
4401 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail161;
4402 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2281, __FILE__"generic-match.c", __LINE__4402);
4403 {
4404 tree _r;
4405 _r = constant_boolean_node (true, type);
4406 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4406, __FUNCTION__
))->base.side_effects_flag)
)
4407 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4408 return _r;
4409 }
4410next_after_fail161:;
4411 return NULL_TREE(tree) nullptr;
4412}
4413
4414static tree
4415generic_simplify_78 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4416 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4417, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4418{
4419/* #line 3246 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4420 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)
4421 && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))(((enum tree_code) (((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 4421, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4421, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[2])
, (TS_TYPED), "generic-match.c", 4421, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4422 && TREE_CODE (TREE_TYPE (captures[2]))((enum tree_code) (((contains_struct_check ((captures[2]), (TS_TYPED
), "generic-match.c", 4422, __FUNCTION__))->typed.type))->
base.code)
!= BOOLEAN_TYPE
4423 && INTEGRAL_TYPE_P (TREE_TYPE (captures[3]))(((enum tree_code) (((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 4423, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 4423, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[3])
, (TS_TYPED), "generic-match.c", 4423, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4424 && (TYPE_PRECISION (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 4424, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4424, __FUNCTION__))->
type_common.precision)
>= TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "generic-match.c", 4424
, __FUNCTION__))->type_common.precision)
4425 || !TYPE_UNSIGNED (TREE_TYPE (captures[2]))((tree_class_check ((((contains_struct_check ((captures[2]), (
TS_TYPED), "generic-match.c", 4425, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4425, __FUNCTION__))->
base.u.bits.unsigned_flag)
)
4426 && (
44270
4428 || !TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4428, __FUNCTION__
))->base.side_effects_flag)
)
4429)
4430 {
4431 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail162;
4432 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3253, __FILE__"generic-match.c", __LINE__4432);
4433 {
4434 tree res_op0;
4435 {
4436 tree _o1[2], _r1;
4437 _o1[0] = captures[4];
4438 _o1[1] = captures[5];
4439 _r1 = fold_build2_loc (loc, cmp, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], _o1[0], _o1[1]);
4440 res_op0 = _r1;
4441 }
4442 tree res_op1;
4443 res_op1 = captures[1];
4444 tree res_op2;
4445 res_op2 = captures[0];
4446 tree _r;
4447 _r = fold_build3_loc (loc, COND_EXPR, type, res_op0, res_op1, res_op2);
4448 return _r;
4449 }
4450next_after_fail162:;
4451 }
4452 return NULL_TREE(tree) nullptr;
4453}
4454
4455static tree
4456generic_simplify_79 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4457 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
4458, const enum tree_code ARG_UNUSED (bitop)bitop __attribute__ ((__unused__)), const combined_fn ARG_UNUSED (bswap)bswap __attribute__ ((__unused__)))
4459{
4460 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail163;
4461 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3894, __FILE__"generic-match.c", __LINE__4461);
4462 {
4463 tree res_op0;
4464 res_op0 = captures[0];
4465 tree res_op1;
4466 {
4467 tree _o1[1], _r1;
4468 _o1[0] = captures[1];
4469 {
4470 _r1 = maybe_build_call_expr_loc (loc, bswap, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4470, __FUNCTION__))->typed.type)
, 1, _o1[0]);
4471 if (!_r1)
4472 goto next_after_fail163;
4473 }
4474 res_op1 = _r1;
4475 }
4476 tree _r;
4477 _r = fold_build2_loc (loc, bitop, type, res_op0, res_op1);
4478 return _r;
4479 }
4480next_after_fail163:;
4481 return NULL_TREE(tree) nullptr;
4482}
4483
4484static tree
4485generic_simplify_80 (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 1539 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4490 if (tree_nop_conversion_p (type, TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4490, __FUNCTION__))->typed.type)
)
4491 && tree_nop_conversion_p (type, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4491, __FUNCTION__))->typed.type)
)
4492)
4493 {
4494 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail164;
4495 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 1541, __FILE__"generic-match.c", __LINE__4495);
4496 {
4497 tree res_op0;
4498 {
4499 tree _o1[1], _r1;
4500 _o1[0] = captures[0];
4501 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4501, __FUNCTION__))->typed.type)
!= type)
4502 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4503 else
4504 _r1 = _o1[0];
4505 res_op0 = _r1;
4506 }
4507 tree res_op1;
4508 {
4509 tree _o1[1], _r1;
4510 {
4511 tree _o2[1], _r2;
4512 _o2[0] = captures[1];
4513 _r2 = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 4513, __FUNCTION__))->typed.type)
, _o2[0]);
4514 _o1[0] = _r2;
4515 }
4516 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4516, __FUNCTION__))->typed.type)
!= type)
4517 _r1 = fold_build1_loc (loc, NOP_EXPR, type, _o1[0]);
4518 else
4519 _r1 = _o1[0];
4520 res_op1 = _r1;
4521 }
4522 tree _r;
4523 _r = fold_build2_loc (loc, MULT_EXPR, type, res_op0, res_op1);
4524 return _r;
4525 }
4526next_after_fail164:;
4527 }
4528 return NULL_TREE(tree) nullptr;
4529}
4530
4531static tree
4532generic_simplify_81 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4533 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4534, const combined_fn ARG_UNUSED (COPYSIGN_ALL)COPYSIGN_ALL __attribute__ ((__unused__)))
4535{
4536/* #line 320 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4537 if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
4538)
4539 {
4540 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4540, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail165;
4541 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail165;
4542 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 321, __FILE__"generic-match.c", __LINE__4542);
4543 {
4544 tree res_op0;
4545 res_op0 = captures[0];
4546 tree _r;
4547 _r = fold_build1_loc (loc, ABS_EXPR, type, res_op0);
4548 return _r;
4549 }
4550next_after_fail165:;
4551 }
4552 return NULL_TREE(tree) nullptr;
4553}
4554
4555static tree
4556generic_simplify_82 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4557 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
4558)
4559{
4560/* #line 3873 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4561 if (tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4561, __FUNCTION__))->typed.type)
, type)
4562)
4563 {
4564 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail166;
4565 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3874, __FILE__"generic-match.c", __LINE__4565);
4566 {
4567 tree res_op0;
4568 res_op0 = captures[0];
4569 tree _r;
4570 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4571 return _r;
4572 }
4573next_after_fail166:;
4574 }
4575 return NULL_TREE(tree) nullptr;
4576}
4577
4578static tree
4579generic_simplify_83 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4580 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4581, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4582{
4583/* #line 5217 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4584 if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))(((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4584, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4584, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[0])
, (TS_TYPED), "generic-match.c", 4584, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4585 && !(targetm.have_canonicalize_funcptr_for_compare ()
4586 && ((POINTER_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4586, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4586, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
4587 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[1])))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 4587, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 4587, __FUNCTION__
))->typed.type))->base.code) == FUNCTION_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 4587, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 4587, __FUNCTION__
))->typed.type))->base.code) == METHOD_TYPE)
)
4588 || (POINTER_TYPE_P (TREE_TYPE (captures[3]))(((enum tree_code) (((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 4588, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 4588, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
4589 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (captures[3])))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
((captures[3]), (TS_TYPED), "generic-match.c", 4589, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 4589, __FUNCTION__
))->typed.type))->base.code) == FUNCTION_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[3]), (TS_TYPED), "generic-match.c", 4589, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 4589, __FUNCTION__
))->typed.type))->base.code) == METHOD_TYPE)
)))
4590 && single_use (captures[0])
4591)
4592 {
4593/* #line 5226 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4594 if (TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4594, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4594, __FUNCTION__))->
type_common.precision)
== TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4594, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4594, __FUNCTION__))->
type_common.precision)
4595 && (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == INTEGER_CST
4596 || captures[2] != captures[3])
4597 && (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4597, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4597, __FUNCTION__))->
base.u.bits.unsigned_flag)
== TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4597, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4597, __FUNCTION__))->
base.u.bits.unsigned_flag)
4598 || cmp == NE_EXPR
4599 || cmp == EQ_EXPR)
4600 && !POINTER_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4600, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4600, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
4601)
4602 {
4603/* #line 5236 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4604 if (TREE_CODE (captures[2])((enum tree_code) (captures[2])->base.code) == INTEGER_CST
4605)
4606 {
4607 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4607, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail167;
4608 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail167;
4609 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5237, __FILE__"generic-match.c", __LINE__4609);
4610 {
4611 tree res_op0;
4612 res_op0 = captures[1];
4613 tree res_op1;
4614 res_op1 = force_fit_type (TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4614, __FUNCTION__))->typed.type)
, wi::to_widest (captures[2]), 0,
4615 TREE_OVERFLOW (captures[2])((tree_class_check ((captures[2]), (tcc_constant), "generic-match.c"
, 4615, __FUNCTION__))->base.public_flag)
);
4616 tree _r;
4617 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4618 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4618, __FUNCTION__
))->base.side_effects_flag)
)
4619 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
4620 return _r;
4621 }
4622next_after_fail167:;
4623 }
4624 else
4625 {
4626 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4626, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail168;
4627 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail168;
4628 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5239, __FILE__"generic-match.c", __LINE__4628);
4629 {
4630 tree res_op0;
4631 res_op0 = captures[1];
4632 tree res_op1;
4633 {
4634 tree _o1[1], _r1;
4635 _o1[0] = captures[2];
4636 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4636, __FUNCTION__))->typed.type)
!= TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.c"
, 4636, __FUNCTION__))->typed.type)
)
4637 _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.c"
, 4637, __FUNCTION__))->typed.type)
, _o1[0]);
4638 else
4639 _r1 = _o1[0];
4640 res_op1 = _r1;
4641 }
4642 tree _r;
4643 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4644 return _r;
4645 }
4646next_after_fail168:;
4647 }
4648 }
4649 else
4650 {
4651/* #line 5241 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4652 if (TYPE_PRECISION (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4652, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4652, __FUNCTION__))->
type_common.precision)
> TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4652, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4652, __FUNCTION__))->
type_common.precision)
4653)
4654 {
4655/* #line 5243 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4656 if ((cmp == EQ_EXPR || cmp == NE_EXPR
4657 || TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4657, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4657, __FUNCTION__))->
base.u.bits.unsigned_flag)
== TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4657, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4657, __FUNCTION__))->
base.u.bits.unsigned_flag)
4658 || (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))((tree_class_check ((((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4658, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4658, __FUNCTION__))->
base.u.bits.unsigned_flag)
4659 && TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4659, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4659, __FUNCTION__))->
base.u.bits.unsigned_flag)
))
4660 && (types_match (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 4660, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4660, __FUNCTION__))->typed.type)
)
4661 || ((TYPE_PRECISION (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4661, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4661, __FUNCTION__))->
type_common.precision)
4662 >= TYPE_PRECISION (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 4662, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4662, __FUNCTION__))->
type_common.precision)
)
4663 && (TYPE_UNSIGNED (TREE_TYPE (captures[1]))((tree_class_check ((((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4663, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4663, __FUNCTION__))->
base.u.bits.unsigned_flag)
4664 == TYPE_UNSIGNED (TREE_TYPE (captures[3]))((tree_class_check ((((contains_struct_check ((captures[3]), (
TS_TYPED), "generic-match.c", 4664, __FUNCTION__))->typed.
type)), (tcc_type), "generic-match.c", 4664, __FUNCTION__))->
base.u.bits.unsigned_flag)
))
4665 || (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == INTEGER_CST
4666 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4666, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4666, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 4666, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4667 && int_fits_type_p (captures[3], TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4667, __FUNCTION__))->typed.type)
)))
4668)
4669 {
4670 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail169;
4671 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5255, __FILE__"generic-match.c", __LINE__4671);
4672 {
4673 tree res_op0;
4674 res_op0 = captures[1];
4675 tree res_op1;
4676 {
4677 tree _o1[1], _r1;
4678 _o1[0] = captures[3];
4679 if (TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4679, __FUNCTION__))->typed.type)
!= TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.c"
, 4679, __FUNCTION__))->typed.type)
)
4680 _r1 = fold_build1_loc (loc, NOP_EXPR, TREE_TYPE (res_op0)((contains_struct_check ((res_op0), (TS_TYPED), "generic-match.c"
, 4680, __FUNCTION__))->typed.type)
, _o1[0]);
4681 else
4682 _r1 = _o1[0];
4683 res_op1 = _r1;
4684 }
4685 tree _r;
4686 _r = fold_build2_loc (loc, cmp, type, res_op0, res_op1);
4687 return _r;
4688 }
4689next_after_fail169:;
4690 }
4691 else
4692 {
4693/* #line 5256 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4694 if (TREE_CODE (captures[3])((enum tree_code) (captures[3])->base.code) == INTEGER_CST
4695 && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))(((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 4695, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4695, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 4695, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE)
4696 && !int_fits_type_p (captures[3], TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4696, __FUNCTION__))->typed.type)
)
4697)
4698 {
4699 {
4700/* #line 5259 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4701 tree min = lower_bound_in_type (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 4701, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4701, __FUNCTION__))->typed.type)
);
4702 tree max = upper_bound_in_type (TREE_TYPE (captures[3])((contains_struct_check ((captures[3]), (TS_TYPED), "generic-match.c"
, 4702, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[1])((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 4702, __FUNCTION__))->typed.type)
);
4703 bool above = integer_nonzerop (const_binop (LT_EXPR, type, max, captures[3]));
4704 bool below = integer_nonzerop (const_binop (LT_EXPR, type, captures[3], min));
4705/* #line 5266 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4706 if (above || below
4707)
4708 {
4709/* #line 5267 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4710 if (cmp == EQ_EXPR || cmp == NE_EXPR
4711)
4712 {
4713 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail170;
4714 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5268, __FILE__"generic-match.c", __LINE__4714);
4715 {
4716 tree _r;
4717 _r = constant_boolean_node (cmp == EQ_EXPR ? false : true, type);
4718 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4718, __FUNCTION__
))->base.side_effects_flag)
)
4719 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4720 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4720, __FUNCTION__
))->base.side_effects_flag)
)
4721 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
4722 return _r;
4723 }
4724next_after_fail170:;
4725 }
4726 else
4727 {
4728/* #line 5269 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4729 if (cmp == LT_EXPR || cmp == LE_EXPR
4730)
4731 {
4732 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail171;
4733 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5270, __FILE__"generic-match.c", __LINE__4733);
4734 {
4735 tree _r;
4736 _r = constant_boolean_node (above ? true : false, type);
4737 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4737, __FUNCTION__
))->base.side_effects_flag)
)
4738 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4739 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4739, __FUNCTION__
))->base.side_effects_flag)
)
4740 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
4741 return _r;
4742 }
4743next_after_fail171:;
4744 }
4745 else
4746 {
4747/* #line 5271 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4748 if (cmp == GT_EXPR || cmp == GE_EXPR
4749)
4750 {
4751 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail172;
4752 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 5272, __FILE__"generic-match.c", __LINE__4752);
4753 {
4754 tree _r;
4755 _r = constant_boolean_node (above ? false : true, type);
4756 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4756, __FUNCTION__
))->base.side_effects_flag)
)
4757 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4758 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4758, __FUNCTION__
))->base.side_effects_flag)
)
4759 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[3]), _r);
4760 return _r;
4761 }
4762next_after_fail172:;
4763 }
4764 }
4765 }
4766 }
4767 }
4768 }
4769 }
4770 }
4771 }
4772 }
4773 return NULL_TREE(tree) nullptr;
4774}
4775
4776static tree
4777generic_simplify_84 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4778 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4779, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)))
4780{
4781/* #line 4648 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4782 if (! FLOAT_TYPE_P (TREE_TYPE (captures[0]))((((enum tree_code) (((contains_struct_check ((captures[0]), (
TS_TYPED), "generic-match.c", 4782, __FUNCTION__))->typed.
type))->base.code) == REAL_TYPE) || ((((enum tree_code) ((
(contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4782, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[0]
), (TS_TYPED), "generic-match.c", 4782, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[0]), (TS_TYPED), "generic-match.c", 4782, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 4782, __FUNCTION__
))->typed.type))->base.code) == REAL_TYPE)))
4783 || ! HONOR_NANS (captures[0])
4784)
4785 {
4786 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail173;
4787 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4650, __FILE__"generic-match.c", __LINE__4787);
4788 {
4789 tree _r;
4790 _r = constant_boolean_node (true, type);
4791 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 4791, __FUNCTION__
))->base.side_effects_flag)
)
4792 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4793 return _r;
4794 }
4795next_after_fail173:;
4796 }
4797 else
4798 {
4799/* #line 4651 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4800 if (cmp != EQ_EXPR
4801)
4802 {
4803 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail174;
4804 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 4652, __FILE__"generic-match.c", __LINE__4804);
4805 {
4806 tree res_op0;
4807 res_op0 = unshare_expr (captures[0]);
4808 tree res_op1;
4809 res_op1 = captures[0];
4810 tree _r;
4811 _r = fold_build2_loc (loc, EQ_EXPR, type, res_op0, res_op1);
4812 return _r;
4813 }
4814next_after_fail174:;
4815 }
4816 }
4817 return NULL_TREE(tree) nullptr;
4818}
4819
4820static tree
4821generic_simplify_85 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4822 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4823, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4824{
4825 if (TREE_SIDE_EFFECTS (_p1)((non_type_check ((_p1), "generic-match.c", 4825, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail175;
4826 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail175;
4827 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 339, __FILE__"generic-match.c", __LINE__4827);
4828 {
4829 tree res_op0;
4830 res_op0 = captures[0];
4831 tree _r;
4832 _r = non_lvalue_loc (loc, res_op0);
4833 return _r;
4834 }
4835next_after_fail175:;
4836 return NULL_TREE(tree) nullptr;
4837}
4838
4839static tree
4840generic_simplify_86 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4841 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree *captures
4842, const combined_fn ARG_UNUSED (SIGNBIT)SIGNBIT __attribute__ ((__unused__)))
4843{
4844 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail176;
4845 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 6666, __FILE__"generic-match.c", __LINE__4845);
4846 {
4847 tree _r;
4848 _r = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];
4849 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 4849, __FUNCTION__
))->base.side_effects_flag)
)
4850 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[0]), _r);
4851 return _r;
4852 }
4853next_after_fail176:;
4854 return NULL_TREE(tree) nullptr;
4855}
4856
4857static tree
4858generic_simplify_87 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4859 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4860, const enum tree_code ARG_UNUSED (shiftrotate)shiftrotate __attribute__ ((__unused__)))
4861{
4862 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail177;
4863 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3310, __FILE__"generic-match.c", __LINE__4863);
4864 {
4865 tree _r;
4866 _r = captures[0];
4867 if (TREE_SIDE_EFFECTS (captures[1])((non_type_check ((captures[1]), "generic-match.c", 4867, __FUNCTION__
))->base.side_effects_flag)
)
4868 _r = build2_loc (loc, COMPOUND_EXPR, type, fold_ignored_result (captures[1]), _r);
4869 return _r;
4870 }
4871next_after_fail177:;
4872 return NULL_TREE(tree) nullptr;
4873}
4874
4875static tree
4876generic_simplify_88 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4877 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4878, const enum tree_code ARG_UNUSED (op)op __attribute__ ((__unused__)))
4879{
4880/* #line 3772 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4881 if (tree_nop_conversion_p (type, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4881, __FUNCTION__))->typed.type)
)
4882 && tree_nop_conversion_p (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4882, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4882, __FUNCTION__))->typed.type)
)
4883)
4884 {
4885 {
4886/* #line 3774 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4887 wi::overflow_type overflow;
4888 wide_int mul = wi::mul (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
4889 TYPE_SIGN (type)((signop) ((tree_class_check ((type), (tcc_type), "generic-match.c"
, 4889, __FUNCTION__))->base.u.bits.unsigned_flag))
, &overflow);
4890/* #line 3780 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4891 if (types_match (type, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4891, __FUNCTION__))->typed.type)
)
4892 && types_match (TREE_TYPE (captures[0])((contains_struct_check ((captures[0]), (TS_TYPED), "generic-match.c"
, 4892, __FUNCTION__))->typed.type)
, TREE_TYPE (captures[2])((contains_struct_check ((captures[2]), (TS_TYPED), "generic-match.c"
, 4892, __FUNCTION__))->typed.type)
) && !overflow
4893)
4894 {
4895 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4895, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail178;
4896 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4896, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail178;
4897 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail178;
4898 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3782, __FILE__"generic-match.c", __LINE__4898);
4899 {
4900 tree res_op0;
4901 res_op0 = captures[0];
4902 tree res_op1;
4903 res_op1 = wide_int_to_tree (type, mul);
4904 tree _r;
4905 _r = fold_build2_loc (loc, op, type, res_op0, res_op1);
4906 return _r;
4907 }
4908next_after_fail178:;
4909 }
4910 else
4911 {
4912 {
4913/* #line 3783 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
4914 tree utype = unsigned_type_for (type);
4915 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 4915, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail179;
4916 if (TREE_SIDE_EFFECTS (captures[3])((non_type_check ((captures[3]), "generic-match.c", 4916, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail179;
4917 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail179;
4918 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3784, __FILE__"generic-match.c", __LINE__4918);
4919 {
4920 tree res_op0;
4921 {
4922 tree _o1[2], _r1;
4923 {
4924 tree _o2[1], _r2;
4925 _o2[0] = captures[0];
4926 if (TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 4926, __FUNCTION__))->typed.type)
!= utype)
4927 _r2 = fold_build1_loc (loc, NOP_EXPR, utype, _o2[0]);
4928 else
4929 _r2 = _o2[0];
4930 _o1[0] = _r2;
4931 }
4932 {
4933 tree _o2[2], _r2;
4934 {
4935 tree _o3[1], _r3;
4936 _o3[0] = captures[1];
4937 if (TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 4937, __FUNCTION__))->typed.type)
!= utype)
4938 _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
4939 else
4940 _r3 = _o3[0];
4941 _o2[0] = _r3;
4942 }
4943 {
4944 tree _o3[1], _r3;
4945 _o3[0] = captures[2];
4946 if (TREE_TYPE (_o3[0])((contains_struct_check ((_o3[0]), (TS_TYPED), "generic-match.c"
, 4946, __FUNCTION__))->typed.type)
!= utype)
4947 _r3 = fold_build1_loc (loc, NOP_EXPR, utype, _o3[0]);
4948 else
4949 _r3 = _o3[0];
4950 _o2[1] = _r3;
4951 }
4952 _r2 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 4952, __FUNCTION__))->typed.type)
, _o2[0], _o2[1]);
4953 _o1[1] = _r2;
4954 }
4955 _r1 = fold_build2_loc (loc, op, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4955, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
4956 res_op0 = _r1;
4957 }
4958 tree _r;
4959 _r = fold_build1_loc (loc, NOP_EXPR, type, res_op0);
4960 return _r;
4961 }
4962next_after_fail179:;
4963 }
4964 }
4965 }
4966 }
4967 return NULL_TREE(tree) nullptr;
4968}
4969
4970static tree
4971generic_simplify_89 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4972 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4973, const enum tree_code ARG_UNUSED (minmax)minmax __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (maxmin)maxmin __attribute__ ((__unused__)))
4974{
4975 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail180;
4976 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 3168, __FILE__"generic-match.c", __LINE__4976);
4977 {
4978 tree res_op0;
4979 {
4980 tree _o1[2], _r1;
4981 _o1[0] = captures[1];
4982 _o1[1] = captures[3];
4983 _r1 = fold_build2_loc (loc, maxmin, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 4983, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
4984 res_op0 = _r1;
4985 }
4986 tree _r;
4987 _r = fold_build1_loc (loc, BIT_NOT_EXPR, type, res_op0);
4988 return _r;
4989 }
4990next_after_fail180:;
4991 return NULL_TREE(tree) nullptr;
4992}
4993
4994static tree
4995generic_simplify_90 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
4996 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
4997, const enum tree_code ARG_UNUSED (outer_op)outer_op __attribute__ ((__unused__)))
4998{
4999/* #line 2451 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5000 if (!TYPE_SATURATING (type)((tree_not_check4 ((type), "generic-match.c", 5000, __FUNCTION__
, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE), (ARRAY_TYPE
)))->base.u.bits.saturating_flag)
5001)
5002 {
5003/* #line 2509 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5004 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", 5004, __FUNCTION__))->typed.type))->
base.code) == REAL_TYPE)))
|| flag_associative_mathglobal_options.x_flag_associative_math)
5005 && !FIXED_POINT_TYPE_P (type)(((enum tree_code) (type)->base.code) == FIXED_POINT_TYPE)
5006)
5007 {
5008/* #line 2605 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5009 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", 5009, __FUNCTION__))->typed.type))->
base.code) == ENUMERAL_TYPE || ((enum tree_code) (((contains_struct_check
((type), (TS_TYPED), "generic-match.c", 5009, __FUNCTION__))
->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((type), (TS_TYPED), "generic-match.c"
, 5009, __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"
, 5009, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
5010)
5011 {
5012/* #line 2608 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5013 if (!CONSTANT_CLASS_P (captures[1])(tree_code_type[(int) (((enum tree_code) (captures[1])->base
.code))] == tcc_constant)
5014)
5015 {
5016 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail181;
5017 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2609, __FILE__"generic-match.c", __LINE__5017);
5018 {
5019 tree res_op0;
5020 {
5021 tree _o1[2], _r1;
5022 {
5023 tree _o2[1], _r2;
5024 _o2[0] = captures[0];
5025 _r2 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o2[0]);
5026 _o1[0] = _r2;
5027 }
5028 _o1[1] = captures[2];
5029 _r1 = fold_build2_loc (loc, outer_op, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 5029, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
5030 res_op0 = _r1;
5031 }
5032 tree res_op1;
5033 {
5034 tree _o1[1], _r1;
5035 _o1[0] = captures[1];
5036 _r1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, _o1[0]);
5037 res_op1 = _r1;
5038 }
5039 tree _r;
5040 _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5041 return _r;
5042 }
5043next_after_fail181:;
5044 }
5045 }
5046 else
5047 {
5048/* #line 2610 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5049 if (!ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 5049, __FUNCTION__))->typed.
type))->base.code) == ENUMERAL_TYPE || ((enum tree_code) (
((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 5049, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((captures[1])
, (TS_TYPED), "generic-match.c", 5049, __FUNCTION__))->typed
.type))->base.code) == INTEGER_TYPE) || ((((enum tree_code
) (((contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 5049, __FUNCTION__))->typed.type))->base.code) == COMPLEX_TYPE
|| (((enum tree_code) (((contains_struct_check ((captures[1]
), (TS_TYPED), "generic-match.c", 5049, __FUNCTION__))->typed
.type))->base.code) == VECTOR_TYPE)) && (((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 5049, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 5049, __FUNCTION__
))->typed.type))->base.code) == ENUMERAL_TYPE || ((enum
tree_code) (((contains_struct_check ((((contains_struct_check
((captures[1]), (TS_TYPED), "generic-match.c", 5049, __FUNCTION__
))->typed.type)), (TS_TYPED), "generic-match.c", 5049, __FUNCTION__
))->typed.type))->base.code) == BOOLEAN_TYPE || ((enum tree_code
) (((contains_struct_check ((((contains_struct_check ((captures
[1]), (TS_TYPED), "generic-match.c", 5049, __FUNCTION__))->
typed.type)), (TS_TYPED), "generic-match.c", 5049, __FUNCTION__
))->typed.type))->base.code) == INTEGER_TYPE)))
5050 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))((((enum tree_code) (((contains_struct_check ((captures[1]), (
TS_TYPED), "generic-match.c", 5050, __FUNCTION__))->typed.
type))->base.code) == POINTER_TYPE || ((enum tree_code) ((
(contains_struct_check ((captures[1]), (TS_TYPED), "generic-match.c"
, 5050, __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"
, 5050, __FUNCTION__))->typed.type)), "generic-match.c", 5050
, __FUNCTION__))->base.u.bits.unsigned_flag || global_options
.x_flag_wrapv))
5051)
5052 {
5053 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail182;
5054 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2612, __FILE__"generic-match.c", __LINE__5054);
5055 {
5056 tree res_op0;
5057 {
5058 tree _o1[2], _r1;
5059 {
5060 tree _o2[2], _r2;
5061 _o2[0] = captures[0];
5062 {
5063 tree _o3[1], _r3;
5064 _o3[0] = captures[2];
5065 _r3 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 5065, __FUNCTION__))->typed.type)
, _o3[0]);
5066 _o2[1] = _r3;
5067 }
5068 _r2 = fold_build2_loc (loc, outer_op, TREE_TYPE (_o2[0])((contains_struct_check ((_o2[0]), (TS_TYPED), "generic-match.c"
, 5068, __FUNCTION__))->typed.type)
, _o2[0], _o2[1]);
5069 _o1[0] = _r2;
5070 }
5071 _o1[1] = captures[1];
5072 _r1 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (_o1[0])((contains_struct_check ((_o1[0]), (TS_TYPED), "generic-match.c"
, 5072, __FUNCTION__))->typed.type)
, _o1[0], _o1[1]);
5073 res_op0 = _r1;
5074 }
5075 tree _r;
5076 _r = fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, res_op0);
5077 return _r;
5078 }
5079next_after_fail182:;
5080 }
5081 else
5082 {
5083/* #line 2613 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5084 if (types_match (type, captures[1])
5085)
5086 {
5087 {
5088/* #line 2614 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5089 tree cst = const_binop (outer_op, type, captures[0], captures[2]);
5090/* #line 2615 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/match.pd" */
5091 if (cst && !TREE_OVERFLOW (cst)((tree_class_check ((cst), (tcc_constant), "generic-match.c",
5091, __FUNCTION__))->base.public_flag)
5092)
5093 {
5094 if (TREE_SIDE_EFFECTS (captures[0])((non_type_check ((captures[0]), "generic-match.c", 5094, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail183;
5095 if (TREE_SIDE_EFFECTS (captures[2])((non_type_check ((captures[2]), "generic-match.c", 5095, __FUNCTION__
))->base.side_effects_flag)
) goto next_after_fail183;
5096 if (__builtin_expect (!dbg_cnt (match), 0)) goto next_after_fail183;
5097 if (__builtin_expect (dump_file && (dump_flags & TDF_FOLDING), 0)) fprintf (dump_file, "Applying pattern %s:%d, %s:%d\n", "match.pd", 2616, __FILE__"generic-match.c", __LINE__5097);
5098 {
5099 tree res_op0;
5100 res_op0 = cst;
5101 tree res_op1;
5102 res_op1 = captures[1];
5103 tree _r;
5104 _r = fold_build2_loc (loc, MINUS_EXPR, type, res_op0, res_op1);
5105 return _r;
5106 }
5107next_after_fail183:;
5108 }
5109 }
5110 }
5111 }
5112 }
5113 }
5114 }
5115 return NULL_TREE(tree) nullptr;
5116}
5117
5118static tree
5119generic_simplify_91 (location_t ARG_UNUSED (loc)loc __attribute__ ((__unused__)), const tree ARG_UNUSED (type)type __attribute__ ((__unused__)),
5120 tree ARG_UNUSED (_p0)_p0 __attribute__ ((__unused__)), tree ARG_UNUSED (_p1)_p1 __attribute__ ((__unused__)), tree *captures
5121, const enum tree_code ARG_UNUSED (cmp)cmp __attribute__ ((__unused__)), const enum tree_code ARG_UNUSED (ncmp)ncmp __attribute__ ((__unused__)))