Bug Summary

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