gimple-match.c

Bug Summary

File:	objdir/gcc/gimple-match.c
Warning:	line 9704, column 7 Value stored to 'arg00' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

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
6	bool
7	gimple_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	}
34	next_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	}
61	next_after_fail2:;
62	}
63	}
64	}
65	break;
66	}
67	default:;
68	}
69	}
70	break;
71	default:;
72	}
73	return false;
74	}
75
76	bool
77	gimple_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	}
106	next_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	}
128	next_after_fail4:;
129	}
130	break;
131	}
132	default:;
133	}
134	return false;
135	}
136
137	bool
138	gimple_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	}
164	next_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	}
189	next_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	}
213	next_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	}
226	next_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	}
242	next_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	}
259	next_after_fail10:;
260	}
261	}
262	break;
263	}
264	default:;
265	}
266	return false;
267	}
268
269	bool
270	gimple_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	}
284	next_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	}
308	next_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	}
325	next_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	}
344	next_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	}
363	next_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	}
380	next_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	}
397	next_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	}
416	next_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	}
435	next_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	}
452	next_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	}
469	next_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	}
486	next_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	}
503	next_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	}
522	next_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	}
541	next_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	}
560	next_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	}
577	next_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	}
596	next_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	}
613	next_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	}
632	next_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	}
647	next_after_fail31:;
648	}
649	break;
650	}
651	default:;
652	}
653	}
654	break;
655	default:;
656	}
657	return false;
658	}
659
660	bool
661	gimple_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	}
684	next_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	}
702	next_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	}
725	next_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	}
750	next_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	}
776	next_after_fail36:;
777	}
778	}
779	}
780	break;
781	}
782	default:;
783	}
784	}
785	break;
786	default:;
787	}
788	return false;
789	}
790
791	bool
792	gimple_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	}
806	next_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	}
823	next_after_fail38:;
824	}
825	}
826	break;
827	}
828	default:;
829	}
830	return false;
831	}
832
833	bool
834	gimple_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	}
863	next_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	}
876	next_after_fail40:;
877	}
878	}
879	break;
880	}
881	default:;
882	}
883	}
884	break;
885	default:;
886	}
887	if (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	}
897	next_after_fail41:;
898	}
899	}
900	return false;
901	}
902
903	bool
904	gimple_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	}
935	next_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	}
957	next_after_fail43:;
958	}
959	break;
960	}
961	default:;
962	}
963	return false;
964	}
965
966	bool
967	gimple_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	}
985	next_after_fail44:;
986	}
987	}
988	break;
989	}
990	default:;
991	}
992	return false;
993	}
994
995	bool
996	gimple_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	}
1014	next_after_fail45:;
1015	}
1016	}
1017	break;
1018	}
1019	default:;
1020	}
1021	return false;
1022	}
1023
1024	bool
1025	gimple_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	}
1061	next_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	}
1086	next_after_fail47:;
1087	}
1088	break;
1089	}
1090	default:;
1091	}
1092	}
1093	break;
1094	default:;
1095	}
1096	return false;
1097	}
1098
1099	bool
1100	gimple_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	}
1114	next_after_fail48:;
1115	}
1116	}
1117	return false;
1118	}
1119
1120	bool
1121	gimple_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	}
1135	next_after_fail49:;
1136	}
1137	}
1138	return false;
1139	}
1140
1141	bool
1142	gimple_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);
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	}
1156	next_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	}
1178	next_after_fail51:;
1179	}
1180	break;
1181	}
1182	default:;
1183	}
1184	}
1185	break;
1186	default:;
1187	}
1188	return false;
1189	}
1190
1191	bool
1192	gimple_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	}
1273	next_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	}
1324	next_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
1370	static bool
1371	gimple_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	}
1386	next_after_fail54:;
1387	return false;
1388	}
1389
1390	static bool
1391	gimple_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	}
1406	next_after_fail55:;
1407	return false;
1408	}
1409
1410	static bool
1411	gimple_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	}
1426	next_after_fail56:;
1427	return false;
1428	}
1429
1430	static bool
1431	gimple_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	}
1480	next_after_fail57:;
1481	}
1482	return false;
1483	}
1484
1485	static bool
1486	gimple_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	}
1510	next_after_fail58:;
1511	}
1512	return false;
1513	}
1514
1515	static bool
1516	gimple_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	}
1535	next_after_fail59:;
1536	}
1537	return false;
1538	}
1539
1540	static bool
1541	gimple_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	}
1556	next_after_fail60:;
1557	return false;
1558	}
1559
1560	static bool
1561	gimple_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	}
1614	next_after_fail61:;
1615	}
1616	return false;
1617	}
1618
1619	static bool
1620	gimple_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	}
1635	next_after_fail62:;
1636	return false;
1637	}
1638
1639	static bool
1640	gimple_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	}
1667	next_after_fail63:;
1668	}
1669	return false;
1670	}
1671
1672	static bool
1673	gimple_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	}
1718	next_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	}
1746	next_after_fail65:;
1747	}
1748	}
1749	}
1750	return false;
1751	}
1752
1753	static bool
1754	gimple_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	}
1773	next_after_fail66:;
1774	}
1775	return false;
1776	}
1777
1778	static bool
1779	gimple_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	}
1797	next_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	}
1814	next_after_fail68:;
1815	}
1816	}
1817	return false;
1818	}
1819
1820	static bool
1821	gimple_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	}
1843	next_after_fail69:;
1844	}
1845	return false;
1846	}
1847
1848	static bool
1849	gimple_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	}
1875	next_after_fail70:;
1876	return false;
1877	}
1878
1879	static bool
1880	gimple_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	}
1970	next_after_fail71:;
1971	}
1972	}
1973	return false;
1974	}
1975
1976	static bool
1977	gimple_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	&& (
1990	1
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	}
2014	next_after_fail72:;
2015	}
2016	return false;
2017	}
2018
2019	static bool
2020	gimple_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	}
2035	next_after_fail73:;
2036	return false;
2037	}
2038
2039	static bool
2040	gimple_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	}
2054	next_after_fail74:;
2055	return false;
2056	}
2057
2058	static bool
2059	gimple_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	}
2086	next_after_fail75:;
2087	return false;
2088	}
2089
2090	static bool
2091	gimple_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	}
2105	next_after_fail76:;
2106	return false;
2107	}
2108
2109	static bool
2110	gimple_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	}
2138	next_after_fail77:;
2139	return false;
2140	}
2141
2142	static bool
2143	gimple_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	}
2214	next_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	}
2298	next_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	}
2316	next_after_fail80:;
2317	}
2318	}
2319	}
2320	}
2321	}
2322	}
2323	}
2324	}
2325	}
2326	}
2327	return false;
2328	}
2329
2330	static bool
2331	gimple_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	}
2345	next_after_fail81:;
2346	return false;
2347	}
2348
2349	static bool
2350	gimple_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	}
2423	next_after_fail82:;
2424	}
2425	}
2426	return false;
2427	}
2428
2429	static bool
2430	gimple_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	}
2467	next_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	}
2485	next_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	}
2502	next_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	}
2520	next_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	}
2545	next_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	}
2563	next_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	}
2580	next_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	}
2598	next_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	}
2627	next_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	}
2648	next_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	}
2675	next_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	}
2696	next_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	}
2744	next_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	}
2776	next_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	}
2802	next_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	}
2828	next_after_fail98:;
2829	}
2830	}
2831	}
2832	}
2833	}
2834	}
2835	}
2836	}
2837	}
2838	}
2839	}
2840	}
2841	}
2842	return false;
2843	}
2844
2845	static bool
2846	gimple_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	}
2934	next_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	}
2961	next_after_fail100:;
2962	}
2963	}
2964	}
2965	}
2966	}
2967	return false;
2968	}
2969
2970	static bool
2971	gimple_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	}
2998	next_after_fail101:;
2999	}
3000	return false;
3001	}
3002
3003	static bool
3004	gimple_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	}
3018	next_after_fail102:;
3019	return false;
3020	}
3021
3022	static bool
3023	gimple_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	}
3043	next_after_fail103:;
3044	}
3045	return false;
3046	}
3047
3048	static bool
3049	gimple_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	}
3087	next_after_fail104:;
3088	}
3089	return false;
3090	}
3091
3092	static bool
3093	gimple_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	}
3114	next_after_fail105:;
3115	}
3116	return false;
3117	}
3118
3119	static bool
3120	gimple_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	}
3147	next_after_fail106:;
3148	}
3149	}
3150	}
3151	return false;
3152	}
3153
3154	static bool
3155	gimple_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	}
3181	next_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	}
3194	next_after_fail108:;
3195	}
3196	return false;
3197	}
3198
3199	static bool
3200	gimple_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	}
3218	next_after_fail109:;
3219	}
3220	return false;
3221	}
3222
3223	static bool
3224	gimple_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	}
3250	next_after_fail110:;
3251	}
3252	}
3253	}
3254	return false;
3255	}
3256
3257	static bool
3258	gimple_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	}
3310	next_after_fail111:;
3311	}
3312	}
3313	return false;
3314	}
3315
3316	static bool
3317	gimple_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	}
3340	next_after_fail112:;
3341	}
3342	}
3343	return false;
3344	}
3345
3346	static bool
3347	gimple_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	}
3373	next_after_fail113:;
3374	}
3375	return false;
3376	}
3377
3378	static bool
3379	gimple_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	}
3394	next_after_fail114:;
3395	return false;
3396	}
3397
3398	static bool
3399	gimple_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	}
3413	next_after_fail115:;
3414	return false;
3415	}
3416
3417	static bool
3418	gimple_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	}
3433	next_after_fail116:;
3434	return false;
3435	}
3436
3437	static bool
3438	gimple_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	}
3457	next_after_fail117:;
3458	}
3459	return false;
3460	}
3461
3462	static bool
3463	gimple_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	}
3484	next_after_fail118:;
3485	}
3486	return false;
3487	}
3488
3489	static bool
3490	gimple_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	}
3550	next_after_fail119:;
3551	}
3552	}
3553	return false;
3554	}
3555
3556	static bool
3557	gimple_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	}
3596	next_after_fail120:;
3597	}
3598	}
3599	return false;
3600	}
3601
3602	static bool
3603	gimple_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	}
3617	next_after_fail121:;
3618	return false;
3619	}
3620
3621	static bool
3622	gimple_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	}
3641	next_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	}
3659	next_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	}
3689	next_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	}
3710	next_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	}
3728	next_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	}
3756	next_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	}
3770	next_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	}
3797	next_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	}
3811	next_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	}
3842	next_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	}
3856	next_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	}
3875	next_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	}
3889	next_after_fail134:;
3890	}
3891	}
3892	}
3893	}
3894	}
3895	}
3896	}
3897	}
3898	}
3899	}
3900	}
3901	}
3902	return false;
3903	}
3904
3905	static bool
3906	gimple_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	}
3945	next_after_fail135:;
3946	}
3947	return false;
3948	}
3949
3950	static bool
3951	gimple_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	}
3969	next_after_fail136:;
3970	}
3971	return false;
3972	}
3973
3974	static bool
3975	gimple_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	}
3999	next_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	}
4018	next_after_fail138:;
4019	}
4020	}
4021	}
4022	return false;
4023	}
4024
4025	static bool
4026	gimple_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	}
4087	next_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	}
4118	next_after_fail140:;
4119	}
4120	}
4121	}
4122	}
4123	return false;
4124	}
4125
4126	static bool
4127	gimple_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	}
4154	next_after_fail141:;
4155	}
4156	return false;
4157	}
4158
4159	static bool
4160	gimple_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	}
4193	next_after_fail142:;
4194	}
4195	return false;
4196	}
4197
4198	static bool
4199	gimple_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	}
4217	next_after_fail143:;
4218	}
4219	return false;
4220	}
4221
4222	static bool
4223	gimple_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	}
4274	next_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	}
4330	next_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	}
4419	next_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	}
4488	next_after_fail147:;
4489	}
4490	}
4491	}
4492	}
4493	}
4494	}
4495	}
4496	}
4497	return false;
4498	}
4499
4500	static bool
4501	gimple_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	}
4538	next_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	}
4555	next_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	}
4569	next_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	}
4585	next_after_fail151:;
4586	}
4587	}
4588	}
4589	}
4590	return false;
4591	}
4592
4593	static bool
4594	gimple_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	}
4621	next_after_fail152:;
4622	}
4623	return false;
4624	}
4625
4626	static bool
4627	gimple_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	}
4649	next_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	}
4663	next_after_fail154:;
4664	}
4665	}
4666	return false;
4667	}
4668
4669	static bool
4670	gimple_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	}
4712	next_after_fail155:;
4713	}
4714	}
4715	}
4716	return false;
4717	}
4718
4719	static bool
4720	gimple_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	}
4749	next_after_fail156:;
4750	}
4751	}
4752	return false;
4753	}
4754
4755	static bool
4756	gimple_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	}
4797	next_after_fail157:;
4798	}
4799	}
4800	}
4801	return false;
4802	}
4803
4804	static bool
4805	gimple_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	}
4820	next_after_fail158:;
4821	return false;
4822	}
4823
4824	static bool
4825	gimple_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	}
4882	next_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	}
4927	next_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	}
4952	next_after_fail161:;
4953	}
4954	}
4955	}
4956	}
4957	}
4958	}
4959	}
4960	return false;
4961	}
4962
4963	static bool
4964	gimple_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	}
4994	next_after_fail162:;
4995	}
4996	return false;
4997	}
4998
4999	static bool
5000	gimple_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	}
5020	next_after_fail163:;
5021	}
5022	return false;
5023	}
5024
5025	static bool
5026	gimple_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	}
5040	next_after_fail164:;
5041	return false;
5042	}
5043
5044	static bool
5045	gimple_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	}
5102	next_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	}
5147	next_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	}
5172	next_after_fail167:;
5173	}
5174	}
5175	}
5176	}
5177	}
5178	}
5179	}
5180	return false;
5181	}
5182
5183	static bool
5184	gimple_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	}
5203	next_after_fail168:;
5204	}
5205	return false;
5206	}
5207
5208	static bool
5209	gimple_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	}
5227	next_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	}
5244	next_after_fail170:;
5245	}
5246	}
5247	return false;
5248	}
5249
5250	static bool
5251	gimple_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	}
5281	next_after_fail171:;
5282	}
5283	return false;
5284	}
5285
5286	static bool
5287	gimple_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	}
5301	next_after_fail172:;
5302	return false;
5303	}
5304
5305	static bool
5306	gimple_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	}
5321	next_after_fail173:;
5322	return false;
5323	}
5324
5325	static bool
5326	gimple_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	}
5350	next_after_fail174:;
5351	}
5352	}
5353	return false;
5354	}
5355
5356	static bool
5357	gimple_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	}
5399	next_after_fail175:;
5400	}
5401	}
5402	return false;
5403	}
5404
5405	static bool
5406	gimple_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 (
5434	0
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
5447	\|\| TREE_CODE (base1)((enum tree_code) (base1)->base.code) == STRING_CST))